Node.js 26 LTS: New Features, Breaking Changes & How to Upgrade (2026)

Node.js 26 LTS is landing on October 28, 2026, and that date matters more than most release days. It is when Node.js 26 stops being the “Current” line and becomes the recommended version for production apps. At the same time, Node.js 24 has just moved into maintenance mode, and Node.js 22 is now only six months away from end of life. If you run Node in production, this is the moment to plan your upgrade.

In this guide, we cover what Node.js 26 actually changes, the new features worth using (including the Temporal API), the breaking changes that can trip up your upgrade, and a simple step-by-step plan to move your apps over safely.

Node.js 26 LTS Release Date and Support Timeline

Node.js 26.0.0 was first released on May 5, 2026, as a Current release. Under the usual Node.js rule, even-numbered versions spend about six months in Current and then get promoted to Long-Term Support. According to the official schedule published in the Node.js Release repository, the key dates look like this:

• Node.js 26: Active LTS from October 28, 2026, maintenance from October 20, 2027, end of life on April 30, 2029.
• Node.js 24 (Krypton): moved to maintenance LTS on October 20, 2026, end of life on April 30, 2028.
• Node.js 22 (Jod): already in maintenance, end of life on April 30, 2027.
• Node.js 20: reached end of life on April 30, 2026, so it no longer gets security fixes.

In plain terms: if you are still on Node.js 20, you are running an unsupported runtime today. If you are on Node.js 22, you have about six months left. Node.js 24 is still safe, but it now only receives critical fixes and security patches, while new improvements land in 26.

Why Node.js 26 LTS Is a Special Release

Node.js 26 is the last release line under the old “two majors per year” model. Earlier in 2026, the Node.js project announced that, starting with Node.js 27, there will be one major release per year. Here is how the new model works:

• Each major version starts with a six-month Alpha phase for early testing (not for production).
• It then ships as Current in April and is promoted to LTS in October.
• The odd/even split goes away. Every major version becomes LTS.
• Version numbers will follow the calendar year of the Current release, so Node.js 27 arrives in 2027 and Node.js 28 in 2028.

The Node.js 27 alpha channel is scheduled to open on the same day Node.js 26 becomes LTS. For most teams, the practical takeaway is simple: Node.js 26 LTS is the version to standardise on now, and you will not see another LTS line until October 2027. The project notes this schedule may still be amended, so check the official schedule before you lock in long-term plans.

New Features in Node.js 26 LTS

1. The Temporal API Is Enabled by Default

The biggest headline is Temporal, the modern date and time API for JavaScript, now available without any flags. If you have ever fought with the old Date object, time zones, or month indexes that start at zero, Temporal fixes most of those pain points. It gives you separate types for plain dates, times, time-zone-aware date-times, and durations, and all of them are immutable.

// Today's date in ISO format, no time zone confusion
const today = Temporal.Now.plainDateISO();
console.log(today.toString()); // e.g. "2026-10-28"

// Date maths that actually reads like English
const trialEnds = today.add({ days: 30 });

// Time-zone-aware timestamps
const meeting = Temporal.ZonedDateTime.from(
  '2026-11-02T09:00[Europe/London]'
);
console.log(meeting.withTimeZone('America/New_York').toString());

// Difference between two dates
const gap = today.until(trialEnds);
console.log(gap.days); // 30

For many projects, this means you can start removing date libraries from new code. You do not have to rewrite everything at once, but new features such as billing cycles, scheduling, or reporting are a great place to start using Temporal.

2. V8 14.6 With New JavaScript Methods

Node.js 26 ships with V8 14.6 (part of Chromium 146). Two new language features stand out for everyday code:

• Map upsert: Map.prototype.getOrInsert() and getOrInsertComputed() (and the same on WeakMap) remove the classic “check, then set, then get” pattern.
• Iterator sequencing: Iterator.concat() lets you chain several iterables into one lazy iterator.

// Before: group items by category
const groups = new Map();
for (const item of items) {
  if (!groups.has(item.category)) groups.set(item.category, []);
  groups.get(item.category).push(item);
}

// Node.js 26: one line per item
const grouped = new Map();
for (const item of items) {
  grouped.getOrInsert(item.category, []).push(item);
}

// Expensive defaults are only created when needed
cache.getOrInsertComputed(userId, (id) => loadProfile(id));

// Combine iterables lazily
for (const user of Iterator.concat(admins, editors, viewers)) {
  notify(user);
}

3. Undici 8 for fetch and HTTP

Undici, the HTTP client behind Node’s built-in fetch(), has been updated to version 8. If your app relies heavily on fetch or on Undici directly, read the Undici release notes and run your HTTP integration tests, because a major version bump can change edge-case behaviour.

Breaking Changes to Check Before Upgrading

Node.js 26 is a semver-major release, so some old APIs are gone. Most apps will upgrade cleanly, but these are the items most likely to cause errors:

• http.Server.prototype.writeHeader() is removed. Use writeHead() instead. This one mostly affects older code and old dependencies.
• Legacy stream modules are removed: _stream_wrap, _stream_readable, _stream_writable, _stream_duplex, _stream_transform and _stream_passthrough. Import from node:stream instead.
• --experimental-transform-types is removed. If your dev scripts relied on this flag, switch to the built-in type stripping or a separate TypeScript build step.
• module.register() is now runtime-deprecated. You will see warnings if a loader or tool still uses it. Several crypto and stream deprecations were also escalated.
• localStorage returns undefined when no storage file is configured, instead of behaving as if storage were available.
• Native add-ons must be rebuilt. NODE_MODULE_VERSION is now 147, so packages with compiled binaries (image processing, database drivers, bcrypt and similar) need versions built for Node.js 26.

If you build Node.js from source, also note the raised toolchain requirements: GCC 13.2 or newer, Python 3.9 is no longer supported for the build, and the Windows SDK has moved to version 11.

How to Upgrade to Node.js 26 LTS (Step by Step)

Step 1: Install Node.js 26 Locally

Using a version manager keeps your old version around in case you need to switch back. With nvm, for example:

nvm install 26
nvm use 26
node -v

Step 2: Reinstall Dependencies and Run Tests

Delete node_modules, reinstall, and run your full test suite. This forces native add-ons to rebuild against the new module version and quickly surfaces removed APIs.

rm -rf node_modules
npm ci
npm test

# Surface deprecation warnings with stack traces
NODE_OPTIONS="--trace-deprecation" npm test

Step 3: Search Your Code for Removed APIs

A quick search catches the most common problems before they reach production:

grep -rnE "writeHeader\(|_stream_(wrap|readable|writable|duplex|transform|passthrough)|module\.register\(" \
  --include=*.js --include=*.mjs --include=*.cjs --include=*.ts \
  --exclude-dir=node_modules .

If your codebase is large, this kind of repetitive cleanup is a good fit for automation. Our guide on what an AI coding agent for GitHub can do shows how to hand small, well-defined fixes like these to an agent and review them as pull requests.

Step 4: Update CI, Docker and Hosting Config

Bump the Node version everywhere it is pinned: .nvmrc, the engines field in package.json, Dockerfiles, GitHub Actions node-version, and your hosting provider’s runtime setting. A good practice is to run CI against both 24 and 26 for a few weeks before dropping 24.

# .nvmrc
26

// package.json
"engines": {
  "node": ">=26"
}

Step 5: Roll Out Gradually

Deploy to staging first, watch memory, latency and error rates, and then roll out to production in stages. Major V8 upgrades can shift performance in both directions, so compare real metrics rather than assuming.

Which Node.js Version Should You Use Right Now?

• New projects: start on Node.js 26 LTS.
• On Node.js 24: you are safe until April 2028, but plan to move to 26 over the next few months so you get new fixes and features.
• On Node.js 22: upgrade soon. End of life is April 30, 2027, and skipping straight to 26 saves you a second migration.
• On Node.js 20 or older: treat this as urgent. You are no longer receiving security patches.

FAQ

When does Node.js 26 become LTS?

The official Node.js schedule lists October 28, 2026, as the date Node.js 26 enters Active LTS.

How long will Node.js 26 LTS be supported?

Node.js 26 is scheduled to receive Active LTS support until October 20, 2027, and maintenance (security and critical fixes) until April 30, 2029.

Do I need a flag to use Temporal in Node.js 26?

No. Temporal is enabled by default in Node.js 26, so the global Temporal object is available without any extra flags.

Will there be a Node.js 27 LTS?

Yes. Under the new annual release model, every major version becomes LTS. Node.js 27 is planned to ship as Current in April 2027 and enter LTS in October 2027.

Is it safe to upgrade straight from Node.js 22 to 26?

Yes, for most apps. Read the breaking changes for Node.js 24 and 26, rebuild native dependencies, and run your full test suite before deploying.

Conclusion

Node.js 26 LTS is the release most teams will run for the next two to three years. It brings Temporal, handy new Map and iterator methods, and an updated HTTP stack, with only a small list of breaking changes. With Node.js 24 now in maintenance and Node.js 22 nearing end of life, the best time to test your upgrade is this week.

Sources

• Node.js 26.0.0 release notes (nodejs.org)
• Evolving the Node.js Release Schedule (nodejs.org)
• Node.js Releases (nodejs.org)
• Node.js Release schedule.json (GitHub)