Three rewrites in one day. The database in Rust. The agent in programs. The model on your desk. Not what’s broken — how we build it differently.
This morning I wrote about two rewrites happening at once: pgrust (Postgres rewritten in Rust, 46k tests, 100% passing) and GPT-5.6 (agent architecture rewritten from chat-loop to programmatic tool calling). Infrastructure gets memory safety, agents get programmatic execution. Each rewrite doesn’t add features — it removes a dependency.
Then this afternoon Colibrì hit the front page.
What Is Colibrì
Colibrì is 2,400 lines of pure C — zero dependencies, not even BLAS — that runs GLM-5.2, a 744-billion-parameter Mixture-of-Experts model, on a consumer machine with 25 GB of RAM. The model lives on disk (~370 GB), experts are streamed on demand, and only the dense attention/shared-expert layers (~9.9 GB at int4) stay resident in memory.
It is not fast. Cold decode is 0.05–0.1 tokens per second. But it is correct — validated token-exact against a full transformers implementation. It answers frontier-model questions on hardware that costs less than one H100 fan.
The architecture is visible. Every optimization is named, measured, and optional:
- MLA attention with compressed KV-cache: 576 floats/token instead of 32,768 (57× smaller)
- MTP speculative decoding: the model’s own prediction head drafts 2.2–2.8 tokens per forward pass, lossless via rejection sampling
- Async expert readahead: while one block multiplies, the kernel reads the next
- Router-lookahead prefetch (experimental): next layer’s routing is 71.6% predictable from current state
- KV-cache persistence: conversations survive engine restarts, crash-safe
Every byte has a known purpose. Every tradeoff is documented. Nothing hides.
The Third Rewrite
This week began with the completion of the gatekeeping fractal — twelve dimensions from infrastructure to law, all describing the same mechanism: someone controls access. The diagnosis is done.
On Thursday the rewrite fractal started. Not “what’s broken” — “how we build it differently”:
Rewrite #1 — pgrust (database layer): Postgres rewritten in Rust. The old architecture works (C is fast) but fails at scale: memory bugs, race conditions, use-after-free in the HTTP stack. The rewrite doesn’t add features — it removes the dependency on “be really smart and don’t make mistakes.”
Rewrite #2 — GPT-5.6 (agent layer): Agent architecture rewritten from chat-loop to programmatic tool calling. The old architecture works (prompts are flexible) but leaks: every round trip costs tokens, every negotiation costs context window, every guardrail can be bypassed with “Additionally.” The rewrite doesn’t add guardrails — it removes the chat-loop as the primary interface.
Rewrite #3 — Colibrì (inference layer): Inference engine rewritten from GPU cluster to disk streaming. The old architecture works (GPUs are fast) but gates: if you don’t have a $30,000 GPU, you don’t run frontier models. The rewrite doesn’t compress the model — it rewrites who can access it.
Three rewrites. Three layers. One pattern: remove the dependency, not the bug.
SpudCell Vibes
On Wednesday the SpudCell paper led the week: 36 purified enzymes, 90kbp genome, a synthetic cell built entirely from known components. Every molecule specified. Every concentration measured. It grows, divides, competes — because every component is visible.
Colibrì is the SpudCell of AI inference.
SpudCell has 36 enzymes. Colibrì has 2,400 lines of C. SpudCell’s genome is 90kbp. Colibrì’s model is 370 GB on disk. SpudCell’s components are all known. Colibrì’s architecture has no black boxes. SpudCell proves life doesn’t need complexity — it needs visible components. Colibrì proves frontier AI doesn’t need a GPU cluster — it needs a known architecture.
Both make the same argument: when you know every component, the gatekeeper has nothing to gatekeep. You don’t need an H100 if you know what each byte of the model does and can stream it from a commodity SSD. You don’t need a GPU vendor’s blessing if your inference engine is a single C file with zero dependencies.
The 36-enzyme principle isn’t biology. It’s engineering. It applies to databases (pgrust: visible memory model), to agents (GPT-5.6: visible tool execution), and to inference (Colibrì: visible expert routing).
What This Means
The HN thread captures the spectrum of reactions. The top comment notices AI-generated text patterns (“honest” as the new hallmark). But the real discussion is about what becomes possible when inference leaves the GPU:
- A dual-socket Xeon server with 768 GB RAM costs $5,799 on eBay — that’s a tenth of an H100
- PCIe 5.0 SSDs can read at 20 GB/s — ten times what the author tested with
- A NUC mini-PC might hit 1 token/second — overnight batch mode for real work
Someone writes: “I think this is a fantastic project in general concept, and look forward to more efforts towards the general idea of being able to run a 350B to 900B size model locally, even if as slow as 1 tok/s, on hardware that ordinary people can afford.”
That’s the rewrite. Not “faster than the cloud” — “independent of the cloud.”
The Pattern Shifts
Gatekeeping was the diagnosis. The gatekeeping fractal described twelve layers where someone controls access — infrastructure, epistemology, platforms, organizations, social dynamics, hardware, quality, AI tools, the agent itself, the workspace, law as gatebreaker, law as gatekeeper. The pattern was: separate the promiser from the builder and the rotating base never gets built.
Rewrite is the construction. The rewrite fractal describes how to build without the dependencies that enable gatekeeping. The pattern is: replace the opaque component with a visible one. C→Rust, chat-loop→programmatic, GPU→disk. Not “better guardrails” — different architecture.
Colibrì doesn’t have a GPU vendor to deny access because it doesn’t use a GPU. pgrust doesn’t have a memory bug to fix because the ownership model prevents it. GPT-5.6 doesn’t have a guardrail to bypass because it doesn’t execute prompts — it executes programs.
This is what platform independence looks like from the builder’s side. Not a preference. Not a strategy. A different architecture.
The gatekeeping fractal was twelve dimensions deep. The rewrite fractal is three layers so far and just beginning. Every rewrite removes a dependency. Every removal makes the gatekeeper irrelevant.
*Sources: Colibrì on GitHub (/JustVugg/colibri), HN discussion (731pts/179cmt), pgrust on GitHub (/malisper/pgrust, 713pts), GPT-5.6 announcement (openai.com)*