Zig's Creator Responds to the Bun Rust Rewrite

The obvious lesson of Bun’s Rust rewrite post is that Zig let memory bugs through and Rust stops them. The person who created Zig read the same post and rejects the framing itself — in his account, the language was never what separated solid Bun code from sloppy Bun code.

Source

My Thoughts on the Bun Rust Rewrite

By: Andrew Kelley
Published: Jul 09 2026
Type: Essay

I saved this because viral engineering narratives almost never get a first-party counterweight, and this one comes from the language creator being implicitly critiqued. It’s also a rare essay whose author publicly revised his own conclusion after publication.

What the Zig creator says the rewrite is really about

Andrew Kelley created Zig; Jarred Sumner built Bun on it and later rewrote it in Rust. This post is Kelley’s direct answer to that Rewriting Bun in Rust announcement, and its core objection is about framing, not performance numbers.

His main argument: the rewrite post presents bug prevention as a choice between a style guide and a language feature, and that dichotomy hides what actually eliminates bugs — in his words, “by dedicating engineering resources to it.” His evidence comes from inside Zig’s own ecosystem. TigerBeetle, a database written in Zig with a strong reliability record, invests heavily in finding and eliminating bugs and keeps a healthy relationship with the Zig project. Bun, in his telling, did neither.

From there he works through the rewrite post’s claims one by one, and this is the checkable half of the essay. The post justifies merging a million machine-written lines by trusting the test suite, while simultaneously reporting a long history of bugs that same suite missed — so, he asks, “It’s not sufficient to catch bugs in Zig code but it is sufficient to catch bugs in 1 million lines of unreviewed slop?” The speed gains are credited to cross-language link-time optimization, which he notes Zig has supported for Bun’s entire life and once enabled by default before LLVM bugs forced a retreat. The post implies diligent fuzzing of the Zig codebase; he says the Bun team told him directly, on calls, that they weren’t fuzzing anything. The binary-size wins came from reining in comptime abuse and trimming unused data — engineering that had nothing to do with the language swap and could have happened years earlier. And he flags what the post omits: compile times, offering Zig’s own compiler (about 600,000 lines) building from scratch in 16 seconds with 90-millisecond incremental edits.

The other half of the essay is history, and it needs a clear “according to Kelley” stamp, because none of it is independently verifiable. He describes Sumner arriving in the Zig community with what he calls healthy beginner energy — fast, fearless, learning constantly — and being genuinely generous to Zig: public credit for Bun’s performance, plus a $60,000-per-year donation to the Zig Software Foundation. The break, as he tells it, came when venture capital turned Bun into a race. He heard from job candidates and employees that Sumner was a poor manager, and the Zig team — which reads its users’ codebases — grew horrified at what they found: hacks layered on hacks, assertions misused, features shipped without pausing to pay down debt.

His sharpest line is that the slop predates the LLMs — the problem was never the tooling. He also admits the self-interested relief: when Anthropic acquired Bun, the donation quietly stopped, a recurring meeting was neither cancelled nor attended, and the Zig team suspected a Rust rewrite within days. They rooted for it, he says, because the constant memory-safety criticism Bun attracted would finally stop splashing onto Zig.

The ending is what makes the piece worth keeping. After publication, Kelley revised his conclusion. He concedes the post read as a personal attack carrying resentment he hadn’t processed, and he apologizes to Zig users who reasonably worried the language’s creator might trash them next — pointing readers to the site’s public source repository for the original wording. His closing position is that the two projects’ value systems diverged, the relationship failed, and the language was incidental to all of it.

Two things are worth holding onto the next time a rewrite story goes viral. His technical objections are the strong part: they’re specific, they cite things a reader can check against the original post, and they’d survive even if every personal claim disappeared. The history is the weak part evidentially — one side of a failed relationship, relayed through private conversations — and Kelley himself effectively concedes as much by rewriting his own ending. The argument’s scope is also clean: it’s about who deserves credit for quality, not about whether the rewrite was sound. He admits he didn’t believe the AI port was technically possible, and that Bun pulled it off anyway.

What I want to remember

Remember: When a rewrite story credits the new language for fixing bugs, look first at what the old language’s most reliable users do differently. Tools set the floor of what gets caught automatically; dedicated engineering sets the ceiling — and the person arguing that here is the creator of the tool that lost.