By ECMAScript 2026 was ratified on June 30. The committee approved nine features, but most coverage stops at listing them. The useful question is which ones matter to your codebase right now, and which are worth waiting on. The answer depends on whether you write server-side JavaScript, do numeric work, or are still shipping Moment.js to production in 2026.
Temporal: The Date Object Replacement That Actually Works
JavaScript’s Date was designed in ten days in 1995. It has been embarrassing the language ever since — mutable by default, timezone-naive, and famously 0-indexed for months. January is 0. This is not a joke.
The Temporal API, which reached TC39 Stage 4 in March 2026 and is officially part of the ES2026 spec, replaces it. The core types are Temporal.Instant for exact points in time, Temporal.ZonedDateTime for timezone-aware datetimes, and Temporal.PlainDate for calendar dates without timezone context. Every operation returns a new object. Nothing mutates. The full specification is available at ECMA International’s official ES2026 spec, and Paweł Grzybek’s breakdown covers each feature in detail.
// The old way — and its landmines
const date = new Date('2026-07-20T14:00:00');
date.setDate(date.getDate() + 30); // mutates the original — good luck debugging that
// The Temporal way
const meeting = Temporal.ZonedDateTime.from('2026-07-20T14:00:00[America/New_York]');
const nextMonth = meeting.add({ days: 30 }); // meeting is untouchedDST transitions work correctly. Arithmetic operates on calendar units, not raw seconds, so adding one day across a daylight saving boundary gives you the same wall-clock time, not the same elapsed time. That alone eliminates a class of bug that has caused production incidents at companies that should have known better.
Native support is in Chrome 144+, Firefox 139+, and Edge 144+. Node.js 24 ships Temporal behind the --harmony-temporal flag. For production today, use the official @js-temporal/polyfill maintained by TC39 contributors. It tracks the spec closely and is considered production-ready. Moment.js has been deprecated since 2020. This is the replacement.
Math.sumPrecise: The Floating-Point Fix You’ve Been Workarounding
Every JavaScript developer has typed 0.1 + 0.2 in a console and seen 0.30000000000000004. This is IEEE 754 floating-point arithmetic, not a JavaScript bug, and it affects every language. What ES2026 does is give you a precise summation method for when correctness actually matters.
// Classic
0.1 + 0.2 // 0.30000000000000004
[0.1, 0.2, 0.3].reduce((a, b) => a + b) // 0.6000000000000001
// ES2026
Math.sumPrecise([0.1, 0.2]) // 0.3
Math.sumPrecise([1e20, 0.1, -1e20]) // 0.1 — handles catastrophic cancellation tooThe method accepts any iterable, including generators and Sets. If you’re writing financial software, data aggregation pipelines, or anything that sums numbers of varying magnitude, this is the one you’ve been waiting for. It won’t make all floating-point problems disappear — division still has no exact answer in binary — but summation precision is fixed.
Explicit Resource Management: The using Keyword
If you write server-side JavaScript, you’ve written code that opens a file, queries a database, or acquires a lock — and then carefully wrapped it in try/finally to make sure cleanup happens even when something throws. ES2026 introduces using and await using, which bind resource cleanup to the block scope.
// Before: verbose and easy to get wrong
let conn;
try {
conn = await db.connect();
await conn.query(sql);
} finally {
await conn?.close();
}
// After
await using conn = await db.connect();
await conn.query(sql);
// conn[Symbol.asyncDispose]() runs automatically when the scope exits — error or notTypeScript 5.2+ already supports this. Node.js 22+ ships it without a flag. If your team writes backend Node.js, you can start using it today. The pattern follows what Python’s with and C#’s using have done for years — it’s just taken JavaScript a while to catch up.
The Smaller Wins Worth Knowing
Map.getOrInsert() collapses the common pattern of checking whether a Map key exists, setting a default if not, and then reading the value — all into one call. map.getOrInsert(key, default) returns the existing value or inserts and returns the default. The computed variant getOrInsertComputed(key, fn) only calls the factory function if the key is actually missing, which matters if the default is expensive to create.
Array.fromAsync() fills the gap that Array.from() left open. You can now convert async iterators, paginated API responses, and async generators directly to arrays without a manual for await loop. It also accepts an optional mapping function, mirroring the sync version’s API.
Uint8Array now has native .toBase64(), .toHex(), Uint8Array.fromBase64(), and Uint8Array.fromHex() methods. If you’ve been reaching for Buffer in Node.js or external libraries for binary encoding, those workarounds are now optional. Error.isError() gives you a reliable way to check if something is actually an error object without instanceof failing across iframes or module realms. And Iterator.concat() lets you sequence multiple iterators without writing a custom generator.
What You Can Use Today
Most of the non-Temporal features ship natively in Chrome 137+, Firefox 131+, and Node.js 22+. If you’re on current tooling, using, Math.sumPrecise, Map.getOrInsert, and Array.fromAsync are available without configuration. Temporal needs either Chrome 144+ / Firefox 139+ or the MDN Temporal documentation and the official polyfill. For legacy browser support, core-js covers everything except Temporal.
The ECMAScript annual release cycle means these features will be table stakes within 12 months. The Temporal API specifically ends a two-decade dependency on external date libraries. If your team is still running Moment.js in production, this is the migration event you’ve been waiting for. The spec is approved. The polyfill works. The only thing left is the upgrade.
