back
853 comments
Drilling into the original article where Jarred explained the reasoning behind the change, It's pretty clear that under zig the team was doing things by hand that are automatic in rust.

Humans and agents share one thing: they are both non-deterministic. He talks about the issue of tracking memory lifecycles manually in zig so it can be explicitly freed. As expected, this leads to a long list of bugs where people missed things.

Rust does this automatically. It removes an entire class of errors from his backlog. From an engineering management perspective, this looks like a pretty good trade.

The bonus here is that compiler errors are exactly the kind of deterministic guardrail you need to put around coding agents. Claude works really well if you give it a way to test for correctness and "make it compile" is a pretty good target.

There's a general version of this: the artifact you expose plus the test you run on it. Deterministic tests turn stochastic output into a hard guarantee. Wrote it up here if useful: https://michael.roth.rocks/blog/verification-surface/

Zig (like C) is simply not a good language to use if you're going to do many small allocations with uncorrelated lifetimes. To write robust Zig (or C) code, you must manage lifetimes yourself, for example by grouping allocations on an arena or by having fixed buffers of "things".

You can just do that, and then Zig is really no less robust than Rust. But if you want to do "managed language" style allocation patterns (like what llms generally prefer), it doesn't make sense to use it.

> Rust does this automatically.

A garbage collected language does this automatically. Rust still requires thinking about and tracking memory lifecycles, but the borrow checker will complain and keep you from doing it wrong. That's why LLMs like Rust. It gives immediate feedback on what to fix. By-default constant reference parameters helps prevent major performance problems.

> Rust does this automatically. It removes an entire class of errors from his backlog.

Even with the huge amount of "unsafe" rust currently in bun? https://news.ycombinator.com/item?id=48967630

I thought that this was just an initial translation to unsafe rust in which they haven't actually gained any of those benefits yet, although presumably they can go there quickly now.
> He talks about the issue of tracking memory lifecycles manually in zig so it can be explicitly freed. As expected, this leads to a long list of bugs where people missed things.

Yes, and again the "you're holding it wrong" people or "you are not a good enough developer" people will try to do juggling with a chainsaw and lose a couple of fingers in the process

Claude Code's endorsement (and real-world testing) speaks louder than internet discussions that are at this point 30 years old (and probably more)

> "make it compile" is a pretty good target.

But only as far as "make it compile" is a good predictor of runtime behavior. In C++ for instance, I can "make it compile" and it still crashes at runtime or does other undesirable things.

I seem to recall this Rust rewrite is all "unsafe" meaning it really doesn't automatically eliminate those issues.
Good thing there are tons of languages that do that out of the box, and which are frankly quite fast.
Rust is the clear winner of LLM era, you can't say otherwise.
Bah.

Personally my take on the entire affair is quite negative, whatever Jarred or Simonw says about it.

I think Bun owned by Anthropic and the entire rewrite with AI is not the real point (even if it's quite interesting, though).

My take is that Jarred, and Bun,didn't demonstrate a serious, adult approach, from "this is my branch, you are overreacting" message to just proceeding with a 1mil+ PR merged in less than month.

The communication is the issue, and it was handled very badly, in a way that impacted trust and divisions.

Was it so difficult to adopt the approach that the TS team adopted for 7.0?

> For me this outputs Bun v1.4.0 (macOS arm64). The most recent release of Bun on GitHub is currently v1.3.14 from May 12th, so that v1.4.0 version number in Claude supports them shipping a preview of a not-yet-released Bun version.

And so, the FOSS project "Bun" silently dies in darkness and is now something completely else. I'm glad I still had "Investigate if Bun is worth it" on my TODO list and hadn't yet gotten to it.

What is the governance structure for Bun by the way? Couldn't find any documents/explanations about how it's supposed to work. I'm guessing it's essentially just "Anthropic decides what gets done and accepted" today?

Maybe I’m taking crazy pills, but I’m still stuck on “why the hell does a TUI need to run in terminal React by way of JavaScript”

The fact that Anthropic felt the need to buy a runtime so they could make their TUI better speaks more to the quality of engineering than anything else IMO.

If rewrites are so easy, why not rewrite CC in a native language? Would’ve been a hell of a lot cheaper.

Why all the mess with Bun?

Couldn't they have rewritten Claude Code in Rust directly? No more need for a JS runtime, better performance, etc... If their agents can do Zig to Rust, why not JS to Rust?

All the emotion of speculations aside, how it runs? It boots faster yeah, but what about RAM and CPU usage? Weird dead loop or dead locks?

If it run as good as before or even better, then that's kinda impressive.

I'm a developer so I really don't like it when AI might took my job, but if everyone on this planet could create a software for themselves exactly as how they wanted with just a few simple demands, that will change the world for the better.

Think of it as a democratization of technology. You don't want Microsoft stealing your data? Just ask a AI to write an OS for you. You don't want Google to listen to what you're saying? Just ask a AI to design a phone for you. If one day the AI ended up doing that, it will be the ultimate technology self-sufficient. In front of that, your job security is insignificant.

It is also why keeping the tech open source is that much important. Otherwise, it's still the same old shit again and again, and, you lose your job too.

Maybe I'm taking crazy pills, but I swore there have been very similar comments I've seen as the current top post by weakfish:

> Maybe I’m taking crazy pills, but I’m still stuck on “why the hell does a TUI need to run in terminal React by way of JavaScript”

> The fact that Anthropic felt the need to buy a runtime so they could make their TUI better speaks more to the quality of engineering than anything else IMO.

> If rewrites are so easy, why not rewrite CC in a native language? Would’ve been a hell of a lot cheaper.

It turns out, there's some similar sentiments in the last year ish:

https://news.ycombinator.com/item?id=47043325

https://news.ycombinator.com/item?id=47105720

https://news.ycombinator.com/item?id=48001113

https://news.ycombinator.com/item?id=46134570

https://news.ycombinator.com/item?id=46124596

I'm not a fan of any of the technologies, companies, or people related to this. I just couldn't shake the feeling that I've seen similar comments.

September and all.

Anecdotal, but I’ve been getting segfaults in Claude Code. I run inside Kitty tabs, and the entire tab becomes unusable when this happens. No response to inputs at all from that point.

When this happens, a link shows up to report the issue. It’s not clickable (likely due to the segfault), and perhaps more important: it’s encoded, so you can’t see what you would be sending in your report.

Hope it gets better.

It's a transpile. And not even a good one. The generated code is far from idiomatic rust. Some may consider it an abomination.
Incidentally, Claude Code has been very buggy for me lately (much more so than before). Lots of TUI rendering issues causing, e.g., the conversation history to be garbled etc.
Whatever the headaches of the internals, I haven’t heard any substantive outcomes in hacker news that have been impacted by this change.

Yes if we had a Zig->Rust transpiler maybe it would produce similar output. But I can’t find one. We’d have to use an agent to build one first :)

The port of Bun, which has >5000 open github issues, is used in Claude Code, which has >11000 open github issues. Do people use Bun in things that are expected to work reliably? Have any such projects tried the upgrade yet?
a terminal app now has a supply chain long enough to include a runtime acquisition. somewhere between "rewrote it in Rust" and "ship it" someone said "or we could just buy the company"
Why even write Claude code in JavaScript at that point, assuming they write the application logic in node and also include the interpreter in the application?
Contrary to many, I have high hopes that Jarred and team will lapidate the ported codebase and it will continue to flourish as an open source project.
Oh good, the vibe coded prompt injection vector that casually accesses things in my home directory without permission is running on a vibe coded prerelease runtime using lots unsafe rust. What could go wrong?
Is anyone else failing to understand all the internet drama surrounding this?

The rewrite may work out on a technical level or it may not. Let's wait and see. The Bun project did not swear a blood oath to use Zig forever, and it's ultimately their choice to switch to a different programming language.

Beyond that, people seem to be incredibly emotionally involved with this, for reasons that entirely escape me.

Ah so that's why it has been crashing constantly for me.
Is it easier to rewrite Bun than it is to rewrite Claude?
Why not just use Deno that's made in Rust and also has safety in mind?
They’re just wildly successful terrible engineers who can describe problems well and have unlimited token budgets. If they were paying for their own token use, the software would be better, they simply don’t have financial incentive to be more performant.

A dirty secret of AI data centers are that they’re only getting 40-60% efficiency out of their GPU clusters and because the moneygun go brrrrr they just buy more.

You wonder why they’re so afraid of the Chinese competition… they can’t afford to be as wasteful

I'm stupid and clearly too stupid to google too. Is bun simply a better nodejs? Assuming it true that all of Claude code is now written by AI, why would AI care about using bun over node?
Has all of this drama turned anyone else a bit sour on bun?

I have a long running side project I migrated to bun, and I'm starting to regret it. I don't want to build on top of this much churn.

Damn, I should have not migrated to Bun. Should I revert back to Npm?
It is absolutely amazing to me that this ai rewrite work so well, maybe claude is not really that much of a complicated tool to stress the bun runtime but still...
It’s interesting that Bun was a human rewrite from Go to Zig. (I think?). Then rewritten from Zig to Rust.

AI is pretty good at rewrites and ports. Quite good infact.

I love bun - although disliked how Jarred did the conversion.

Project-wise, nothing has changed.

Bun was always great because of the fantastic dx - it was just really easy to use , with stuff like out of the box typescript (unreal that it took so long for node, and it's behind a super long flag, wtf...). And it didnt have the weirdness of deno, it maintained backwards compatability with node api, and it just worked.

But it was never stable. You'd have to be fool to believe that a single project could stably do everything bun covers. It's always been an insane project. It was built on top of zig, a langauge that hasn't reached 1.0, and is constantly changing, and throw in how he was rewriting his own custom zig stuff. Like c'mon, let's apply some common sense here.

For me, little has changed. I am still going to use bun as a nice dev tool, and use node for production.

It was an intersting case. Watched a youtube video about this and discussion from zig founder and bun was a little weird.
Yeah, I noticed. I had Claude write a quick JS script for me a few days ago, it then tried to use Bun to run it. When it couldn't find it, it tried to install it with `sudo pacman`. I had to fucking tell it to use Node instead.
My perl re-write is not very good.
Anthropic bought Bun, so they kinda, sorta had to make this work. I am sure the cost at $145,000 in Claude time will get some attention.

I am curious how this will work going forward from FOSS perspective. Will humans be allowed to modify the generated code? Only the .md prompts for the agents? Or what?

This post is just "they didn't lie"...
Turns out it was just a build step after all.
So does that make Claude Code any better?

Can you select text with shift + arrow keys now in the command line client? :)

Basically Anthropic can ship any trojan in underhanded Rust to any target because it is not possible to audit 1M lines of slop.

And the crowd is cheering.