Node 26 is the line you'll be running next year, and the first question is the dull one: what stops working on the first launch? I went through the 26.0.0 release notes, then ran every item that I could run on Node 24.21.0 and Node 26.10.0 side by side. Three things fail loudly, two change quietly, and one is a fix you can ship today. The monorepo behind this site, 1,808 unit tests, didn't care which runtime it got.
Should you move to 26 now?
Not in a hurry. Node 24 moved to Maintenance LTS on 20 October 2026 and gets fixes until 30 April 2028. Node 26 became Active LTS eight days later and runs until 30 April 2029, according to the Node.js release schedule. That's a year of extra life for the price of one upgrade.
| Line | Became LTS | Maintenance from | End of life |
|---|---|---|---|
| Node 22 (Jod) | 2024-10-29 | 2025-10-21 | 2027-04-30 |
| Node 24 (Krypton) | 2025-10-28 | 2026-10-20 | 2028-04-30 |
| Node 26 (Lithium) | 2026-10-28 | 2027-10-20 | 2029-04-30 |
Read the middle column twice. "Active LTS" means Node 26 now, even though nothing on 24 is on fire. The download index lists v26.13.0 as the first LTS build and v26.13.1 following on 10 November, with V8 14.6 and npm 11.20.0.
If you're coming from Node 20, it's already past end of life, so skip 24 and go to 26 directly, after reading what 22 and 24 changed in the Node.js 20 to 24 migration guide. If you're on 22, you have until April 2027, and there's no reason to rush a Friday deploy.
What did I run, and on which versions?
I used the two newest builds I had installed: 24.21.0 and 26.10.0, both on macOS arm64. The latest 26 patch is 26.13.1, but every item below is a semver-major change that landed in 26.0.0, so it's present on every 26.x release, including the LTS. I didn't run 26.13.1 itself.
The probes live in one small project, examples/nodejs-24-to-26-migration, and npm test asserts all eight checks on whichever Node you start it with. It passed 8 of 8 on both versions, which is the point: the assertions describe the difference, and each one differs the way the changelog says.
What breaks the moment you start the process?
Three removals. Each one is a hard failure, not a warning.
http writeHeader(). The old alias for writeHead() is gone. On 24.21.0 typeof http.ServerResponse.prototype.writeHeader is function; on 26.10.0 it's undefined, so the call throws a TypeError the first time a request reaches it.
// before: works on 24, TypeError on 26
res.writeHeader(200, { "content-type": "text/plain" });
// after: works on both
res.writeHead(200, { "content-type": "text/plain" });
A search for .writeHeader( is enough to find every caller.
The legacy stream modules. require("_stream_readable") and its four siblings loaded on 24.21.0 and threw MODULE_NOT_FOUND on 26.10.0. _stream_wrap was removed as well; it already printed a DEP0125 deprecation warning on 24. The public replacements have been there for years:
// before
const Readable = require("_stream_readable");
// after
const { Readable, Writable, Duplex, Transform, PassThrough } = require("node:stream");
--experimental-transform-types. On 24.21.0 the flag runs an enum file with an experimental warning. On 26.10.0 Node doesn't start at all and prints bad option. That matters because the flag usually hides inside an npm script, so the first sign is a red CI job rather than a stack trace. The longer story, including parameter properties, is in the native TypeScript guide. The short fix is to stop needing it:
// const-object.ts: erasable syntax only, runs on 24 and 26 with no flag
const Color = { Red: 0, Green: 1 } as const;
type Color = (typeof Color)[keyof typeof Color];
const picked: Color = Color.Green;
console.log(picked);
Plain enum Color { Red, Green } fails with ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX on both runtimes without the flag, so on 26 the enum has to change, or you move that file to a build step.
The flag that rescued your enums on 24 is the line that stops your process on 26.
Will your dependencies hit the same removals?
That's the question that decides whether the upgrade takes an hour or a week, so I scanned for it. In the monorepo's installed tree, 2,128 package directories and 46,527 JavaScript files, I searched for literal require("_stream_...") calls and .writeHeader( calls. Both came back with zero hits. A control search for require("stream") found plenty, so the scan itself was working.
Two limits apply. A regex can't see a dynamic require(name), and the number is for one repository's dependencies, not yours. Run the same two searches on your own node_modules before trusting mine.
grep -rlE "require\(['\"]_stream_(readable|writable|duplex|transform|passthrough|wrap)['\"]\)" node_modules --include='*.js' --include='*.cjs'
grep -rlE "\.writeHeader\(" node_modules --include='*.js' --include='*.cjs'
Native addons are the separate case. 26.0.0 raises the module ABI to 147, so anything compiled for 24 needs a rebuild or a prebuilt binary for the new version. That's also why a clean npm ci on 26 matters more than a green test run on a cached node_modules.
What changes without breaking anything?
Two items, and neither fails a build.
Temporal is on by default. On 26.10.0 typeof Temporal is object; on 24.21.0 it's undefined. Nothing breaks if you never touch it. If a library feature-detects Temporal and falls back to a polyfill, it'll now take the native path on 26. I didn't test any third-party polyfill, so treat that as a reason to read your own detection code, not a finding. The Temporal API explainer covers what the types do.
module.register() is deprecated. It still runs on 26.10.0, but prints DEP0205 and tells you to use module.registerHooks(). The replacement already exists on 24.21.0, which I confirmed by running it there, so this is the one change you can make before you upgrade:
import { registerHooks } from "node:module";
registerHooks({
resolve(specifier, context, nextResolve) {
return nextResolve(specifier, context);
},
});
What can you use once you're on 26?
Several things that used to need a polyfill exist natively. I checked each one on both binaries: Map.prototype.getOrInsertComputed() and Iterator.concat() are functions on 26.10.0 and undefined on 24.21.0, next to the Temporal global above. This runs as written on 26.10.0:
const cache = new Map();
const a = cache.getOrInsertComputed("user:42", (k) => ({ key: k, loaded: true }));
const b = cache.getOrInsertComputed("user:42", () => { throw new Error("never runs"); });
console.log(a === b, cache.size); // true 1
console.log([...Iterator.concat([1, 2], new Set([3]), "ab".split(""))].join(","));
// 1,2,3,a,b
getOrInsertComputed is the one I'll use most. The classic check, create, store pattern collapses into one call, and the factory only runs on a miss. One more change sits under the surface: the bundled fetch client moved from Undici 7.29.1 on Node 24 to 8.10.2 on Node 26, so if you pin your own undici for proxies or mocks, run those tests first.
What did a real test suite say?
I ran the monorepo's unit tests, 1,808 of them across 134 files, four times on each runtime. The result was less tidy than I wanted.
One failure repeated in every run on both versions: a visual-baseline check for one blog, unrelated to Node. The rest moved around. Node 24 ended runs with between 1 and 3 failures, Node 26 with between 2 and 11, and the worst 26 run is the number that looks bad. Was that a runtime problem? I didn't assume either way. The extra failures came from files that talk to git and the shell, and in the worst 26 run there were five of them. I took the three that failed most often and ran them on their own, three times on each runtime. All 33 tests passed every time, on both.
So the honest reading is that the full-suite noise came from load on a busy machine, not from Node 26, and I'd rather say that than hide the 11. If your suite is stable, you'll get a cleaner signal than I did.
A separate, larger measurement points the same way. I ran the full vitest run over the whole monorepo, 451 test files and 8,481 tests, three rounds per version, interleaved so a busy minute hit both equally.
| Round | Node 24.21.0 | Node 26.10.0 |
|---|---|---|
| 1 | 52.08 s | 46.66 s |
| 2 | 46.16 s | 44.34 s |
| 3 | 47.09 s | 47.17 s |
| Median | 47.09 s | 46.66 s |
That's a 0.9 percent gap with a six-second spread inside one version, so it's a tie. An empty process start says the same: a 28.9 ms median on Node 24 and 29.8 ms on Node 26 over 20 launches each. Both versions finished with 8,476 passing tests, and the same three failed on both, repo debt that has nothing to do with the runtime. Did I expect a speedup? A little. On this workload there isn't one, so the reason to move is support and APIs, not speed.
I didn't measure real HTTP throughput, memory, Linux or Windows, or native addons beyond the ones in this repo. These numbers describe one TypeScript monorepo on one Mac.
What's the order I'd follow?
- Switch to
registerHooks()on 24, where it already works. - Search your own code and
node_modulesfor the two removed APIs, then replacewriteHeaderwithwriteHead. - Look through
package.jsonscripts and CI for--experimental-transform-types, and rewrite enums asas constobjects. - Run a clean install and your full test suite on 26, then compare against 24 before you blame either. If the suite is slow, the Vitest 5 migration notes help trim it first.
- Read your Temporal feature detection.
That's an afternoon for a small service. The part that costs time is rarely the code; it's the CI image and the Docker base tag you forgot were pinned to 24.