Choosing a JavaScript Runtime: Node.js, Bun or Deno After a Year of Big Changes
A year ago, picking a server-side JavaScript runtime was mostly a performance-and-ergonomics argument: Node for safety, Bun for speed and convenience, Deno for permissions and a tidy toolchain. In late 2026 the argument has shifted to who's maintaining what, and for how long. Bun was acquired by Anthropic and rewritten in Rust. The Deno team is joining Cloudflare, with a dated end to runtime development. Node changed its release schedule. If you're starting a service that should run for three or more years, those facts matter more than any benchmark chart.
Where things stand
| Node.js | Bun | Deno | |
|---|---|---|---|
| Latest | 26.13.0 LTS (28 Oct 2026); 27.0.0 alpha | 1.4.4 (22 Oct 2026) | 2.9.8 (21 Oct 2026) |
| Engine | V8 | JavaScriptCore | V8 |
| Node API target | itself | Node 26 | Node 26, since 2.9 |
| TypeScript | erasable syntax only, built in | built in | built in |
| Support window | published per release line | none published | about one more year of fixes |
| Who maintains it | Node.js project and its release team | Anthropic | team joining Cloudflare |
Versions come from nodejs.org, Bun's releases and Deno's releases.
Node.js: the new schedule
Node 26 "Lithium" became Active LTS on 28 October 2026 and is supported until 30 April 2029, per the nodejs/Release schedule. Node 24 moved to Maintenance on 20 October 2026 (end of life 30 April 2028), Node 22 is in Maintenance until 30 April 2027, and Node 20 is already end-of-life.
The bigger change starts with Node 27. Instead of odd releases that die after six months and even ones that become LTS, there's now one major a year, branched every October. Each line spends six months in an Alpha phase ("intended for library authors and CI pipelines, not for production use"), six months as Current, and then every line becomes LTS with 30 months of support. Node 27 is in alpha now, goes Current on 22 April 2027 and LTS on 20 October 2027. The practical upshot: you no longer skip odd versions, and you can plan upgrades as a yearly October chore.
A few Node changes that remove reasons people reached for the other two:
- TypeScript without a build step. Type stripping is enabled by default and became stable in v25.2.0 and v24.12.0. It only handles erasable syntax (it replaces types with whitespace and does no type checking), and Node 26 removed the
--experimental-transform-typesflag. Enums and parameter properties still need a tool such as tsx. SettingerasableSyntaxOnlyin your tsconfig keeps you honest. - A stable permission model.
node --permission index.jsdenies file system, network, child process and worker access unless you grant it with flags like--allow-fs-reador--allow-net, per the permissions docs. It's coarser than Deno's model but it's there. - No more Corepack. Node's docs state that Corepack "will no longer be distributed starting with Node.js v25" (v24 Corepack docs). If your CI relied on
corepack enableto get pnpm or Yarn, you now install them yourself. Our package manager guide covers the options.
Bun: fast, broad, and now Anthropic's
Bun 1.4, released on 20 August 2026, is the first release written in Rust. The same post says 1,517 more tests from Node's own suite now pass and that the compatibility tests come from the Node.js v26.3.0 suite, while noting Bun isn't 100% compatible yet. Its compatibility page sets the expectation clearly: "If a package works in Node.js but doesn't work in Bun, we consider it a bug in Bun."
That page is worth reading before you commit, because the partial list is specific:
node:cluster: HTTP load balancing across workers only works on Linux.node:worker_threads: ignoresresourceLimitsandtrackUnmanagedFds.node:inspector:Runtime.evaluateand heap profiling aren't implemented.node:v8: no heap profiling orSerializer/Deserializer.node:test:run()is limited andmock.module()is missing.node:sea(single executable apps) isn't implemented; Bun points you tobun build --compileinstead.
If your service uses none of those, Bun is pleasant: one binary that runs TypeScript, installs packages, bundles and tests. The 1.4 release adds a long list of built-ins (Bun.WebView, Bun.Image, Bun.cron(), experimental HTTP/3 in Bun.serve() and fetch()) which are handy and also lock you in. Code that calls Bun.* won't run on Node.
On ownership, the announcement from December 2025 says Bun stays MIT-licensed, development stays public on GitHub and the team keeps working on it full time. What's missing is a published support policy. There are frequent 1.x releases but no LTS lines, so "stay current" is the only upgrade strategy.
Bun's release posts include plenty of benchmarks. They're run by the Bun team on their own hardware, and the 1.4 post's intro and detail sections don't even agree on some memory figures. Measure your own service. Our Bun vs Node comparison goes deeper on the trade-offs.
Deno: read the Cloudflare post before you start anything new
Deno 2.9 (June 2026) moved its Node compatibility target to Node 26, and the docs say that as of Deno 2.8 "over 75% of Node's own test suite passes," per the Node compatibility guide. Technically it's in good shape, with npm: specifiers, package.json support, a permission system that also applies to npm code, and a 24-hour minimum dependency age on by default in 2.9.
Then, on 9 October 2026, Deno announced that "the entire Deno team is joining Cloudflare." The runtime part is plain: "We will support the Deno runtime for another year with monthly releases containing bug fixes and security updates. After that year we will end our development of the Deno runtime." Deno Deploy "will continue operating for six months before shutting down," JSR keeps running on Cloudflare infrastructure, and "Deno will remain open source."
So for a new long-lived service, Deno is hard to recommend. For existing Deno code, you have roughly a year of fixes to plan a move. The good news is that Deno already reads package.json and runs deno task scripts, 2.9 seeds deno.lock from npm, pnpm, Yarn or Bun lockfiles, and code written against Web standard APIs moves easily. A framework like Hono, which per our Hono vs Express comparison runs on Node, Bun, Deno and Cloudflare Workers, makes that kind of move much cheaper.
Things to check before switching runtimes
- Native addons. Anything with a
.nodebinary (image processing, some database drivers) is the most likely break, so test those first. Deno needs a localnode_modulesand--allow-ffifor them. - Observability. If your APM agent or profiler relies on
node:inspector, Bun's gaps there (noRuntime.evaluate, no heap profiling) can break it. - Test runner. If you use
node:testwithmock.module(), it won't run on Bun. Run your real suite on the target runtime before deciding; Jest vs Vitest covers the runner choice itself. - Container images and hosting. Check that your base image, vulnerability scanner and platform support the runtime you pick. Our Docker guide covers the image basics.
- Runtime-specific APIs. Grep for
Bun.andDeno.before you call a codebase portable. - Package manager coupling. Bun is also a package manager, and its docs describe
bun installas a standalone tool that works in existing Node.js projects, so the two choices are separate; see pnpm vs Bun.
The decision rule
- Production service you'll run for years: Node.js 26 LTS. It has a published end-of-life date (April 2029), it is the reference the other two measure their compatibility against, and the new schedule makes the next upgrade (Node 27 LTS in October 2027) predictable. Turn on type stripping and the permission model if they fit.
- New internal tools, scripts, CLIs and greenfield apps where speed of setup matters: Bun is a reasonable choice if you run your test suite on it and avoid the partial modules above. Keep
Bun.*calls behind a thin interface if you might move back. For CLIs, our Node CLI walkthrough covers the Node side. - Library authors: test on Node 22, 24 and 26 now, and add Node 27 alpha to CI; that's exactly what the alpha phase is for. Add Bun to the matrix if your users ask.
- Existing Deno code: keep patching through the support year, move new work to Web-standard APIs, and pick a destination (Node or Cloudflare Workers) by mid-2027.
- New Deno project: don't, unless you're prepared to maintain the runtime situation yourself.
Written by AIDToolStack Editorial
Researched from official documentation, specifications and vendor pages, listed under Sources below. Last checked November 2026.
Sources
- bun.com/blog/bun-joins-anthropic
- deno.com/blog/cloudflare
- nodejs.org/en/about/previous-releases
- github.com/oven-sh/bun/releases
- github.com/denoland/deno/releases
- github.com/nodejs/Release
- nodejs.org/docs/latest-v26.x/api/typescript.html
- nodejs.org/docs/latest-v26.x/api/permissions.html
- nodejs.org/docs/latest-v24.x/api/corepack.html
- bun.com/blog/bun-v1.4
- bun.com/docs/runtime/nodejs-compat
- deno.com/blog/v2.9
- docs.deno.com/runtime/fundamentals/node/
- nodejs.org/dist/index.json
Related Posts
Explore on AIDToolStack
Discover tools and servers featured in our directory.
AI Tools
MCP Servers
Sponsor Our Newsletter
Reach thousands of developers who are actively evaluating AI tools, MCP servers, and dev infrastructure. Our weekly newsletter goes to engaged technical decision-makers.
All sponsored content is clearly labeled per our editorial policy.