Even with a cold cache, `bun install` with a large-ish dependency graph is significantly faster than `npm install` in my experience.

I don't know if Deno does that, but some googling for "deno install performance vs npm install" doesn't turn up much, so I suspect not?

As a runtime, though, I have no opinion. I did test it against Node, but for my use case (build tooling for web projects) it didn't make a noticeable difference, so I decided to stick with Node.

Despite the page title being "Fullstack dev server", it's also useful in production (Ctrl-F "Production Mode").

I don't know how Deno is today. I switched to Bun and porting went a lot smoother.

Philosophically, I like that Bun sees Node compatibility as an obvious top priority. Deno sees it as a grudging necessity after losing the fight to do things differently.

JSC is still the JS engine for WebKit-based browsers, especially Safari, and per Apple App Store regulations the only JS engine supposedly allowable in all of iOS.

It's more "mature" than V8 in terms of predating it. (V8 was not a fork of it and was started from scratch, but V8 was designed to replace it in the Blink fork from WebKit.)

It has different performance goals and performance characteristics, but "less tested" seems uncharitable and it is certainly used in plenty of "real-world tasks" daily in iOS and macOS.

[1] https://jsr.io/ [2] https://fresh.deno.dev/

except this sense:

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

Additionally, depending on round, they also have multiples, like 2x meaning they get at least 2x their investment before anyone else gets anything

Maybe an easier first step would be to open source Claude Code...?

If your userbase or the current CEO likes it or not.

It's basically the Jevons paradox for code. The price of lines of code (in human engineer-hours) has decreased a lot, so there is a bunch of code that is now economically justifiable which wouldn't have been written before. For example, I can prompt several ad-hoc benchmarking scripts in 1-2 minutes to troubleshoot an issue which might have taken 10-20 minutes each by myself, allowing me to investigate many performance angles. Not everything gets committed to source control.

Put another way, at least in my workflow and at my workplace, the volume of code has increased, and most of that increase comes from new code that would not have been written if not for AI, and a smaller portion is code that I would have written before AI but now let the AI write so I can focus on harder tasks. Of course, it's uneven penetration, AI helps more with tasks that are well-described in the training set (webapps, data science, Linux admin...) compared to e.g. issues arising from quirky internal architecture, Rust, etc.

> .... and in 12 months, we might be in a world where the ai is writing essentially all of the code. But the programmer still needs to specify what are the conditions of what you're doing. What is the overall design decision. How we collaborate with other code that has been written. How do we have some common sense with whether this is a secure design or an insecure design. So as long as there are these small pieces that a programmer has to do, then I think human productivity will actually be enhanced

(He then said it would continue improving, but this was not in the 12 month prediction.)

Source interview: https://www.youtube.com/live/esCSpbDPJik?si=kYt9oSD5bZxNE-Mn

Another option is that this was an equity deal where Bun shareholders believe there is still a large multiple worth up potential upside in the current Anthropic valuation.

Plus many other scenarios.

On the opposite spectrum it's just that Claude and Bun are great technologies that joined forces.

Programming languages all are a balance between performance/etc and making it easy for a human to interact with. This balance is going to shit as AI writes more code (and I assume Anthropic wants a future where humans might not even see the code, but rather an abstraction of it... after all, all code we look at is an abstraction on some level).

Claude Code is a 1B+ cash machine and Anthropic directly uses Bun for it.

Acquiring Bun lowers the risk of the software being unmaintained as Bun made $0 and relied on VC money.

Makes sense, but this is just another day in San Francisco of a $0 revenue startup being bought out.

Faster install and less disk space due to hardlink? Not really all that important to me. Npm comes with a cache too, and I have the disk space. I don't need it to be faster.

With the old-school setup I can easily manually edit something in node_modules to quickly test a change.

No more node_modules? It was a cool idea when yarn 2 initially implemented it, but at the end of the day I prefer things to just work rather than debug what is and isn't broken by the new resolver. At the time my DevOps team also wasn't too excited about me proposing to put the dependencies into git for the zero-install.

The reason why you see so many GitHub issues about it is because that's where the development is. Deno is great. Bun is great. These two things can both be great and we don't have to choose sides. Deno has it's use case. Bun has it's. Deno want's to be secure and require permissions. Bun just wants to make clean, simple, projects. This fight between Rust vs The World is getting old. Rust isn't any "safer" when Deno can panic too.

Why invest into a company that has the additional burden of developing bun, why not in a company that does only the hosting?

Codex has the opposite issue. It has an open client, which is relatively pointless, because it will accept only one system prompt and one prompt only.

> Over the last several months, the GitHub username with the most merged PRs in Bun's repo is now a Claude Code bot. We have it set up in our internal Discord and we mostly use it to help fix bugs. It opens PRs with tests that fail in the earlier system-installed version of Bun before the fix and pass in the fixed debug build of Bun. It responds to review comments. It does the whole thing.

You do still need people to make all the decisions about how Bun is developed, and to use Claude Code.

They're effectively bringing on a team that's been focused on building a runtime for years. The models they could throw at the problem can't be tapped on the shoulder, and there's no guarantee they'd do a better job at building something like Bun.

and

Implementing the Decisions

are complementary, one of these is being commoditised.

And, in fact, decimated.

Personally I am benefitting almost beyond measure because I can spend my time as the architect rather than the builder.

I see it as two hairy things canceling out: the accelerating trend of the JS ecosystem being hostage to VCs and Rauch is nonsensical, but this time a nonsensical acquisition is closing the loop as neatly as possible.

(actually this reminds me of Harry giving Dobby a sock: on so many levels!)

Sounds like "monetizing Bun is a distraction, so we're letting a deep-pocketed buyer finance Bun moving forward".

And kept their fraudulent name.

Anthropic are on track to reach $9BN in annualised revenue by the end of the year, and the six-month-old Claude Code already accounts for $1BN of that.

like when a political leader says they have full faith in one of their ministers, you know said minister will be gone by next week.

Video games are of course a different story.

Now the real question is, does the game loads significant better now, or does the performance still suck? In which case it might be more an excessive case of yak-shaving. And if yes, when can we except the release?

Culturally I see pure vibe coders as intersecting more with entrepreneurfluencer types who are non-technical but trying to extend their capabilities. Most technical folks I know are fairly disillusioned with pure vibe coding, but that's my corner of the world, YMMV

I feel like an important step for a language is when people outside of the mainline language culture start using it in anger. In that respect, Zig has very much "made it."

That said, if I were to put on my cynical hat, I do wonder how much of that Anthropic money will be donated to the Zig Software Foundation itself. After all, throwing money at maintaining and promoting the language that powers a critical part of their infrastructure seems like a mutually beneficial arrangement.

We never associated with Bun other than extending an invitation to rent a job booth at a conference: this was years ago when I had a Twitter account, so it's fair if Jarred doesn't remember.

If Handmade Cities had the opportunity to collaborate with Bun today, we would not take it, even prior to this acquisition. HMC wants to level up systems while remaining performant, snappy and buttery smooth. Notable examples include File Pilot [0] or my own Terminal Click (still early days) [1], both coming from bootstrapped indie devs.

I'll finish with a quote from a blog post [2]:

> Serious Handmade projects, like my own Terminal Click, don’t gain from AI. It does help at the margins: I’ve delegated website work since last year, and I enjoy seamless CI/CD for my builds. This is meaningful. However, it fails at novel problems and isn’t practical for my systems programming work.

All that said, I congratulate Bun even as we disagree on philosophy. I imagine it's no small feat getting acquired!

[0] https://filepilot.tech

[1] https://terminal.click

[2] https://handmadecities.com/news/summer-update-2025/

This sounds so cringe. We are talking about computer code here lol

In my experience, the extreme anti-LLM people and extreme pro-vibecoding people are a vocal online minority.

If you get away from the internet yelling match, the typical use case for LLMs is in the middle. Experienced developers use them for some small tasks and also write their own code. They know when to switch between modes and how to make the most of LLMs without deferring completely to their output.

Most of all: They don't go around yelling about their LLM use (or anti-use) because they're not interesting in the online LLM wars. They just want to build things with the tools available.

"You buy me this, next time I save you on that", etc...

"Raised $19 million Series A led by Khosla Ventures + $7 million"

"Today, Bun makes $0 in revenue."

Everything is almost public domain (MIT) and can be forked without paying a single dollar.

Questionable to claim that the technology is the real reason this was bought.

Reminds me of when Tron, the crypto company, bought BitTorrent.

Does that mean anything at all?

OpenAI is a public benefit corporation.

I use Hono, Zod, and Drizzle which AFAIK don't need Node compat.

IIRC I've only used Node compat once to delete a folder recursively with rm.

Amount of people at big corps that care about their lawsuit, and would switch their IT guidelines from node to Deno due to such heroic efforts?

Zero.

Bun has a better standard library than Deno. You get a DB driver, S3 client, etc which on Deno are all third party deps. It was the main reason I got interested in Bun. The speed is nice though during dev. Everything feels instant.

Not yet; similar concerns were addressed by Dahl 6mo ago: https://deno.com/blog/greatly-exaggerated / https://archive.vn/L6His

Thanks for assuming I “read” about bundlers somewhere, though. I’ve been using (and configuring) them since they existed.

There are degrees to this though. A panic + unwind in Rust is clean and _safe_, thus preferable to segfaults.

Java and Go are another similar example. Only in the latter can races on multi-word data structures lead to "arbitrary memory corruption" [1]. Even in those GC languages there's degrees to memory safety.

1: https://go.dev/ref/mem

The whole point every CEO with a toe in the AI pool can't stop bleating on about is that software engineering is dead and replaced by AI.

bun is MIT licensed, they could take bun free of charge and use their Phd level software engineer god machine to iterate on it.

I've heard that TypeScript is pretty rough on agentic coding loops because the idiomatic static type assertion code ends up requiring huge amounts of context to handle in a meaningful way. Is there any truth to it?

The language syntax has nothing to do with it pairing well with agentic coding loops.

Considering how close Typescript and C# are syntactically, and C#'s speed advantage over JS among many other things would make C# the main language for building Agents. It is not and that's because the early SDKs were JS and Python.

In their, quality software can be written in any programming language.

In practice, folks who use Python or JavaScript as their application programming language start from a position of just not carrying very much about correctness or performance. Folks who use languages like Java or C#, do. And you can see the downstream effects of this in the difference in the production-grade developer experience and the quality of packages on offer in PIP and NPM versus Maven and NuGet.

what makes you think so?

I believe strong typing is very very useful for human coding,

I'm not convinced its so 'very very' for agents.

With more runway comes more investor expectations too though. Some of the concern with VC backed companies is whether the valuation remains worthwhile. $26mm in funding is plenty for 14 people, but again the question is whether they can justify their valuation.

Regardless happy for the Oven folks and Bun has been a great experience (especially for someone who got on the JS ecosystem quite late.) I'm curious what the structure of the acquisition deal was like.

Please give me Java tools over C, C++, JavaScript or Python ones, any day of the week.

Only .NET and Rust compare equally in quality of DX.

AI tools value simplicity?!?

Check in the Python dependency management chaos, what it is the proposal this month, from what AI startup doing Python tools in Rust?

How many mass security incidents have there been with npm just the last few weeks?

(I’m half joking, that’s awesome for Zig!)

Builders build. Sometimes it's not about picking the right tools for the job or starting with the right choices. Sometimes it's just about building.

To use your road analogy - sometimes people just go for a drive. Sometimes those people end up right where they are supposed to be.

Isn’t every success story really an example of survivorship bias?

Nobody made DOOM in Excel because they thought it made a good engine.

Anyone who has spent time working with LLMs knows that the LinkedIn-style vibecoding where someone writes prompts and hits enter until they ship an app doesn't work.

I've had some fun trying to coax different LLMs into writing usable small throwaway apps. It's hilarious in a way to the contrast between what an experienced developer sees coming out of LLMs and what the LinkedIn and Twitter influencers are saying. If you know what you're doing and you have enough patience you really can get an LLM to do a lot of the things you want, but it can require a lot of handholding, rejecting bad ideas, and reviewing.

In my experience, the people pushing "vibecoding" content are influencers trying to ride the trend. They use the trend to gain more followers, sell courses, get the attention of a class of investors desperate to deploy cash, and other groups who want to believe vibecoding is magic.

I also consider them a vocal minority, because I don't think they represent the majority of LLM users.

Creating ~50 different types of calculators in JavaScript. Gemini can bang out in seconds what would take me far longer (and it's reasonable at basic tailwind style front-end design to boot). A large amount of work smashed down to a couple of days of cumulative instruction + testing in my spare time. It takes far long to think of how I want something to function in this example than it does for Gemini to successfully produce it. This is a use case scenario where something like Gemini 3 is exceptionally capable, and far exceeds the capability requirements needed to produce a decent outcome.

Do I want my next operating system vibe coded by Gemini 3? Of course not. Can it knock out front-end JavaScript tasks trivially? Yes, and far faster than any human could ever do it. Classic situation of using a tool for things it's particularly well suited.

Here's another one. An SM-24 Geophone + Raspberry PI 5 + ADC board. Hey Gemini / GPT, I need to build bin files from the raw voltage figures + timestamps, then using flask I need a web viewer + conversion on the geophone velocity figures for displacement and acceleration. Properly instructed, they'll create a highly functional version of that with some adjustments/iteration in 15-30 minutes. I basically had them recreate REW RTA mode for my geophone velocity data, and there's no way a person could do it nearly as fast. It requires some checking and iteration, and that's assumed in the comparison.

putting everyone using the generated outputs into a sort of unofficial grey market: even when using first-party tools. Which is weird.

Thank you! I appreciated how you wrote up this clarifying.

One of my favorite things is describing a bug to an LLM and asking it to find possible causes. It's helped track something down many times, even if I ultimately coded the fix.

[1] https://codeberg.org/ziglang/zig/src/commit/be9649f4ea5a32fd...

Sometimes people use the term to mean that the buyer only wants some/all of the employees and will abandon or shut down the acquired company's product, which presumably isn't the case here.

But more often I see "acqui-hire" used to refer to any acquisition where the expertise of the acquired company are the main reason to the acquisition (rather than, say, an existing revenue stream), and the buyer intends to keep the existing team dynamics.

An analogous example off the top of my head is Shopify hired Rafael Franca to work on Rails full-time.

To everyone else: I acknowlege that this post is not adding value but if you were one of the lucky 1/10000 you would understand that I have no choice.

you could also run java with js if you are brave enough https://kreijstal.github.io/java-tools/

Super premature optimization. It’ll hallucinate what lines it needs to read, it’ll continuously miss critical context in favor of trimming tokens.

Luckily we can now hook and force the agent to read full files at least once.

There was recently a conference which was themed around the idea that typescript monorepos are the best way to build with AI

Kind of tangent but I used to think static types were a must-have for LLM generated code. But the most magical and impressively awesome thing I’ve seen for LLM code generation is “calva backseat driver”, a vscode extension that lets copilot evaluate clojure expressions and generally do REPL stuff.

It can write MUCH cleaner and more capable code, using all sorts of libraries that it’s unfamiliar with, because it can mess around and try stuff just like a human would. It’s mind blowingly cool!!

Nobody cares about this, JS is plenty fast for LLM needs. If maximum performance was necessary, you're better off using Go because of fast compiler and better performance.

I've seen codebases of varying quality in nearly every language, "enterprise" and otherwise. I've worked at a C# shop and it was no better or worse than the java/kotlin/typescript ones I've worked at.

You can blame the "average" developer in a language for "not caring ", but more likely than not you're just observing the friction imposed by older packaging systems. Modern languages are usually coupled with package managers that make it trivial to publish language artifacts to package hubs, whereas gradle for example is it's own brand of hell just to get your code to build.

do so because a boss told them 'thats the way we deal with correctness and performance around here'

the fact that their boss made that one decision for them does not somehow transmit the values behind the one decision.

I hope they won't be as douchey.

If the build script being a DSL is the issue, they're even experimenting around declarative gradle scripts [0], which is going to be nice for people used to something like maven.

0: https://declarative.gradle.org/

- a javascript developer

No, survivorship bias (in this context) means to wrongly see a minor subgroup as the majority. But the successful subgroup is not always a minority, or falsely labelled.

You get a feel for how much direction they need after working for a while and tooling and accessible documentation is really important for quality.

Then you give them a task and review the results. In (backend/systems) programming it's pretty binary whether a solution works or not, it's not a matter of taste but something you can just validate with hard data.

I've done so many tiny/small/medium sized utilities for myself in the last year it's crazy[0]. A good bunch of them are 95-100% vibecoded, meaning I was just the "project manager" instructing what features I want and letting the agent(s) make it work.

I think I have a pretty good feel for the main agentic systems and what they can do in the context of what I do so I know what to tell them and how - each has its own distinct way of working and using the wrong one for the wrong job is either stupid, frustrating or just a waste of time.

[0] https://indieweb.org/make_what_you_need

> had a vague idea that "Zig people" were generally "Software You Can Love" or "Handmade Software Movement" types

Folks at Bun are "Zig people" for obvious reasons, and a link was made with Handmade software. This happened multiple times before with Bun specifically, so my response is not a "pivot" of any kind. I've highlighted and constrasted our differences to prevent further associations inside a viral HN thread. That's not unreasonable.

I also explicitly congratulated them for the acquisition.

[0] https://handmade.network/m/abnercoimbre

For example: what’s in the middle for programming?

For me 0 is writing 0 and 1. For others 0 is making the nand ports.

And 100 is ai llm vibe.

So 50/middle would be what exactly? It all depends.

Same for anything really. Some people I know keep saying not 8 not 80 to mean the middle.

Like what’s in the middle for amount of coding per day? 12 h? 8h? 2h?

What’s middle for making money? 50k, 500k, 500m?

What’s the middle for taking cyanide ? 1g? 1kg?

What about water? What about food? What about anything?

As you can see, it’s all relative and whomever says it, is trying to push his narrative as “middle” aka correct, while who does more or less is “wrong”.

[1]: https://taskusanakirja.com/

Because now the Bun team don't have to redirect their resources to implementing a sustainable business model.

No they don't.

I get how it might not be as useful in a production deployment where the system/container will be setup just for that Python service, but for less structured use-cases, `uv` is a silver bullet.

This is only true for older .NET Framework applications.

If anyone ever requested/used an eggdrop(?) bot from #farmbots or #wildbots on quakenet then thanks to you too; that was certainly one of the next steps down the path I took. A (probably very injectable) PHP blog and a bunch of TCL scripts powering bots, man I wish I could review that code now.

So how did it work back in the day, people would just submit text and it would get upvoted? I always assumed like half of them were just made up.

seems to work. relies on that individual quote being indexed, and google SERPs feeling like returning full results at the moment, of course. when the latter fails, I've found success with site: queries on Bing (of all places.)

https://teavm.org/

Bun claims this feature is for running untrusted code (https://bun.com/reference/node/vm), while Node says "The node:vm module is not a security mechanism. Do not use it to run untrusted code." I'm not sure whom to believe.

My personal experience and anecdotal evidence is in line with this hypothesis. Using the likes of Microsoft's own Copilot with small simple greenfield TypeScript 5 projects results in surprisingly poor results the minute you start leaning heavily on type safety and idiomatic techniques such as branded types.

> There was recently a conference which was themed around the idea that typescript monorepos are the best way to build with AI

There are also flat earth conferences.

Makes me wonder what a theoretical “best possible language for vibe coding” would look like

I've noticed LLMs just slap on "as any" to solve compile errors in TypeScript code, maybe this is common in the training data. I frequently have to call this out in code review, in many cases it wasn't even a necessary assertion, but it's now turned a variable into "any" which can cause downstream problems or future problems

That's not true, if anything, C# is faster and also compiles fast enough.

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

And that was my point. The choice of using JS/TS for LLM stuff was made for us based on initial wave of SDK availabilities. Nothing to do with language merits.

The problem with Gradle is that it never had a clear philosophy to begin with. It's trying to be everything to everybody, changes best practices every year and has enough features that the project at hand could entirely be built out of Gradle scripts itself.

And oh, it still requires an update to run everytime a new JDK is released even though the SDK is the most backward compatible thing ever written.

Nobody knows WHO has the copyright but it's been decided in courts that AI definitely doesn't own it.

I took your comment as referring to people who like to manually unroll their loops rather than members of some particular community, so GP's nitpicking on specifics of that interpretation looked out of place.

I'm willing to wager that 99.99% of readers do not associate "Handmade" with the org you're associated with, and that most didn't know it existed until this comment. So yes "really", without OP replying, it's understandable that the poster you're replying inferred it had nothing to do with you.

> So 50/middle would be what exactly? It all depends.

Using LLMs to explore code bases, doing deep research, asking it to do code reviews or find bugs, but not pushing code that LLMs have authored might be one example in the middle.

Cyanide has an LD50 (50% chance of death) in the 1-2 mg/kg range when taken orally. So middle for taking cyanide is probably 1.5mg/kg. 90mg for someone 60kg.

Sadly the middle ground in other topics is less easy to define!

Clever!

- https://news.ycombinator.com/item?id=24401292

https://www.wheresyoured.at/why-everybody-is-losing-money-on...

Plus last time I checked Oracle lost that lawsuit.

Java is possibly the safest bet on the future, it's open source both in spec and in the most common implementation (OpenJDK), and is so widely used that there are multiple FAANG companies critically dependent on Java working that alone could continue the development of the platform were anything happen.

Besides, Oracle has been a surprisingly good steward of the language.

It has similar bases on facts.

As far provenance, I assume a lot of them were made up too, but this one was real.

But the majority of projects are on a newer JDK than 8 for quite some years now.

It looks like Bun also supports Shadow Realms which from my understanding was more intended for sandboxing (although I have no idea how resources are shared between a host environment and Shadow Realms, and how that might potentially differ from the node VM module).

You declare your schema with a good TS ORM then use something like TRPC to get type inference from your schemas in your route handlers and your front end.

You get an enforced single source of truth that keeps the AI on track with a very small amount of code compared to something like Java.

This really only applies to full stack SAAS apps though.

https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

I tell the LLM to include typing on any new code.

The agent is running the test harness and checking results.

Gradle is better from this perspective, and hopefully with its "kotlinization" we will see some stability, which was the biggest issue it had before.

You see how makes no sense this in the “middle” concept?

Bottom is 0? Or is 1mg? Or what?

Top is killing a human by dose? Killing an elephant dose? Make you feel dizzy?

What’s too much? What’s being in the middle?

You see, it’s a stupid logic “in the middle”. The point is being in the middle or moderate is not always “good”.

Also it’s hard to define. Tbh only non logical people throw words like “in the middle” etc

All modern OS’s behave this way. When your process starts and is assigned an address, you get an area. It can balloon but it starts somewhere. When the process ends, that area is reclaimed.

Claude will likely be bundled up nicely with Bun in the near future. I could see this being useful to let even a beginner use claude code.

Edit:

Lastly, what I meant originally is that most front-end work happens with tools like Node or Bun. At first I was thinking they could use it to speed up generating / pulling JS projects, but it seems more likely Claude Code and bun will have a separate project where they integrate both and make Claude Code take full advantage of Bun itself, and Bun will focus on tight coupling to ensure Claude Code is optimally running.

To this day Android Java is not fully compatible with Java proper, and Kotlin became Google's version of C#.

For example, if I have a struct `PageEntity` with a field `Id`, and I am iterating over a slice of such IDs, I would prefer using `pid` instead of `pageEntityId` as the variable name. But Java APIs and conventions tend to use these longer names, so I find it takes more thinking to remember the different names instead of quickly seeing the behavior of code at a glance.

Java also tends to have a lot of inheritance which results in these long glued-together names and makes it harder to follow program flow because behaviors get introduced in multiple different places (i.e., it has the opposite of locality of behavior).

But those are just my opinions and experiences! I know many people love Java, and it is a versatile and powerful language.

In any case, what are the proposed benefits of the "kotilization"? I tried it about a year ago but realized that it's just a syntax level-wrapper around the same old DSL underneath. In the end, I still viewed it as an ill-described DSL with a massive learning curve outside of happy-paths.