Bun Rewrites 535K Lines of Zig into Rust in Four Months, Eliminates

Jarred Sumner, the creator of Bun, announced that the JavaScript and TypeScript runtime, bundler, and package manager has completed a full rewrite of its codebase from Zig to Rust. The effort converted 535,000 lines of Zig into equivalent Rust code and shipped roughly four months after work began — well ahead of the one-year estimate the team had projected before leveraging AI-assisted tooling to accelerate the migration.

This article covers the mechanics of that language switch, what it changes for developers who run Bun in production, how to pick up the new binary today, and what rough edges to watch while the Rust codebase matures. If you maintain a Node.js-compatible server, a monorepo bundled with Bun, or a CI pipeline that depends on Bun's package manager, the information below is directly relevant to your upgrade path.

What Bun Rewrites 535K Lines of Zig into Rust shipped

Bun's original implementation was written in Zig, a low-level systems language that gives programmers manual control over memory allocation but provides no compile-time enforcement of memory safety rules. Sumner's team built Bun in Zig to chase raw performance, and the runtime did achieve competitive throughput against Node.js and Deno on several benchmarks. The tradeoff was a recurring class of memory safety bugs — use-after-free errors, untracked allocations, and slow-to-reproduce memory leaks — that Zig's compiler could not catch automatically.

The Rust rewrite targets that problem at the type-system level. Rust's borrow checker statically verifies that every memory reference is valid at the time it is used, rejecting programs that contain data races or use-after-free patterns before they compile. By moving 535,000 lines of existing Zig into Rust, Sumner's team gains that enforcement across the entire runtime, bundler, and package manager surface — not just in newly written modules. Numerous memory leaks that had accumulated in the Zig codebase are reported as eliminated as a direct consequence of the rewrite.

What changed for builders in Bun Rewrites 535K Lines of Zig into Rust

The most immediate change for developers is the expected end of a category of intermittent crashes and memory-growth bugs that were difficult to reproduce and patch in the Zig codebase. Because Rust's borrow checker enforces ownership at compile time, the class of defects that previously required manual auditing or runtime sanitizer passes to surface should no longer accumulate in the same way.

The four-month delivery — versus a twelve-month projection — was enabled by AI-assisted code translation tools that automated portions of the Zig-to-Rust conversion. While the team has not detailed which tooling was used, the compression of timeline suggests that large sections of the Zig code were structurally translated rather than hand-ported, which also means the Rust output will need ongoing review for idiomatic correctness.

How to install or upgrade Bun Rewrites 535K Lines of Zig into Rust

Existing Bun installations can be updated to the latest release using Bun's built-in upgrade command. No external package manager step is required:

bun upgrade

For a fresh install on macOS or Linux using the official install script:

curl -fsSL https://bun.sh/install | bash

On macOS with Homebrew:

brew upgrade bun

After upgrading, confirm the installed binary is the Rust-based release by checking the version output. The runtime, bundler, and package manager are all distributed as a single binary, so a single upgrade covers all three components. There is no separate model switch or flag needed — the rewrite is the default binary going forward.

Gotchas and compatibility in Bun Rewrites 535K Lines of Zig into Rust

A codebase of 535,000 lines translated at accelerated pace with AI tooling is not automatically idiomatic Rust. The borrow checker enforces correctness, but it does not guarantee that the translated code uses Rust's standard patterns for error propagation, async handling via Tokio, or efficient use of lifetimes. Developers who contribute to Bun or audit its internals should expect to encounter translation artifacts — code that compiles cleanly but reads as Zig idioms expressed in Rust syntax.

On the consumer side, the public API and CLI behavior of Bun are not expected to change as a result of the language switch, since the rewrite targets the implementation layer rather than the interface. However, any rewrite at this scale carries the risk of behavioral regressions in edge cases. Projects that rely on Bun for bundling or package resolution in CI should run their existing test suites against the upgraded binary before promoting it to production. Filing issues against the Bun repository with minimal reproducers remains the recommended path if unexpected behavior surfaces post-upgrade.

What to watch after Bun Rewrites 535K Lines of Zig into Rust

The Rust rewrite eliminates the memory safety category of bugs, but it opens a follow-on question: whether the AI-assisted translation preserved the performance characteristics that made Bun attractive in the first place. Sumner's team has not yet published comparative benchmarks pitting the Rust binary against the Zig binary on the workloads — HTTP throughput, cold-start latency, package install time — that Bun has historically led. Independent benchmark results from the community will be the clearest signal of whether the migration preserved the runtime's performance story.

Longer term, the move to Rust positions Bun's internals on the same language used by Deno's core and by several high-throughput systems in the JavaScript ecosystem. That alignment may simplify future collaboration on shared infrastructure, attract contributors more familiar with Rust than Zig, and make it easier to adopt upstream Rust crates for networking and I/O. The more pressing near-term watch item is patch velocity: the first few minor releases after a rewrite of this size typically surface the edge cases the borrow checker could not catch — logical bugs rather than memory bugs — and the rate at which those patches land will indicate how stable the new foundation is.