Kelley walks through each of Sumner's stated reasons — compile times, memory safety, contributor pool, async maturity, library availability — and argues each one doesn't hold up against the actual numbers. His forensic breakdown concludes the migration case is weaker than it sounds, particularly since Zig's incremental compiler is finally landing and would materially change the compile-time calculus.
Kelley points to Bun's actual bug tracker as evidence the project isn't being ground down by the class of memory-safety vulnerabilities Rust's borrow checker eliminates. The bugs Sumner cited publicly have mostly been logic errors, so rewriting a working codebase to prevent bugs you aren't hitting doesn't pencil out.
Kelley's central rhetorical move is to concede that Rust is a fine language with a large ecosystem while disputing the framing that Zig failed Bun. He accepts the first claim readily but argues the second doesn't follow from it, and that bundling the two is what makes the rewrite narrative feel inevitable when it isn't.
Kelley emphasizes that Zig's incremental compiler — years in the making — is finally landing, which materially changes the compile-time argument that underlies much of the rewrite pitch. Committing to an 18-month Rust migration now locks in a comparison against a version of Zig that will not exist by the time the rewrite ships.
Andrew Kelley, the creator of Zig, published a long-form response to Jarred Sumner's announcement that Bun would begin rewriting significant portions of its codebase in Rust. The post landed on Hacker News and cleared 550 points inside a day, which for a language-implementer's personal blog is a lot.
Kelley's tone is not defensive — it's forensic. He walks through each reason Sumner gave for the migration and pushes back on the ones he thinks don't survive contact with the actual numbers. Compile times, memory safety, the size of the contributor pool, the maturity of async, the availability of libraries — each gets its own paragraph, and each ends with a version of "the case is weaker than it sounds."
The post matters because Bun is not a hobby project. It is the single most-visible Zig codebase in production, the one that shows up in benchmarks and JobsScript conference talks and the one people point to when they argue Zig is ready. If Bun quietly drifts to Rust over the next 18 months, the Zig pitch loses its best marketing asset.
Kelley's central move is to separate two claims that usually get bundled together: "Rust is a good choice for Bun" and "Zig failed Bun." He concedes the first — Rust is obviously a fine language and a giant ecosystem — and disputes the second. That distinction is doing a lot of work.
On memory safety, he argues that Bun's actual bug tracker doesn't look like a project being ground down by use-after-frees. The bugs Sumner mentioned publicly have mostly been logic bugs, not the class of vulnerability that Rust's borrow checker eliminates. Kelley's implication: you don't rewrite a working codebase to prevent a class of bug you aren't hitting. On compile times, he points out that Zig's incremental compiler — the one he has been building for years — is finally landing, and that a rewrite decision made now is being made against a moving target.
The contributor-pool argument is where he gets sharpest. Sumner's framing was that hiring Rust developers is easier than hiring Zig developers. Kelley's counter is that Bun's contributor graph is dominated by a small number of full-time employees regardless of language, and that the marginal open-source contributor to a JavaScript runtime is not choosing based on host language anyway. He is probably right about this, though it's the kind of "probably right" that doesn't survive a CFO conversation.
What is missing from Kelley's post — and this is the honest read — is any acknowledgment that Zig's own instability has been a real tax on Bun. Bun has spent years chasing breaking changes in a language that is still pre-1.0. Sumner has said as much in Discord. Kelley doesn't engage with this directly, which is the one soft spot in an otherwise careful piece.
The HN thread is worth reading in full. The Rust partisans are, predictably, doing a victory lap. The interesting comments are from people who have shipped production Zig — they are mostly quiet, or they are agreeing with Kelley in the specific and worrying in the general. One commenter put it: "Andrew is right on the technical merits and losing on the vibes, and vibes are what compound."
If you are picking a systems language in 2026, the useful thing here is not "Zig vs. Rust," which is a tired argument. The useful thing is the checklist Kelley implicitly hands you.
First: audit your actual bug classes before you pick a language based on the ones you fear. Memory safety is a real category, but if your production incidents are 90% logic bugs and cache invalidation, a borrow checker does not save you. Second: separate language maturity from ecosystem maturity from tooling maturity — they move at different speeds and a project can be strong on one axis and weak on another. Third: notice who is doing the rewriting. Rewrites are expensive; when a serious team commits to one, they are usually right about something even if the stated reason isn't the real one.
The honest version of the Bun story is probably that Sumner is tired of tracking Zig's breaking changes and that the contributor-pool argument is a public-facing version of an internal exhaustion. That's a legitimate reason. It's also a reason that only applies to teams operating at Bun's scale and pace. Most projects picking Zig today are not going to hit the same wall.
The next 12 months will tell us whether Kelley's response was a turning point or a eulogy. If Zig 1.0 ships with the incremental compiler and one or two other high-profile projects stay the course, the Bun defection reads as one team's local decision. If more Zig users start quietly porting to Rust — and if Kelley finds himself writing this post a second time about a different project — it becomes a pattern. Either way, the fact that the language's creator felt the need to respond publicly, in this much detail, is itself the story.
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.