The editorial argues that Zig served its purpose as a bootstrapping language — enabling zero-overhead C interop and comptime metaprogramming for rapid early development. The shift to Rust is framed as responding to scaling needs: a mature crate ecosystem, battle-tested async runtimes, and a viable hiring pool that Zig cannot yet offer.
By surfacing Jarred Sumner's announcement to Hacker News where it scored 475 points, heldrida highlighted the significance of achieving near-complete test compatibility across tens of thousands of tests on Linux x64 glibc — suggesting the rewrite is substantively complete rather than aspirational.
The editorial emphasizes that reaching 99.8% parity on even one platform before public release represents 'the hard part done,' noting the test suite covers Node.js API compatibility, bundler behavior, transpilation, and the package manager — making this a comprehensive validation of the rewrite's fidelity.
The editorial explicitly identifies ecosystem maturity and hiring as the key factors, noting that Rust offers 'production-grade crates, battle-tested async runtimes, and a hiring pool that actually exists.' As Bun grew from a solo project to a company with a team and customers, the practical calculus shifted away from Zig's technical elegance toward Rust's operational advantages.
Jarred Sumner, creator of Bun, announced that the experimental Rust rewrite of the Bun JavaScript runtime has reached 99.8% test compatibility on Linux x64 glibc. The post, shared via Twitter in May 2026, drew immediate attention on Hacker News (scoring 475 points), reigniting the conversation about systems language choices for JavaScript infrastructure.
Bun originally shipped written in Zig — a deliberate choice at the time, driven by Zig's lack of hidden control flow, comptime metaprogramming, and the ability to interop directly with C without bindings. That choice was central to Bun's identity and marketing. Now the team is methodically replacing that foundation with Rust, and they're doing it without breaking the API surface.
The 99.8% figure refers to Bun's existing test suite — tens of thousands of tests covering Node.js API compatibility, bundler behavior, transpilation, and the package manager. Reaching that level of parity on even one platform (Linux x64 glibc) before the rewrite ships publicly is a significant engineering milestone.
### The Zig bet didn't fail — it graduated
It's tempting to read this as "Zig wasn't good enough." That's too simple. Bun used Zig to move fast in the early days: zero-overhead C interop meant wrapping JavaScriptCore, zlib, and BoringSSL without binding generators. Comptime let them generate lookup tables and protocol parsers at compile time. Zig served its purpose as a bootstrapping language for a small team moving at extreme velocity.
But Rust offers something Zig still doesn't at scale: a mature ecosystem of production-grade crates, battle-tested async runtimes, and a hiring pool that actually exists. As Bun grew from a solo project to a company with a team and customers, the calculus shifted. The rewrite isn't an indictment of Zig — it's an acknowledgment that different stages of a project optimize for different things.
### 99.8% is the hard part done
Anyone who's done a large rewrite knows the last 2% takes 80% of the time. But 99.8% is different from 95%. At 95%, you're still missing major codepaths. At 99.8%, you're chasing edge cases in obscure Node.js APIs and platform-specific behavior. The gap between 99.8% and 100% is measured in weird `fs.watch` behaviors and `child_process` signal handling on exotic configurations — not fundamental architecture gaps.
The fact that they chose to announce at this number, on a specific platform, suggests confidence. They're not showing a prototype; they're showing a migration path.
### The JavaScript tooling stack converges on Rust
Consider the landscape in mid-2026:
- SWC (Rust): powers Next.js transpilation - Turbopack (Rust): Vercel's bundler - Oxc (Rust): parser, linter, transformer - Rolldown (Rust): Vite's next bundler - Biome (Rust): formatter and linter - Lightning CSS (Rust): CSS transformation - Bun (now Rust): full runtime + bundler + package manager
The holdouts are V8/JavaScriptCore themselves (C++) and Node.js (C++). Everything in the layer between "the engine" and "your application code" is converging on Rust. Bun completing its Rust migration would make it the first full JavaScript runtime where the non-engine systems code is predominantly Rust — a template other projects will study.
If you're using Bun in production today: Nothing changes immediately. The Rust rewrite is experimental and not yet shipping. But the migration path looks credible, which means Bun's long-term maintainability story just got stronger. Fewer bus-factor concerns about Zig expertise.
If you're evaluating Bun vs Node.js: The rewrite signals institutional commitment. Companies betting on Bun can now point to a codebase that will attract Rust contributors — a dramatically larger talent pool than Zig. This matters for enterprise adoption decisions where "can we hire people to maintain this" is a gate.
If you're building JavaScript tooling: The message is clear. Rust is the lingua franca for JS infrastructure in 2026. If you're starting a new parser, bundler, or dev server today, choosing anything other than Rust requires a specific, defensible reason. The ecosystem effects (shared crates, common AST formats, contributor mobility between projects) compound with each major project that joins the Rust camp.
If you're a Zig enthusiast: This is a data point, not a death sentence. Zig remains excellent for embedded, kernel-adjacent, and greenfield systems work. But for application-infrastructure (runtimes, build tools, CLI tools), Rust's ecosystem depth is pulling projects in like gravity. The question for Zig's community is whether a killer app emerges that *can't* be built as well in Rust.
The next milestones to watch: macOS and Windows compatibility numbers, performance benchmarks versus the Zig implementation (Rust should be roughly equivalent, but memory allocation patterns may differ), and a timeline for the experimental flag to drop. If Bun ships a stable Rust-backed release in 2026 with performance parity, it closes the last major argument against Rust for JS tooling: "but can it match a hand-tuned Zig implementation?" The answer, apparently, is yes — and with 99.8% compatibility to prove it.
Very impressive that they could do this so quickly because I have been on a similar project (porting TypeScript to Rust) for 5 months. But I guess I don't have access to Mythos and unlimited tokens. I'm also close to 100% pass rate. 99.6% at the time of writing.https://tsz.devRus
I just want to comment that I think it's a good change if we look past the AI involvement.Bun has had an extremely high amount of crashes/memory bugs due to them using Zig, unlike Deno which is Rust.Of course, if Bun's Rust port has tons of `unsafe`, it won't magically solve them
6 days of work to do this. Even if it doesn't end up becoming meaningful, it shows just how tokens and work done will be linked now and in the future.It's going to be hard to compete with someone or a company that has more compute. They will just be able to do things you can't.
Completely unbased, but I don’t want to have to do anything with bun anymore. It’s just a gut feeling, but I don’t trust them and support them.They fork Zig to utilize LLM rewrites and build something the Zig team clearly disregarded (non-deterministic compiling)And now like a whiny baby they LLM re
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.
From 4 days ago: https://news.ycombinator.com/item?id=48019226 > I work on Bun and this is my branch > > This whole thread is an overreaction. 302 comments about code that does not work. We haven’t committed to rewriting. There’s a very high chance all this code gets thrown o