←All posts

Node.js 26 Is Now LTS: A Practical Upgrade Checklist

Node.js 26 'Lithium' moved to Long Term Support on October 28, 2026, and Node 24 has dropped to maintenance. Here's what actually changes for your apps — Temporal by default, V8 14.6, Undici 8, removed APIs — and a checklist for upgrading without surprises.

Node.js 26 Is Now LTS: A Practical Upgrade Checklist

If your production servers, CI images, and serverless functions are pinned to Node.js 24, the clock just moved. On October 28, 2026, Node.js 26.13.0 "Lithium" entered Long Term Support, with security support running through the end of April 2029. A week earlier, Node 24 left Active LTS and moved into maintenance mode, according to the endoflife.date Node.js tracker.

Node 26 is also the last release line under the old odd/even schedule — the project is moving to one major release per year. For teams that only upgrade on LTS boundaries, this is the version you'll live with for a while, so it's worth doing deliberately.

Where every supported line stands

As of mid-November 2026, the supported lines look like this (dates from endoflife.date):

Line Status Security support ends
Node 26 Active LTS April 30, 2029
Node 24 Maintenance LTS April 30, 2028
Node 22 Maintenance LTS April 30, 2027
Node 20 End of life April 30, 2026

Two takeaways. If you are still on Node 20, you've been running without security patches since the spring — that's the urgent upgrade. If you're on 22, you have about five months of runway left; skipping straight to 26 is the sensible move. Teams on 24 aren't in danger, but maintenance mode means fewer backports, so plan the move rather than letting it drift.

What actually changed in Node 26

The full list is in the Node.js 26.0.0 release notes. The changes most teams will notice:

Temporal is on by default

The headline feature: the Temporal API no longer needs an experimental flag. Temporal replaces the long list of Date pitfalls — mutable objects, zero-indexed months, no real time zone support — with immutable types that separate "a point in time" from "a date on a calendar" from "a wall-clock time in a specific zone."

// No flag, no polyfill on Node 26
const meeting = Temporal.ZonedDateTime.from(
  '2026-11-20T09:00[America/New_York]'
);

const inBerlin = meeting.withTimeZone('Europe/Berlin');
console.log(inBerlin.toString());
// 2026-11-20T15:00:00+01:00[Europe/Berlin]

const today = Temporal.Now.plainDateISO();
const eol = Temporal.PlainDate.from('2027-04-30');
console.log(today.until(eol, { largestUnit: 'days' }).days);

If your codebase pulls in @js-temporal/polyfill or a date library mainly to do time zone math, Node 26 lets you start retiring that dependency on the server. Just keep in mind that browser support is a separate question — shared isomorphic code may still need the polyfill on the client.

V8 14.6: upsert and iterator concat

Node 26 ships V8 14.6, which brings two small but handy language additions. The "upsert" methods remove the classic get-check-set dance on Map and WeakMap:

const byTenant = new Map();

// Before
if (!byTenant.has(id)) byTenant.set(id, []);
byTenant.get(id).push(event);

// Node 26
byTenant.getOrInsert(id, []).push(event);

// Lazy default — the callback only runs on a miss
cache.getOrInsertComputed(key, (k) => expensiveLookup(k));

And Iterator.concat() chains iterables lazily without spreading them into a temporary array:

for (const row of Iterator.concat(primaryRows, replicaRows)) {
  process(row);
}

Undici 8 under fetch()

The built-in fetch() is powered by Undici, which jumps to the 8.x line in Node 26. For most code this is invisible. If you import undici directly for its lower-level Agent, Pool, or interceptors, check its changelog alongside the runtime upgrade.

The breaking changes to check first

Most applications upgrade cleanly, but the following removals and deprecations from the 26.0.0 release are the ones that tend to show up in older code and dependencies:

  • http.Server.prototype.writeHeader() is gone. It was a long-deprecated alias. Use res.writeHead().
  • The legacy _stream_* modules are removed — _stream_readable, _stream_writable, _stream_duplex, _stream_transform, _stream_passthrough, and _stream_wrap. Import from node:stream instead. These mostly appear inside old, unmaintained packages, so search your node_modules, not just your own source.
  • --experimental-transform-types was removed. Built-in type stripping still runs erasable TypeScript, but if you relied on this flag for enums or namespaces, you'll need a real build step (or to rewrite those constructs).
  • module.register() is now runtime-deprecated. Custom loaders built on it will print warnings; plan a migration to the synchronous module.registerHooks() API.
  • NODE_MODULE_VERSION is now 147. Native add-ons compiled against the old ABI won't load. Packages built on Node-API are ABI-stable and unaffected; anything else needs a rebuild or a new prebuilt binary.
  • localStorage returns undefined unless a storage file is configured. If any shared code feature-detects localStorage on the server, verify it still takes the right branch.

A quick way to find the low-hanging problems before you touch CI:

# Old stream internals and writeHeader in your code and deps
grep -rnE "require\(['\"]_stream_|writeHeader\(" src node_modules \
  --include=*.js --include=*.cjs --include=*.mjs | head -50

# Run your test suite with deprecations surfaced as errors
NODE_OPTIONS="--throw-deprecation" npm test

Patch level matters: start on 26.13.1 or later

Don't pin to the exact LTS-transition build. On November 11, 2026, the project shipped Node.js 26.13.1, a security release fixing multiple high-severity issues in HTTP/2 and TLS handling, along with dependency updates to Brotli, llhttp, SQLite, and Undici. Public-facing servers using node:http2 or node:tls should treat this as required. Node 24 and Node 22 received patched releases the same day, so if you can't upgrade majors yet, at least move to the latest patch on your current line.

A rollout plan that works

  1. Bump the version everywhere at once. .nvmrc/.node-version, the engines field in package.json, Dockerfile base images, CI matrices, and your serverless runtime setting. Mismatches between local and CI are where "works on my machine" bugs come from.
  2. Rebuild native dependencies. Delete node_modules, reinstall, and run npm rebuild if you vendor anything compiled.
  3. Run tests with --throw-deprecation. It turns quiet warnings — including module.register() — into failures you can't ignore.
  4. Canary before you cut over. Send a slice of production traffic to Node 26 instances and compare error rates, p95 latency, and memory before shifting the rest. GC and JIT changes in a new V8 can move memory profiles in either direction.
  5. Adopt Temporal gradually. Start with new code paths that do time zone or duration math; don't rewrite working Date code just because you can.

Takeaways

Node.js 26 is now the default choice for new projects and the target for any upgrade still sitting on 20 or 22. The breaking changes are narrow — mostly long-deprecated APIs and native add-on rebuilds — and the payoff is Temporal without a polyfill, a newer V8, and three-plus years of security support. Start on 26.13.1 or later, align versions across every environment, run your suite with deprecations as errors, and canary the rollout. That's an afternoon of work for most services, and it buys you runway until 2029.

←Back to all posts
Next step

Need help shipping software?

Tell us what you're trying to build. A discovery call, a one-page summary within 48 hours, a proposal within a week.

Response · 48h·NDA on request·US contracts only