Node.js 26 becomes LTS on October 28. Who should upgrade now, what's new (Temporal, Map upsert), what was removed, a script that finds breaking patterns before you upgrade, and a safe rollout plan from Node 22 or 24.
- Published
- Reading
- 14 min
- Author
- Yaroslav Tsarenko

On October 28, 2026, Node.js 26 becomes an LTS release. For most teams that's the signal to plan the upgrade. Three separate questions tend to get mixed up here: which security patch to install right now, when to move to the 26 line, and what in your project might break along the way.
This guide answers all three with code: support dates, the new features worth using, the removed APIs, a preflight script that scans a project in under a second, a CI matrix and a step-by-step rollout. All examples are TypeScript, type-checked with TypeScript 6.0 and @types/node 26.
What actually happens on October 28
Node.js 26.0.0 shipped on May 5, 2026, and spent six months as "Current", the phase where APIs can still change. On October 28 it becomes Active LTS: from then on it receives bug and security fixes without breaking changes. The authoritative schedule lives in the nodejs/Release repository:
| Line | Status at the end of October 2026 | Maintenance from | End of life |
|---|---|---|---|
| Node.js 20 | unsupported | — | Apr 30, 2026 |
| Node.js 22 | Maintenance LTS | Oct 21, 2025 | Apr 30, 2027 |
| Node.js 24 | Maintenance LTS | Oct 20, 2026 | Apr 30, 2028 |
| Node.js 26 | Active LTS from Oct 28, 2026 | Oct 20, 2027 | Apr 30, 2029 |
| Node.js 27 | alpha from Oct 28, 2026 | — | Apr 30, 2030 |
There's a second change on the same day. Node.js 26 is the last line under the old "even releases become LTS, odd ones don't" model. Starting with Node.js 27 the project moves to a yearly cycle: one major release every April, LTS promotion every October, and every release becomes LTS. The odd-numbered experimental lines disappear. In their place comes a six-month alpha phase meant for library authors and CI pipelines.
For anyone running a business on Node.js that's good news. Upgrades become a predictable once-a-year event on a fixed calendar, and you can plan budgets around them.
Security first: the October 21 patch
Before thinking about the 26 line, patch the line you're on. On October 21, 2026, Node.js shipped security releases for every supported line: 26.12.1, 24.22.1 and 22.23.4. They fix 10 vulnerabilities, four of them rated High:
| CVE | What's wrong | Affected lines |
|---|---|---|
| CVE-2026-111497 | out-of-bounds write in the Brotli decoder (node:zlib): crash, memory disclosure or code execution |
22, 24, 26 |
| CVE-2026-105482 | dns.resolve*() truncates hostnames at a NUL byte |
22, 24, 26 |
| CVE-2026-105483 | certificate checks miss IPs written with fullwidth digits | 24, 26 |
| CVE-2026-106069 | leading-zero IPv4 hosts (0127.0.0.1) are parsed differently by different layers |
22, 24, 26 |
The Brotli bug is the nasty one. Compressed requests and responses pass through zlib in a lot of applications, often without anyone thinking about it. Checking takes a second:
node -p "process.version"v24.22.1If you're below 22.23.4, 24.22.1 or 26.12.1 on your line, upgrade today. Don't forget Docker images: a node:24 tag without a patch number only picks up the fix when the image is rebuilt. Managed platforms usually roll the patch out for you, but it's still worth confirming process.version in your logs.
Who should move to 26, and when
The rule of thumb: production picks the version, not a developer's laptop. Running Node.js 26 locally gains you nothing if your host can't run it yet.
| Your situation | What to do |
|---|---|
| Still on Node.js 20 or older | Urgent: no security fixes since April 30, 2026. Go straight to 24 or 26 |
| Node.js 22 | Plan the move before April 2027. If your host allows it, skip to 26 so you only upgrade once |
| Node.js 24 | Install 24.22.1 and plan 26 for 2027 calmly. You have until April 2028 |
| New project | 26 if your host supports it; otherwise 24 with a plan to move |
| Serverless (Vercel, Lambda) | Wait for official 26 support from the provider rather than shipping a custom runtime |
Vercel deserves a specific note because so many Next.js apps live there. As of late October, the Vercel docs list 24.x (default) and 22.x for builds and Functions, and Node.js 20 was deprecated on October 1, 2026. Node.js 26 is officially available only in Vercel Sandbox. So don't set "engines": { "node": "26.x" } in a Vercel project yet. Wait until 26.x appears in the project's Node.js Version setting.
What's new and worth using
The full list is in the 26.0.0 release notes. Three things matter for day-to-day work.
New
- Temporal by defaultdates and time zones without a library
- Map.getOrInsertComputedupsert without has/set
- V8 14.6 and Undici 8Iterator.concat, new fetch client
Removed
- _stream_* modulesuse node:stream
- writeHeader()writeHead() only
- --experimental-transform-typesno enums or namespaces without a build
Deprecated
- module.register()DEP0205, move to registerHooks()
- Some crypto and stream APIsDEP0201, DEP0203, DEP0204
Temporal instead of Date
The headline change: the Temporal API is enabled by default. Temporal is the new JavaScript standard for dates and times. It fixes the long-standing problems with Date: mutability, no real time zone support and surprising month arithmetic.
Here's the kind of bug Date creates silently. On October 25, 2026, clocks in Ukraine (and most of Europe) fall back one hour. A meeting happens every day at 10:00. What happens when you add "one day" to Saturday's meeting?
const meeting = Temporal.ZonedDateTime.from("2026-10-24T10:00[Europe/Kyiv]");
console.log(meeting.add({ days: 1 }).toString());
console.log(meeting.add({ hours: 24 }).toString());
const legacy = new Date("2026-10-24T10:00:00+03:00");
legacy.setTime(legacy.getTime() + 24 * 60 * 60 * 1000);
console.log(legacy.toLocaleString("uk-UA", { timeZone: "Europe/Kyiv" }));2026-10-25T10:00:00+02:00[Europe/Kyiv]
2026-10-25T09:00:00+02:00[Europe/Kyiv]
25.10.2026, 09:00:00Temporal distinguishes "the next calendar day", which gives 10:00 as a human expects, from "exactly 24 hours later", which gives 09:00 after the clock change. Code that adds 24 * 60 * 60 * 1000 to a Date quietly moves reminders, bookings and email sends by an hour twice a year.
Two more places where Temporal behaves predictably:
const trialEnds = Temporal.PlainDate.from("2026-01-31").add({ months: 1 });
console.log(trialEnds.toString());
const since = Temporal.PlainDate.from("2026-05-05").until("2026-10-28", { largestUnit: "months" });
console.log(since.toString(), since.months, since.days);2026-02-28
P5M23D 5 23A trial that starts on January 31 ends on February 28, not "March 3" as setMonth() would give you. Date differences come back in months and days directly, with no manual math.
On types: TypeScript 6.0 ships built-in Temporal types under lib: ["esnext"] or the narrower esnext.temporal. If some services still run on 22 or 24, add temporal-polyfill. It has the same API, and you delete it once you've upgraded.
Map upsert: getOrInsert and getOrInsertComputed
V8 14.6 adds methods that retire the classic if (!map.has(k)) map.set(k, ...) dance. Grouping orders by tenant:
type Order = { tenant: string; total: number };
const orders: Order[] = [
{ tenant: "acme", total: 120 },
{ tenant: "globex", total: 80 },
{ tenant: "acme", total: 40 },
];
const byTenant = new Map<string, Order[]>();
for (const order of orders) {
byTenant.getOrInsertComputed(order.tenant, () => []).push(order);
}
console.log([...byTenant].map(([tenant, list]) => `${tenant}: ${list.length}`));[ 'acme: 2', 'globex: 1' ]getOrInsertComputed only calls the factory when the key is missing. That makes it a clean fit for in-memory caches, counters and lazily created per-tenant clients. The types are in TypeScript 6.0's esnext lib.
Iterator.concat and Undici 8
Iterator.concat() chains several iterators without building intermediate arrays, which is handy when you page through data from more than one source. The built-in fetch now runs on Undici 8. If you configured fetch with a custom Agent or dispatcher, run your integration tests against external APIs before switching.
What was removed, and what breaks
The list is short, but every item on it can stop a deploy.
Removed outright:
- the
_stream_wrap,_stream_readable,_stream_writable,_stream_duplex,_stream_transformand_stream_passthroughmodules. Modern code doesn't import them, but old dependencies sometimes still callrequire("_stream_readable"); http.Server.prototype.writeHeader()— usewriteHead();- the
--experimental-transform-typesflag. If apackage.jsonscript passes it,noderefuses to start.
Native addons. NODE_MODULE_VERSION is now 147. Addons built on Node-API, which includes sharp and most modern packages, keep working because that interface is stable across versions. Older addons compiled against a specific V8 version must be rebuilt (npm rebuild) or upgraded. The preflight script below lists every native addon in your tree.
Deprecated with a runtime warning:
module.register()(DEP0205). The replacement is the synchronousmodule.registerHooks(); there's an example below;- a few
crypto(DEP0203, DEP0204) andstream(DEP0201) APIs. They're warnings for now, but CI running with--throw-deprecationturns them into failures so you find them early.
localStorage on the server. On Node.js 26, without the --localstorage-file flag, the global localStorage is undefined. Review any server code that expects it. Client components aren't affected.
A preflight script: find problems before you upgrade
Rather than reading the changelog and grepping by hand, I wrote a small script. It prints the current version and your engines field, lists native addons in node_modules, and scans your code for patterns that break on Node.js 26. It's TypeScript and runs directly with node, no build step (more on that in the next section).
import { readdir, readFile } from "node:fs/promises";
import path from "node:path";
const root = process.argv[2] ?? process.cwd();
const risky: [RegExp, string][] = [
[/require\(["']_stream_\w+["']\)|from ["']_stream_\w+["']/, "legacy _stream_* modules were removed"],
[/\.writeHeader\(/, "writeHeader() was removed, use writeHead()"],
[/\bregister\(\s*["'][^"']+["']\s*,\s*import\.meta\.url/, "module.register() is runtime-deprecated (DEP0205)"],
[/--experimental-transform-types/, "the flag was removed in Node 26"],
[/\blocalStorage\b/, "localStorage is undefined without --localstorage-file"],
];
async function* walk(dir: string, skip: Set<string>): AsyncGenerator<string> {
for (const entry of await readdir(dir, { withFileTypes: true })) {
if (skip.has(entry.name)) continue;
const full = path.join(dir, entry.name);
if (entry.isDirectory()) yield* walk(full, skip);
else yield full;
}
}
const pkg = JSON.parse(await readFile(path.join(root, "package.json"), "utf8"));
console.log(`node ${process.version}, engines: ${pkg.engines?.node ?? "not set"}`);
const native = new Set<string>();
for await (const file of walk(path.join(root, "node_modules"), new Set([".cache"]))) {
if (file.endsWith(".node") || file.endsWith("binding.gyp")) {
const rel = path.relative(path.join(root, "node_modules"), file).split(path.sep);
native.add(rel[0].startsWith("@") ? `${rel[0]}/${rel[1]}` : rel[0]);
}
}
console.log(`native addons (Node-API ones keep working, others need a rebuild): ${native.size ? [...native].join(", ") : "none"}`);
const code = /\.(m|c)?(j|t)sx?$|package\.json$/;
const skip = new Set(["node_modules", ".next", ".git", "dist", "build"]);
let hits = 0;
for await (const file of walk(root, skip)) {
if (!code.test(file)) continue;
const lines = (await readFile(file, "utf8")).split("\n");
lines.forEach((line, i) => {
for (const [re, why] of risky) {
if (re.test(line)) {
hits++;
console.log(`${path.relative(root, file)}:${i + 1} ${why}`);
}
}
});
}
console.log(hits ? `${hits} place(s) to review` : "no known Node 26 breaking patterns found");Save it as node26-check.ts next to a package.json with "type": "module" and run node node26-check.ts ./my-service. Here's real output from a test service with some legacy code (run on Node 25.7):
node v25.7.0, engines: >=20
native addons (Node-API ones keep working, others need a rebuild): none
package.json:1 the flag was removed in Node 26
src/server.ts:2 legacy _stream_* modules were removed
src/server.ts:3 writeHeader() was removed, use writeHead()
3 place(s) to reviewSome honest caveats. This is pattern matching, not program analysis, so expect false positives. On this very site the script flagged localStorage in five client components that never run on the server. It also can't see problems inside your dependencies; CI with --throw-deprecation covers that. What you get is a list of concrete places to start, in under a second.
Running TypeScript without a build: what changed
Node.js can run .ts files directly. It strips the type annotations and executes the JavaScript that's left. The docs mark this Stable as of 25.2.0 and 24.12.0. Nothing is type-checked, so tsc --noEmit in CI is still mandatory.
Node.js 26 removed --experimental-transform-types, the flag that allowed TypeScript constructs which generate code: enum, namespace with values, and constructor parameter properties. The rule is now simple: code you run directly with node must use erasable syntax only. Turn on "erasableSyntaxOnly": true in tsconfig.json and the compiler flags everything that won't run.
The usual replacement for an enum:
export const OrderStatus = { Pending: "pending", Paid: "paid", Refunded: "refunded" } as const;
export type OrderStatus = (typeof OrderStatus)[keyof typeof OrderStatus];
const status: OrderStatus = OrderStatus.Paid;
console.log(status);paidIf you're moving to TypeScript 6.0 at the same time, watch one changed default: types is now []. Without an explicit "types": ["node"] in tsconfig.json, the types for process, Buffer and the rest of the Node API disappear. The rule carries over to the native TypeScript 7 compiler; what else breaks there (rootDir, ESLint, next build) is in my TypeScript 7 migration guide.
Module loaders: from register() to registerHooks()
If you have a custom loader for path aliases, test mocks or instrumentation, module.register() now prints a DEP0205 warning. The docs recommend synchronous module.registerHooks(): the hooks run on the same thread, are simpler to reason about and support deregister(). Here's an @/ alias pointing at src/:
import { registerHooks } from "node:module";
const srcRoot = new URL("./src/", import.meta.url);
registerHooks({
resolve(specifier, context, nextResolve) {
if (specifier.startsWith("@/")) {
return nextResolve(new URL(specifier.slice(2), srcRoot).href, context);
}
return nextResolve(specifier, context);
},
});node --import ./hooks.ts main.tshello, Node 26main.ts imports @/lib/hello.ts, and the hook maps it to src/lib/hello.ts. registerHooks() has been available since Node 22.15, so the same code runs on 22, 24 and 26. You can migrate the loader before you upgrade Node.
CI on two versions at once
The cheapest way to upgrade without surprises is to run your tests on both the current and the new version for a few weeks. A minimal GitHub Actions matrix:
name: ci
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
node: [24, 26]
steps:
- uses: actions/checkout@v7
- uses: actions/setup-node@v7
with:
node-version: ${{ matrix.node }}
cache: npm
- run: npm ci
- run: npx tsc --noEmit
- run: npm test
env:
NODE_OPTIONS: --throw-deprecationfail-fast: false keeps a failure on 26 from cancelling the run on 24, so you always see both results. --throw-deprecation turns deprecation warnings into errors, so you catch them in tests rather than in production logs. And npm ci on 26 immediately tells you whether every native addon still builds.
For Docker, change the base image, for example from node:24-bookworm-slim to node:26-bookworm-slim. In production, pin the exact version (node:26.12.1-bookworm-slim) and bump it on purpose, not on every rebuild.
Next.js apps: upgrade the framework too
For Next.js the Node.js version itself is rarely the problem. The docs require Node.js 20.9 or newer, so both 24 and 26 work. The bigger point is to upgrade the two together. On October 14, 2026, Next.js shipped an out-of-band security update, versions 16.4.1 and 15.5.28. It fixes two critical remote code execution bugs, one in use cache functions that return typed arrays and one in the Image Optimization API when handling SVG, plus a high-severity denial of service via Server Actions.
So add npm ls next to your Node.js upgrade checklist, and make sure you're at or above the fixed version on your line. Both upgrades go through the same CI and staging checks, so there's no reason to pay for two separate test cycles. The database is the next layer with a deadline: PostgreSQL 14 loses support on November 12, 2026, and I covered that upgrade in PostgreSQL 19: what's new and how to upgrade.
Step-by-step rollout
Order matters more than speed. For a typical production service on Node.js or Next.js:
- day 0Security patch22.23.4 / 24.22.1 / 26.12.1 — today
- day 1Reconpreflight script, native addons, hosting
- week 1CI on two versions24 + 26 matrix, --throw-deprecation
- week 2Stagingnode:26 image, load, logs
- week 3Productiongradual rollout, rollback plan
- Security patch today. 22.23.4, 24.22.1 or 26.12.1 in every environment, including workers, cron jobs and Docker images.
- Recon. Run the preflight script, check native addons with
npm ls, and confirm your host supports 26.x. - CI on 24 and 26. Fix whatever fails and upgrade dependencies that print deprecation warnings.
- Staging on 26. Use the same image that will go to production. Exercise real flows: payments, webhooks, background jobs, file generation. Compare memory and response times against the current version.
- Gradual production rollout. One instance or a slice of traffic first, then the rest. Your rollback plan is the previous image, restorable with one command.
- Clean up. Update
engines,.nvmrcand the docs, and removetemporal-polyfillif you used it.
What usually hurts isn't Node.js itself. It's the background jobs and integrations nobody runs by hand. I've written separately about reliable background workers in Node.js: retries, idempotency and a dead-letter queue make upgrades like this far calmer. I did similar work on Node.js (queues, streaming PDFs and faster PostgreSQL) for a US order-management platform.
Upgrade checklist
| Check | How | Done when |
|---|---|---|
| Security patch | node -p "process.version" in every environment |
≥ 22.23.4 / 24.22.1 / 26.12.1 |
| Hosting | project settings, provider docs | 26.x is listed as supported |
| Native addons | preflight script, npm ci on 26 |
everything builds or uses Node-API |
| Removed APIs | preflight script, search for _stream_, writeHeader |
zero matches |
| Deprecated APIs | tests with --throw-deprecation |
tests are green |
| TypeScript | erasableSyntaxOnly, "types": ["node"] |
tsc --noEmit passes |
| Next.js | npm ls next |
≥ 16.4.1 or ≥ 15.5.28 on your line |
| Dates | search for 24 * 60 * 60 * 1000, setMonth( |
critical paths use Temporal or are covered by tests |
| Rollback | previous image or version in settings | rollback tested at least once |
What to do this week
Node.js 26 LTS is a calm upgrade with no architectural upheaval. What breaks is mostly old dependencies and forgotten flags, while Temporal and the new Map methods pay off every day.
The minimum for this week: install the October 21 patch, run the preflight script and add 26 to your CI matrix. Move production once tests are green on both versions and your host officially supports 26.x. If your app runs on Next.js, my guide to the App Router in production covers the framework side. If you'd like help with the upgrade or an audit of a Node.js backend, here's how I work on Next.js and Node.js projects.
Was this useful?
– likes · – views
Questions people ask
When does Node.js 26 become LTS and how long is it supported?
Node.js 26 enters Active LTS on October 28, 2026, moves to Maintenance on October 20, 2027, and reaches end of life on April 30, 2029 — the longest runway of any supported line.
Do I need to upgrade from Node.js 24 right away?
No. Node.js 24 gets security fixes until April 30, 2028. What is urgent is the October 21, 2026 security patch: upgrade to 24.22.1 now and plan the move to 26 once your host supports it.
What is most likely to break when I upgrade to Node.js 26?
Native addons that aren't built on Node-API (NODE_MODULE_VERSION is now 147), the removed _stream_* modules, http writeHeader(), the removed --experimental-transform-types flag, and server code that assumes a global localStorage.
Can I use Temporal instead of Date now?
On Node.js 26 Temporal is enabled by default and TypeScript 6.0 ships built-in types for it (lib esnext or esnext.temporal). If some services still run on Node 22 or 24, use temporal-polyfill, which has the same API.
Does Vercel support Node.js 26?
As of late October 2026, Vercel's docs list 24.x (default) and 22.x for builds and Functions; Node.js 26 is officially available in Vercel Sandbox. Check the Node.js Version setting in your project before setting engines to 26.x.