Bun Is Being 'Vibe-Ported' from Zig to Rust — by Claude

What happened

Bun — the JavaScript runtime that challenged Node.js and Deno by betting on Zig for its core implementation — is being ported to Rust. The work is happening in the open on GitHub, on a branch named `claude/phase-a-port`, with a structured `PORTING.md` document laying out the migration plan in phases. The initial commit landed with enough substance to hit 647 points on Hacker News within hours.

The branch name is the headline: Claude, Anthropic's AI model, is doing the heavy lifting. This isn't a human rewrite with AI assist — it's a systematic, AI-driven translation of Zig source into Rust, with human review and correction. The community has already coined the term "vibe-porting" for the approach: feed a codebase to an LLM, prompt it to produce idiomatic output in the target language, iterate on correctness. Think of it as vibe coding's infrastructure-grade sibling.

This is the first time a major production runtime has publicly used LLM-driven translation as its primary migration strategy. Previous AI-assisted rewrites have been internal, partial, or on smaller codebases. Bun's core is roughly 300,000+ lines of Zig — this is not a weekend experiment.

Why it matters

### The Zig question

Bun was, by a wide margin, the most prominent production use of the Zig programming language. Jarred Sumner chose Zig for its manual memory control, comptime metaprogramming, and zero-overhead interop with C — qualities that let Bun outperform Node on raw throughput benchmarks. Bun's success was Zig's best recruiting pitch.

If Bun migrates away from Zig, the language loses its most visible proof that Zig is production-ready for large-scale systems software. That doesn't mean Zig is dead — TigerBeetle and other projects remain committed — but the narrative damage is real. Language ecosystems live and die on flagship projects, and this is a defection from the flagship.

The likely technical motivations for Rust: a vastly larger ecosystem of crates, more mature async primitives, better tooling (cargo, clippy, rust-analyzer), a deeper hiring pool, and — crucially — memory safety guarantees that don't rely on discipline alone. Zig's explicit allocator model is elegant but punishing at scale; Rust's borrow checker catches classes of bugs that Zig leaves to the programmer.

### The AI migration angle

The more disruptive story is the methodology. Language migrations have historically been multi-year, multi-team death marches. Python 2 to 3 took a decade. Large C++ to Rust rewrites at Google and Microsoft have consumed hundreds of engineer-years. The premise of vibe-porting is that LLMs can compress these timelines by an order of magnitude — not by writing perfect code, but by producing a reasonable first draft that humans refine.

The phased approach in Bun's porting plan suggests hard-won pragmatism. Phase A likely targets the most self-contained modules — parsing, string handling, utility layers — where Zig-to-Rust translation is most mechanical. The gnarly parts — Bun's event loop, its JavaScriptCore bindings, platform-specific syscall layers — will be later phases where AI output needs heavy human correction.

This mirrors how professional translators use machine translation today: MT produces the draft, humans post-edit for correctness and idiom. The productivity gain is real but variable. For well-structured, well-typed source code, LLM translation can be surprisingly accurate. For code that relies on Zig-specific patterns like comptime or error unions with complex semantics, the AI will hallucinate Rust that compiles but subtly misbehaves.

### Community reaction

The Hacker News discussion (647 points) splits into predictable camps. Rust advocates see validation. Zig partisans see betrayal — or at minimum, a premature judgment on a language still pre-1.0. A third camp, arguably the most interesting, focuses entirely on the AI angle: if this works, every company sitting on a legacy codebase in Language A just got a template for migrating to Language B.

Skeptics raise legitimate concerns. Translated code often preserves the idioms of the source language rather than adopting the idioms of the target — you get "Zig written in Rust syntax" rather than idiomatic Rust. This matters for maintainability. A codebase that doesn't feel native to its language becomes a maintenance burden that grows over time, as new contributors fight patterns that don't match their mental models.

What this means for your stack

If you use Bun in production: Don't panic. The port is exploratory and phased. Bun's current Zig-based releases aren't going anywhere near-term. But start watching the `claude/phase-a-port` branch — if this gains momentum and the Bun team commits publicly, it signals that future Bun internals will be Rust, which affects anyone writing native Bun plugins or contributing to the runtime.

If you're evaluating Zig for a new project: This is a data point, not a verdict. Zig remains a compelling language for specific use cases — embedded systems, game engines, anything where you want C-level control with better ergonomics. But the ecosystem risk just increased. If you're choosing between Zig and Rust for a new systems project in 2026, Rust's ecosystem gravity is now even harder to argue against.

If you manage a legacy codebase: This is the story to watch. If Bun successfully ports 300K+ lines of systems code using AI-assisted translation, it validates a migration pattern that could apply to C-to-Rust, Java-to-Kotlin, or any large-scale language transition. The tooling isn't mature yet — don't file a JIRA to port your monolith next quarter — but the trajectory is clear. Start experimenting with LLM-assisted translation on isolated modules. Understand the failure modes before you need to do it at scale.

If you're an AI tooling builder: Note what's happening here. Code translation is a use case where LLMs provide immediate, measurable value — not "10x developer" hand-waving, but concrete output that can be diff'd, compiled, tested, and benchmarked against the original. Expect dedicated code-migration products to emerge within the year.

Looking ahead

The Bun-to-Rust port is three stories in one: a major runtime reconsidering its foundational language choice, the Zig ecosystem losing its standard-bearer, and AI-assisted code migration graduating from experiment to practice. Whether the port succeeds or stalls, the attempt itself shifts what developers consider feasible. The branch name says it all — `claude/phase-a-port` — and the industry is watching to see if Phase B ever ships.