A search-and-inference database from scratch in pure Zig

I've actually been using this to build a local file search agent. I started building it on the Go version of Antfly, but the new Zig runtime is a huge improvement (better resource utilization, reliability, recovery, ...)

Anyone who has used Spotlight search on macOS knows that (1) it can be an absolute resource hog, and (2) it's relatively useless (even with Siri stuff they added in macOS 27). So I was eager to take a stab at a native app that did both better and kept everything on-device (no external inference providers), and building it on Antfly meant I could run it all from one engine (way simpler to coordinate than a whole RAG pipeline).

[Disclaimer: I work at Antfly. The local search app is in preview now at searchaf.com. We plan on open-sourcing it soon (probably with its own Show HN post), as a handy reference architecture.]

(Disclosure: I work at Antfly, joined recently)

Before joining the team I started developing a comprehensible input curation engine for my own language learning purposes built on Antfly. I'm indexing Anki study decks to track my approximate passive vocabulary in Spanish, indexing public domain reading material for content, and using hybrid search/RRF to surface content that best fits my current level at any given moment. I'm also playing around with using Antfly inference to generate limited rewrites of difficult passages, in order to bring the comprehension into a range that fits my level.

It's a fun use case that seemed to sit nicely at an intersection of what antfly does well. I also think the concept generalizes nicely to broader user-adapted learning/study use cases that don't involve shipping a boat load of behavioral data to a cloud/model provider.

So far have just implemented this for reading material but could imagine extending to some cool areas! (video + audio being obvious next targets)

I know I should be saying congrats on the new engine, but selfishly I want to hear more about how you did it.

So, the simulator only works if it knows what "correct" looks like and what kinds of failures to throw at the code, right? Who decided those two things? Was it the same agent that wrote the code? Were those human-written, or did they fall out of the formal specs?

You had three things that could each say "this is right", the end-to-end tests, the formal model, and how the old Go version behaved. When they disagreed, which one did you trust? Did the test ever turn out to be the thing that was wrong?

When the simulator caught something before release, was it usually the code that was wrong, or the definition of correct?

Feels like there's some really useful insights about best practices for coding with agents. I wonder if the Bun team used a similar approach if they still would have switched.

Yeah open question what "perfect" search would even be, like would that just end up being indistinguishable from a kind of magical omniscience? And then there's "can I literally just find that one freaking slideshow from a while ago with that one client... or is it in Google Drive...?" And I really don't want the solution to be that we just plug everything into Claude

We rewrote Antfly, which I introduced to the world a little bit back https://news.ycombinator.com/item?id=47414291, from Go to Zig.

Thought it is interesting to juxtapose to the Bun rewrite from Anthropic and wanted to talk about why we went the other way! Would love to talk about our process or the technology!

Benchmarks against are linked in the article but here they are again for posterity https://antfly.io/releases/v0.2

Caution: antfly is not open licensed. Use it at your own risk.