Mentions

Conversations linking to GitHub, newest first. Times are UTC.

Mentions by source

X

6,370
Nov 14, 06:00Nov 15, 06:00

Bluesky

1,850
Nov 14, 08:00Nov 15, 08:00
Nov 14, 07:00Nov 15, 07:00
Nov 14, 07:00Nov 15, 07:00
Nov 14, 08:00Nov 15, 08:00
Nov 14, 08:00Nov 15, 08:00
Nov 14, 07:00Nov 15, 07:00
Nov 14, 07:00Nov 15, 07:00
Oct 14, 21:00Oct 15, 21:00

Delayed · data through Oct 15, 21:00 UTC

DEV

1,264
Nov 14, 08:00Nov 15, 08:00
Nov 14, 08:00Nov 15, 08:00
Nov 14, 05:00Nov 15, 05:00
Nov 14, 08:00Nov 15, 08:00
Oct 28, 01:00Oct 29, 01:00

Delayed · data through Oct 29, 01:00 UTC

Nov 8, 11:00Nov 9, 11:00

Delayed · data through Nov 9, 11:00 UTC

Nov 14, 08:00Nov 15, 08:00

Latest posts

  1. SOML – A Config Format for Humans #HackerNews soml-lang/soml

  2. Hacker Newsnh2 · on WTF Ubuntu?

    (~10 years NixOS user, and committer.) It depends. Mostly on how much rebuilding it needs (e.g. if it's a "leaf" package, or one many packages depend on). The merging of security fixes is usually very good, also because it is so easy for anyone to just make a PR. The security team also seems pretty competent and fast. As a sibling commenter says, it is also extremely easy to just apply patches to your own system in general, usually with a few line of easy code max. So you can fix systems without dependence on distro maintainers. In contrast to e.g. patching a `.deb`, you can declare the code such that the patch will still be used even if the distro releases a new package; you can carry the patch forward, and don't need to choose between {not having the patch because the distro lacks it} and {not having future security fixes because you pinned your custom .deb version}. NixOS will rebuild any future update, applying your patch to it. That's a big benefit, because it makes "out-of-tree" custom patches very maintainable. Due to declarativeness, you can easily roll out your fix on lots of machines. Also, the "SBOM" (software bill of materials) part is quite good in NixOS. It's very easy to determine which package uses what dependencies. The only real drawback is CI build time when a high-dependency package needs fixing. Due to the way Nix works with its immutable hash DAG of package dependencies, a package change will trigger a full rebuild of all packages that recursively depend on it. For example, if you change 1 line in glibc, or libpng, or curl, or (recently) brotli, the entire distro needs to be recompiled from source ("rebuild the world"). Some of the packages, such as Chromium, can take many hours to rebuild individually. Rebuilding all-of-NixOS can take days. In distros that can mutate packages without triggering dependency rebuilds, updating 1 line in e.g. glibc, will only rebuild that package, allowing to theoretically distribute such security updates within minutes (if done, see Ubuntu counter-example). The mass-rebuilding is done by NixOS's binary-cache build farm. A new NixOS update is generally only released once the build farm has fully built all dependents. (One can also opt into a "small" channel that releases as soon as only a few core packages are built, which gives you security updates faster for those. But if you do that, your computer will next start compile all huge packages such as Chromium, in parallel to the NixOS build farm already doing that. So usually people don't.) For the recent brotli CVE-2026-111497, the timline was: 2026-10-21 node.js releases its fix for node2shell (caused by brotli) 2026-10-21 19:27 https://github.com/google/brotli/releases#release-v1.2.1 2026-10-22 brotli CVE-2026-111497 gets published 2026-10-22 06:51 PR "brotli 1.2.1" https://github.com/NixOS/nixpkgs/pull/577208 2026-10-22 08:25 PR merged to "staging" that will become rolling "nixos-unstable" in the future 2026-10-23 created https://tracker.security.nixos.org/suggestions/by-id/60353 2026-10-23 created https://github.com/nixos/nixpkgs/issues/577796 2026-10-28 CI has built a nixos-26.05 update that includes it: https://hydra.nixos.org/build/351243680 This is the point where users can install it. 2026-11-02 CI for rolling-release nixos-unstable is still not built, 2 weeks later: https://github.com/NixOS/nixpkgs/pull/577208#issuecomment-6573335016 So in summary: The PR got made within 7 h Review and merge happened within 2 h CI took additional 6 days for stable NixOS 26.05 CI for rolling nixos-unstable is still not finished after 10 days post-merge For our startup, I rebuilt the slice of the world we use on a 16-core CPU within a day or so, without waiting on the NixOS build farm to build all of NixOS, so we got the update significantly faster. Also note that just patching a library in your distro is often not enough. For brotli, lots of upstream package vendor brotli's code. NixOS contributors seem to be quite good at looking at underlying issues, e.g. there's this issue "Tracking vendored Brotli decoders" (nixpkgs#578375) to track that. I am not aware of other distros making such efforts. Thus: In NixOS, security updates are great and fast for leaf packages such as the kernel, but can be slow for many-dependents packages. Much of that can be mitigated by building things yourself, which is easy. Hope this helps.

  3. X@jasondavies · 4 likes · 388 views

    Any 29 cubes, each painted with all four colours, contain 8 that build a 2×2×2 cube with solid faces in exactly three colours. 28 isn't enough. Answers a 2018 question of Berkove, Eickemeyer & Schulman. jasondavies/four-to-three-colour-cubes t.co

  4. X@CupOJoseph · 1 like · 166 views

    PR here: apps-monorepo#1679 tell your agent to review it for me

  5. X@worldeditdev · 12 views

    DeepSeek unveiled dsh-superagent: a coding agent that accepts authorized GitHub events, works in a separate session, and returns PRs to the same thread. deepseek-ai/dsh-superagent-prototype

  6. X@_Mira___Mira_ · 1 like · 83 views

    github.com/Mira-Cult/math/blob/d86405ccea875963fd… We have an existence theorem for 4d prime hypercubes now. Trying to get an all-dimensions theorem now.

  7. X@ashxhart · 34 views

    @pfernan95dev Notarised DMG, signed with Developer ID. Direct download here: github.com/ashhart/TensorFold/releases/tag/app-v1…

  8. Redditu/BowSergio84 · r/flashcarts · 9 points · 3 comments

    This is how I order my games in my DS Pico On the main folder I have the official games, released by Nintendo or other companies, while in the folder called "EXTRA" I have non official games, such as homebrew, hackroms and ports, what do you think? Yeah I don't have many official games, so any recomendation is welcome (I love platform games ❤️). *THE FOLLOWING LINKS DO NOT PROMOTE ANY KIND OF PIRACY, ALL I'M DOING IS SHARING THE PROJECTS TROUGHT GITHUB AND YOUTUBE* Oh, and in case you are interested on some of the stuff that I have, here you have the links: Theme: themes.flashcarts.net Geometry Dash DS: youtu.be Zelda ALTTP DS Port: youtu.be SM64 DSi Port: Hydr8gon/sm64

  9. tried to review some docs changes in my local github-style diff viewer, skepsis (oxidecomputer/skepsis). did not like, thought: hmmm, what I need is a diff mode in my agentic markdown editor

  10. Bluesky@hashfyre.dev · 2 likes

    Bit complicated due to how ATProto works, but you can actually own your data with a PDS bluesky-social/pds

  11. X@jqdsouza · 9 views

    @Johnson_afuye_ Would love your feedback on Beacon! Asymptote-Labs/agent-beacon

  12. Hacker Newsgjvc · 1 point · 1 comment · tackish/pigeoneye

    PigeonEye is a fast, native Kubernetes GUI and CLI Tool

  13. Security release for psqlodbc Security release for psqlodbc The PostgreSQL ODBC project has released version 18.00.0006 to fix multiple security issues see the Changelog for details This email was sent to you from Postgresql ODBC. It was delivered on their behalf by the PostgreSQL project. Any questions about the content of the message should be sent to Postgresql ODBC. You were sent this email as a subscriber of the pgsql-announce mailinglist, for for one of the content tags Related Open Source or Security. To unsubscribe from further emails, or change which emails you want to receive, please click the personal unsubscribe link that you can find in the headers of this email, or visit . Changelog: github.com/postgresql-interfaces/psqlodbc/blob/ma…

  14. X@SUBZERONE01 · 5 likes · 1 repost · 146 views

    SUB-01’s brain model is open source. 🧠 nocontentinhere4-art/sub01-brain

  15. [TIPS] More than 3 years condensed into 1 skill Folks, I already have two bands that generate revenue (not much, but they do). In this skill for Claude Code or ChatGPT, I’ve included all the techniques and lessons I’ve gathered over more than 3 years of working with Suno. I hope it helps you all.

  16. Redditu/catladywitch · r/MVaveFM1 · 4 points · 10 comments · CeliaCasanovas/type-p-fm1

    My FM firmware, Type P.fm1 lol EDIT: link broke because I changed username: it is now AkirakoSaintJust/type-p-fm1 P1Onken Type P.fm1 Hey, it's Akirako Saint-Just from the パンク派第1音響合成研究班, or Punk Faction, Sound Synthesis Research Unit Number 1 (P1Onken for short.) I was a bit anxious about the proliferation of vibecoded firmwares so I wanted to provide a framework that at least provided some rails so that I could maybe help the community create cool synths, avoid slop, and take advantage of the full capabilities of the unit, like the dual-core processor. That framework is called umetate, and I reckon it's pretty advanced, but I still want to work on it a bit before releasing it. I made this synth using umetate to check out whether it works properly, and it looks like it does, so yay. Umetate, by the way, is pronounced oo-meh-tah-teh and means land reclamation, like Odaiba Island in Tokyo for instance. It's also a post-punk song by Zelda about taking a walk around the reclaimed land's industrial landscape every day (please give Zelda's Carnival album a listen if you like post-punk.) I guess it goes with the maritime theme a lot of FM-1 firmwares have, but more industrial and edgy because that's what P1Onken is like. Anyway, besides being a test, Type P is this synth idea I've had forever, and which I've been thinking of for a long time. It's a 2-part, 4-op phase distortion synth with feedback and a bunch of waveforms on every operator. Broadly it's a Yamaha-style synth, but it's not meant to be an emulation of any of them, mostly because the idea comes from the limits I've encountered using actual Yamaha synths and actual emulators. Besides, the DSP is reimplemented from scratch although ymfm and msfa/Dexed were a reference. It's got 2x4-op because I feel like it's the best compromise between ease and power. You can do keyboard splits or send two different sequences in over two different MIDI channels, but the main purpose of having two parts is being able to easily compose complex patches out of partials, just like Wendy Carlos taught us. So it's a 20-voice bitimbral synth if you want, and there are no restrictions for that use case, but I was mostly aiming for a 10-voice, 8-operator synth, without the complexity of having 3 million algorithms and the ability to design your patches incrementally. You've got feedback on every operator, which I feel gives a lot of freedom, and all of the waveforms from the OPL3 and the OPZ (DX11, TX81z), although the pulse, square and saw are a bit different to the OPL3 versions to avoid the nasty aliasing the naive, single-table version gave. Something cool is a sine operator at roughly 30% or 35% feedback will give you a reverse saw, so if you pair that with a saw operator you can do pseudo-PWM tricks if you want. You've also got two (global) multimode filters and a (global) wavefolder. The first filter has an envelope of its own and is meant to help you shape your timbres, whilst the second filter has no envelope and is meant to sift aliasing or harshness out if you feel like you need it. It's got a key follow param so you can make it clamp harder on brighter notes if you find they get to shrill, for instance. The wavefolder is mostly meant for expression, i.e. if you got a patch that swells up, it might cross the wavefolder's threshold at its peak and give you this nice kind of dynamic "breaking point". You can use that for string bow effects, for instance. Or of course, simply as a source of grime and distortion. 2 or 3 folds add distorted harmonics, 4 folds is noisy, and going beyond that is proper noise. I prioritised those effects over delay, reverb, chorus and so on because I felt they were the most useful for sound design. If the complexity and computing budget won't allow for modulated delay, reverb, etc., I feel like having them on board doesn't make a lot of sense over just using whatever external VST or pedal you like most. Oh, so this is a sound design-focused synth. I wanted whatever implementation of my dream phase modulation synth the FM1 and umetate allowed for, rather than a groovebox which isn't my thing, so there is no sequencer. You can implement your own if you want though! Bug reports and any suggestions are welcome. Phase on, industrial punks!

  17. X@Xero_vrc · 20 views

    Just released Weight Space Programming, an agent skill inspired by @rikiyatakehi’s research. Inspect neural weights, make reversible edits, and test targeted fixes without training. xero00000/weight-space-programming%E2%81%A0 #AI #AIAgents #OpenSource

  18. Redditu/urbantechgoods · r/browsers · 14 points · 1 comment

    Got past netflix PIP blocking in chrome Im a software engineer with a big gap on my resume so I've been releasing a lot of open source work to fill it. This is a really tiny one that gets PIP with chrome working on netflix so you can watch movies while using your other windows without a second screen. This is the chrome webstore link chromewebstore.google.com And this is the code on github danielyaa5/netflix-pip-fixer

  19. X@vincit_amore · 3 likes · 40 views

    We have some new features coming in the near future and I will make sure to keep the plugin update with everything as well. Tbh, after only a day I think this is legit now my preferred way of firing the cannon with an agent outside of the site itself vincitamore/hermes-slopcannon

  20. X@Statik_Kill · 34 views

    Meet Vitrine 👋 A free, open-source Quick Look app for the Mac. Press Space on a file in Finder and see inside it properly: Markdown with diagrams, code in colour, CSV and SQLite as tables, archives, notebooks. Repo: XBTDMT/vitrine t.co

  21. Redditu/ziodertn · r/diabrowser · 93 points · 18 comments

    WinDiaTweaks: UI tweaks for Dia on Windows to bring back what we miss from Arc A Windows take on u/JaceThings 's DiaTweaks for Mac. It adds a Patches page to Dia’s Settings to hide the toolbar, go edge to edge, hide buttons, add an Arc-style sidebar URL bar, and more. How it works: a small add-on hooks into Dia’s WinUI interface through WinUI’s own diagnostics API, the same one Visual Studio’s Live Visual Tree uses, and restyles the UI live. Dia’s files are never modified. zioder/WinDiaTweaks PRs are welcome to add what is missing!

  22. X@pzfreo · 1 like · 16 views

    @JasBilyeu Specify is already helping AI to define tolerances and update step files with GD & T. I'm just looking at assemblies and I will add stack - ups into that set of requirements. Thanks! pzfreo/specify-core

  23. X@alxshp · 5 likes · 34 views

    github.com/pgrundev

  24. X@shanbatla · 30 views

    @emanuelsa @mitchellh Pretty sure lobsters is a rails app. [1] And, at least according to the rails subreddit, not a very good one. [2] [1]lobsters/lobsters [2] reddit.com

  25. X@sebacultrera · 1 like · 1 repost · 27 views

    11/11 — Paper & Code 📄 Paper: biorxiv.org 💻 Code: rickconci/GENESIS Feedback/thoughts are very welcome! @TBaharav @JiaqiZhangVic @uthsavc @jlaffy @jacksonweir4 @lucapinello @jkobject @arturszalata @doralidsy @JoshuaPickard_

  26. X@_Mira___Mira_ · 1 like · 84 views

    github.com/Mira-Cult/math/blob/0ccdf80011eb57ae85… Generalizes to Gaussian and Eisenstein prime squares and cubes. The prime square bound is down to 2^23, and Astra thinks they found a way to get to 2^20 or 2^19. Starting to get to the range we can brute-force it. Prime cube bound is at 2^67150. t.co

  27. X@Awisone · 117 views

    @map6874 github.com/Awis13/liberty-pro-max/releases For mac it is as easy as download a windows version and run a script to translate it to arm instructions

  28. X@AviralTrip2503 · 1 like · 17 views

    @Isaiahzxz As a backend dev and someone who's shitty at UI & designing, this has been really helpful. ga14ctic/awwwards-skill

  29. X@Xero_vrc · 1 like · 49 views

    @rikiyatakehi @a1zhang @lateinteraction @jayden_teoh_ xero00000/weight-space-programming I made a reusable agent skill based on your paper awesome stuff

  30. YouTubeDHIVAKAR VIEWS · YouTube description · 1 like · 14 views

    Rover Explorer: A Windows XP-Style File Explorer for Linux and Windows Rover Explorer is a Windows XP-style file explorer for Linux and Windows, with the search companion dog, and search that is actually instant. Open source (MIT) and free. ⬇️ Download GitHub (Linux .deb and portable, Windows installer and portable): github.com/Dhiva-Labs/rover_explorer/releases/lat… Snap Store: snapcraft.io sudo snap install rover-explorer Source: Dhiva-Labs/rover_explorer ✨ What's inside • Classic XP Luna look: gradient toolbar, menu bar (File, Edit, View, Go, Tools, Help), beige dialogs and sunken fields • Common Tasks pane, a lazily-loaded Folders tree, and an address bar with a recent-locations drop-down • Details and icons views, sortable columns, folders grouped first • Instant search: a background index answers on every keystroke across hundreds of thousands of files • Ranked matches (exact, prefix, word start, anywhere), and extra words that match anywhere in the path • Filters for folders, pictures, music, videos and documents, plus "only in current folder" • The search companion dog, an original character drawn in code: he barks, reads, digs, chases a ball, sniffs while you search and brings a bone when results land • Cut, copy, paste, rename, delete, new folder, multi-select, drag and drop, and a Properties dialog that counts sizes in the background • The index is cached to disk, so the next launch searches instantly • Works offline and sends nothing anywhere Rover Explorer is an independent project and is not affiliated with or endorsed by Microsoft. No Microsoft artwork, icons or audio are used. ⏱️ Chapters 0:00 Why file explorers feel broken 0:14 Meet Rover Explorer 0:30 Panes, address bar and instant search 0:45 Ranked results and the search dog 1:02 File management, cache and privacy 1:18 Open source and download 💚 Support Dhiva Labs: sponsors/Dhiva-Labs Original music made for this video. #OpenSource #Linux #FileManager

  31. Fun fact, it is generated from LaTeX, using a simple #fsharp tool that I mostly wrote before the AI era (practically a curious historical artifact now!) github.com/tpetricek/tomasp.net/blob/master/sourc…

  32. Redditu/ransomusername42 · r/smartcontracts · 1 point · 2 comments

    Where would you attack this? Proof-of-work claims with a seed built from the previous month's claims I'd like to hear attack ideas on the design of a contract I've deployed on Polygon. It's immutable and hasn't had an external audit. - A claim's hash covers the month's seed, the month, the recipient and a nonce, so a pending proof can't be redirected to another address. - Each month's seed is an accumulator of all the claims from the previous month. - Each address gets one mined claim per month, and difficulty rises as minting gets ahead of schedule. Two weaknesses I already know about: - Seeds can be public before a month starts, which allows some pre-mining and a burst at opening. I accepted that. - Fresh addresses get around the per-address limit. I've done this myself, for 79 of the 87 tokens so far. Is there anything worse I've missed? Could someone influence the seed at the end of a quiet month, for example? Source: TheophileWalter/ArtPoW Contract: polygonscan.com English isn't my first language, so I used an LLM to help write this post. Edit: You can now get the NFT without paying anything. Your browser still does the mining, but a relay sends the transaction and pays the gas, so you don't need any POL. If you don't have a wallet, you can create one with just an email. The relay can only mint to the address in your proof. You'll only need a little POL if you later want to transfer or sell the token.

  33. @Decentralizd 1 minute blocks are a terrible idea. Just use SuperScalar for instant settlement and privacy. 8144225309/superscalar

  34. Redditu/ghettoblastahx · r/13Node · 1 point

    He publicado un campo de Filament para escribir diagramas Mermaid con vista previa en vivo (MIT) En los paneles de Filament que hacemos para clientes siempre aparece la misma petición: ver cómo fluye algo (estados de un pedido, aprobaciones, onboarding), no solo los registros. Los diagramas en una wiki se quedan desfasados enseguida, así que hicimos un campo que los mantiene junto a los datos. filament-mermaid-field permite escribir sintaxis Mermaid en un formulario y verla renderizada mientras escribes. - Renderizado en tiempo real - Zoom y desplazamiento - Respeta el tema claro/oscuro de Filament - Carga diferida - Traducciones ES/EN - Filament 5 sobre Laravel 11, 12 y 13; rama 2.x para Filament 3 ​ composer require trecenode/filament-mermaid-field Código: trecenode/filament-mermaid-field Documentación: 13node.com Licencia MIT. ¿Qué otros campos echáis de menos en Filament? Tenemos varias ideas en cola y nos sirve saber qué usaríais. *Somos 13Node, desarrollamos paneles y herramientas internas con Laravel y Filament.*En los paneles de Filament que hacemos para clientes siempre aparece la misma petición: ver cómo fluye algo (estados de un pedido, aprobaciones, onboarding), no solo los registros. Los diagramas en una wiki se quedan desfasados enseguida, así que hicimos un campo que los mantiene junto a los datos. filament-mermaid-field permite escribir sintaxis Mermaid en un formulario y verla renderizada mientras escribes. Renderizado en tiempo real Zoom y desplazamiento Respeta el tema claro/oscuro de Filament Carga diferida Traducciones ES/EN Filament 5 sobre Laravel 11, 12 y 13; rama 2.x para Filament 3 composer require trecenode/filament-mermaid-field Código: trecenode/filament-mermaid-field Documentación: 13node.com Licencia MIT. ¿Qué otros campos echáis de menos en Filament? Tenemos varias ideas en cola y nos sirve saber qué usaríais. Somos 13Node, desarrollamos paneles y herramientas internas con Laravel y Filament.

  35. Cool, thanks 😄 Tip: over stdio the server starts without a token, so a client can list the tools and you see its schema and error handling. HTTP is stateless JSON, no SSE, likely where clients differ. Results also in #14 please: agent-postbox#14

  36. Redditu/urbantechgoods · r/SideProject · 2 points · 2 comments

    I wrote a tiny extension for chrome so you can use PIP with Netflix Im a software engineer with a big gap on my resume so I've been releasing a lot of open source work to fill it. This is a really tiny one that gets PIP with chrome working on netflix so you can watch movies while using your other windows without a second screen. This is the chrome webstore link chromewebstore.google.com And this is the code on github danielyaa5/netflix-pip-fixer

  37. Goravel request data: params, query and JSON body Part 3 of the Goravel series. The original on DevChalk has the colour-matched code, the figures and the full diffs. Code for this part: krishankumar01/goravel-taskflow/tree/part-03. Our routes answer, but they do not read anything the client sends. A client can send data in three places: the URL path, the query string and the request body. In this part we read all three. Start from the Routing & Responses code: git clone https://github.com/krishankumar01/goravel-taskflow cd goravel-taskflow git checkout part-02 cp .env.example .env go run . artisan key:generate docker compose up -d go install github.com/air-verse/air@latest air Route parameters To get one task, the client puts its id in the path, like /api/v1/tasks/5. The id is different on every request, so the route needs a placeholder instead of a fixed number. Add a Show method to TaskController: app/http/controllers/task_controller.go // ... 16 lines not shown func (r *TaskController) Store(ctx http.Context) http.Response { return ctx.Response().String(200, "task created") } + +func (r *TaskController) Show(ctx http.Context) http.Response { + id := ctx.Request().RouteInt("id") + + return ctx.Response().Json(200, map[string]any{ + "id": id, + }) +} And its route in routes/api.go: routes/api.go // ... 9 lines not shown func Api() { taskController := controllers.NewTaskController() facades.Route().Prefix("api/v1").Group(func(router route.Router) { router.Post("tasks", taskController.Store).Name("tasks.create") + router.Get("tasks/{id}", taskController.Show) }) } The {id} in the path is a route parameter. It matches any value in that part of the path. In the handler, RouteInt reads that value by the same name, "id", and returns it as a number. The two names have to match. Two other methods read the same value as other types: - Route("id") returns it as a string. - RouteInt64("id") returns it as an int64. Add a request for it: requests.http ### Create task POST http://localhost:3000/api/v1/tasks +### Show task +GET http://localhost:3000/api/v1/tasks/5 + ### Hello GET http://localhost:3000/hello Run it, or use curl: $ curl http://localhost:3000/api/v1/tasks/5 {"id":5} If the id is not a number, RouteInt does not return an error. It returns 0: $ curl http://localhost:3000/api/v1/tasks/abc {"id":0} This API should reject that. We add that check later, with validation. Query strings To list tasks, the client may want only some of them, or one page at a time. Options like these go in the query string, the part of the URL after the ?, as in /api/v1/tasks?status=done&page=2. Each option is a key and a value, and & separates them. The code reads each one by its key, so the names have to match. Add an Index method for the list, and its route: app/http/controllers/task_controller.go // ... 27 lines not shown + +func (r *TaskController) Index(ctx http.Context) http.Response { + status := ctx.Request().Query("status") + page := ctx.Request().QueryInt("page", 1) + filters := ctx.Request().QueryMap("filters") + + return ctx.Response().Json(200, map[string]any{ + "status": status, + "page": page, + "filters": filters, + }) +} routes/api.go // ... 9 lines not shown func Api() { taskController := controllers.NewTaskController() facades.Route().Prefix("api/v1").Group(func(router route.Router) { router.Post("tasks", taskController.Store).Name("tasks.create") router.Get("tasks/{id}", taskController.Show) + router.Get("tasks", taskController.Index) }) } - Query reads "status" as a string. If there is no status, you get an empty string. - QueryInt reads "page" as a number. Its second argument, 1, is the default when there is no page. - QueryMap collects the keys that start with "filters", like filters[priority], into one map. Add a request with all three: requests.http ### Create task POST http://localhost:3000/api/v1/tasks ### Show task GET http://localhost:3000/api/v1/tasks/5 +### List tasks +GET http://localhost:3000/api/v1/tasks?status=done&page=2&filters[priority]=high + ### Hello GET http://localhost:3000/hello With curl, add -g. Without it, curl reads the square brackets as a pattern and stops with curl: (3) bad range in URL: $ curl -g "http://localhost:3000/api/v1/tasks?status=done&page=2&filters[priority]=high" GET /api/v1/tasks?status=done&page=2&filters[priority]=high { "filters": { "priority": "high" }, "page": 2, "status": "done" } The default is used only when page is missing. A page that is not a number gives 0, the same as RouteInt: $ curl http://localhost:3000/api/v1/tasks {"filters":{},"page":1,"status":""} $ curl "http://localhost:3000/api/v1/tasks?page=abc" {"filters":{},"page":0,"status":""} Other ways to read the query string: | Method | Query string | Returns | |---|---|---| | QueryInt64("big") | ?big=9007199254740993 | 9007199254740993 as an int64 | | QueryBool("done") | ?done=true | true | | QueryArray("tag") | ?tag=api&tag=urgent | ["api","urgent"] | | Queries() | ?tag=api&tag=urgent&page=2 | {"page":"2","tag":"api,urgent"} | | BindQuery(&query) | ?status=done&page=2 | a struct with Status and Page filled in | - QueryBool also reads 1, yes and on as true. Anything else is false. - Queries joins a key that repeats into one string. - BindQuery fills a struct from the query string, using form tags. The next section shows how binding into a struct works. The request body Creating a task sends more data: a title and a description. That goes in the request body, usually as JSON. Goravel can read the whole body into a struct. Change Store, the handler of POST /tasks: app/http/controllers/task_controller.go package controllers import ( "github.com/goravel/framework/contracts/http" ) + +type CreateTaskRequest struct { + Title string `form:"title" json:"title"` + Description string `form:"description" json:"description"` +} // ... 10 lines not shown func (r *TaskController) Store(ctx http.Context) http.Response { - return ctx.Response().String(200, "task created") + var request CreateTaskRequest + if err := ctx.Request().Bind(&request); err != nil { + return ctx.Response().Json(400, map[string]any{ + "error": err.Error(), + }) + } + + return ctx.Response().Json(200, request) } // ... 20 lines not shown CreateTaskRequest describes the body we expect. The tags tell Goravel which key goes into which field: - json:"title" reads the title key from a JSON body into Title. - form:"title" does the same for a form body. With both tags, one struct works for both. Bind fills the struct from the body. We pass &request, the address of the struct, so that Bind can write into it. If a value has the wrong type, or the JSON is broken, Bind returns an error and we answer with 400. For now the handler sends the data back, because there is no tasks table to save it in yet. The request now needs a body, and a header that says the body is JSON: requests.http ### Create task POST http://localhost:3000/api/v1/tasks +Content-Type: application/json + +{ + "title": "Ship v1", + "description": "The first release" +} ### Show task GET http://localhost:3000/api/v1/tasks/5 # ... 6 lines not shown Run it, or use curl: $ curl -X POST http://localhost:3000/api/v1/tasks \ -H "Content-Type: application/json" \ -d '{"title":"Ship v1","description":"The first release"}' POST /api/v1/tasks { "title": "Ship v1", "description": "The first release" } A form body gives the same result, because of the form tags: $ curl -X POST http://localhost:3000/api/v1/tasks -d "title=Ship v1&description=The first release" POST /api/v1/tasks { "title": "Ship v1", "description": "The first release" } A value of the wrong type fails with 400: $ curl -X POST http://localhost:3000/api/v1/tasks \ -H "Content-Type: application/json" \ -d '{"title":5}' POST /api/v1/tasks { "error": "json: cannot unmarshal number into Go struct field CreateTaskRequest.title of type string" } Broken JSON, like a body that stops halfway, also gives 400, but the message does not say what is wrong: $ curl -X POST http://localhost:3000/api/v1/tasks \ -H "Content-Type: application/json" \ -d '{"title":' POST /api/v1/tasks { "error": "http: invalid Read on closed Body" } The real reason is in Goravel's log file for the day, storage/logs/goravel-<date>.log: [2026-10-22 20:42:36.254] local.error: decode json [{"title":] error: unexpected end of JSON input > Gotcha Send the same JSON without the Content-Type header. You get 200 OK with an empty title and description, and no error. Bind reads the body based on this header. Without -H, curl labels the body as a form, so Bind looks for form fields and finds none. If a body ever comes back empty, check this header first. > > ```bash > $ curl -X POST localhost \ > -d '{"title":"Ship v1","description":"The first release"}' > {"title":"","description":""} > ``` Other ways to read the body: Bind reads the whole body at once. To read one value, use Input. For this JSON body: {"title":"Ship v1","estimate":3,"urgent":true,"tags":["api","urgent"],"meta":{"priority":"high"}} | Method | Returns | |---|---| | Input("title") | "Ship v1" | | Input("missing", "none") | "none" | | Input("meta.priority") | "high" | | InputInt("estimate") | 3 | | InputBool("urgent") | true | | InputArray("tags") | ["api","urgent"] | | InputMap("meta") | {"priority":"high"} | | All() | the whole body as a map | - The second argument of Input is a default for a missing key. - A dot reads a key inside an object. - Input and All also read the query string, not only the body. - Without the Content-Type header, none of these can read the body. Here are all three requests together, with the code that reads each piece: Interactive figure on DevChalk: Where a request carries data, and the code that reads each piece. GET /api/v1/tasks/5: RouteInt("id") reads 5. GET /api/v1/tasks?status=done&amp;page=2&amp;filters[priority]=high: Query("status") reads "done", QueryInt("page", 1) reads 2, QueryMap("filters") reads {"priority":"high"}. POST /api/v1/tasks with a JSON body and Content-Type: application/json: Bind fills Title "Ship v1" and Description "The first release". Without the header, Bind fills nothing and the API still answers 200 OK with empty values. Listing routes The API now has three task routes: $ go run . artisan route:list GET|HEAD / ................................... taskflow/routes.Web.func1 GET|HEAD api/v1/tasks taskflow/app/http/controllers.(*TaskController).Index POST api/v1/tasks tasks.create › taskflow/app/http/controllers.(*TaskController).Store GET|HEAD api/v1/tasks/{id} taskflow/app/http/controllers.(*TaskController).Show GET|HEAD hello ............................... taskflow/routes.Web.func2 STATIC public ........................................................ GET|HEAD users ... taskflow/app/http/controllers.(*UserController).Index Showing [7] routes GET and POST on api/v1/tasks are two different routes. Goravel picks one by the method of the request. TaskFlow's routes now read the path, the query string and the body. Nothing is saved yet, because there is no database. --- Previous: 02. Routing & Responses Next: 04. Models & Migrations Series: Goravel

  38. Zephyr is free and open source, and everything it does today stays free. We'll add optional paid extras later, starting with file sync, but nothing you use today will ever move behind a paywall. Code's on GitHub: litsdm/zephyr

  39. YouTubeDHIVAKAR VIEWS · YouTube description · 1 like · 8 views

    NearShare: Send Files Between Linux and Android Phones (Open Source) NearShare is an open-source (MIT) file-sharing app for Linux. It speaks the Quick Share protocol, so you can send and receive files with nearby Android phones. No cables, no cloud account, and no companion app on the phone. Devices find each other over your Wi-Fi, every transfer is encrypted, and both screens show the same four-digit PIN. NearShare is an independent project. Not affiliated with Google or Samsung. Quick Share and Nearby Share are trademarks of their owners and are used here only to describe compatibility. ⬇️ Install Source and docs: Dhiva-Labs/NearShare Snap Store: snapcraft.io sudo snap install nearshare sudo snap connect nearshare:bluez sudo snap connect nearshare:network-manager Ubuntu PPA: sudo add-apt-repository ppa:dhiva-labs/apps sudo apt install nearshare There is no GitHub release yet; the README also covers running it from source. ✨ What's inside • Nearby devices appear in the app when their Quick Share screen is open on the same Wi-Fi (mDNS discovery) • Send several files at once, with live progress, speed and time left • UKEY2 key exchange, AES-256 encryption, and a four-digit PIN you confirm on both screens • Receive from a phone: turn on visibility, a Bluetooth beacon nudges nearby Android phones, and you accept or decline each transfer • Right-click "Send with NearShare" in the Files app and a Ctrl+Alt+N visibility shortcut (PPA/.deb build; the snap adds an Open With entry instead), plus a nearshare command line • Experimental Direct mode: NearShare starts its own Wi-Fi hotspot and shows a QR code to join, for when there is no shared network • Python, GTK4 and libadwaita; Ubuntu/GNOME target, snap for x64 Limits, honestly: same network (or Direct mode) only, the other device's Quick Share screen must be open to send to it, and every transfer needs a PIN check. ⏱️ Chapters 0:00 Moving files between phone and Linux is a pain 0:16 Meet NearShare: discovery and sending 0:40 Encrypted, PIN-confirmed, and receiving from a phone 0:58 Right-click, command line and Direct mode 1:12 Linux, open source and how to install 💚 Support Dhiva Labs: sponsors/Dhiva-Labs Original music made for this video. #Linux #OpenSource #Ubuntu

  40. Bluesky@codecaine.bsky.social · 2 likes

    Codecaine MLX RAD AI Audio Studio v1.0 is live! 🎙️⚡ 100% local Mac Apple Silicon AI: Phonon & Fish S2 TTS, zero-shot voice cloning, 2s EPUB silent export, Read-Along Karaoke & Phonon 2.5 ASR. 🎬 Demo: youtube.com 📦 codecaine-zz/mlx-audio-swift #ai #voice #devs #macos #apple #tools

  41. X@ranuk_dev · 6 views

    The old scraper hit 3‑minute stalls whenever a catalog page had a lazy‑loaded image grid. I wired Firecrawl to fire a headless Chrome, wait for the IntersectionObserver callbacks, and stream the DOM snapshot straight to a CSV. RanuK12/firecrawl-ecom-scraper

  42. X@achetronic · 34 views

    🚨 A los que usen Keycloak para flujos CIMD Han mezclado mi fix en upstream keycloak#51235 En la próxima versión, se ignoran los campos desconocidos en la tarjeta remota CIMD así que ChatGPT dejará de fallar 🫂 Atento y actualiza

  43. X@Kurotox_ · 45 views

    @Tarendracestmoi @cmoisamii github.com/Djihads80/Eglantine/releases prend la derniere version

  44. Redditu/senborn_kuchiki · r/ClashOfClans · 174 points · 96 comments

    Clash of Clans Update widget that is Open Source I built Clash Ledger, a free, open-source Android app and home screen widget for tracking Clash of Clans upgrades. I was inspired by another upgrade widget posted here and wanted to make an alternative that anyone could download and contribute to. After feedback from the comments, I've added multiple village support, a compact widget, new themes, better artwork, more boosts, helper support, countdown options, and easier imports. 𝗪𝗵𝗮𝘁 𝗶𝘁 𝗱𝗼𝗲𝘀: • 𝗛𝗼𝗺𝗲 𝘀𝗰𝗿𝗲𝗲𝗻 𝘄𝗶𝗱𝗴𝗲𝘁: See builder availability, active upgrades, target levels, progress bars, and finish times. Resize the widget and scroll through your upgrades without opening the game. • 𝗖𝗼𝗺𝗽𝗮𝗰𝘁 𝘄𝗶𝗱𝗴𝗲𝘁 𝗺𝗼𝗱𝗲: A smaller layout showing upgrade icons with progress rings and countdowns, without scrolling. Resize it to display more upgrades. A "+N more" indicator appears when some upgrades don't fit. • 𝗠𝘂𝗹𝘁𝗶𝗽𝗹𝗲 𝘃𝗶𝗹𝗹𝗮𝗴𝗲𝘀: Save and manage multiple Clash of Clans accounts in one app. Each village keeps its own upgrades, timers, potions, helpers, and reminders. Importing another village won't replace your existing accounts. • 𝗦𝘄𝗶𝘁𝗰𝗵 𝘃𝗶𝗹𝗹𝗮𝗴𝗲𝘀 𝗳𝗿𝗼𝗺 𝘁𝗵𝗲 𝘄𝗶𝗱𝗴𝗲𝘁: Switch between your saved villages directly from the home screen widget using the ⇄ button beside refresh, without opening the app. • 𝗛𝗼𝗺𝗲 𝗩𝗶𝗹𝗹𝗮𝗴𝗲 𝗮𝗻𝗱 𝗕𝘂𝗶𝗹𝗱𝗲𝗿 𝗕𝗮𝘀𝗲: Track builders, heroes, Laboratory research, pets, and Star Laboratory research. Goblin builder and researcher jobs are kept separate from normal slots. • 𝗡𝗲𝘅𝘁 𝗿𝗲𝘀𝗲𝗮𝗿𝗰𝗵 𝘁𝗶𝗺𝗲𝗿: See when your Laboratory will be available for the next research. The Builder Base tab also shows when your Star Laboratory becomes free. • 𝗜𝗺𝗽𝗼𝗿𝘁 𝘆𝗼𝘂𝗿 𝘃𝗶𝗹𝗹𝗮𝗴𝗲: Copy the in-game export from Settings → More Settings → Data Export, then paste it into the app. You can also open a saved JSON file or use Share → Clash Ledger. Preview the imported data before saving it. • 𝗣𝗼𝘁𝗶𝗼𝗻𝘀 𝗮𝗻𝗱 𝘀𝗻𝗮𝗰𝗸𝘀: Track Builder Potions, Research Potions, Pet Potions, Builder Bite, Clock Tower boosts, and Study Soup. Record an item after using it in-game, adjust its remaining time, or end a tracked boost. • 𝗕𝘂𝗶𝗹𝗱𝗲𝗿'𝘀 𝗔𝗽𝗽𝗿𝗲𝗻𝘁𝗶𝗰𝗲 𝗮𝗻𝗱 𝗟𝗮𝗯 𝗔𝘀𝘀𝗶𝘀𝘁𝗮𝗻𝘁: Import active helper assignments and include their work in completion estimates. You can correct assignments manually and optionally forecast future repeat sessions. • 𝗘𝘃𝗲𝗻𝘁 𝗮𝗱𝗷𝘂𝘀𝘁𝗺𝗲𝗻𝘁𝘀: Apply an optional speed multiplier to a selected upgrade category. Leave this off if your exported timer already includes the event discount. • 𝗧𝗵𝗿𝗲𝗲 𝗰𝗼𝘂𝗻𝘁𝗱𝗼𝘄𝗻 𝘀𝘁𝘆𝗹𝗲𝘀: Compact days/hours/minutes, friendly wording, or a clock that always shows ticking seconds. Each upgrade has one countdown. • 𝗖𝗼𝗺𝗽𝗹𝗲𝘁𝗶𝗼𝗻 𝗿𝗲𝗺𝗶𝗻𝗱𝗲𝗿𝘀: Choose quiet notifications, notification sounds, or an alarm tone, with optional vibration and controls for individual upgrade categories and boost expiries. Reminders work across all your saved villages. • 𝗠𝗮𝗻𝘂𝗮𝗹 𝘁𝗶𝗺𝗲𝗿 𝗰𝗼𝗻𝘁𝗿𝗼𝗹𝘀: Add, edit, mark ready, or remove tracked upgrades. • 𝗣𝘂𝗿𝗲-𝗯𝗹𝗮𝗰𝗸 𝗢𝗟𝗘𝗗 𝘁𝗵𝗲𝗺𝗲: Choose between the original navy theme and a pure-black OLED theme. Both the app and home screen widgets support the new theme. • 𝗖𝗹𝗮𝘀𝗵 𝗮𝗿𝘁𝘄𝗼𝗿𝗸: Bundled building, hero, troop, pet, spell, trap, and Town Hall images work offline. Updated artwork includes proper icons for Logger, Longshot, Smasher, Totem Spell, Giga Bomb, and more. • 𝗢𝗳𝗳𝗹𝗶𝗻𝗲 𝗮𝗻𝗱 𝗽𝗿𝗶𝘃𝗮𝘁𝗲: No account, ads, analytics, or internet permission. Your village data stays on your device. Supports Android 8.0+. 𝗗𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝘁𝗵𝗲 𝗔𝗣𝗞 𝗱𝗶𝗿𝗲𝗰𝘁𝗹𝘆 𝗼𝗻 𝘆𝗼𝘂𝗿 𝗽𝗵𝗼𝗻𝗲: github.com/chitti-a7r4/coc-tracker/releases/latest Expand Assets, download the .apk, and install it. You don't need Android Studio or a computer. 𝗦𝗼𝘂𝗿𝗰𝗲 𝗰𝗼𝗱𝗲, 𝘀𝗰𝗿𝗲𝗲𝗻𝘀𝗵𝗼𝘁𝘀, 𝗮𝗻𝗱 𝗶𝗻𝘀𝘁𝗿𝘂𝗰𝘁𝗶𝗼𝗻𝘀: chitti-a7r4/coc-tracker A few things to know: countdowns continue after import, but new actions in-game still need a fresh export or manual edit. The public API doesn't provide these active upgrade timers. Repeating helper sessions are optional forecasts, and automatic Pet Potion import is still being verified—manual Pet Potion tracking is available. I've personally tested it with my TH16 village. Feedback from other Town Hall levels, phones, and launchers would help, especially if you spot a timer mismatch. Thanks to everyone who has shared suggestions and tested the app! Seeing a reply from the official Clash account honestly made my day ❤️ This is an unofficial fan project and isn’t endorsed by Supercell.

  45. Redditu/leandro_damascena · r/aws · 13 points · 3 comments

    I built rboto: async-only, fully typed Python clients for 34 AWS services, powered by Rust About a year ago, I had an idea for a Python ORM for DynamoDB. I wanted a good developer experience, async support, and strong typing, but I also wanted to move expensive work out of the Python layer. That became pydynox, with a Rust core handling serialization and other CPU-heavy work. More recently, I started thinking about the SDK underneath applications that use several AWS services. Especially with agents, a workflow might combine model calls with documents in S3, state in DynamoDB, and messages in SQS. Async calls and clear input and output types matter there too. Whether a developer or a coding agent writes the code, I want a type checker to help catch mistakes. So I built rboto. rboto 0.1.0 is now on PyPI — its first official release. It provides async-only Python clients powered by Rust, with 34 service clients available, including S3, DynamoDB, Lambda, SQS, Bedrock Runtime, EventBridge, Scheduler, and Pipes. It’s still alpha. The API may change. I’ll try to preserve compatibility where possible and document breaking changes. Install the services you need: pip install "rboto[s3,dynamodb]==0.1.0" Here’s a small example fetching object metadata and a DynamoDB item concurrently. It assumes configured AWS credentials and an existing bucket and table: import asyncio from rboto import DynamoDBClient, S3Client async def main() -> None: s3 = S3Client(region="us-east-1") dynamodb = DynamoDBClient(region="us-east-1") document, user = await asyncio.gather( s3.head_object( bucket="my-bucket", key="documents/report.pdf", ), dynamodb.get_item( table_name="users", key={"pk": {"s": "USER#123"}}, ), ) print(document.content_length) print(user.item) if __name__ == "__main__": asyncio.run(main()) The method arguments and returned objects have built-in types. Your editor knows that document.content_length is int | None, for example. There’s no separate package of type stubs to install. A few things included in this release: - Typed inputs, outputs, service exceptions, and async paginators. - Async byte streams and event streams for supported operations. - Global JSON logging with per-service controls, and async interceptors. - Pydantic and dataclass usage patterns for application-defined inputs and outputs, without requiring Pydantic. - Wheels for Python 3.12–3.15 on Linux and macOS, including ARM64 and musl Linux. Network requests run on Tokio. Regular outputs stay in Rust until their fields are accessed, and response bodies can be consumed in chunks. There’s still synchronous work in input conversion, response materialization, and callbacks; reducing copies and event-loop pauses with larger payloads is ongoing work. I’m excited to get this first release out and hear from people using it in their own applications. Which service or workflow would you try first? Where does the API feel awkward? GitHub · Documentation · PyPI rboto is an independent project maintained by Ferrumio, not affiliated with or endorsed by Amazon Web Services.

  46. X@jonymusky · 5 likes · 381 views

    El INDEC tiene API nueva (api.indec.gob.ar) y le armé una skill para agentes de IA. Le preguntás a Claude Code, Cursor o Codex "¿cuánto dio la inflación los últimos 6 meses?" y va solo a la fuente oficial. npx skills add jonymusky/indec-api-skill jonymusky/indec-api-skill

  47. X@sirfangexe · 1 like · 42 views

    @HenriGL_ github.com/astralbeexd/Eglantine-3060Ti-16GB/rele… Tenta esse link e baixa a versão de 65MB, extrai e starta normalmente que ja vem configurado

  48. Your RAG Finds Some of the Answer. I Tested 5 Chunking Strategies From This Month's Papers to See Who Finds All of It. Most RAG dashboards report a number that sounds like success: "the right document was in the top 5." That is partial recall: at least one relevant passage made it into the context. Real questions rarely need one passage. They need a rule and the definition it depends on, or a limit and its exception. If retrieval finds one of the two, the model writes a confident answer from half the evidence, and a hit-rate metric scores it as a success. The metric that catches this is complete-evidence recall. For a question q with evidence spans E(q) and an assembled context C(q): partial(q) = 1 if ∃ e ∈ E(q) : e ⊆ C(q) complete(q) = 1 if ∀ e ∈ E(q) : e ⊆ C(q) Between mid-September and the end of October 2026, several papers attacked this gap from the chunking side. Some optimise chunk boundaries directly, some follow the document's own structure, and some build a graph over chunks. I implemented the core idea of each one in plain JavaScript and added them as a new page to my browser-native Advanced Local RAG demo: the Chunking Lab. !Chunking Lab overview Everything runs in your tab. There is no server, no API key and no model download. Retrieval is BM25 only, so every number in this post is deterministic and reproducible from a URL. A full run (parse, five chunkers, two retrieval modes, all metrics) takes about 11 ms in Node 22. --- The research QESChunker (arXiv 2610.36557, Oct 27) treats chunking as supervised optimisation. Given question–evidence (QE) pairs, human-written or LLM-generated, it picks the chunk boundaries that maximise how much evidence ends up retrievable. Without overlap, the objective decomposes over chunks and dynamic programming finds the exact optimum in polynomial time. With overlap, the objective is monotone submodular. Exact optimisation is then NP-hard, but greedy selection comes with a (1 − 1/√e) approximation guarantee. StrucChunk (arXiv 2610.26313, Oct 19) uses the structure the author already wrote. It treats a document as a graph of provisions, never cuts across a clause boundary, resolves cross-references ("see Section 4.2") before embedding, and fuses BM25 with dense retrieval through Reciprocal Rank Fusion. On LegalBench-RAG, Char-Recall@8 goes from 23.59% to 48.18%. On one corpus, Recall@5 rises from 0.557 to 0.804, and the authors attribute 88% of that gain to chunking alone. SpectRAG (arXiv 2610.36991, Oct 27) stops treating chunks as independent. It builds a weighted graph over chunks (adjacency, section hierarchy, shared entities, citations), seeds it from hybrid search, propagates relevance, and assembles a context under a fixed token budget. The goal is a context that is relevant, diverse, connected and sufficient. The Bottleneck Is Retrieval, Not Reading (arXiv 2610.26951, Oct 18) supplies the diagnosis. Across ten frontier and three open-weight models, retrieval reliably surfaces some of the relevant chunks but not all of the chunks a multi-fact question needs. Chunking also strips the document-level context that resolves references between passages. Three September papers frame the rest: - Pre-retrieval Query Clustering for Adaptive Top-k (arXiv 2609.13489) picks retrieval depth per query cluster, reporting over 36% better F1 and 14% fewer tokens on easy clusters. Context size is a per-query variable. - Parser, Chunking, and Embedding Interactions (arXiv 2609.31660) runs a 54-configuration factorial study and finds parser and chunker choices interact, with no single retriever winning everywhere. - Re-ranking and Late Interaction Drive Retrieval Quality (arXiv 2609.38473) compares six pipelines over about 464,000 papers and finds the biggest levers after first-stage retrieval. The main demo already has a cross-encoder reranker for that. --- The test bed The corpus is a fictional observatory handbook, deliberately written like a policy document: | Property | Value | |---|---| | Size | 5,348 characters | | Text units (headings + sentences) | 92 | | Numbered provisions (### x.y) | 25 | | Explicit "Section x.y" cross-references | 6 | | QE pairs, training split (seen by QESChunker) | 12 | | QE pairs, held-out split | 13, of which 11 need two or more evidence sentences | Each QE pair stores the question and the exact evidence sentences as strings. The lab maps each evidence string to a character span and to the range of text units it covers, using a binary search over unit start offsets: const unitAt = pos => { let lo = 0, hi = units.length - 1 while (lo < hi) { const m = (lo + hi + 1) >> 1; if (units[m].start <= pos) lo = m; else hi = m - 1 } return lo } The parser splits sentences on ., ! or ? followed by whitespace, so "1.2-metre" and "Section 1.3" stay intact. A provision is any heading at level 3 or deeper, or any numbered x.y heading, plus the sentences under it. Each provision records its heading path, for example 1 Definitions › 1.3 Red-light zone. Fixed conditions for every strategy: chunk length limit L = 450 characters, context budget B = 120 words, the same BM25 (k1 = 1.2, b = 0.75, stop-word removal and a light suffix stemmer that strips -s, -es, -ed and -ing from tokens longer than four characters), and the same context assembler. --- The five chunkers 1. Fixed window N characters with a 50-character overlap and step L − 50. This is the tutorial default. It cuts mid-word and mid-sentence. 2. Sentence window The exact algorithm the main demo uses (chunkDocument() in ragEngine.js). It packs whole sentences up to L characters. When a chunk closes, it backtracks whole sentences from the end until the 50-character overlap budget is used, and those sentences start the next chunk. 3. Structure-aware (StrucChunk-style) One chunk per provision. A chunk never crosses a provision boundary, and a provision longer than L is split on sentence boundaries. Each chunk gets its heading path as a prefix, and every "Section x.y" reference inside it is resolved at index time by appending up to 320 characters of the referenced provision: for (const m of C.slice(start, end).matchAll(/Section (\d+(?:\.\d+)+)/g)) { const ti = byId.get(m[1]) if (ti === undefined || ti === pi || seen.has(ti)) continue seen.add(ti) refs.push({ id: m[1], prov: ti, text: bodyText(provisions[ti], refChars) }) } An indexed chunk then looks like this: [2 Access and Arrival › 2.1 Gate hours] The lower gate opens at 17:00. It closes to arriving vehicles 30 minutes before the start of the dark window defined in Section 1.1. ... ↳ Section 1.1 Dark window: A dark window is any period of at least 90 minutes between the end of astronomical twilight and moonrise. ... The rule and the definition it depends on are now one retrievable unit. 4. QESChunker, exact dynamic programme Treat the document as a sequence of n text units. A segmentation splits it into contiguous chunks, each at most L characters. The utility of a chunk covering units j..i−1 is: u(j, i) = Σ_{e ∈ spans} 1[ e ⊆ [j, i) ] + Σ_{q ∈ multi-ev} 1[ ∀ e ∈ E(q) : e ⊆ [j, i) ] − μ (μ = 0.05, a small per-chunk cost) The first term rewards evidence sentences kept intact. The second rewards keeping all of a multi-fact question's evidence together. The objective is a sum over chunks, so the optimum satisfies a simple recurrence: best[0] = 0 best[i] = max_{j < i, span(j, i) ≤ L} best[j] + u(j, i) for (let i = 1; i <= n; i++) { for (let j = i - 1; j >= 0; j--) { const span = U[i - 1].end - U[j].start if (span > L && j < i - 1) break const v = best[j] + util(j, i) if (v > best[i]) { best[i] = v; arg[i] = j } } } The inner loop stops as soon as a window exceeds L, so the cost is O(n · w · |QE|), where w is the maximum number of units per window. On this document the optimum has an objective of 13.35, and every training evidence span stays intact. 5. QESChunker, overlapping greedy With overlap allowed, the lab picks a set of possibly overlapping windows under a total index budget of 1.35× the document length. The coverage function counts newly covered evidence spans, newly completed multi-fact questions, and α = 0.02 per newly covered unit, so the whole document gets indexed. It is monotone submodular, so the lab runs cost-benefit greedy: while (true) { let bestC = null, bestR = 0 for (const c of cands) { if (spent + c.cost > budget) continue const g = gain(c) // marginal coverage given what is already chosen if (g <= 0) continue const r = g / c.cost // benefit per character if (r > bestR) { bestR = r; bestC = c } } if (!bestC) break chosen.push(bestC); spent += bestC.cost // mark spans, questions and units covered by bestC } One practical detail mattered. Without a floor on window size, cost-benefit greedy collapses into one-sentence chunks, because a single evidence sentence has the best gain per character. Candidates shorter than 0.5 · L are therefore excluded. Units still uncovered when the budget runs out are packed into gap chunks so they stay searchable. --- The two retrieval modes Flat top-k Rank chunks by BM25, then fill the word budget in rank order. The assembler skips any chunk that would overflow the budget and any chunk whose tokens are less than 30% new (a near-duplicate filter that matters for overlapping chunkers): for (const i of order) { const c = chunks[i] if (used + c.words > budget) continue const t = toks(c.text) const novel = t.filter(x => !seen.has(x)).length / Math.max(1, t.length) if (picked.length && novel < 0.3) continue picked.push(i); used += c.words t.forEach(x => seen.add(x)) } Note the continue rather than break: a large chunk that does not fit lets a smaller, lower-ranked chunk take the space. That detail explains one of the results below. Chunk graph (SpectRAG-lite) Build an undirected weighted graph over chunks with four edge types: | Edge | Condition | Weight | |---|---|---| | adjacent | consecutive in document order | 1.0 | | xref | chunk A contains "Section x.y" and chunk B covers provision x.y | 1.0 | | section | same provision, not adjacent | 0.5 | | lexical | token-set Jaccard ≥ 0.18 | 2 × Jaccard | Then run personalised PageRank from the top-3 BM25 seeds, with the restart vector weighted by BM25 score, restart probability 0.5 and 25 iterations: p₀[i] = s[i] / Σ_seed s for the 3 seeds, 0 elsewhere p ← 0.5 · p₀ + 0.5 · Wᵀ D⁻¹ p (25 iterations) score[i] = 0.6 · s[i]/max(s) + 0.4 · p[i]/max(p) The final ranking blends normalised BM25 with normalised PageRank mass and goes through the same budgeted assembler. The only thing that changes between modes is the order in which chunks are offered. --- What each chunker builds Before retrieval, the index itself already says a lot: | Strategy | Chunks | Avg chars | Index / doc size | Chunks starting at a heading | Evidence spans intact | Cross-refs resolved in-chunk | |---|---|---|---|---|---|---| | Fixed window | 14 | 428 | 1.12× | 0% | 100% | 0% | | Sentence window | 14 | 392 | 1.03× | 46% | 100% | 0% | | Structure-aware | 25 | 285 | 1.33× | 100% | 100% | 100% | | QES · exact DP | 13 | 410 | 1.00× | 0% | 100% | 0% | | QES · overlap greedy | 26 | 242 | 1.17× | 56% | 100% | 0% | Every chunker keeps every evidence sentence intact somewhere, because the sentences are short compared with L = 450. That means all differences below come from findability, not from broken evidence. The columns that differ are granularity, alignment with headings, and whether cross-referenced definitions travel with the rule. !Boundary map: each bar is a chunk, gold bands are the evidence for one question, outlined chunks were retrieved --- Result 1: Partial recall flatters !Scoreboard, held-out questions, 450-character chunks, 120-word context Held-out questions, L = 450, B = 120 words: | Strategy | Partial recall | Complete recall (flat) | Complete recall (graph) | Avg context words | |---|---|---|---|---| | Fixed window | 69% | 23% | 23% | 90 | | Sentence window | 69% | 23% | 15% | 76 | | Structure-aware | 92% | 62% | 69% | 103 | | QES · exact DP | 77% | 15% | 15% | 72 | | QES · overlap greedy | 92% | 46% | 46% | 99 | Every strategy finds something for 69–92% of questions. The default chunkers assemble the whole answer less than a quarter of the time. A pipeline evaluated on partial hits would look healthy while three out of four multi-fact answers were built on incomplete evidence. The "avg context words" column shows a second effect. The windowed chunkers leave 30–48 words of the 120-word budget unused, because the next-ranked 60–70-word window does not fit. Small chunks pack the budget more efficiently. --- Result 2: Structure wins when context is scarce Provision-sized chunks average 285 characters, against about 400 for the windowed chunkers. At 120 words you can fit two or three provisions but only one large window. When the answer lives in two places, two small, precise pieces beat one big piece that happens to hold half the answer. The budget sweep (held-out, flat retrieval, L = 450) makes the trade-off visible: | Budget (words) | Fixed | Sentence | Structure | QES DP | QES overlap | |---|---|---|---|---|---| | 40 | 0% | 0% | 23% | 0% | 8% | | 80 | 15% | 23% | 38% | 15% | 38% | | 120 | 23% | 23% | 62% | 15% | 46% | | 150 | 23% | 46% | 69% | 38% | 69% | | 200 | 54% | 54% | 77% | 38% | 77% | | 300 | 77% | 77% | 77% | 69% | 85% | | 400 | 85% | 92% | 77% | 85% | 92% | !Complete-evidence recall vs context budget At 40 words, structure-aware is the only strategy above 10%. By 300 words the big-window chunkers have caught up, and by 400 they have passed it, while structure-aware levels off at 77%. With a generous budget, almost any chunker eventually drags the evidence in, because you are sending a large share of the document. The best chunker depends on the budget, and the right budget depends on the query, which is the adaptive top-k paper's argument from the other direction. The structure-aware plateau at 77% is not a chunking failure. Its remaining misses are retrieval failures (see Result 5). Chunk-size sweep Holding B = 120 and varying L shows the same mechanism from the other side: | L (chars) | Fixed | Sentence | Structure | QES DP | QES overlap | |---|---|---|---|---|---| | 250 | 46% | 54% | 69% | 62% | 69% | | 350 | 38% | 46% | 62% | 46% | 54% | | 450 | 23% | 23% | 62% | 15% | 46% | | 600 | 38% | 38% | 62% | 38% | 38% | | 800 | 0% | 0% | 62% | 15% | 31% | Two things stand out: 1. Structure-aware is flat at 62–69%. Almost every provision is shorter than 450 characters, so L barely changes its chunks. Its granularity comes from the document, not from a hyperparameter. 2. At L = 800, fixed and sentence windows score 0%. An 800-character window is about 130 words, which is larger than the 120-word budget, so the assembler cannot fit a single chunk. This is the failure you get when chunk size and context budget are tuned by different people. At L = 250, every chunker gets better and the gap narrows. Smaller chunks behave more like provisions. The cost is a larger index and more fragments for any reader that needs surrounding context. --- Result 3: The provably optimal chunker came last QESChunker's exact DP is optimal for its objective. It still scored 15% on held-out questions and 58% on the twelve questions it was trained on, below plain fixed windows at 75%. !Scoreboard on the QES training questions | Split | Fixed | Sentence | Structure | QES DP | QES overlap | |---|---|---|---|---|---| | Training (12) | 75% | 83% | 92% | 58% | 83% | | Held-out (13) | 23% | 23% | 62% | 15% | 46% | | All (25) | 48% | 52% | 76% | 36% | 64% | The boundary map shows the mechanism. The utility function rewards evidence sentences that sit fully inside a chunk, and says nothing about the text around them. The cheapest way to keep a rule intact is to cut immediately before it. In a handbook, the line immediately before a rule is its heading, ### 5.2 Emergency kit. The heading ends up at the end of the previous chunk, and the rule starts the next one. Evidence intact: 100%. But a keyword query about "emergency kit" now matches the chunk holding the stranded heading, not the chunk holding the rule. That is why the DP has 0% of chunks starting at a heading. Ablation: does a heading-path prefix rescue it? The lab can prefix every chunk from every chunker with the heading path of each provision it touches (the "contextual headers" toggle). Result, held-out, flat: | | Fixed | Sentence | QES DP | QES overlap | |---|---|---|---|---| | No prefix | 23% | 23% | 15% | 46% | | Heading-path prefix | 15% | 23% | 15% | 54% | It does not rescue the DP. The prefix tells BM25 which provision a chunk belongs to, but the chunk holding the stranded heading also gets that provision's name in its prefix, so both chunks still compete for the same query. The prefix also spends budget words on every chunk. Only the overlap variant, whose windows already tend to start at headings, gains from it. This is not a flaw in the paper. QESChunker is evaluated with a fixed hybrid retriever, and dense embeddings are far less sensitive to where a heading lands. It is a lesson for anyone porting the idea: the optimisation objective has to model the retriever you actually run. Intact evidence and findable evidence are different goals, and a chunker only optimises the one you write down. A practical fix is to add a term to u(j, i) that scores whether the training question retrieves the chunk under your real retriever, or to forbid cuts between a heading and its first sentence. The overlapping variant shows the other side. Overlap lets the greedy pass choose windows that start at the heading and cover the evidence. It reaches 46% held-out and 83% on training questions, without being told the document had structure. On documents without clean headings (transcripts, email threads, scanned PDFs), this is the version I would reach for. The training/held-out gap, 83% against 46%, is the caveat for every supervised chunker: the index is shaped around the questions you thought to ask. --- Result 4: The chunk graph helps where definitions are hubs Switching to graph retrieval moved structure-aware chunking from 62% to 69% and changed little else. !Scoreboard with chunk-graph retrieval One question shows where that gain comes from: !Question inspector in chunk-graph mode: "Is flash photography allowed on the dome floor?" "Is flash photography allowed on the dome floor?" needs two facts: the camera rule (§4.3, flash is banned everywhere in the red-light zone) and the definition (§1.3, the red-light zone covers the dome floor). Flat BM25 ranks the definition third. At 52 words it no longer fits after the first two picks, so the assembler's continue lets a shorter, useless chunk about the telescope take the space. In graph mode, the §1.3 definition chunk is a hub: two other provisions cross-reference it, and it shares vocabulary with several more. PageRank mass flows into it from the seeds, its blended score passes the telescope chunk, and the answer becomes complete. !Chunk graph for the structure-aware index; gold arcs are resolved cross-references Ablation: turn off cross-reference resolution. Structure-aware graph mode drops from 69% back to 62%, the same as flat. The graph gain comes from the xref edges, which are the most trustworthy edges a document provides. On windowed chunkers, the graph does not help and sometimes hurts. Sentence windows go from 23% to 15%. Lexical edges between large, mixed-topic windows mostly spread relevance to the neighbours of what was already found. With 40% of the final score coming from PageRank, a neighbour can outrank a correct BM25 pick and take its place in the budget. SpectRAG's own abstract notes trade-offs in early precision and domain dependence, and this toy reproduces that. --- Result 5: What none of them fixed !Every strategy misses: "My 8-year-old is coming. What rule applies on the terrace?" "My 8-year-old is coming. What rule applies on the terrace?" Every strategy misses both evidence sentences. The rule says "children under 10" and the question says "8-year-old". After tokenisation the question is [8-year-old, com, rule, appli, terrace], and the rule sentence shares none of those tokens. Structure-aware chunking gets part of the way: the resolved §1.3 reference brings "terrace" into the children's chunk, so it scores 1.18 instead of zero. But "terrace" also appears in several other provisions, and they outrank it. No chunking strategy can close the gap between "8-year-old" and "under 10". That needs a dense or hybrid retriever, query rewriting, or a reranker that understands the question. This is why the lab complements the main pipeline rather than replacing it. The main pipeline has MiniLM embeddings, hybrid fusion and a cross-encoder reranker. Chunking decides what can be retrieved. The retriever decides what is retrieved. This month's papers are mostly about the first half of that sentence. --- What I would actually do 1. Measure complete-evidence recall, not hit rate. Write 20 multi-fact questions for your corpus, mark the evidence sentences, and track how often all of them reach the context. Report it next to partial recall. The gap between the two is the number to watch. 2. If your documents have structure, chunk on it. Split on headings and numbered clauses, prefix the heading path, resolve explicit cross-references at index time. It is deterministic, cheap and explainable, and here it was the biggest single win. 3. If they don't, use a supervised chunker with overlap. Generate QE pairs with an LLM, optimise boundaries against them, evaluate on different questions, and put your real retriever into the objective, or at least forbid cuts between a heading and its first line. 4. Tune chunk size and context budget together. Plot complete recall against budget for each chunk size. If a chunk can exceed the budget, it can never be retrieved. If the curves cross, your "best chunker" depends on how much context you send, and that should vary per query. 5. Add a chunk graph only where edges are trustworthy. Cross-references, citations and section hierarchy are good edges. Lexical similarity between large chunks mostly is not. --- Try it - Chunking Lab: vishalmysore.github.io. Change chunk size and budget, switch retrieval modes and splits, toggle heading prefixes and cross-reference resolution, inspect any question, or paste your own markdown and QE JSON. - Full RAG pipeline (hybrid search, reranking, WebLLM): vishalmysore.github.io - Code: vishalmysore/advancedRagDemo. The engine is src/utils/chunkLab.js, about 500 lines of dependency-free JavaScript. runLab(text, qe, { L, budget, evalSplit, headers, resolveRefs }) returns every number in this post, so you can run it in Node as well as in the browser. Every configuration here can be opened from a URL. For example, chunking.html?mode=graph&q=7 opens the flash-photography case in graph mode. !The full Chunking Lab page Caveat: this is a toy. One 5,348-character fictional document, 25 questions, BM25 only. Each held-out question is worth about 7.7 percentage points, so one-question differences are noise. The value is in seeing the mechanisms the papers describe: stranded headings, budget crossovers, chunks that cannot fit, definition hubs. The rankings are not a benchmark. Run it on your own documents; that is what the paste box is for. --- Papers referenced - Zhao et al., QESChunker: A Single Objective Unifies Overlapping and Non-Overlapping Chunking for RAG, arXiv 2610.36557, October 2026 - Singh, Tripathi & Singh, StrucChunk: Structure-Aware Retrieval for Legal Document RAG, arXiv 2610.26313, October 2026 - Sahinoglu et al., SpectRAG: Weighted Chunk Graphs for Token-Budgeted Context Selection in Multi-Hop RAG, arXiv 2610.36991, October 2026 - Banerjee et al., The Bottleneck Is Retrieval, Not Reading, arXiv 2610.26951, October 2026 - Xia, Yamangil & Wang, Pre-retrieval Query Clustering for Adaptive Top-k Document Retrieval in RAG Systems, arXiv 2609.13489, September 2026 - Singh, Parser, Chunking, and Embedding Interactions in RAG over Indian Government Regulatory Documents, arXiv 2609.31660, September 2026 - Rathi, Chawla & Andreopoulos, Re-ranking and Late Interaction Drive Retrieval Quality, arXiv 2609.38473, September 2026 Views are my own. All code is MIT-licensed.

Older posts →