To the contrary, I think any problem with this release would be jumped on harshly so they're being more careful than usual. There's not a rush for the community to move to 1.4 and any issues could poison the community trust.

They chose to use a react rendering to native TUI renderer, which was a source of a lot of performance issues.

AFAIK, they have written a new renderer.

That's such a stupid engineering choice that it really makes one question if the people working at Anthropic have any software engineering ability at all. There's no excuse for running React in a freaking TUI.

Which is equally terrible and has earned them every single rendering engineer in the world taking the piss out of them when they proudly announced it was as complicated as rendering a video game.

The source of the performance issue here is their own incompetence, actually. I have never in my entire career heard of a rendering pipeline as idiotic as the custom one they built.

Which makes the parent comment’s “Bun performance hacks and optimizations” sound a little far-fetched, at least in this scenario I don’t think that’s gonna be the deciding factor. Their vendored JSC is also not touched by this port-rewrite at all whatsoever (still Cpp), so I’m not sure if it’s even possible to hack-improve all that much there.

If it was about Claude Code itself, they could have rewritten it. They keep saying they don't even write code any more, so it shouldn't even matter what language it's in.

I imagine the $800k or whatever this has cost is coming out of Anthropic's marketing budget, so they can make a big splash about it.

[0] https://bun.com/blog/bun-in-rust

Rewriting a runtime with well-defined interfaces and behavior is quite different from rewriting a user-facing application under active development by a decent chunk of their organization.

(I don't mean to be critical of the Bun maintainers, who have always been open about the fact that they leveraged the specific context of their project to do this effectively.)

Bun is a major part of the web ecosystem, having it developed by them via AI, sounds like a gigantic pr win.

It was never that large but it did have a shot at getting more popular - until this drama.

No one worth their salt is building on Bun anymore, the creators and maintainers of bun have demonstrated their complete lack of care around engineering and support. It’s just too risky.

If you install bun you're still getting the zig version.

I don't see major reasons to doubt the rust rework, especially as so much capital and token investment is being thrown at it.

As long as it fits better than alternatives, I see no major reasons to change.

> I don't see major reasons to doubt the rust rework, especially as so much capital and token investment is being thrown at it.

You shouldn't trust the rust rework. Despite the mountains of capital and token investment which have been thrown at it, they still only ship the zig version to users.

Jared and the other developers are new to the Rust codebase, even if the structure is largely familiar. They're also likely focusing on other priorities right now such as tracking down instances of 'unsafe', rather than making user-facing changes (which might encourage a release).

Bugfixes could encourage rapid new releases, but perhaps the rewrite simply hasn't been very buggy? As far as I know, those on the canary channel haven't reported any major issues, or even really noticed the change. So perhaps there's little reason for new releases right now, as the team slowly churns through the backlog.

> P.S. Anthropic’s C compiler and Cursor’s FastRender web browser haven’t had any commits for months.

I always assumed those were just experiments in capability, and weren't meant to be ongoing projects. I would hope that nobody is using them directly today.

I think they're taking things "gradually" as they are under a lot of scrutiny and no rush for full release.

But at some point if “moving one of the biggest actively maintained and used codebases to it without anyone noticing” is dismissed as “it doesn’t mean all that much”, then we’ve lost the plot a little bit somewhere.

(also, fwiw, a manual rewrite would be under the same scrunity and suffer from the same skepticism, at least when obviously rushed).

After spending a lot of time thinking about the language, I came up with a relatively simple algorithm based on the language design - there are a few operators that mutate state, so basically just try combinations of those until your next memory cell contains the thing that you want, then lock those instructions in and advance.

Basically RNG yourself to victory.

The original code for that algorithm is here (python, + my own interpreter): https://github.com/wallstop/malbolge-toolkit/tree/dd942fb981...

I've since llmified it as an exercise.

BUT! The whole reason for this comment is to nerd say that printing stuff is relatively easy if you invest the time in learning the language's primitives and think of programming in it more as algorithms to operate on the op codes instead of literally writing code.

Now, to do more interesting things other than printing - I'd have to spend even more time thinking about the language, which I don't want to

Thanks for sharing!

Really? We had language machines for decades that couldn't do it. One that could was only built in the last 2 years max but that's something you expect from language machines? Lol Okay

A calculator that can find all primes will be cool. A language machine that translates english into JavaScript is cool. A language machine that translates Zig into Rust is cool. Language machines are cool, not awe-inspiring or surprising to me.

Like, come on already.

However if "replacing small sections of code" is heralded as "the most amazing achievement in software development" then we've all lost the plot a little bit somewhere.

It makes sense both ways, no?

The reality is, of course, most people aren't going to notice. If the functionality and performance is 1:1 why would they? Is it impressive? A bit, but not how you're positioning it. People seem to forget LLMs are good at what they've learned from training data. And the LLM is good at compressing time. The only notable thing about these types of marketing spins is that a rewrite was accomplished in a small time frame that was hard to pull off before LLMs. The actual act of the move is less so.

Did the codebase improve? Is it more performant? I've seen nothing to really stake those claims with any objectiveness. Lastly: what was gained?

https://en.wikipedia.org/wiki/F2c

Claude code interacts with many system processes, files, etc, as well as external APIs. Processes audio via built in dictation. Manages a bunch of nasty auth. Etc etc.

What are the categories of features that wouldn't be exercised by this class of software?

To release this to the world and not have it be a catastrophe, they need to have confidence that Bun itself satisfies the promises that it has made, both explicitly and implicitly (bearing in mind Hyrum's law!) to all those projects out there using it, none of which are owned by Anthropic and many of which are not source visible to them. It's a much, much higher bar.

This is an impressive milestone for their rewrite. There are a lot of comments trying to downplay this as being unimpressive for some reason, but I can’t see them as anything other than sour grapes because the rewrite hasn’t crashed and burned like they were hoping.

I am sure we are both right though.

This is a key problem with LLM exuberance: it's very tempting to trade on decades of experience in software using LLMs, because one is tired of typing and manual figuring-out, it seems to work if you're competent, and the payoff is essentially immediate. The real bill comes in the mail much later.

I consider typing to be secondary to software engineering, but I do concede that for those cases that typing really is the bottleneck, LLMs can certainly be of value.

Those cases are rare, though.

Otherwise all of us would just be able to build bun via a prompt.

Various people have claimed that Bun in Zig had a lot of tech debt. If they’re to be believed, it seems natural to assume the rewrite does, too. Perhaps all this activity is paying down some of that debt.

It took TypeScript a year to go from announcing tsgo to releasing TypeScript 7.0. That work was done in parallel; here the work is being done serially — and it’s likely to take much less than a year for a new release.

These are not comparable at all. The bun "rewrite" really is more of a translation of a software that is mainly dogfooded, created with an at best loose regard for a wider ecosystem.

TypeScript 7.0. by comparison is not just a translation from one language to another. It's a true rewrite that at the same time has to consider a massive existing ecosystem (which needs to catch up first or you risk fragmenting it). Plus you might as well consider 6.x part of the effort, since that was the stepping-stone.

Also where bun really is just a runtime implemented with a bunch of glue code plus supporting tooling, TypeScript is much more complex. Change one part of TypeScript and you can get cascading issues somewhere else in the compiler easily. Change something in Bun and you'll likely just break some discrete part.

This seems self-contradictory. If it's just a translation, doesn't that mean it remains fully compatible with that wider ecosystem? All the existing APIs retain identical behavior given the preexisting comprehensive test suite that had to go 100% green after all.

It's not.

Passing an existing test suite just moves the optimistic lower bound to incidental compatibility, it doesn't move it to intentional - "regard" implies you gave it thought.

Plus, it's not just about code: it's also about giving the ecosystem a migration path. Dumping 500k LOC on people and discontinuing development of the zig version effective immediately (there hasn't been a release since and the zig tree is only a reference - the build script is removed afaik) is the opposite of what TypeScript did. If you broke someone's N-API module because of a regression not caught by your suite they're now between a rock and a hard place.

The good news is that there's nobody there to notice. The bun userbase is miniscule* compared to TypeScript's.

* negligible? irrelevant? laughably small? I'm struggling to find an adjective that does the difference justice.

What kind of migration path beyond 0 regression do you think is needed? And if the latest Zig version is no longer available, how were at least 2 forks based on it submitted to HN? And what kind of release are you expecting when the team is working to fully migrate to the port (so far it's still marked canary)? If someone's using an untested (ie. very likely unpublished) API, well it sucks to be them but they should know the risks.

And again the self-contradictory argumentation. If the userbase is as miniscule as you imagine then your criticisms are essentially meaningless. No ecosystem worth giving a migration path and nobody's N-API module breaking because of a regression, right?

Where did I ever claim this? I said they don't even have the Zig build script in their repo anymore - they're clearly not intending to make any more changes to it, even if the code is still lying there next to the Rust code.

> If the userbase is as miniscule as you imagine then your criticisms are essentially meaningless.

They're not criticisms, they're observations. The point is that the challenge is not comparable - because TypeScript's existing ecosystem is part of their challenge.

And what does that matter if the ability for others to build the project isn't affected?

> they're observations

So... what do you want? It's all very pointless to even address.

https://github.com/microsoft/typescript-go/discussions/411#d...

> But this wasn't a compiler redesign, and the TypeScript to Go move was far more automatable and more one-to-one in its mapping.

So basically the opposite of what you're saying.

What's taken 1:1, deliberately, was the compiler core. That was almost perfectly 50% of the non-test code. A close translation of that was a starting point, but open CHANGES.md or it's history and you'll see it's quickly diverging even on its surface.

The closest matching, interesting large area of it is probably the checker. Easily recognizable on a function level, even if not being a single file anymore:

https://github.com/microsoft/typescript-go/tree/main/interna...

https://raw.githubusercontent.com/microsoft/TypeScript/refs/... (The TS file is 3MB and github won't display it inline)

You'll find a lot of the same data structures (as far as that's possible in a TS-to-Go translation + ripples from areas that were more heavily changed) and functions lying around, just in slightly different places. Because of the AST changes and TS/Go differences on a line-level each function might look different, but where there is a loop in the TS one, there's probably one in Go.

The other half of the project is heavily changed or completely new/different (like concurrency, less weird language service).

Hence, the author concludes that rust rewrite is not complete as bun in rust is not released yet.

I agree with author's POV.

I was hoping for more push back against https://bun.com/blog/bun-in-rust - which is pretty thorough and has some decent arguments and reasoning for why they did the rewrite.

Perhaps. But were that the case, one would think they'd be quite eager to say so.

Are you expecting them to live-tweet their work or something?

why shouldnt upcoming work be as public as the rewrite itself was?

The beauty of FOSS tho is Jarred owes the community nothing, and anyone can fork bun previous to migration and keep maintaining it on zig if they so wish.

long live open source

The author's assumption is that a rewrite is not just a mechanical translation of code - it's also a state of stability. And no release, for the author (I agree) means no stability.

It's like a developer who says that after a week of work, a feature is 90% ready, but the other 10% is still not ready (for release) after months.

This is one of the funnier takes on the rewrite. Bun was held up as a flagship Zig project for years. Then they chose to rewrite in Rust and everyone up to the Zig author has suddenly switched to claiming that Bun was terrible code all along.

I use more (albeit cached) when centering a div.

Also worth noting simple horizontal centering of divs was never a problem, margin: auto was defined in CSS Level 1 in 1996 [1].

It was vertical centering that took a very long time to crack, which really became trivial with Flexbox which was first drafted in 2009[2] but became available unprefixed in browsers between 2012 and 2014 [3] about 13 years ago.

[1] https://www.w3.org/TR/REC-CSS1-961217

[2] https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/

[3] https://caniuse.com/flexbox

Subnote: I'm not counting the display: table hacks.

I will have to steal it for an upcoming AI tools meeting I have at work.

Also, pretty clever as centering a div w/ CSS has been notoriously difficult to achieve.

I keep seeing this. What is "un-idiomatic" rust?

To actually get the safety benefits of Rust in a real way you have to rework those files to not treat eachother as C code. This is the interesting and the difficult part of a rewrite in Rust, and one that an unsupervised LLM rewrite is probably not even going to attempt.

I don't think this latter stage has actually happened with Bun's codebase. The result of the Rust rewrite in Bun's case is actually less safe than the Zig it is replacing, especially because (I am told) a lot of the new Rust code is unsound (introducing UB).

You can use deterministic linting for `unsafe` usage, have agents target `unsafe`, etc. It's pretty easy. You can even run `miri` against the code and give that as a tool for LLM feedback. I've done this all before and it works fine.

> The result of the Rust rewrite in Bun's case is actually less safe than the Zig it is replacing, especially because (I am told) a lot of the new Rust code is unsound (introducing UB).

I'm unconvinced that this is true. How could you tell? You only know about the rust bugs because rust makes them grep'able/ trivial to verify, there's no way of knowing which bugs existed in zig that didn't translate. Regardless, the problem is now trivial to understand in Rust and start to target.

Why not? A complete test suite exists, so it just boils down to "reimplement this code to reduce the number of 'unsafe' references, while keeping the tests passing" (the last part isn't even needed since Claude loves to run tests and linters anyway).

That's a really strong motivation for the Rust port. It's literally impossible to take a path not leading to an unacceptable outcome because the Rust compiler fails the compile if code no longer marked "unsafe" is still actually unsafe, and the tests fail if the implementation is incorrect. The compiler actively helps to force the LLM to do things properly.

How odd. Lot of mental gymnastics going on there.

    Do the rewrite that looks like we transpiled our Zig code to Rust. We can gradually refactor it to reduce unsafe usage and look more like idiomatic Rust after Bun v1.4 ships.

The original version of Bun was already a line-by-line (manual) port of esbuild from Go to Zig (also mentioned in this post), so the Zig code already wasn't "Zig-idiomatic" and apparently riddled with problems. That doesn't inspire much confidence in the LLM-translated Rust version tbh.

And yet Claude Code, which is the primary consumer, continues to chug away without any issue (that I, as a fairly heavy user, have encountered).

Eg. goto/jump, bare "except" statements in python, etc... In Rust, unsafe has its uses and is a first class language feature, but it certainly isn't idiomatic to use it to mimic access patterns from other languages (unless absolutely necessary).

that is indeed a roughly accurate definition of what "unidiomatic" means

And most executives are figuring this into their calculus right now because they were burned badly during COVID. Meta, Google, etc were loose with hiring and engineers flocked from their lower-paying companies in droves. The brain drain was real.

One public company I was at lost nearly 2/3rds of their engineers and mostly to Meta (granted, they had other problems but it was mostly about money -- the offers were excessive). Then market conditions forced them to freeze hiring and they've had a slow exodus of senior talent since as the firefighting has become constant.

AI adoption has only accelerated problems for them.

We've taken this "only two years and then leave" philosophy to an extreme and now companies are totally justified in not investing in their engineers anymore.

It was purely about maxing your compensation because changing jobs nets you more than promotions & raises.

I've never met an engineer in my life who truly earned a promotion every year and very few every two. Very few companies have org charts that even support that or have that many levels. This logic/advice only really applies at a few companies and people have adopted it no matter where they work. There's not enough growth/hiring at 95% of companies to even come close. The Peter Principle is also a real thing. Everyone's competence has a ceiling.

There's even an implicit understanding of this that people at smaller companies have inflated titles and you typically rank them down 1-2 levels when hiring/acquiring at larger companies.

Now I do agree that companies haven't been investing in their engineers, but that doesn't also mean this isn't a vicious cycle. Employers and employees are in a mexican standoff and things are only going to get worse until one side comes to its senses. Employers have all the leverage for it to not be them.

For the vast majority of companies the average tenure of an engineer sits between 18 and 30 months. They're also mostly hiring young engineers in their 20s. As an employer what is your upside to making such investments before they're at least mid-career? A lot of people seem to want the world and offer nothing in return for it.

You don't view it as a problem that companies consistently compensate new hires higher than they are their experienced employees?

Hell, I would have been perfectly happy to never change employers in my entire career to date, if my salary had anywhere near kept pace with my peers who were job-hopping.

It depends on the current employee and the incoming employee. They are not interchangeable cogs. Also not everyone consistently provides good value over their tenure -- a lot tend to work hard early and then for various reasons taper off. It's not necessarily their fault, but companies definitely are aware of this.

Personally I tend to value growth of my skillset over growth of income and that has largely informed my movement. I move when there's no longer interesting work if the compensation is at least fair. I've never been about comparing myself to others -- especially when most of my peers' left the industry after 5-10 years.

And you don’t think that has anything to do with incentives (or lack thereof)?

> I've never been about comparing myself to others

Doesn’t have to be about comparing oneself to others. More about the cost of living increasing because software engineering salaries are rising around you…

No, that's almost never it. It's mostly life circumstances, burnout, frustration with management, etc.

> More about the cost of living increasing because software engineering salaries are rising around you…

We're already talking about very well-paid software engineers here. Appealing to a sense of sympathy over cost of living concerns of 1% earners and them trying to become 0.5% earners isn't exactly a strong argument here...

I feel like all of those things are assuaged by more money, and not having to spend half your time job hunting...

I'm similar to many people, I wouldn't have left some jobs in the past had I been treated with a modicum of respect and if my compensation went up with my tenure. But time and time again, pay ranges go up as new hires join in, but you're treated like you're insane for asking your compensation as a senior to match the compensation of a newly joined junior.

I think with sequential approach (translate -> make idiomatic) it is easier. However, I am not sure that monetary difference is going to be as stark as $165k vs 3 engineers/year. Especially, if you consider that no one knows that is what in the code at the end.

Sure, you can argue that now it doesn’t matter — agents and all that, but I am not so sure.

Not necessarily. Didn’t Microsoft port the TS compiler to Go and they did it by translating the TS? It wasn’t idiomatic Go.

The question pops up: was the point of this rewrite to get more publicity reach? Was it all marketing? I can schedule a rewrite of Wordpress to Rust just today, call it a day in a week and proclaim a great end to PHP in Wordpress - but then, it's all pointless. The whole point of Wordpress is PHP.

I know I'm comparing apples to oranges here as Bun is not the same as Wordpress. But is it really that distant to not use this analogy?

For future, I'll be asking myself one question: who has skin in this game?

What's the point of this rewrite? Who benefits from it?

What a time to be alive

It means shrewd.

E.g. we should keep our wits about us when someone is making big hyperbolic claims about LLM that they directly benefit from, because maybe they have a motive to mislead either themselves, or us

I shouldn't be surprised though, of course. Giving any credit or slack to a high-valuation LLM company is a silly endeavor.

But what makes software is not the fast creation of a "product" but that actual development of its features. Figuring out how everything needs to work together, fixing the bugs, and the o so boring UI work.

I have used LLMs to create stuff like word clones just for fun. It was a disaster. Sure, it had the basic functionality. But the moment you started with page structure (harder then one non-stop scrolling page), tables, images, rotating, and so many details that make up just the basics of word. Not even the extended functionality. You see every LLM just fall on its face.

Sure, i can clone sqlite from c to rust. Hell, i may even get it to do all the tests 100%. But there is a 99% chance that the clone will be slower, as it lacks the years of optimizations from the original language. There will be new bugs because of the language changeover. There is a need for future support and fixes.

People threat software like its something it is not. But unlike the past where your clients question your sanity for charging 100k for a piece of software. Not understanding its not just about writing the code. Now those expectation are even more pushed forwards, because of articles like this.

I constantly see software being published on reddit that does X, Y, Z only for the authors to abandon it as fast as they vibe coded it. Because fixing bugs is NOT sexy. Even with a LLM at your fingertips. Dealing with nagging users, is not sexy. Dealing with security issues, is NOT sexy. Dealing with data structure / databases, especially as your system changes ... you get the point.

Not understanding to the core the software you wrote, is going to exploded in your face.

This is why these stupid "we rewrote X into Z with a LLM in Y days" mean nothing. Its one thing to get a head start using this trick, its another to actually learn the code of your rewrite. And dedicated the time into maintaining the port, growing it, fixing it. This is where a lot of software fails. But now this crap is out there, instead of the maintained version of Zig, now we have a unmaintained Rust version that clouded the airwaves because if people now search for it, those articles "X in Z days" will pop up.

What have we become ...

If you explore Github, you're gonna see thousands of abandoned game engines, compilers for made-up languages. And that has been happening since before the LLM era.

I used to be part of an OS messaging board in the early 2000s and almost everyone had their own OS. A dozen people or so could even run Firefox! I remember (now legend) Terry bothering us to check out LoseThos or GodOS or whatever was its name, but quite a few people had OSs that could do more than that.

Not all software needs to be commercial to be useful, even if it's just for a learning experience. I have learned a lot from those experiments, even if they're not polished.

Yeah, but the people authoring those learned something.

> I used to be part of an OS messaging board in the early 2000s and almost everyone had their own OS.

Great example! I, too, once had my own toy OS, and browsed OSDev wiki nonstop. The thing is no one in the OS dev community were writing things they intended to place in front of actual users!

The difference now is that these incomplete projects:

a) Don't leave their owners any wiser than when they started, and

b) Are actually intended by their owners to be used by actual users.

> I have learned a lot from those experiments, even if they're not polished.

Would you have learned as much if you told a magic box "Make me an OS" and then slapped your name on it and uploaded it to GH?

I've built tools myself with AI assistance and I've learned a bunch, and will still keep learning.

Temple OS :)

This is fine so long as the author is learning something (questionable) and not polluting the commons with "I made this in a weekend" vibe slop.

Almost all of my prototypes are made this way. "I made this in a weekend", is more often, "I made this in a day". Like any trad-coded project, time to vibe code a backend vs frontend time is 1:N

This is exactly the same as demanding, that people who post their thoughts always post original, useful thoughts. It's just not going to happen. Making something easy will increase the total volume and the majority of that volume will be junk. It's inevitable. What is needed is a search engine for quality software. Perhaps LLMs can do that, since they are better at understanding concepts than generating them.

But it seems like we're finally starting to accept that "accidentals" like network effects, ownership, accountability, etc. are important. Of course, that's why many of us fled to technical corners in the first place - because the "accidentals" become tied up with things like nepotism, unfair and arbitrary judges from random humans who don't understand your merit, the need for bullshitting more than real technical value. Supposedly, anyways.

I never thought of this from this perspective but indeed it seems to be totally true.

Short-termism at its peak. Code maintainers will learn the hard way how to set the boundaries between ai-generated code, and human maintainable code.

I worked for a startup that stopped feature development and did a complete rewrite of a huge codebase. I was assigned to a side project during this time and missed the entire rewrite process. I came back to a completely rewritten codebase.

There was almost no learning curve, despite being in an entirely different language. The core architecture, data structures, and concepts were the same.

If you read the Bun blog post on how they did it, their rewrite was similar: The first step was getting it into a new language, not rearchitecting it from scratch.

I think they did it the right way based on my pre-LLM. Rewriting into a different language as fast and basically as possible is important for getting the team switched over quickly. Rewriting into a different language in X days is actually a good goal to minimize.

> If you read the Bun blog post on how they did it, their rewrite was similar: The first step was getting it into a new language, not rearchitecting it from scratch

They eventually might regret this, when they are trying to get rid of the last lines of unsafe code. Rust needs to be written differently before you can write safe things to perform fast when compared to other languages or unsafe code. It takes a lot of experience before you can see it.

If this were a major issue then you'd have to always nail your Rust architecture correctly from day 1 to handle future unknowns, and this isn't the case.

More importantly, LLMs are more than capable of figuring out how to rearchitect code and they have no problem making sweeping refactors for you.

Also if you whip something up, you tend not to care for it as much as something you took the time to create in a "proper" manner.

What do you think of https://scramblequest.app and https://wordpeek.app ?

I have never looked at any of the code for them

edit: Yeesh, misread your comment as "word games" not "word clones" and was very confused about the claim. Probably should have noted my confusion and re-read.

Word is basically an operating system. Unix people like to make fun of Emacs for being one, but Word is basically one, too. And all the features in there are used, otherwise Microsoft wouldn't keep them around.

And .doc files are basically a memory dump.

In case of ccc (claudes C compiler) they just did not use any tests, though they are many existing C testsuite. They just stopped, when it finished compiling the kernel, still failing hundreds of tests.

Not really. Transpilers have existed since forever.

The hard part is all the edge cases. (And LLMs don't solve this problem; they probably akshually exacerbate it.)

LLMs amazed us and we've been trying to find a good use for them since and there's a lot things like this, replacing a transpiler with a non-deterministic machine that just guesses when it doesn't know the answer.

Shouldn't we be targeting LLMs at problems that traditional software absolutely can't handle?

I think there are tons of learnings to be shared about how to do this stuff, but it seems like it's all blocked behind arguments over whether AI is the best or worst thing ever, and penis-measuring contents about how to hold the tool. The net benefit is a very open question, and both the doom and gloom perspective and the AI booster perspective are valuable and have a lot of things right. But there's a dearth of information about what things work, what things don't, what happens in the process of using AI, how to adjust one's behavior and which of those adjustments is harmful even if effective.

But then, I'm part of the problem. I keep meaning to write up a series of experience reports, but it's a lot of work. More fun to vibe a new feature into existence, or to finally fix a UI wart...

If you have an LLM or human just start coding up something without nailing down those decisions first, then he/she/it will implicitly make those decisions arbitrarily in the moment (usually based more on pattern-matching than real weighing of alternatives) and the result will be a massive mess.

Ideally for an LLM, you'd hand-write a highly detailed DESIGN.md file to encode those decisions and a suite of test fixtures to enforce them.

I still believe it was the good decision, but I also know that I wouldn't be the first person to run the release in prod.

I think Jarred should start making release candidates instead of releases to take some of the pressure off.

You and me both friend!

If you're being pedantic, no it's not "done," but nothing ever is.

One single product, AFAIK, and one ladden with bugs and issue too.

I am mostly bullish on AI capabilities, so from my perspective I don't see why we should be skeptical that frontier LLMs guided by experienced devs can translate whole libraries like that. Good follow-up questions would be how expensive it currently is to do so, and whether we will see people branching into all-in on AI versus no-AI camps as happened in this case.

No one on their team had Rust experience

There are so many non-quantifiable properties to evaluate of the 'before' and 'after' codebases. Choices and preferences to be had about languages, language porting in general, and LLM coding.

After all that, pretend we could have a clear convincing distillation of the port and want to go apply the lessons learned. If someone doesn't get LLM porting results as good as Bun did, or it cost them substantially more in tokens, then they're "holding it wrong." If someone is underwhelmed by Bun's results, then it was just a proof of concept and the models have gotten so much better in the last 6 months anyway you can't compare.

There's a laundry list of reasons to be skeptical about LLM results in general. The biggest one is that LLMs are excellent at creating output that looks right but is nevertheless still wrong.

In this particular case, there's also a specific reason: This is obviously a marketing stunt regardless of whether the claimed results hold up. Anthropic has a long history of just lying and making shit up, so any results are subject to extra scrutiny.

"Anthropic has a long history of just lying and making shit up"

Every now and then I wonder, if LLMs were created by honest people would they be more honest themselves?

and ho, the bloat, do not forget the bloat, which is technical debt towards the future.

I am not anti-ai per-se, but I consider the software I write as a prouct to add features to and maintain over time. So in this case I think it is not wise to say that bc you got something impressive fast you are done. Now you have bugs, architecture, bloat removal, and others...

Letting an AI manage all the workflow is a recipe for disaster in anything that is not strictly short-term. For this reason, I hardly code one-off scripts myself anymore and I hardly use AI for big things besides discussions with the prompt, reviews and snippets. For adding tests it can also be useful.

For full, long-term products, they try to sell agents, and tokens and the like. I think they do not work well enough what I tried. It always ends up as a bloated unmantainable mess.

Unless something that is totally autonomous (by this I mean 100% autonomous) and automated ever exists, I see writing software that can be maintained by humans still critical. As long as this exists, the productivity upper bound will be that of humans reviewing and driving the workflow, even if with AI support.

Thankfully now I have some good material to post-rationalise my intuitive dislike

We can't have commited and involved people working on opensource stuff and simultaneously avoid drama when their sence of identity/beliefs/pride is devalued.

The leaked code of the claude had switch flag where claude pretends to be employee. You can't trust/expect that those PR's were authored by people.

Oh, that company that I heard did not use humans aymore to write software and bragged about it? I heard, correct me if I am wrong.

Something does not match here...

That’s peanuts, if not the shells of the peanuts, for a project and company of this magnitude

- just because it doesn’t help 99.9% of the companies today it doesn’t mean it won’t help them tomorrow

- 0.01% of the companies employ a much bigger percentage of people

- 99.9% of companies won’t need to do a project of this magnitude

If it turns out the rewrite cost stupid amounts of money and leads to a bad outcome, it's just a misleading ad.

We developers now need to explain that to illuminated management and colleagues.

But sadly HN is hiding my post... :(

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

EDIT: I'd love to hear why I'm downvoted.

Can you explain that more?

Going forward, I will strive to not make leaps that my audience can't follow.

In the Bun v1.4 video, I promised a certain number of newly passing Node.js tests were added to force us to improve compatibility, and that number is not true yet. The release is delayed until it is true. The PRs to make it true are up but not merged yet. Most likely next Tuesday we’ll do the release of 1.4.

Node has 4-6 weeks without a meaningful release (other than security stuff) pretty much every December. I think the criticism in the article is unfounded and whomever needed/wanted a release should have asked first instead of writing an "angry" blog post.

(I'm a Node.js maintainer)

I'm consistently skeptical about new tech whether it is NoSQL or Blockchain or Serverless. Some of the things I'm skeptical about fail and some succeed.

The fact it's taking a while to release is still insanely fast. I'm sure they may be some bumps.

Being skeptical is good and some stuff succeeds and some doesn't - but building tools is still fun and cool, whether it's useful or widely adopted or not :)

Did it really cost $1 million instead of the 150k that’s been floating around?

If you don’t like the price now just give it some time.

The point is that these kind of heroics can actually work now and they’re only going to get cheaper.

I don’t mean to sound negative about what you wrote, it was an interesting read.

"We at WC Duck recommend WC Duck"... I'm left scratching my head, if you'd care to spell out what the saying means for non-Dutch I'd appreciate it :)

So the first thing an English native might get from "Canard WC" is probably hoax toilet, I expect the duck imagery of the product would bring the "canard" == "duck" meaning across though.

Ah, for context, which I suspect you may be unaware of, Jarred (the person who said the rewrite to rust went well) is the creator of bun, and the guy behind the rewrite.

1. Assume the Rust rewrite of Bun went badly

2. Then something must be grievously wrong with a released bun runtime based on that code

3. Claude Code uses the released bun runtime based on that code

4. From #2 and #3, something must be grievously wrong with Claude Code

5. If something were grievously wrong with Claude Code, users would reduce use of Claude Code and use alternative tools

6. From #4 and #5, users are reducing use of Claude Code and using alternative tools

7. Claude Code has wide use and use is growing across all software engineering verticals

8. #6 and #7 contradict

9. From the contradiction, the assumption in #1 is false

The parts that are not explicitly spelled out here are an exercise for the reader. It doesn't really matter if the guy who wrote Bun said this or my uncle said this.

I always thought it was common sense and just basic critical thinking to take people paid by Anthropic praising products of Anthropic with a grain of salt (and let's be clear, that's what this is), but apparently it's not.

[1] What it actually proved is up for debate.

I guess I'm debating, but it seemed clear enough to me? It proved that AI models and their harnesses are to the point where you can give them some work to do and leave them unattended for a long time, and they'll keep doing productive work for quite a while. This was a novel thing, and quite unclear, at the time the experiment was performed.

Obviously, the word "productive" is doing a lot of work there, but in my understanding the intention was nowhere near "commercially viable" or "practically useful", it was more like "not doing stupid shit like writing comments of the form 'This file contains the implementation implementation implementation implementation implementation implementation implementation implementation implementation implementation implementation implementation implementation ...'".

Maybe somewhere in the vicinity of "either passing more tests or generating more valid tests"?

We recently started cross-compiling all the builds on Linux arm64 and that made it a little faster (I wrote a CLI tool to download the correct macOS headers for cross-compilation). We also have a daily cron job that asks claude to make the slowest tests faster while adding more assertions.

We shard to a lot of machines for tests and I’d be worried about running out if we used dedicated servers.

BuildKite is fine but I wouldn’t be that surprised if we move off of BuildKite to a custom thing at some point. Months ago, we switched from CMake to a handrolled typescript build system and it made our builds faster and simpler.

I suppose my second question would be how much Bun spends on CI per month atm - I'd imagine that robobun would have ramped up the bill a fair bit

codex trivially built me a self-hosted gh actions runner workflow for ephemeral vm's (just a big bash script that manages the vms with qemu). i even sped up the builds with my own custom base image with everything installed in it that i need too.

it works flawlessly.

fanning that out to starting and stopping instances wouldn't be too much of a stretch.

https://developer.apple.com/documentation/virtualization/run...

I look forward to the postmortem!

A retrospective is just the reflecting part, without implying you believe it is going to fail and you're looking for some schadenfreude ;)

Example: https://blog.codinghorror.com/game-development-postmortems/ Note the dual emphasis on both "what went right" and "what went wrong," not just one or the other.

Yes; I think what I described matches that meaning?

Post-death, as in: "it's over," "activity has halted," "no more work being done."

Death does not necessarily have a bad/negative connotation. It's just the end of something.

This is in contrast to the original comment: "something that went so wrong you had to kill it." Death does not imply something went wrong or that it happened forcefully.

I guess "autopsy" generally is talking about "finding the cause of death" so maybe that has a more negative connotation ("something (bad) happened, causing death, let's find it").

Ah, words with their fuzzy meanings (:

Which makes even less sense as we all know software is never done, unless it truly is dead.

Sure, that's true. It's not really relevant to people who don't speak Latin.

> It’s synonymous with autopsy!

This isn't true. I have no idea how you got here. In English an autopsy is a surgical procedure performed on a corpse for the purpose of identifying the cause of death. In particular, it's a noun. "Post-mortem" in the etymologically literal "after death" sense is an adverb or adjective identifying whatever it is as taking place chronologically after some contextually-specified death.

But, you seem to put some weight on the etymology of a word independently of its current meaning. In that case autopsy "literally means" to witness something personally, as opposed to hearing about it from someone else. (It's "self-eye" in Greek just as post mortem is "after death" in Latin.) Somehow I doubt that's what you had in mind...?

They don't mean similar things and they aren't used similarly. A postmortem is, as you note in part, a report or a meeting for the purpose of producing or discussing such a report; an autopsy is a surgical procedure. They're as "synonymous" as the words "cigarette" and "cancer".

Now you get it.

You can be the crabby old guy complaining about how the youth ruined English ... or you can accept that languages aren't immutable, and that the meaning of postmortem is no longer it's literal meaning.

> The goal of a postmortem is to draw meaningful conclusions to help you learn from your past successes and failures. Despite its grim-sounding name, a postmortem can be an extremely productive method of improving your development practices.

Mostly in the opensource, or marketing-blog spaces. The detailed investigation and fix report was a favorite genre of blogpost. And if someone's bragging about the design of an enhancement, or investigating a bug, then the overall product isn't dead. They're (usually) not talking shit to anyone. It's the bug that's dead. Or security indecent that's over. Or a schedule milestone that's "dead and burred".

It's a 1 chili pepper level of spicy to use a slang term that relates to death. I'd never read it as hoping someone fails. I think people let the corpotalk center of the brain overreact to anything that's not couched in euphemism.

You’re taking it very literally here, it does not involve anything being dead or killed.

We’ve used this in the software, games, film and construction industries for decades at this point.

Substitute Mortem for Ship and that’s how people use it.

This is from July 8, 2026. And while you did link it in your article, what else are you expecting?

- How many people have updated Claude/Bun to the latest version.

- How many subscribers care about reporting issues. Most of them are forced to use the tool against their will and have mentally checked out already. Why report issues if your employer values slop code anyway. Just log the hours and keep your head down. Maybe it is not expedient for the AI narrative to report issues!

- How many subscriptions are real vs. bulk distiller accounts.

- If subscriber numbers are inflated.

Judging by the weird Claude Code Github issues page, there are suspiciously few new issues: about 2 to 3 a day only vs. alleged subscriber numbers of 4 million.

By default, Claude Code updates itself all the time without asking for permission, so I'd say most users are on the latest versions.

Supposedly they used a game engine to render their TUI but I’ve never had an FPS game do that.

No GUI developer would ever put this on the same thread.

Yes Boris, tell me more about how "coding is solved".

Edit: literally just now, while writing a claude code hook, opus5 gave me this LOC because apparently the changelog and what's in the transcripts _differs_; great docs d00ds.

    # Present only for a subagent's calls. Both spellings accepted: the changelog
    # names `agent_id`, transcripts use `agentId`, and we need not care which lands.
    agent=$(printf '%s' "$input" | jq -r '.agent_id // .agentId // empty')

What's stopping the LLM from having unscrupulously injected something nefarious into the codebase that you are unaware of?

What's stopping future updates from the LLM from doing the same?

Are you aware of the potential ramifications of deploying thousands of lines of non-human reviewed code to millions of users machines?

Are you happy to be personally responsible for the horrendous outcomes that could occur in these situations?

I guess they put it in capitals for a reason.

It could be argued, probably successfully, that this is a case of gross negligence and that Anthropic should be held accountable for harm caused due to their reckless actions.

Especially now that they have been made aware of the possibility, they also cannot claim ignorance of the potential issues.

Certain consumer rights, depending upon the country, also cannot simply be removed or waived due to a organisation's terms of use or implied contract.

Rewrites of this scale certainly justify long canary release periods!

> Anthropic is dogfooding this, the machine is still ticking along, and Anthropic employees are directly involved.

The problem is that your article's central claim is that there hasn't been a Bun release since the Rust rewrite - which can be read as implying that the rewrite hasn't been used in production.

But it's been used in production on millions of machines running Claude Code for over a month!

I think failing to acknowledge that hurts the credibility of the article. It's been a heated discussion point in this thread already.

I don't agree that using something in a very specific environment is the same as a wide release.

I trust readers will either know the backstory or read the articles I link to. Such is life if they don't.

Do you think it would weaken the article?

When I said it would improve the credibility I did mean it. My instinct on reading the article this morning was "this person doesn't know that Claude Code runs on Bun, which weakens their credibility in presenting the argument they are making here."

You could argue that the release tag isn't important - but at the top of this comment thread a member of the team confirms they delayed the release to finish some extra testing. So the ambiguity around if the project is complete and pointing to the lack of a release mirrors internal sentiment as well.

I had a funny thought that Bun might add a release tag while I was still writing the article. In that case I'd still publish it, because the point is we still don't know the cost it took to get to a viable, wide, release. The $165k isn't the full story.

It's not your article, bud. They have already addressed your concerns, and don't need to make changes just because you feel the article isn't "fair".

> My instinct on reading the article this morning was "this person doesn't know that Claude Code runs on Bun, which weakens their credibility in presenting the argument they are making here."

And your instinct was clearly mistaken. You should read the article more carefully before offering criticism.

There's an easy fix. If they don't want to take my advice that's completely fine.

Well it hasn't. "Production" for a language runtime means being generally available for arbitrary use. The engineers that built the runtime using it to release one closed source binary to the public is, at best, an extremely narrow beta test.

I was optimistic those would be going down over time but it looks like they've stayed pretty constant: https://news.ycombinator.com/item?id=48966569#48967630

I get that there's a baseline of unsafe that's necessary, but I was under the impression that some of those unsafes were in places where they could be replaced by more idiomatic Rust at a later date.

I feel like it made me generally more ambitious in what I’d throw at a coding model, but also made me focus a lot more on our testing harness and keeping a lot of it at the boundaries outside the language specific parts.

Having been part of several huge rewrites before, some multi-year long, I definitely would consider bun’s rewrite an enormous success. To keep such a level of test and feature parity, and add improvements on top of it, is a massive engineering feat.

https://ziggit.dev/t/buz-a-drop-in-replacement-for-bun-using...

I have no skin in this game, and the Zig version is also using LLMs if that helps take the culture war out of it. But, it has always been true in my experience that someone who really understands a problem space can outcompete someone who just throws resources (in hundreds of thousands of dollars of token spend) at it.

The main issue that justified the rewrite were memory bugs, especially related to interaction with GC managed Javascript objects. There is no fully general way to prevent those bugs in Zig, and I don't see any claims that they did so in Buz.

Migrating to Rust in a one-to-one translation with unsafe blocks does not make the code any more safe initially. It might provide tools to do a significant refactor that solves lifetime issues with Rust's help, but I haven't seen evidence that they've done that either. They're also embedding a large C++ codebase, JavaScriptCore, so there are always going to be unsafe areas and touchpoints where memory issues could live, and Rust won't magically solve them.

> Bun is the quintessential AI slop project at this point. Inheriting that is no easy task. I don’t think any human should sacrifice their sanity untangling this mess of 600K lines of slop code. For that reason, I will not be accepting any human-coded contributions until I deem the project to be in a sane enough shape. It will likely require most subsystems to be rewritten.

They're refusing to accept human-authored contributions. They're using LLMs to do the work. The author says they'll use LLMs to de-slop what they think is slop, and humans are banned from contributing.

I don't think you should take this seriously.

I've heard stories of LLMs changing tests to get all the tests to pass instead of actually fixing code. So I'm not sure I trust it just because tests pass. I also think that tests do not and cannot check everything.

I also don't trust it just because it compiles in Rust. The Rust compiler does not check everything.

So at what point do projects like this cross from "untrusted" to "trusted"?

That's very easy to prevent. Don't let them edit the tests! Run the test suite against a reserved copy.

But the article talks about how so much code was written so fast. Seems to me that to create that much code that fast you have to have AI produce both the code and the tests.

So I am not sure in this project if the AI can edit the tests or not. I assume that because this is Anthropic the AI is doing as much as possible, which would include editing tests.

You can go and check if the AI edited the tests yourself: look at the git history of those files in the public Bun repository.

In general I would agree though, and would take it one step further: the agent writing the source code should not even be able to see the tests, nor the agent writing the tests see the source code.

If you're going to do serious development with Rust, I suggest forking the compiler. Upstream your fixes to a fork which takes AI contributions, or fork your own. Or keep all of your improvements private, that works just fine.

The marketing value of this to Anthropic (if Anthropic even cares, this might just be the Bun team selling past the close) is to show that such a rewrite is possible and delivers engineering value. If exactly this project is $800K today, it'll be $200K and then $80K soon, so it's not so important to the story that it's cheap, just that a big "cool" rewrite is possible, and delivers velocity to the buisness.

Writing code is a different thing.