Node.js 26 Goes LTS October 28: What Breaks, What’s New

Node.js 26 becomes long-term support on October 28 — nine days from now. It ships Temporal as a default global, stabilizes native TypeScript execution, and removes a handful of APIs that have been deprecated long enough. If you run Node.js in production, the upgrade window is open. Here is what changed and whether you should jump now or wait.

What Breaks First

Most Node.js 24 apps will upgrade cleanly. But there are five things worth checking before you do:

• http.Server.prototype.writeHeader() is gone. It was an undocumented alias for writeHead() that crept into older middleware. Replace it.
• Six legacy _stream_* modules are removed: _stream_readable, _stream_writable, _stream_duplex, _stream_transform, _stream_passthrough, _stream_wrap. Use node:stream instead.
• Native add-ons need a rebuild. The ABI bumped to 147. Run node-gyp rebuild in any package with compiled .node files, or wait for their maintainers to cut new releases.
• Readable streams now read one buffer at a time, not ahead. Apps doing manual stream manipulation may see throughput differences.
• module.register() is runtime-deprecated. Not removed yet, but the clock is running.

Run this before upgrading:

grep -r "writeHeader\|_stream_readable\|_stream_writable" ./src

If nothing comes back, your codebase is probably fine. If something comes back, you have a ten-minute fix.

TypeScript Native Is Stable — With a Real Catch

Running node app.ts without flags is now stable in Node.js 26. No --experimental-strip-types, no loader, no build step for simple scripts. That is genuinely useful for CLIs, tooling, and quick scripts.

But stable does not mean complete. Node.js performs type stripping — it removes TypeScript annotations and runs the result. It does not compile TypeScript. That distinction matters because four constructs generate actual JavaScript, not just type annotations:

• Enums
• Namespaces with runtime values
• Constructor parameter properties
• Import aliases

Use any of those in a .ts file you run with bare node, and it will either fail or silently misbehave. The --experimental-transform-types flag that previously papered over this is gone entirely in Node 26.

// This will break at runtime in Node.js 26
enum Status {
  Active = 'active',
  Inactive = 'inactive',
}

For projects that rely on enums or namespace merging, keep using tsc or a loader like tsx. For greenfield scripts without those constructs, node app.ts is now a real option.

Temporal API: The Date Fix You Have Been Waiting For

The Temporal API is now a top-level global in Node.js 26 — no flag, no import, just Temporal. It fixes the one thing Date was never going to fix: DST-aware calendar arithmetic. The TC39 Temporal proposal spent years in committee; it has finally landed where it matters.

Here is the bug that has broken appointment scheduling systems twice a year since forever:

// Date: adds exactly 24 hours — wrong on DST transition days
const tomorrow = new Date(Date.now() + 24 * 60 * 60 * 1000);

// Temporal: adds 1 calendar day — correct regardless of DST
const tomorrow = Temporal.Now.zonedDateTimeISO().add({ days: 1 });

On a DST transition day, “tomorrow at the same time” and “exactly 24 hours from now” are different answers. Date always gives you the latter. Temporal.ZonedDateTime gives you the former, because it carries an IANA timezone and understands that some days are 23 or 25 hours long.

The tradeoff: Temporal operations cost roughly 19 times more than equivalent Date operations. Do not swap Date.now() or timestamp logging for Temporal. Use it where correctness matters — scheduling, reminders, calendar display, timezone conversion. Keep Date everywhere else.

V8 14.6: Two Additions Worth Knowing

Node.js 26 ships V8 14.6, which adds two small but genuinely useful JavaScript methods:

// Map.getOrInsert — cleaner than the if-not-exists pattern
const cache = new Map();
const result = cache.getOrInsert('key', computeDefault());

// Iterator.concat — chain iterators without an intermediate array
const combined = Iterator.concat(iteratorA, iteratorB);
for (const item of combined) { /* ... */ }

Map.getOrInsert() handles the get-or-default-and-store pattern natively. Iterator.concat() lets you compose iterators without spreading them into arrays first — useful for large datasets where the intermediate allocation matters.

Should You Upgrade Now?

Node.js 24 LTS runs until April 2027. There is no pressure to move immediately. The practical path:

1. Today: Add Node.js 26 to your CI matrix alongside 24. A node-version: [24, 26] GitHub Actions matrix will surface any compatibility issues without touching production.
2. October 28: Upgrade staging environments once LTS is official.
3. November onward: Move production after confirming staging stability.

One more thing: Node.js 26 is the last release under the old even/odd schedule. Starting with Node.js 27 — whose alpha begins this month — the project moves to one major release per year, every release gets LTS, and version numbers align with the calendar year. The confusing “only even versions get LTS” rule finally dies. Node 26 is a good last-of-the-old-era release to land on.