Node 26 Is LTS: Your Date Bugs Just Lost Their Excuse

Node 26 Is LTS: Your Date Bugs Just Lost Their Excuse

Node 26 LTS brings flag-free Temporal and new JavaScript APIs, offering safer date handling while requiring checks for removed APIs and the Linux libatomic dependency.

Martin Ferret

Martin Ferret

November 17, 2026

Node 26 Is LTS: Your Date Bugs Just Lost Their Excuse

new Date("2026-11-05") is November 4th.

Not everywhere. Just for half of your users.

Node.js 26 became LTS on October 28, 2026. It is the first LTS where Temporal works without a flag.

Here is what changes, what breaks, and what is still missing.

Every snippet below was run on November 3, 2026, with Node 26.13.0 and, for comparison, Node 24.22.2. The outputs are pasted as they came out.

Where Node 26 stands today

  • Version: 26.13.0, codename Lithium, promoted to LTS on October 28, 2026.
  • Engine: V8 14.6.
  • Support: until April 2029.
  • Previous LTS: Node 24, where Temporal only works behind -harmony-temporal.

What you get without a flag

I ran the same probe on both versions:

const has = (name, value) =>
  console.log(name.padEnd(24), typeof value);

has("Temporal", globalThis.Temporal);
has("Map#getOrInsert", Map.prototype.getOrInsert);
has("Map#getOrInsertComputed", Map.prototype.getOrInsertComputed);
has("Iterator.concat", Iterator.concat);
has("Uint8Array.fromHex", Uint8Array.fromHex);

Node 24.22.2:

Temporal                 undefined
Map#getOrInsert          undefined
Map#getOrInsertComputed  undefined
Iterator.concat          undefined
Uint8Array.fromHex       undefined

Node 26.13.0:

Temporal                 object
Map#getOrInsert          function
Map#getOrInsertComputed  function
Iterator.concat          function
Uint8Array.fromHex       function

Five new globals and methods. Temporal is the one that matters.

Bug 1: adding a month

With Date

const d = new Date(2026, 0, 31);
d.setMonth(d.getMonth() + 1);

console.log(d.toDateString());

Output:

Tue Mar 03 2026

January 31 plus one month is March 3rd.

February 31 does not exist, so Date silently overflows into March.

With Temporal

const next = Temporal.PlainDate
  .from("2026-01-31")
  .add({ months: 1 });

    console.log(next.toString());

Output:

2026-02-28

Temporal clamps to the last valid day. That is what a billing date or a subscription renewal expects.

Bug 2: parsing a date

With Date

Run with TZ=America/New_York:

console.log(new Date("2026-11-05").getDate());

Output:

4

A date-only string is parsed as midnight UTC.

In New York, midnight UTC is still November 4th. Every user west of Greenwich sees the wrong day.

With Temporal

console.log(Temporal.PlainDate.from("2026-11-05").day);

Output:

5

A PlainDate is a calendar date. It has no time and no time zone, so there is nothing to shift.

Bug 3: mutation

With Date

const start = new Date(2026, 10, 5);
const end = start;
end.setDate(end.getDate() + 7);

console.log(start.toDateString());

Output:

Thu Nov 12 2026

end and start are the same object. Moving the end moved the start.

With Temporal

const start = Temporal.PlainDate.from("2026-11-05");
const end = start.add({ days: 7 });

console.log(start.toString(), end.toString());

Output:

2026-11-05 2026-11-12

Every Temporal object is immutable. add returns a new one.

Bug 4: daylight saving time

In Paris, clocks jump forward on March 29, 2026.

So is "tomorrow" 24 hours from now? Temporal lets you say which one you mean:

const noon = Temporal.ZonedDateTime
  .from("2026-03-28T12:00[Europe/Paris]");

console.log(noon.add({ days: 1 }).toString());
console.log(noon.add({ hours: 24 }).toString());

Output:

2026-03-29T12:00:00+02:00[Europe/Paris]
2026-03-29T13:00:00+02:00[Europe/Paris]
  • One day keeps the wall-clock time: noon stays noon.
  • 24 hours is exact elapsed time: it lands at 1 p.m. With Date, you only get the second one, and you have to know it.

Bonus: durations that read like a human

const today = Temporal.PlainDate.from("2026-11-05");

console.log(today.until("2026-12-25").toString());
console.log(
  today.until("2026-12-25", { largestUnit: "months" }).toString()
);

Output:

P50D
P1M20D

50 days, or 1 month and 20 days. No more dividing milliseconds by 86_400_000.

Also new: Map.prototype.getOrInsert

The "get or default" dance is now one call.

Counting

const counts = new Map();

for (const word of ["a", "b", "a"]) {
  counts.set(word, counts.getOrInsert(word, 0) + 1);
}

console.log([...counts]);

Output:

[ [ 'a', 2 ], [ 'b', 1 ] ]

Grouping

Use getOrInsertComputed when the default is an object. The callback only runs when the key is missing:

const groups = new Map();
const users = [
  { team: "admin", name: "Ana" },
  { team: "dev", name: "Bo" },
  { team: "admin", name: "Cy" },
];

for (const u of users) {
  groups.getOrInsertComputed(u.team, () => []).push(u.name);
}

console.log([...groups]);

Output:

[ [ 'admin', [ 'Ana', 'Cy' ] ], [ 'dev', [ 'Bo' ] ] ]

Also new: Iterator.concat

Chain any iterables lazily, without spreading them into an array first:

const all = Iterator.concat(
  [1, 2],
  new Set([3]),
  ["a"].values()
);

console.log([...all]);

Output:

[ 1, 2, 3, 'a' ]

What is still missing

Node 26 is not the whole of modern JavaScript.

Iterator#chunks          undefined
Iterator#join            undefined
Math.sumPrecise          undefined

chunks and join reached Stage 4 at TC39 this fall, but V8 14.6 does not ship them yet.

Stage 4 means "in the spec". It does not mean "in your runtime".

What breaks when you upgrade

Removed APIs

Long-deprecated APIs are gone. One example:

const http = require("node:http");
console.log(typeof http.ServerResponse.prototype.writeHeader);
  • Node 24.22.2: function
  • Node 26.13.0: undefined Search your code and your dependencies for deprecated calls before you switch.

libatomic on Linux

The Node 26 binary now links against libatomic.so.1. Node 24 did not:

$ readelf -d node | grep atomic
 (NEEDED)  Shared library: [libatomic.so.1]

Minimal or custom Docker images may not have it. If it is missing, Node does not start.

Check your base image before you bump the version.

"We'll migrate dates later"

That is fair for a large codebase.

  • Date is not going anywhere.
  • Libraries like date-fns or Luxon still work.
  • Rewriting stable code for its own sake is churn. Where it is wrong: new code.

Every new new Date() you write today is a future bug you will have to migrate. On Node 26, Temporal costs nothing to start using.

What to take away

  • Upgrading to Node 26: check removed APIs and libatomic first.
  • Writing new date code: use Temporal, starting with PlainDate for calendar dates.
  • Grouping or counting in a Map****: use getOrInsert and getOrInsertComputed.
  • Using a fresh Stage 4 feature: check your runtime, not the spec. Let Date handle your old code.

Let Temporal handle everything you write from now on.

Sources

Ready to prove your JavaScript skills?

Get certified in JavaScript

More JavaScript articles

Keep learning JavaScript. Then get certified when you are ready.