You updated Claude Code last month, it kept working, and you never noticed it stopped needing Node.js. That's the news, sort of. Since v2.1.181 (June 17) the CLI ships as a roughly 100MB native binary that bundles the Bun runtime, and on July 19 Simon Willison cracked open his own copy and found Bun 1.4.0 with 563 Rust source files inside. So the thing running your coding agent is now Bun, and Bun's core got rewritten from Zig to Rust, using Claude to do most of the typing. For you, day to day, the honest answer is: almost nothing changed except a slightly faster start. But the how of it kicked off a real fight about whether a million lines of AI-written code should ever ship, so we read the receipts.
The short answer
Claude Code stopped needing Node.js. Since v2.1.181 it ships as a ~100MB native binary that bundles Bun, and as of Bun 1.4.0 that runtime’s core was ported from Zig to Rust, with Claude writing most of it. For you the felt change is small: a faster cold start, steadier updates. The interesting part is the row over shipping a million lines of AI-written code. We split what’s confirmed from what’s still an argument.
What actually shipped
Here’s the plain version. Claude Code used to be an npm package you ran on Node. Now the recommended install is a native executable, about 100MB, that carries its own runtime. That runtime is Bun. And Willison’s July 19 post is the proof it’s really out there: he unpacked his binary and found Bun v1.4.0 plus 563 Rust filenames like src/runtime/bake/dev_server/mod.rs. This isn’t a canary or a flag. It’s on millions of machines already.
The 100MB is worth a beat, because people assume “native binary” means a tiny compiled thing. It doesn’t here. Roughly 95MB of that is the Bun runtime itself, JavaScriptCore engine and all, with maybe 5MB of Claude Code’s own bundled TypeScript on top. Bun’s bun build --compile staples the interpreter to your code and ships them as one file. Your JavaScript is still interpreted at runtime. So this is closer to how PyInstaller wraps Python than to a real ahead-of-time compile. That’s the honest framing, and it explains the size.
What do you get for it? Anthropic gets a single runtime it fully controls, which means cleaner background updates and a lot fewer “my Node version broke it” support tickets. You get a slightly faster start and one less dependency to babysit. That’s the whole user-facing story, and it’s fine.
The Rust rewrite under it
Now the part that got loud. Bun started life in Zig. Somewhere along the way its command-line side crossed 22 million downloads a month and became infrastructure, including the runtime beneath Claude Code. Bun’s core is now part of Anthropic, and Jarred Sumner, Bun’s founder, led a project to port the whole thing from Zig to Rust. The reason was boring and correct: memory safety. Zig let use-after-free bugs, double frees and leaks creep in, and they were a grind to kill by hand. Rust’s compiler refuses most of that class up front.
The method is the headline, though. Sumner didn’t hand-translate it. He pointed Claude at the codebase, ran about 50 workflows in parallel in an implementer-and-reviewer pattern, and let it grind. Roughly 535,000 lines of Zig became over a million lines of Rust. Around 6,500 commits. Eleven days. About $165,000 in API bill. The line counts drift a bit depending on who’s reporting, so don’t quote them to the digit, but the shape holds: this was a genuinely large migration done mostly by a model, and the Claude model doing the heavy lifting was the same tier a lot of us now run daily.
Did it work? On the metric that started the whole effort, yes. Sumner’s own 2,000-build stress test dropped peak memory from about 6,745MB to 609MB. Leaks gone. The rest is less cinematic: roughly 5% faster, a 20% smaller binary, and that 10% Linux startup bump you’d never feel unless you were staring at it.
The “unreviewed slop” fight
Not everyone’s clapping. Andrew Kelley, who created Zig, wrote up his thoughts on July 14 and didn’t soften them. He called the result “unreviewed slop.” His argument is sharp and worth sitting with: the defense of shipping a million lines nobody read line by line is that the test suite catches everything. But, Kelley asks, if that same suite wasn’t good enough to catch bugs in the original Zig, why would it suddenly be enough to vet a million lines of fresh Rust? He also noted, less kindly, that he thought Sumner “was already writing slop well before he had access to LLMs.”
Honestly, I think he’s got half a point and it’s the important half. Not the personal jab. The testing one. A test suite that missed bugs before doesn’t magically become a proof of correctness because the code volume tripled. Rust’s compiler does eliminate whole bug categories, which is real coverage Zig never gave, so it’s not nothing. But “the tests pass” is a weaker claim than it sounds when the tests were the weak link to begin with.
The counterpoint from Bun’s side is that this wasn’t one blind pass. It was adversarial review loops, thousands of commits, and a runtime now serving a very large user base without the sky falling. Both things can be true. The code is probably mostly fine and the review standard was genuinely lower than a human-authored rewrite would get. You’re allowed to hold both.
Should you do anything
Probably not, and that’s the point. If you’re on a recent Claude Code, you’re already running this. Nothing in your workflow needs to change. If you’re still on the npm build, claude install moves you to the native one, and you can skip it with zero consequence if you’d rather stay on Node for now.
The more interesting takeaway isn’t about Claude Code at all. It’s the proof of concept sitting in your terminal. A production runtime, used by millions, got its core language swapped by a model in under two weeks for the price of a used car. That either thrills you or worries you, and Kelley and Sumner are basically arguing about which reaction is correct. We’d just say: run it, keep the receipts in mind, and don’t mistake “it hasn’t broken” for “it was reviewed.” Those are different things, and this whole episode is a decent reminder of the gap. It’s the same tension we flagged when Claude helped attack an open math conjecture: the machine does the volume, a human still owns whether it’s right.
Sources: Simon Willison (Claude Code in Bun in Rust), The Register (Kelley on the rewrite), frr.dev (native build breakdown) and Developers Digest (rewrite stats), July 2026. Bun 1.4.0 and the 563 Rust filenames are Willison’s direct inspection of his own binary. The ~100MB native build and no-Node claim, the ~535k-to-1M line counts, the ~$165k cost and 11-day timeline, and the memory, speed and binary-size numbers are as reported by the sources above; the exact figures vary between write-ups and should be read as approximate.
Frequently asked questions
Does Claude Code still need Node.js?
No, not the native build. Since v2.1.181 Claude Code ships as a single native executable, around 100MB, that bundles the Bun runtime and the app code together. There is no separate Node install to manage. The npm package still exists, but new users are pointed at the native build, and existing npm users can switch by running "claude install".
What actually changed for me as a user?
Very little you would notice. Startup is about 10% faster on Linux, and background auto-updates get more reliable because Anthropic controls the whole runtime. Jarred Sumner, who led the work, put it plainly: startup got faster on Linux but otherwise barely anyone noticed. The big wins were internal, mostly memory leaks getting fixed.
Why was Bun rewritten from Zig to Rust?
Memory safety. Bun was originally written in Zig, and the team kept hitting use-after-free bugs, double frees and leaks that were hard to stamp out. Rust's ownership model catches that class of bug at compile time. Bun's core is now part of Anthropic, and it also happens to be the runtime under Claude Code, so stability there matters directly.
How was a million lines of code rewritten in 11 days?
With Claude, running about 50 parallel workflows in an implementer-and-reviewer pattern. Reports put it at roughly 535,000 lines of Zig turned into over a million lines of Rust, across about 6,500 commits, for around $165,000 in API cost. The exact figures vary between write-ups, so treat them as ballpark, but the scale is real.
Is the AI-written Rust code actually safe to run?
That is the open argument. Andrew Kelley, who created Zig, called the rewrite "unreviewed slop" and questioned whether a test suite that let bugs through in the old Zig code could possibly catch them in a million new lines. Bun's side leans on that same test suite plus adversarial review passes. It is shipping to millions of Claude Code installs already, so in practice you are running it whether the debate settles or not.