2.1 The Last Odd-Even Version#

Since the birth of Node.js, it has always followed the odd-even versioning strategy:

• Even-numbered versions (22, 24, 26) → LTS, recommended for production use
• Odd-numbered versions (23, 25) → Current experimental releases, do not enter LTS, used for testing new features

This set of rules, developed and operated for over a decade, will come to an end after Node.js 26.

2.2 Why Is Change Needed?#

The official Node.js blog explained the four major drivers behind this transformation:

2.3 Node.js 26 Release Schedule#

3.1 Why Is Temporal Needed?#

JavaScript’s Date object has been one of the most frequently complained-about APIs since its birth in 1995:

• Months start from 0 (0 = January), almost everyone has fallen into this trap
• Mutable objects: Modifying a Date instance can produce hard-to-trace side effects
• Weak timezone handling: Lacks native timezone awareness
• Complex date arithmetic: Calculating “the date 30 days from now” requires manual handling of month/year boundaries

The Temporal API completely solves these problems. In Node.js 26, it is fully available without any experimental flags.

3.2 Core Type System#

1
Temporal
2
├── PlainDate          — Plain date (no time, no time zone)
3
├── PlainTime          — Plain time (no date, no time zone)
4
├── PlainDateTime      — Date + time (no time zone)
5
├── PlainYearMonth     — Year + month
6
├── PlainMonthDay      — Month + day
7
├── ZonedDateTime      — Date + time + time zone (complete representation)
8
├── Instant            — Absolute point in time (nanosecond precision, since Unix epoch)
9
├── Duration           — Time duration (years/months/weeks/days/hours/minutes/seconds/milliseconds/microseconds/nanoseconds)
10
├── TimeZone           — Time zone identifier
11
└── Calendar           — Calendar system

3.3 Practical Usage Comparison#

1
// ❌ Old Date API — months start at 0, and modifications are mutable operations
2
const oldDate = new Date(2026, 4, 6);  // 4 = May?
3
oldDate.setDate(oldDate.getDate() + 30); // Modified the original object
4

5
// ✅ New Temporal API — clear semantics, immutable
6
const date = Temporal.PlainDate.from('2026-05-08');
7
const nextMonth = date.add({ days: 30 });  // Returns a new object, date stays unchanged
8

9
// Time zone aware
10
const meeting = Temporal.ZonedDateTime.from('2026-05-08T10:00[Asia/Shanghai]');
11
const inNY = meeting.withTimeZone('America/New_York');
12
console.log(inNY.toString()); // 2026-05-07T22:00:00-04:00[America/New_York]

3.4 Implementation Details#

Temporal’s underlying implementation uses the temporal_rs library written in Rust, rather than relying solely on the V8 engine. This means other JavaScript engines (such as JavaScriptCore and SpiderMonkey) can also integrate it directly, laying the foundation for Temporal to become a cross-runtime standard.

4.1 Map Upsert Methods (Stage 3+)#

V8 14.6 brings native support for the TC39 Upsert proposal:

1
// Traditional approach: two hash lookups
2
if (!map.has(key)) {
3
  map.set(key, computeExpensiveValue());
4
}
5
const value = map.get(key);
6

7
// New approach: one hash lookup
8
const value = map.getOrInsertComputed(key, () => computeExpensiveValue());
9

10
// Or use a static value
11
const value = map.getOrInsert(key, defaultValue);

WeakMap also gains the same getOrInsert / getOrInsertComputed methods.

4.2 Iterator Helper Methods#

1
// Iterator.concat() — merges multiple iterators into a single sequence
2
const a = [1, 2, 3].values();
3
const b = [4, 5, 6].values();
4
const combined = Iterator.concat(a, b);
5

6
for (const n of combined) {
7
  console.log(n); // 1, 2, 3, 4, 5, 6
8
}

4.3 Other V8 14.6 Enhancements#

5.1 Core Improvements#

• WHATWG Fetch spec alignment: Behavior is closer to browser-environment fetch semantics
• HTTP/1.1 and HTTP/2: Optimized persistent connection management
• Connection pool strategy adjustments: Behavior changes in the Pool and Agent classes
• Unified error object format: More consistent error handling

5.2 Notes for Projects That Directly Depend on Undici#

If your project directly imports undici, after upgrading to Node.js 26 it is recommended to check:

1
// If using Undici's low-level API
2
import { Pool, Agent, Dispatcher } from 'undici';
3

4
// Check the full changelog for Undici 8
5
// Pay special attention to Pool configuration options and Dispatcher extension points

6.1 Completely Removed APIs#

6.2 New Runtime Deprecations#

1
// module.register() — enters runtime deprecation
2
// Will output a deprecation warning: DEP0201

8.1 SQLite Enhancements#

Node.js 26 enables the Percentile extension for the built-in node:sqlite module, which is particularly important in data analysis and statistical scenarios:

1
import { DatabaseSync } from 'node:sqlite';
2

3
const db = new DatabaseSync(':memory:');
4
// Percentile extension is enabled by default

8.2 Node.js 26.1.0: Experimental FFI#

Following closely after 26.0.0, 26.1.0 introduces the experimental node:ffi module, allowing native dynamic libraries to be called directly from JavaScript:

1
node --experimental-ffi script.js

This is strategically significant for high-performance computing and system-level applications — JS code can call native functions written in C/Rust with zero overhead.

8.3 Security Fixes#

• Fixed CVE-2026-21717: V8 array index hash collision vulnerability

8.4 async/await Performance Improvements#

Thanks to optimizations in V8 14.6, async/await operation performance has improved by approximately 15%, a direct benefit for server-side applications that heavily use asynchronous operations.

9.1 New Release Cadence#

Starting from Node.js 27, a three-phase release model will be adopted:

1
Alpha (6 months)     →  Current (6 months)    →  LTS (30 months)
2
   Oct ~ Mar           Apr ~ Oct              total 2.5 years
3
   Breaking changes allowed        Stabilization phase             Security fixes
4
   Flexible release cadence         Breaking changes prohibited          Long-term support

9.2 Node.js 27 Alpha Coming Soon#

Key Changes:

• ✅ Every version enters LTS — no more “skip odd versions” rule
• ✅ Version numbers aligned with years — 27 corresponds to 2027, 28 to 2028
• ✅ Alpha channel — replaces the experimental role of odd versions, allowing library authors to test breaking changes early
• ✅ Fewer active release lines — reduced from 4-5 to at most 3

9.3 The Next Decade Roadmap#

10.1 Upgrading from Node.js 24/25#

1
# Use nvm
2
nvm install 26
3
nvm use 26
4

5
# Or use fnm
6
fnm install 26
7
fnm use 26
8

9
# Verify the version
10
node --version  # v26.0.0

10.2 Upgrade Checklist#

1
Node.js 26 Upgrade Checklist
2
├── ☐ Run npx npm-check-updates to check dependency compatibility
3
├── ☐ Check whether native C++ addons are compatible with NODE_MODULE_VERSION 147
4
├── ☐ Search for writeHeader() to replace with writeHead()
5
├── ☐ Check whether 'undici' is imported directly (need to check the Undici 8 changelog)
6
├── ☐ Remove the --experimental-transform-types flag
7
├── ☐ Check usage of old crypto APIs (DEP0182)
8
├── ☐ Verify the GCC compilation environment is ≥ 13.2 (for source compilation scenarios)
9
├── ☐ Gradually migrate old Date operations to the Temporal API
10
├── ☐ Add a Node.js 26 test matrix to CI
11
└── ☐ Short term: Node.js 24 (active LTS, the most conservative choice)
12
    Medium term: Node.js 26 (enters LTS in October, most advanced features)
13
    Urgent: Node.js 22 (maintenance LTS, ample migration window)
14
    Migrate immediately: Node.js 20 (already EOL as of April 30, 2026!)

10.3 Quick Reference of Release Line Status#