Skip to main content
LeoNex News

Notable V8 changes from Node.js 26 to 27

Illustration: Notable V8 changes from Node.js 26 to 27
In this article

The Node.js 27 Alpha upgrades V8 to version 15.6, up from 14.6 in Node.js 26. The upgrade brings several new JavaScript language features, a number of behavior changes, performance improvements and memory adjustments. Some changes may break code that relies on the old behavior, so Node.js developers should review them carefully.

Release policy and ABI compatibility

As Node.js moves to a release schedule with an Alpha phase, potentially breaking V8 changes, such as bulk V8 upgrades, may still appear during the Alpha and Current phases. Changes that affect the ABI (application binary interface) of native addons will come with an increase in NODE_MODULE_VERSION, so that toolchains that pick prebuilt native addons by ABI version keep working. Once version 27 enters the LTS phase, the V8 version of this branch is expected to be stable, with no ABI- or API-breaking changes, except in special cases such as a critical security patch.

New language features

Several features are enabled by default. Math.sumPrecise(iterable) reduces floating-point error accumulation compared with summing in a loop. The Intl.Locale.prototype.variants getter provides access to a locale's variants. There are also new iterator methods:

  • Iterator.prototype.join(separator)

  • Iterator.prototype.includes(value)

  • Iterator.zip(iterables, options)

  • Iterator.zipKeyed(obj, options)

Behavior changes that may affect existing code

Memory, serialization and fatal error handling

Node.js 27 handles many fatal V8 errors through the Node.js fatal error mechanism before aborting, so --report-on-fatalerror can produce diagnostic reports in cases that previously aborted without a report. Some extreme usages, such as overly long template literals or regexps too large to compile, now throw a RangeError instead of crashing the process, but this is not guaranteed and should not be used as program logic.

Memory-related changes include:

Performance, diagnostics and WebAssembly

Performance impact depends on the platform, workload and build configuration; the figures are only meaningful for the benchmarks cited. Many operations are faster: Array.prototype.flat(), copyWithin(), fill(), join(), lastIndexOf() and indexOf() on sparse arrays; String.prototype.split() and localeCompare(); property access on objects with many properties; await on an already fulfilled promise; JSON.parse on some inputs; repeated BigInt modulo with the same divisor is 25% faster on JetStream3's bigint-noble-ed25519. Maglev, V8's optimizing compiler, has also been improved. For regexps, machine code is compiled on first use, so regexps that run many times may be faster but a regexp that is created and run only once may be slower due to compilation cost.

Key points

  • Node.js 27 Alpha upgrades V8 from 14.6 to 15.6, adding features such as Math.sumPrecise and new iterator methods.

  • Some behaviors have changed, such as Math results, seeded Math.random() sequences, the sort algorithm and getTimezoneOffset(), which may break code or tests that rely on the old behavior.

  • A new serialization format means older Node.js versions cannot read data produced by this version.

  • The default old-generation limit increases on machines with 4 GB to 15 GB of RAM, so applications that need a memory cap must set --max-old-space-size.

  • Some flags and features are removed or renamed, including live editing via the inspector and several WebAssembly flags.

More in Software Engineering

Illustration: Rust in CPython? Discussion at the Python Language Summit
SOFT-ENG Software Engineering

Rust in CPython? Discussion at the Python Language Summit

David Hewitt, representing the Rust for CPython project team, returned to the Python Language Summit to ask Python's core developers what they want from Rust. He presented a phased roadmap, success criteria and a proposal to start with an optional Rust backend for the zlib module. The long-term goal is to make Rust…

6 min read

Illustration: Free-threaded Python (no GIL): the next phase
SOFT-ENG Software Engineering

Free-threaded Python (no GIL): the next phase

At the Python Language Summit, Tobias Wrigstad, Fridtjof Stoldt and Donghee Na returned to the topic of Python's post-free-threading era and the question of which high-level concurrency primitives the language should offer. The team proposes the Behavior-Oriented Concurrency (BOC) model…

4 min read

Email newsletter

Receive a selection of new LeoNex News articles by email.

We only use this address to send the newsletter.

Receive a selection of new LeoNex News articles by email. You will receive a confirmation email; the subscription only takes effect after you confirm. Every email includes an unsubscribe link. Read the privacy policy