I believe this completely. They didn't have to join, which means they got a solid valuation.

> Instead of putting our users & community through "Bun, the VC-backed startups tries to figure out monetization" – thanks to Anthropic, we can skip that chapter entirely and focus on building the best JavaScript tooling.

I believe this a bit less. It'll be nice to not have some weird monetization shoved into bun, but their focus will likely shift a bit.

> Almost five years ago, I was building a Minecraft-y voxel game in the browser. The codebase got kind of large, and the iteration cycle time took 45 seconds to test if changes worked. Most of that time was spent waiting for the Next.js dev server to hot reload.

Why in the hell would anyone be using Next.js to make a 3D game... Jarred has always seemed pretty smart, but this makes no sense. He could've saved so much time and avoided building a whole new runtime by simply not using the completely wrong tool for the job.

Happy to answer any questions

> Bun will ship faster.

That'll last until FY 2027. This is an old lie that acquirers encourage the old owner to say because they have no power to enforce it, and they didn't actually say it so they're not on the hook. It's practically a cheesy pickup line, and given the context, it kinda is.

Huh, this feels very odd to read and buying a company outright is definitely not the only way to push Bun to be excellent. Contributing to Bun from their developers, becoming a sponsor, donating through other means, buying 'consulting services' or similar, or even forking it and keeping it up to date would all be also steps towards keeping the Bun excellent.

This is vendoring a dependency on steroids, and first moment interests of community are not aligned with what Antropic needs, it will be interesting to see how this unfolds. History has thought us that this will end up with claims in the blog post not holding much weight.

Very direct, very plain and detailed. They cover all the bases about the why, the how, and what to expect. I really appreciate it.

Best of luck to the team and hopefully the new home will support them well.

Will this make it more or less likely for people to use Bun vs Deno?

And now that Bun doesn't need to run a profitable cloud company will they move faster and get ahead of Deno?

How would the payout split work? It wouldn’t seem fair to the investors if the founder profited X million while the investors get their original money returned. I understand VC has the expectation that 99 out of 100 of investments will net them no money. But what happens in the cases where money is made, it just isn’t profitable for the VC firm.

What’s to stop everyone from doing this? Besides integrity, why shouldn’t every founder just cash out when the payout is life-changing?

Is there usually some clause in the agreements like “if you do not return X% profit, the founder forfeits his or her equity back to the shareholders”?

I'll admit I'm somewhat biased against Bun, but I'm honestly interested in knowing why people prefer Bun over Deno.

Investors must be happy because Bun never had to find out how to become profitable.

In the article they write about the early days

    We raised a $7 million seed round

- Anthropic can't write its TUI app in anything else more suitable than Javascript

- They feel the need to buy a portion of their software supply chain

I did end up fixing Node.js compatibility later but it was extra work. Felt like they just created busy-work. Node.js maintainers should stop deprecating perfectly good features and complicating their modules.

That perspective following “in two-three years” makes me shudder, honestly.

Why not something like c#: native, fast, crossplatform, strongly-typed, great tooling, supports both scripting (ie single file-based) and compiled to a binary with no dependency whatsoever (nativeAOT), great errors and error stacks, list goes on.

All great for AI to recover during its iterations of generating something useful.

Genuinely perplexed.

Agentic systems are no longer just model-driven — they are increasingly runtime-driven through tools, sandboxes, and orchestration layers. When agents are writing code, executing tests, calling external tools, and validating outcomes, the reliability of the entire system becomes a function of the runtime and environment, not just the model.

Controlling the runtime gives Anthropic vertical control across:

- Packaging and distribution - Execution semantics - Performance characteristics - Security surface area - Operational stability

Of course, owning a JavaScript runtime does not magically make runtime deterministic. The dominant sources of variability still sit lower in the stack: OS behaviour, native dependencies, filesystem semantics, scheduling, hardware differences, and network effects. Runtime ownership is necessary, but not sufficient, for true runtime determinism.

What this does signal is a strategic shift in where value is being captured.

Model capability is no longer the only critical layer.

The execution plane is becoming just as strategic too, can see this in ChatGPT 5’s dynamic model routing capability as well as ecosystem wide Tool Calling and MCP adoption, which are all aimed at increasing LLM determinism through traditional software stacks.

Vertical integration here looks far less like a tooling move and far more like a control-plane strategy: consolidate the stack, reduce dependency entropy, and shrink the surface area where behaviour can diverge.

Intelligence may live in the model, but reliability, scalability, and trust are increasingly properties of the system that executes it.

So many of the issues with it seem to be because ... they wrote the damn thing in JavaScript?

Claude is pretty good at a constrained task with tests -- couldn't you just port it to a different language? With Claude?

And then just ... the huge claude.json which gets written on every message, like ... SQLite exists! Please, please use it! The scrollback! The Keyboard handling! Just write a simple Rust or Go or whatever CLI app with an actual database and reasonable TUI toolkit? Why double down and buy a whole JavaScript runtime?

moreover, now they can make investments in order to make it an an even more efficient and secure runtime for model workspaces.

Except Node's author already wrote its replacement: Deno.

This just isn't the hard part of the product.

Like if I was building a Claude Code competitor and I acquired bun, I wouldn't feel like I had an advantage because I could get more support with like fs.read?

I guess we should wait for some opt-out telemetry some time soon. It'll be nothing too crazy at first, but we'll see how hungry they are for the data.

At the very least there must be some part of the agent tasks that can be run in JS, such as REST APIs, fetching web results, parsing CSV into a table, etc.

[1] https://ziglang.org/code-of-conduct/#strict-no-llm-no-ai-pol...

> Being part of Anthropic gives Bun: Long-term stability.

Let's see. I don't want to always be the downer but the AI industry is in a state of rapid flux with some very strong economic headwinds. I wouldn't confidently say that hitching your wagon to AI gives you long term stability. But as long as the rest of us keep the ability to fork an open source project I won't complain too much.

(for those who are disappointed: this is why you stick with Node. Deno and Bun are both VC funded projects, there's only one way that goes. The only question is timeline)

How was Go involved there before Zig?

    npm install -g @anthropic-ai/claude-code

Feels like maybe AI companies are starting to feel the questions on their capital spending? They wanna show that this is a responsible acquisition.

Put the Bun folks directly on that please and nothing else.

Acquisition seems like a large overhead and maybe a slight pivot to me.

Congrats to Jarred and the team!

Using bun on a side project reinvigorated my love of software development during a relatively dark time in my life, and part of me wonders if I would have taken the leap onto my current path if it weren't for the joy and feeling of speed that came from working with bun!

And apparently the submission's source for being the only org I can tell that anticipated this: https://www.theinformation.com/articles/anthropic-advanced-t...

https://github.com/oven-sh/bun/pull/24578

So far, someone from the bun team has left a bunch of comments like

> Poor quality code

...and all the tests still seem to be failing. I looked through the code that the bot had generated and to me (who to be fair is not familiar with the bun codebase) it looks like total dogshit.

But hey, maybe it'll get there eventually. I don't envy "taylordotfish" and the other bot-herders working at Oven though, and I hope they get a nice payout as part of this sale.

This will make sure Bun is around for many, many, years to come. Thanks Anthropic.

Why Bun?

Easy to setup and go. bun run <something.ts>

Bells and whistles. (SQL, Router, SPA, JSX, Bundling, Binaries, Streams, Sockets, S3)

Typescript Supported. (No need to tsc, bun can transpile for you)

Binary builds. (single executables for easy deployment)

Full Node.js Support. (The whole API)

Full NPM Support. (All the packages)

Native modules. (90% and getting better thanks to Zig's interop)

S3 File / SQL Builtin. (Blazingly Fast!)

You should try it. Yes, others do these things too, but we're talking about Bun.

(1) Bun is what technical startups should be. Consistently excellent decisions, hyper focused on user experience, and a truly excellent technical product.

(2) We live in a world where TUIs are causing billion dollar acquisitions. Think about that. Obviously, Bun itself is largely orthogonal to the TUIs. Just another use case. But also obviously, they wouldn't have been acquired like this without this use case.

(3) There's been questions of whether startups like Bun can exist. How will they make money? When will they have to sell out one of the three principles in (1) to do so? The answer seems to be that they don't; at least, not like we expected, and in my opinion not in a sinister way.

A sinister or corrupting sell out would be e.g. like Conan. What started as an excellent tool became a bloated, versioned mess as they were forced to implement features to support the corporate customers that sustained them.

This feels different. Of course, there will be some selling out. But largely the interests of Anthropic seem aligned with "build the best JS runtime", since Anthropic themselves must be laser focused on user experience with Claude Code. And just look at Opencode [^1] if you want to see what leaning all the way into Bun gets you. Single file binary distribution, absurdly fast, gorgeous. Their backend, OpenTUI [^2], is a large part of this, and was built in close correspondence with the Bun folks. It's not something that could exist without Bun, in my opinion.

(4) Anthropic could have certainly let Bun be a third party to which they contributed. They did not have to purchase them. But they did. There is a strange not-quite altruism in this; at worst, a casting off of the exploitation of open source we often see from the biggest companies. Things change; what seems almost altruistic now could be revealed to be sinister, or could morph into such. But for now, at least, it feels good and right.

[^1]: https://github.com/sst/opencode [^2]: https://github.com/sst/opentui

This is promising for Astral et al who I really like but worried about their sustainability. It does point to being as close to the user as possible mattering.

Or perhaps they have in their agreement that Anthropic's own rules don't apply to them?

Serious question, in all this madness

https://www.youtube.com/watch?v=6hEiUq8jWIg

and when this bubble pops down goes bun

What? Oh, lots of slop code?

> Long-term stability. a home and resources so people can safely bet their stack on Bun.

Isn't it the opposite? Now we've tied Bun to "AI" and if the AI bubble or hype or whatever bursts or dies down it'd impact Bun.

> We had over 4 years of runway to figure out monetization. We didn't have to join Anthropic.

There's honestly a higher chance of Bun sticking out that runway than the current AI hype still being around.

Nothing against Anthropic but with the circular financing, all the debt, OpenAI's spending and over-valuations "AI" is the riskier bet than Bun and hosting.

[1] www.bunn.com

To some degree have “opinionated views on tech stacks” is unavoidable in LLMs, but this seems like it moves us towards a horrible future.

Imagine if claude (or gemini) let you as a business pay to “prefer” certain tech in generated code?

Its google ads all over again.

The thing is, if they own bun, and they want people to use bun, how can they justify not preferencing it on the server side?

…and once one team does it… game on!

It just seems like a sucky future, that is now going to be unavoidable.

Why?

Regards.

> We’re hiring engineers.

Careers page:

> Sorry, no job openings at the moment.

/s

It’s wild what happens when a generation of programmers doesn’t know anything except webdev. How far from grace we have fallen.