Node.js 26 LTS: What’s New, Breaking Changes and How to Upgrade from Node 22 and 24 (2026)

Node.js 26 LTS: What’s New, Breaking Changes and How to Upgrade from Node 22 and 24 (2026)

Node.js 26 LTS: What’s New, Breaking Changes and How to Upgrade from Node 22 and 24 (2026)

On 28 October 2026, Node.js 26 LTS arrived under the codename “Lithium”, and it is a more unusual release than its version number suggests. It is the last line built under the ten-year-old even/odd release model, so it is the final LTS that had an odd-numbered “Current” sibling to preview its breaking changes. It ships Temporal enabled by default, V8 14.6, Undici 8, and a set of removals that quietly break code which has been printing deprecation warnings since Node 22. Meanwhile Node 22 reaches end-of-life on 30 April 2027, and Node 24 has already dropped to maintenance. If you run production JavaScript, the upgrade calendar for the next 18 months was set this autumn.

This guide gives you only what can be traced to the official changelogs, docs and schedule file, plus a runbook you can execute this week.

What this covers: verified release and EOL dates, the real feature list, every breaking change that matters when jumping from 22 or 24, native-addon compatibility, Docker and CI commands, a measurement harness, a decision table and the failure modes we expect to see.

Context and Background

Node.js has followed the same rhythm since 2016. A new major ships every April and October. Even-numbered lines become Long Term Support (LTS) in October and receive roughly 30 months of fixes; odd-numbered lines live for about eight months as “Current” and then die. Production teams were told to ride the even lines and treat odd ones as previews.

That model ends with this release. In March 2026 the project published Evolving the Node.js Release Schedule, which moves Node to one major per year. From Node 27 onward every line becomes LTS, and a new Alpha channel of signed, tagged prereleases replaces the odd-numbered Current lines as the place where semver-major changes land first. The announcement describes Node.js 26 as “the last release line under the current model” and Node.js 27 as “the first release line under the new schedule”. Version numbers will now track the calendar year of their first Current release: 27.0.0 in 2027, 28.0.0 in 2028.

The authoritative dates live in schedule.json in the nodejs/Release repository, which the announcement itself recommends as the source of truth. As of 16 November 2026 it records the following lifecycles for the lines most teams care about.

Line Codename First release Active LTS Maintenance End of life
Node 20 Iron 2023-04-18 2023-10-24 2024-10-22 2026-04-30 (already EOL)
Node 22 Jod 2024-04-24 2024-10-29 2025-10-21 2027-04-30
Node 24 Krypton 2025-05-06 2025-10-28 2026-10-20 2028-04-30
Node 25 (none) 2025-10-15 n/a 2026-04-01 2026-06-01 (already EOL)
Node 26 Lithium 2026-05-05 2026-10-28 2027-10-20 2029-04-30
Node 27 (not yet named) Alpha 2026-10-28, Current 2027-04-22 2027-10-20 n/a 2030-04-30

Two consequences follow. First, Node 22 has about five months of security support left. Second, Node 24 is already in maintenance, which means it now receives only critical bug fixes and security patches, not backported features. For a team on 22, the realistic targets are 24 (EOL April 2028) or 26 (EOL April 2029), and the extra year is the main reason to skip a line.

If your organisation runs several runtimes, this is the same calendar-driven decision we walked through for .NET 11 and the upgrade path from .NET 10, and the same discipline applies: pin to a supported line, measure, then move.

What Node.js 26 LTS Actually Changes: The Verified Feature and Breakage Map

Node.js 26 LTS (26.13.0 “Lithium”, promoted 28 October 2026) is supported until 30 April 2029. It ships V8 14.6, Temporal enabled by default, Undici 8, npm 11 and OpenSSL 3.5, and it removes several long-deprecated APIs. Upgrading from Node 24 crosses one ABI bump; from Node 22 it crosses three.

Node.js 26 LTS lifecycle timeline compared with Node 22, Node 24 and the Node 27 alpha channel
Figure 1: Support windows for Node 22, 24 and 26 and the first line on the new annual schedule, Node 27. Dates from nodejs/Release schedule.json.

Figure 1 lays the four lines side by side. Read it left to right: each line moves from Current to Active LTS to Maintenance to end-of-life. The overlap that matters is the period from now to April 2027, when three LTS lines (22, 24 and 26) are all receiving security fixes. After that the overlap is 24 and 26 until April 2028. Node 27 begins as an alpha in the same week Node 26 became LTS, which is new: there is no longer an odd-numbered Current line alongside it.

The release itself: what the version numbers tell you

The Node.js 26.0.0 release notes date the first release to 5 May 2026, with V8 updated to 14.6.202.33 (part of Chromium 146), Undici updated to 8.0.2, and NODE_MODULE_VERSION bumped to 147. The 26.13.0 LTS release notes state that the release “marks the transition of Node.js 26.x into Long Term Support (LTS) with the codename ‘Lithium'” and that, other than metadata such as process.release, “no further changes from Node.js 26.12.1 are included”. A security release, 26.13.1, followed in November 2026.

The official distribution index at nodejs.org/dist/index.json records the bundled components for each build. Pulling it on 16 November 2026 gives the figures below. They are useful because they show exactly how far each jump moves you.

Component Node 22 (latest 22.23.5) Node 24 (latest 24.22.3) Node 26 (26.13.x)
V8 12.4 13.6 14.6
NODE_MODULE_VERSION 127 137 147
npm 10.9.9 11.19.1 11.20.0
OpenSSL 3.5.9 3.5.9 3.5.9
libuv (last listed) 1.51.0 1.52.1 1.52.1

Two details deserve attention. OpenSSL is identical across all three lines today, because the project moved the older lines onto the OpenSSL 3.5 series during 2025 and 2026. TLS behaviour changes are therefore unlikely to come from the library version itself. The jump that matters is V8 and the ABI: any native module compiled against raw V8 headers must be rebuilt, and Node 22 users cross the intermediate ABI values 137 and 141 (Node 25) on the way.

Features you can rely on in production

Temporal is the headline. The 26.0.0 notes say: “The Temporal API is now enabled by default in Node.js 26.” Temporal gives JavaScript immutable date and time types with explicit time zones and calendars, the long-awaited replacement for the mutable, local-time-biased Date object. For anyone who has fought daylight-saving bugs in scheduling code, this removes a dependency on Luxon or date-fns-tz for many use cases. It does not replace Date; existing code keeps working.

V8 14.6 also adds Map.prototype.getOrInsert(), Map.prototype.getOrInsertComputed() (and the WeakMap equivalents) from the “upsert” proposal, plus Iterator.concat(). Users coming from Node 24 also inherit everything from V8 14.1, which Node 25 introduced; the 25.0.0 notes highlight JSON.stringify performance work and built-in Uint8Array base64 and hex conversion.

Several features that started as experiments are now stable, and these are the real reason a Node 22 shop should care:

  • TypeScript type stripping. Marked stable in 25.2.0 and 24.12.0 (PR #60600). Node runs .ts files directly by erasing type annotations. It does not type-check, ignores tsconfig.json (so paths aliases fail), refuses TypeScript files under node_modules, and rejects syntax that needs code generation, such as enum and namespaces containing runtime code. The TypeScript docs page recommends TypeScript 5.8+ with erasableSyntaxOnly. In 26.0.0, the --experimental-transform-types flag that handled enums was removed outright.
  • require(esm). Marked stable in 25.4.0 (PR #60959), together with a --require-module / --no-require-module switch. CommonJS code can require() a synchronous ES module graph without dynamic import().
  • Module compile cache. Also marked stable in 25.4.0 (PR #60971), useful for CLI start-up time.
  • Permission model. Stable since 23.5.0 and 22.13.0, invoked with --permission. Node 25 added --allow-net (marked “Active development” in the docs), and the 26.x line added --allow-ffi (26.1.0) and --allow-openssl-store (26.7.0), both also in active development.
  • Web Storage. localStorage and sessionStorage globals were unflagged in 25.0.0 and are documented as release candidates. In 26.0.0, localStorage returns undefined when no storage file is configured.

Putting the new features to work

Three of the Node.js 26 features change everyday code, so it is worth seeing them concretely. The snippet below uses only APIs documented as enabled by default or stable in the 26.x line.

// Temporal: schedule a job at 09:00 Berlin time, robust across DST changes
const next = Temporal.Now.zonedDateTimeISO('Europe/Berlin')
  .add({ days: 1 })
  .with({ hour: 9, minute: 0, second: 0, millisecond: 0 });
console.log(next.toString());            // includes offset and [Europe/Berlin]
console.log(next.toInstant().epochMilliseconds);

// Upsert (V8 14.6): count events without the get/set dance
const counts = new Map();
for (const e of ['a', 'b', 'a']) counts.set(e, counts.getOrInsert(e, 0) + 1);

// Iterator.concat (V8 14.6): stream two sources lazily
for (const x of Iterator.concat([1, 2].values(), [3].values())) console.log(x);

The Temporal example shows why the API matters for operations code. A Temporal.ZonedDateTime carries its time zone, so adding one day across a daylight-saving boundary keeps the wall-clock time at 09:00 rather than drifting by an hour, which is the classic Date bug in cron-like schedulers. Because Temporal objects are immutable, passing one to a helper cannot silently change the caller’s value.

The permission model is the other feature worth adopting during the upgrade, because Node.js 26 LTS is a natural moment to tighten defaults. Start in audit mode if your release supports it (--permission-audit was added in 25.8.0 per the CLI docs), then enforce:

# Enforce: read only the app and config, write only to /tmp, no child processes
node --permission \
  --allow-fs-read=/app --allow-fs-read=/etc/myapp \
  --allow-fs-write=/tmp \
  server.js

With --permission set, file system, child process, worker, native addon and WASI access are denied unless granted. Network restriction via --allow-net exists but is documented as “Active development”, so treat it as defence in depth, not as your only egress control. The docs also list a sharp limitation: symbolic links are followed even outside granted paths, so granted directories must not contain relative symlinks. Pair the permission model with container-level controls rather than replacing them.

Experiments you should not ship on yet

The 26.x line also contains features clearly marked experimental. The node:ffi module, added in 26.1.0, is documented as “Stability: 1 – Experimental” and “unsafe”: a wrong pointer or symbol signature can crash the process or corrupt memory. The docs also say it is only available in builds with FFI support, so do not assume every binary has it. The --config-file flag was renamed from --experimental-config-file in 26.12.0 after being marked release candidate in 26.7.0. These are worth trying in a branch, but an LTS upgrade should not depend on them.

The practical reading of all this is simple. The value of Node.js 26 LTS is not one big feature. It is that four years of experiments (TypeScript stripping, require(esm), the permission model, compile cache, Temporal) are now either stable or on by default in a line supported until 2029.

Walk-through: Breaking Changes and the Upgrade Runbook

The work in a Node upgrade is rarely the new features. It is the removals. This section lists what breaks, in the order you will hit it, then gives the commands.

What breaks when you cross 24 to 26

The 26.0.0 release notes list these semver-major removals and deprecations. Each one is traceable to a pull request.

Change Status in 26 What to do
http.Server.prototype.writeHeader() Removed (#60635) Use writeHead()
_stream_wrap, _stream_readable, _stream_writable, _stream_duplex, _stream_transform, _stream_passthrough Removed (#60657) Import from node:stream
--experimental-transform-types Removed (#61803) Replace enum with const objects or use a full transpiler
DEP0182, short GCM auth tags without authTagLength End-of-Life (#61084) Pass authTagLength to createDecipheriv()
DEP0205, module.register() Runtime deprecated (#62401) Migrate to module.registerHooks()
DEP0203, passing CryptoKey to node:crypto APIs Runtime deprecated (#62453) Convert with KeyObject.from() or use Web Crypto
DEP0204, KeyObject.from() with non-extractable CryptoKey Runtime deprecated (#62453) Make keys extractable or stay in Web Crypto
DEP0201, options.type in Duplex.toWeb() Runtime deprecated (#62173) Use readableType

The module.register() deprecation is the one most likely to surprise tooling authors. APM agents, test-coverage loaders and mocking libraries used the off-thread async hooks it provides. The deprecations doc is blunt: async hooks proved “complex, involving worker threads orchestration”, with “issues that have proven unresolvable”, and module.register() “will be removed in a future version”. Expect a runtime warning from older instrumentation agents until vendors move to registerHooks().

Crypto changes also need care. Node 26 defaults ML-KEM and ML-DSA PKCS#8 export to a seed-only format (#62178). If you are already experimenting with post-quantum keys and store exported keys, test round-tripping before upgrading.

What breaks when you cross 22 to 24 to 25

Teams jumping from 22 also inherit every break from 23, 24 and 25. The ones verified in the official notes and the deprecations document are:

  • Corepack is no longer distributed from 25.0.0 (#57617). If your Dockerfile or CI runs corepack enable to get pnpm or Yarn, it will fail on 26. Install the package manager explicitly, for example npm install -g corepack or npm install -g pnpm@<version>.
  • fs.F_OK, fs.R_OK, fs.W_OK, fs.X_OK reached End-of-Life in 25.0.0 (DEP0176). Use fs.constants.F_OK.
  • SlowBuffer moved to End-of-Life in 25.0.0 (#58220).
  • tls.createSecurePair was removed in 24.0.0 (#57361).
  • DEP0190: passing an args array to spawn or execFile with shell: true became a runtime deprecation in 24, because the values are not escaped and can enable shell injection.
  • DEP0187: invalid argument types to fs.existsSync became a runtime deprecation in 24; it will throw in future.
  • DEP0169: url.parse() became an application deprecation in 24. It warns for your code, not for code inside node_modules.
  • AsyncLocalStorage uses AsyncContextFrame by default from 24.0.0. Context propagation behaves the same for correct code, but libraries that relied on async_hooks internals may differ.
  • --experimental-permission became --permission in 24.0.0.
  • Linux binaries are linked against libatomic from Node 25. The 26.13.0 notes warn that this “may need to be installed separately depending on your Linux distribution”. Minimal images and hand-rolled base images are where this bites.
  • Web Storage globals exist from 25. Code that uses typeof localStorage !== 'undefined' to detect “am I in a browser” now gets a different answer in some configurations.

Each of these is cheap to fix in isolation. The cost comes from discovering them one production incident at a time. The runbook below is designed to surface all of them in CI first.

Node.js 26 LTS upgrade runbook from inventory through deprecation sweep, CI matrix, performance gate and canary
Figure 2: The upgrade pipeline. Each gate either produces a fix or a documented reason to stay on Node 24 for now.

Figure 2 is the sequence we recommend. The important property is that every step before the canary runs on your current runtime or in CI, so nothing reaches production until the deprecation sweep, the ABI rebuild and the performance comparison have all passed.

Step 1: inventory and deprecation sweep on your current runtime

Before installing Node.js 26 LTS, make your current line tell you what it will break. Node has long supported flags that turn deprecation warnings into hard failures or stack traces.

# Run the full test suite on your CURRENT Node (22 or 24) with deprecations as errors
NODE_OPTIONS="--throw-deprecation" npm test

# Or keep tests running but print where each deprecated call comes from
NODE_OPTIONS="--trace-deprecation" npm test 2>&1 | grep -E "DEP0(169|176|182|187|190|201|203|204|205)" | sort | uniq -c

# Find direct uses of removed APIs in your own code
grep -rnE "writeHeader\(|require\(['\"]_stream_|fs\.(F|R|W|X)_OK|SlowBuffer|createSecurePair|corepack enable" \
  --include=*.{js,cjs,mjs,ts} --exclude-dir=node_modules .

# List dependencies with native code (binding.gyp or prebuilt .node files)
find node_modules -name binding.gyp -o -name "*.node" | sed 's|/build/.*||' | sort -u

--throw-deprecation will fail fast on the first warning, which is noisy but honest. --trace-deprecation is gentler for large suites. Neither catches APIs that were removed outright in 26, which is why the grep step matters. Also check engines fields in your own package.json files: an "engines": {"node": ">=22 <25"} constraint silently blocks installs on 26 when engine-strict is set.

Step 2: install Node.js 26 LTS locally and in containers

# nvm: install the Lithium LTS line by codename or by major
nvm install lts/lithium        # or: nvm install 26
nvm alias default 26
node -p "process.version + ' ' + process.release.lts + ' v8 ' + process.versions.v8 + ' abi ' + process.versions.modules"
# expected shape: v26.13.x Lithium v8 14.6.202.xx abi 147

# fnm and volta equivalents
fnm install 26 && fnm default 26
volta install node@26

For containers, the Docker official node image publishes 26, 26-slim, 26-alpine, 26-bookworm, 26-bookworm-slim, 26-trixie and 26-trixie-slim tags, plus fully pinned 26.13.1-* variants. Pin to a full version or, better, a digest.

# syntax=docker/dockerfile:1
FROM node:26.13.1-trixie-slim AS build
WORKDIR /app
COPY package.json package-lock.json ./
# Corepack is not bundled since Node 25: install your package manager explicitly if needed
RUN npm ci --omit=dev
COPY . .

FROM node:26.13.1-trixie-slim
ENV NODE_ENV=production
WORKDIR /app
COPY --from=build /app /app
USER node
CMD ["node", "--enable-source-maps", "server.js"]

If you build your own base image from the Linux tarball rather than using the official one, add the libatomic package for your distribution (for example libatomic1 on Debian-family systems) and run node -v inside the image as a build-time smoke test. That one line catches the most common “works on my laptop” failure of this upgrade.

Step 3: a CI matrix that spans the transition

Run your suite on all three supported LTS lines, Node 22, Node 24 and Node.js 26 LTS, until Node 22 reaches end-of-life. Library authors should also add the Node 27 alpha, which the release team explicitly asks for: “if you only test on LTS releases, you will not be able to report bugs before they affect your users”.

# .github/workflows/ci.yml
name: ci
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        node: [22, 24, 26]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node }}
          cache: npm
      - run: npm ci
      - run: npm test
        env:
          NODE_OPTIONS: --trace-deprecation

Keep fail-fast: false so a failure on 26 does not hide the result on 22. When the 26 job is green and the deprecation log is clean, change your engines field to ">=24" or ">=26" depending on your support policy.

Native Addons, node-gyp and the ABI Bump

Native modules are the single most likely reason a Node.js 26 LTS upgrade stalls. The rule is mechanical, and Figure 3 encodes it.

Native addon compatibility decision tree for a Node.js 26 LTS upgrade covering Node-API, NAN, prebuilds and node-gyp
Figure 3: How to decide whether a native dependency will work on Node 26 without changes, needs a rebuild, or blocks the upgrade.

A native addon is a compiled .node shared library. It talks to Node through one of two interfaces. Node-API (formerly N-API) is a C ABI that Node keeps stable across major versions. The Node-API documentation explains that an addon built against a given Node-API version keeps working on later Node releases that support that version. Older addons instead use NAN (Native Abstractions for Node) or include V8 headers directly. Those are compiled against a specific NODE_MODULE_VERSION, and Node 26 uses 147. A binary built for Node 24 (137) or Node 22 (127) will refuse to load, typically with an error saying the module “was compiled against a different Node.js version”.

Working through the tree

Start with each dependency that has a binding.gyp or ships .node files. If it uses only Node-API, the existing binary should load; run its tests and move on. Many actively maintained packages now ship Node-API builds, but do not assume it: check each package’s binding.gyp, its README or whether it depends on node-addon-api (a Node-API wrapper) rather than nan.

If it uses NAN or raw V8, it needs a binary for ABI 147. Many packages publish prebuilt binaries per ABI via prebuildify or node-pre-gyp. Check that a Node 26 build exists before upgrading. If none exists, npm falls back to compiling from source with node-gyp, which needs Python and a C++ toolchain in your build image.

Here the 26.0.0 toolchain changes matter, but read them carefully. The notes bump the GCC requirement to 13.2 (#62555) and drop Python 3.9 (#61177). Those are requirements for building Node.js itself. They are a good signal of what the Node 26 headers assume, so an old compiler in your CI image may fail on V8 14.6 headers, but they are not a published minimum for every addon. On Windows the 24.0.0 notes say MSVC was dropped and ClangCL is required to compile Node.js; again, that applies to building Node, not necessarily to your addon.

If the addon compiles but fails against V8 14.6, you have three choices: patch it (the 26.0.0 notes list replacements for deprecated v8::External APIs, which hints at the kind of change involved), replace it with a Node-API or pure-JavaScript alternative, or stay on Node 24 until upstream catches up. Node 24 is supported until April 2028, so staying is a legitimate decision, not a failure.

# Rebuild everything with native code against the active Node version
npm rebuild

# Force a source build of a single addon to see compiler errors clearly
npx node-gyp rebuild --directory node_modules/<addon-name> --verbose

# Confirm what ABI the running Node expects
node -p "process.versions.modules"   # 147 on Node 26

A practical tip: run npm rebuild in the same container image you deploy, not on a developer laptop. The ABI check passes on the laptop, then the deployed image lacks the compiler, falls back to a prebuild that does not exist, and the pod crashes on start.

Measuring Before You Switch: A Performance Harness

Release notes describe V8 optimisations, but no official benchmark tells you how your service will behave on Node.js 26 LTS and V8 14.6. We are not publishing speed-up numbers here, because none we could verify apply to arbitrary workloads. Measure your own.

The harness below runs the same micro-workloads under two Node binaries and prints medians. It uses only built-in modules.

// bench.mjs : run with `node bench.mjs` under each Node version
import { performance } from 'node:perf_hooks';
import { createHash } from 'node:crypto';

const payload = JSON.parse(JSON.stringify(
  Array.from({ length: 5_000 }, (_, i) => ({ id: i, name: `item-${i}`, tags: ['a', 'b'], score: i * 1.5 }))
));

const cases = {
  'json-stringify': () => JSON.stringify(payload),
  'json-parse': () => JSON.parse(JSON.stringify(payload)),
  'sha256-1MB': () => createHash('sha256').update(Buffer.alloc(1 << 20)).digest('hex'),
  'map-upsert': () => {
    const m = new Map();
    for (let i = 0; i < 100_000; i++) {
      const k = i % 1000;
      // getOrInsert exists on Node 26 (V8 14.6); fall back elsewhere
      if (typeof m.getOrInsert === 'function') m.set(k, m.getOrInsert(k, 0) + 1);
      else m.set(k, (m.get(k) ?? 0) + 1);
    }
  },
};

function median(xs) { const s = [...xs].sort((a, b) => a - b); return s[Math.floor(s.length / 2)]; }

for (const [name, fn] of Object.entries(cases)) {
  for (let i = 0; i < 20; i++) fn();                 // warm-up for JIT tiers
  const samples = [];
  for (let i = 0; i < 50; i++) {
    const t0 = performance.now(); fn(); samples.push(performance.now() - t0);
  }
  console.log(`${process.version}\t${name}\t${median(samples).toFixed(3)} ms`);
}
const mu = process.memoryUsage();
console.log(`${process.version}\trss\t${(mu.rss / 1e6).toFixed(1)} MB`);
# Run under both versions with nvm, five times each, on an idle machine
for v in 24 26; do for i in 1 2 3 4 5; do nvm exec $v node bench.mjs; done; done | tee results.tsv

# Service-level check: same build, same load, two runtimes
npx autocannon -c 50 -d 60 http://localhost:3000/health

Micro-benchmarks catch regressions in specific paths, such as JSON-heavy APIs. They do not predict service latency. For that, run the real service under a load generator for at least a minute per runtime and compare p50, p99, throughput and resident memory. Repeat runs and report the spread, not a single figure.

A sensible gate (an illustrative policy, not a measured threshold) is “p99 latency and RSS within 5 percent of baseline, error rate unchanged”. If a path regresses, take a CPU profile with node --cpu-prof on both versions and compare hot functions before deciding whether the cause is your code, a dependency or the runtime.

Garbage collection deserves its own look. Three V8 majors separate Node 22 from Node 26, and heap sizing heuristics are not guaranteed to be identical. If you set --max-old-space-size explicitly for containers, re-check that the value still fits your memory limit under load, and watch for OOM kills during the canary.

Node 24 vs Node 26: When to Upgrade

The decision is not “is Node.js 26 LTS better”. It is “what does each option cost, and until when”. The matrix below is the one we use.

Your situation Recommended target Why
On Node 22, few native addons, active team Node 26 now Skips one migration; support to April 2029 versus April 2028
On Node 22, heavy native addons without Node 26 prebuilds Node 24 now, 26 in 2027 Node 24’s ABI 137 is widely supported; meets the April 2027 deadline
On Node 24, stable service, no feature need Stay, plan 26 by mid-2027 Node 24 has security support until April 2028
On Node 24, want Temporal, stable require(esm) and newer V8 Node 26 after the CI gate Same breakage surface as one major, mostly 25 and 26 removals
Publishing a library Test 22, 24, 26 and the 27 alpha Users span all lines; the project asks authors to test alphas
Relying on module.register() instrumentation Upgrade agent first, then Node Runtime deprecation warnings, future removal
Serverless platform Follow provider support Managed runtimes adopt new lines on their own timeline

The last row deserves emphasis. AWS Lambda, Google Cloud Run functions, Azure Functions and similar platforms publish their own support dates for Node runtimes, which can trail the upstream release. Check your provider’s runtime page before planning. We have not verified each provider’s Node 26 status for this article, so treat it as an open item.

For edge-heavy architectures, the runtime choice may also interact with whether you package functions as containers or WebAssembly modules. We compared those packaging models in our WebAssembly vs containers ADR for edge functions.

Rolling It Out Safely

Once CI is green and the harness shows no regression, the remaining risk is behaviour that only appears under real traffic: HTTP/2 negotiation, memory under production heap shapes, and third-party agents.

Node.js 26 LTS canary rollout sequence from CI matrix through image digest, canary traffic, monitoring and promotion
Figure 4: Canary rollout for a Node 26 runtime change, promoted or rolled back by image digest.

Figure 4 shows the flow for a Node.js 26 LTS rollout. The pull request changes only the base image and engines, nothing else, so the canary isolates the runtime change. CI pushes an image by digest. The orchestrator routes a small slice of traffic (5 percent is a common starting point) to the new pods. Monitoring compares p99 latency, resident memory and error rates against the Node 24 or 22 baseline over one to three days, long enough to cover daily traffic peaks and scheduled jobs. Promotion and rollback are both a digest swap.

Keep the runtime change separate from dependency upgrades. If you bump Express, an ORM and Node in the same release, a regression in the canary has three suspects instead of one.

Trade-offs, Gotchas, and What Goes Wrong

Undici 8 and HTTP/2. Node’s global fetch() is implemented by the bundled Undici. The Undici v7-to-v8 migration guide states that HTTP/2 is now “enabled by default” when a TLS server negotiates it through ALPN, and that allowH2: false restores HTTP/1.1-only behaviour. Our inference, which you should verify against your own upstreams, is that outbound fetch calls to HTTP/2-capable servers may switch protocol after upgrading. That can change connection counts, proxy behaviour and how load balancers spread traffic. Undici 8 also renames the low-level dispatcher handler callbacks and rejects fake Blob objects, which breaks custom interceptors written for v7.

Corepack in containers. Because Corepack stopped shipping in 25.0.0, corepack enable lines in Dockerfiles fail on Node.js 26 LTS images. This is the most common first error.

Minimal images and libatomic. Distroless or hand-built images missing libatomic fail at process start, not at build time, unless you add a node -v smoke test.

TypeScript expectations. Type stripping is stable, but it is not tsc. It will not type-check, does not apply paths, and rejects enum. Teams that dropped their build step on Node 24 and later used --experimental-transform-types for enums will find that flag gone.

Instrumentation agents. APM and coverage tools built on module.register() print runtime warnings and will break when the API is removed. Upgrade agents first.

localStorage detection. Libraries that detect “browser” by checking for localStorage can misbehave now that the global exists in Node.

Security fixes during the transition. The 26.13.1 security release fixed a batch of HTTP/2, TLS, HTTP, zlib and permission-model issues, nine of its line items rated High. Upgrading to the latest patch of whatever line you run matters more than which line you choose.

Anti-pattern: node:latest. Floating tags moved to 26 during this cycle and will move to 27 next year. Pin major, minor and patch, or a digest.

Practical Recommendations

Treat Node.js 26 LTS as a planned, measured runtime change rather than a dependency bump. The deadline that should drive scheduling is 30 April 2027 for Node 22. If you run Node 24, you have until April 2028 and can afford to wait for your native dependencies and APM vendor to catch up, but you should not wait for 2028 itself, because the migration path becomes longer if Node 27 is in LTS by then.

For most service teams on Node 22, we recommend going straight to Node.js 26 LTS in Q1 2027 if your native dependencies are covered, and to Node 24 now if they are not. Library authors should test on 22, 24, 26 and the 27 alpha in CI.

Checklist:

  • [ ] Run your suite on your current line with --throw-deprecation and fix every hit.
  • [ ] Grep for removed APIs: writeHeader, _stream_*, fs.*_OK, SlowBuffer, corepack enable.
  • [ ] List native addons; confirm Node-API or a published ABI 147 prebuild for each.
  • [ ] Update Dockerfiles to a pinned node:26.13.x tag or digest; add a node -v smoke test.
  • [ ] Add 26 to the CI matrix with fail-fast: false; keep 22 until it is EOL.
  • [ ] Run the performance harness and a load test on both runtimes; record p99 and RSS.
  • [ ] Upgrade APM agents and loaders off module.register().
  • [ ] Test outbound fetch against HTTP/2-capable upstreams.
  • [ ] Canary at about 5 percent for one to three days, then promote by digest.
  • [ ] Update engines and documentation once fully rolled out.

Frequently Asked Questions

When did Node.js 26 become LTS, and when does it reach end-of-life?

Node.js 26 first shipped as a Current release on 5 May 2026. Version 26.13.0 promoted it to Long Term Support with the codename “Lithium” on 28 October 2026. According to the nodejs/Release schedule, it stays in Active LTS until 20 October 2027, then moves to Maintenance, and reaches end-of-life on 30 April 2029. The 26.13.0 release notes confirm it “will continue to receive updates through to the end of April 2029”. That gives it roughly a one-year longer runway than Node 24.

What is the codename for Node.js 26 LTS?

The codename is “Lithium”. Node LTS codenames follow the periodic table alphabetically: Node 20 was Iron, Node 22 was Jod (from the German for iodine), Node 24 was Krypton, and Node 26 is Lithium. You can use the codename with version managers, for example nvm install lts/lithium. At runtime, process.release.lts returns the string “Lithium” on an LTS build of Node 26, which is a handy way to assert in a health check or start-up log that production is on the intended release line.

Is it safe to upgrade directly from Node 22 to Node 26?

Yes, but you inherit every breaking change from 23, 24, 25 and 26 at once. The most common are Corepack no longer being bundled, removal of fs.F_OK-style constants, SlowBuffer reaching End-of-Life, the writeHeader and _stream_* removals, and native addon rebuilds across three ABI versions (127 to 147). Running your suite on Node 22 with --throw-deprecation, then adding Node 26 to a CI matrix, surfaces almost all of this before production. Skipping Node 24 saves you one future migration.

Does Node.js 26 run TypeScript natively?

Node.js 26 can run .ts files directly using type stripping, which became stable in Node 25.2.0 and 24.12.0. It removes type annotations without type-checking. It ignores tsconfig.json, so paths aliases do not work, and it rejects syntax that needs code generation, such as enum and namespaces with runtime code. The --experimental-transform-types flag that handled those cases was removed in 26.0.0. You still need tsc --noEmit in CI for type checking, and a full transpiler if you depend on enums.

Will my native modules work on Node.js 26?

If they use Node-API only, they should load without a rebuild, because Node-API is ABI-stable across Node majors. If they use NAN or include V8 headers directly, they must be rebuilt for NODE_MODULE_VERSION 147. Check whether the package publishes a prebuilt binary for Node 26; otherwise npm compiles it with node-gyp, which needs Python and a modern C++ toolchain in the build image. If compilation fails against V8 14.6, replace the module or stay on Node 24 until upstream releases a fix.

How does the new annual release schedule affect Node.js 26?

Node.js 26 is the last line on the old schedule. From Node 27, the project ships one major per year in April, every major becomes LTS, and semver-major changes first appear in a six-month Alpha channel starting each October. LTS duration stays at roughly 30 months, with 36 months total support. For Node 26 users, nothing changes about its own support dates. What changes is that the next LTS after Lithium will be Node 27, from October 2027, with no odd-numbered release in between.

Further Reading

By Riju — about

1 Comment

Leave a Reply

Your email address will not be published. Required fields are marked *