Node.js, the undisputed emperor of JavaScript runtimes, has undergone significant architectural and feature-oriented advancements in its recent major releases, specifically versions 22, 23, and 24. These releases represent a deliberate effort by the Node.js Technical Steering Committee to align the runtime environment more closely with evolving ECMAScript specifications, enhance compatibility with modern Web APIs, and improve performance characteristics relevant to high-throughput, server-side JavaScript applications.

The primary motivation behind these updates is to address the growing demand for a unified runtime that supports both traditional server workloads and emerging application models that benefit from client-like capabilities, such as native WebSocket communication, structured cloning, and typed stream interfaces. To that end, the three successive releases introduce several features previously limited to browser-based environments, such as the URLPattern interface, structuredClone function, and enhanced stream primitives. These enhancements are complemented by optimizations in the underlying V8 engine, enabling faster execution paths through mechanisms like Just-In-Time (JIT) compilation improvements and reduced startup latency.

Furthermore, these versions introduce notable changes in developer experience, including experimental support for TypeScript execution without prior transpilation, formalization of built-in test runner capabilities, and the stabilization of the watch mode. Security and isolation are also addressed through the introduction of a granular permission model, offering developers finer control over runtime capabilities at the process level.

This article presents a technical examination of the most salient features introduced in Node.js versions 22, 23, and 24. Emphasis is placed on language-level changes, runtime behavior modifications, and infrastructural improvements relevant to performance, security, and standards compliance.

Node.js v22: Foundational Enhancements and Runtime Optimizations

Node.js v22, released in April 2024, introduces several enhancements that collectively improve language compliance, runtime performance, and developer experience. This release marks a deliberate evolution of the platform toward broader compatibility with recent ECMAScript features, while continuing to refine internal system behaviors and user-facing modules. As of October 2024, v22 has been designated as a Long-Term Support (LTS) release.

A. JavaScript Engine Upgrade: V8 12.4 and Maglev JIT Integration

The most consequential update in Node.js v22 is the integration of V8 version 12.4, the underlying JavaScript engine. This upgrade introduces support for modern ECMAScript features, including Array.fromAsync() and new set-theoretic operations on Set objects. These additions facilitate improved performance and greater expressiveness for asynchronous and functional programming tasks.

For instance, the Array.fromAsync() function enables asynchronous collection and transformation of iterable or async iterable values:

async function* fetchData() {
  yield* [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)];
}

const result = await Array.fromAsync(fetchData(), async (x) => x * 2);
// result: [2, 4, 6]

Set operations such as union, intersection, and difference are now directly supported by the runtime:

const a = new Set([1, 2, 3]);
const b = new Set([3, 4, 5]);

const union = a.union(b);         // Set {1, 2, 3, 4, 5}
const intersection = a.intersection(b); // Set {3}
const difference = a.difference(b);     // Set {1, 2}

Additionally, the Maglev JIT compiler is enabled by default. Maglev operates as a low-latency optimizing compiler that sits between the Ignition interpreter and the TurboFan optimizing compiler. Its introduction reduces warm-up time and improves performance for CLI tools and ephemeral workloads, which are prevalent in scripting and test automation contexts.

B. Native WebSocket Client Integration

Version 22 includes a native WebSocket client implementation accessible through the global WebSocket object, aligning Node.js more closely with browser environments. This eliminates the need for third-party libraries such as ws for basic WebSocket use cases:

const socket = new WebSocket('wss://echo.websocket.org');

socket.onopen = () => {
  socket.send('Hello from Node.js 22');
};

socket.onmessage = (event) => {
  console.log('Received:', event.data);
};

The presence of native WebSocket support simplifies integration with WebSocket-based APIs and promotes consistency between client and server-side JavaScript code.

C. Enhanced File System API: Glob Support in fs Module

The node:fs module now includes built-in support for glob-based file pattern matching via fs.glob() and fs.globSync() functions. These functions provide recursive and wildcard-enabled directory traversal without requiring external modules.

import { globSync } from 'node:fs';

const files = globSync('src/**/*.test.js');

This enhancement reduces third-party dependency overhead and provides first-class support for a common file system operation in build tooling and test runners.

D. Stabilized Watch Mode for Development Automation

Previously marked as experimental, watch mode is now stable in Node.js v22. It allows a Node.js process to automatically restart upon detecting changes in specified files or directories. This functionality is accessible via the --watch flag:

node --watch app.js

Optionally, the --watch-path flag may be used to restrict watch scope to specific directories:

node --watch-path=src --watch app.js

This feature reduces the need for external process monitoring tools such as nodemon and contributes to a more integrated development experience.

E. Stream System and AbortController Improvements

The default highWaterMark threshold for streams has been increased from 16 KiB to 64 KiB. This change minimizes the frequency of backpressure signals in high-throughput stream pipelines, leading to measurable performance gains in data ingestion and transformation workloads.

Simultaneously, the construction cost of AbortSignal instances has been reduced. This is relevant in request-cancellation scenarios, where abort controllers are instantiated per request or task unit.

F. Promise and Utility Module Enhancements

Node.js v22 introduces Promise.withResolvers(), a static method that separates promise creation from its resolution mechanics. This feature simplifies the handling of externally resolved promises and enhances code clarity in asynchronous control flows:

const { promise, resolve, reject } = Promise.withResolvers();

setTimeout(() => resolve('Done'), 1000);

const result = await promise;

The node:util module now includes support for styled console output via ANSI escape sequences. This allows development tools to produce color-coded logs without relying on third-party styling libraries:

import { formatWithOptions, inspect } from 'node:util';

console.log(formatWithOptions({ colors: true }, '%O', { key: 'value' }));

Node.js Version 23: Enhanced Developer Ergonomics and Emerging Language Support

Released in October 2024, Node.js version 23 builds upon the foundation set by its predecessor by focusing on improving developer ergonomics, expanding native language capabilities, and refining runtime behavior to better support contemporary development workflows. This release maintains the ECMAScript compliance introduced in v22 while introducing several experimental and stabilized features designed to facilitate smoother integration of modern JavaScript and TypeScript applications.

A. Default Enablement of require() Support for ES Modules

One of the principal changes in Node.js 23 is the activation of require()-based loading of ECMAScript modules (ESM) by default. Prior to this release, requiring ESM within CommonJS contexts required the use of the --experimental-require-module flag. In v23, this functionality becomes enabled out of the box, simplifying interoperability between CommonJS and ESM codebases.

Despite its default enablement, this feature remains experimental, emitting a deprecation warning upon first invocation to encourage migration toward native import syntax. Developers may disable this feature via the --no-experimental-require-module flag if necessary.

// Example: requiring an ES module in CommonJS
const esmModule = require('./module.mjs');

This capability facilitates gradual migration strategies and legacy code integration without requiring wholesale refactoring.

B. Native TypeScript Execution

A notable innovation in Node.js 23.6 (released March 2025) is experimental native support for TypeScript file execution without prior transpilation. This feature permits direct execution of .ts files by the runtime, performing only syntactic stripping of type annotations rather than full compilation.

node example.ts

The implementation currently supports a subset of TypeScript features, excluding decorators, enums, and path mappings, and is intended primarily for rapid prototyping and development workflows. The support is contingent upon the use of the --loader flag or enabling via experimental options.

C. Integration of Web Storage APIs (Experimental)

Node.js 23 introduces experimental support for Web Storage APIs, including localStorage and sessionStorage. While these interfaces traditionally reside in browser contexts, their availability within Node.js enables developers to reuse client-side caching and state management paradigms on the server.

localStorage.setItem('token', 'abc123');
const token = localStorage.getItem('token');

Access to these APIs requires explicit enabling via feature flags and is subject to ongoing refinement.

D. Refinements to the Node.js Test Runner

The built-in Node.js test runner experiences enhancements in v23, notably the inclusion of glob-pattern support for specifying test files. This allows more concise and flexible test execution commands, improving test automation and continuous integration pipelines.

node --test "tests/**/*.test.js"

Such improvements reduce reliance on third-party test frameworks for simple use cases and improve native tooling robustness.

E. Deprecation of Windows 32-bit Support

Reflecting evolving platform priorities, Node.js v23 discontinues support for Windows 32-bit architectures. This change is motivated by diminished demand and the desire to streamline maintenance and build infrastructure.

F. OpenSSL Engine and Security Model Updates

Node.js 23 aligns with the upstream OpenSSL 3 cryptographic library by deprecating engine-based options and removing the experimental-policy flag. These adjustments promote adherence to modern cryptographic best practices and simplify the security model of the runtime.

Node.js Version 24: Advancing Web Compatibility and Security Models

Node.js v24, released in May 2025, signifies a substantial progression toward unifying server-side JavaScript with contemporary web standards. This release incorporates advanced JavaScript language features via an upgrade to the V8 engine, broadens native Web API support, enhances security mechanisms through a refined permission model, and improves developer tooling. Together, these changes position Node.js as a more complete, secure, and performant runtime environment.

A. V8 Engine Upgrade to Version 13.6: Language and WebAssembly Features

Node.js 24 integrates V8 version 13.6, introducing multiple ECMAScript features including:

Example usage of RegExp.escape():

const escaped = RegExp.escape('Hello. (How are you?)');
// escaped: Hello\. \(How are you\?\)
const regex = new RegExp(escaped);
console.log(regex.test('Hello. (How are you?)')); // true

B. Expanded Native Web API Support

Node.js 24 continues the trend of incorporating browser-native Web APIs:

const pattern = new URLPattern('/users/:id');
const result = pattern.exec('/users/42');
console.log(result.pathname.groups.id); // 42

C. Security and Permission Model Stabilization

The permission model undergoes stabilization in Node.js 24, providing developers with granular control over runtime capabilities. The command-line flag simplifies to --permission to restrict filesystem, environment variables, and network access:

node --permission=fs,env app.js

This model enforces principle of least privilege, enhancing application security by limiting unnecessary access to system resources.

D. Test Runner and Developer Experience Enhancements

The built-in Node.js test runner now supports automatic awaiting of subtests, reducing boilerplate and potential for asynchronous errors:

test('outer', (t) => {
  t.test('inner', () => {
    // No explicit await required
  });
});

Other improvements include more robust CLI options and better integration with modern JavaScript testing paradigms.

E. HTTP Client Upgrades and Tooling Improvements

Node.js 24 updates its internal HTTP client to Undici version 7, providing improved HTTP/2 support, request interceptors for caching and retries, DNS enhancements, and WebSocket streaming capabilities.

The integrated package manager, npm, is upgraded to version 11, delivering faster installation, enhanced security auditing, and more predictable script execution behavior.

F. Experimental Features

Prospective Features in Upcoming Node.js Releases

The Node.js development community and Technical Steering Committee maintain a forward-looking roadmap that continues to evolve the runtime environment in alignment with emerging JavaScript standards, developer requirements, and platform security imperatives. Several features currently under proposal or active development suggest the trajectory for subsequent major Node.js versions.

A. Full Native ECMAScript Module Interoperability

While Node.js 22 and 23 have introduced experimental support for loading ECMAScript modules via the require() function, complete and seamless interoperability between CommonJS and ECMAScript modules remains an area of active investigation. Future releases aim to eliminate legacy interoperability caveats, reduce overhead in mixed module environments, and standardize module resolution strategies.

B. Expanded TypeScript Native Execution

Building upon the initial native TypeScript support introduced in v23.6, subsequent releases are anticipated to broaden feature coverage, including support for decorators, enums, path aliases, and advanced type system features. This would enable TypeScript applications to run untranspiled in production environments with performance and correctness guarantees.

C. Enhanced Web API Coverage

The inclusion of Web APIs such as Web Storage and Web Streams in recent releases marks a paradigm shift toward full web platform parity. Future versions are expected to expand this coverage to include:

These features would further unify client and server JavaScript programming models.

D. Advanced Security and Sandbox Models

The permission system introduced in v24 represents a foundational security mechanism. Planned enhancements include finer-grained sandboxing capabilities, dynamic permission granting and revocation at runtime, and integration with hardware-backed security modules. These developments aim to bolster Node.js’s suitability for multi-tenant, cloud-native, and edge-computing scenarios.

E. Performance and Observability Improvements

Continued optimizations of the V8 engine, JIT compiler pipeline, and native diagnostics tooling are anticipated. These include:

Conclusion

This analysis of Node.js versions 22, 23, and 24 has identified significant advancements in language compliance, runtime performance, and security models. Version 22 introduced foundational improvements including the V8 12.4 engine upgrade, native WebSocket client support, and enhanced file system capabilities. Version 23 focused on developer ergonomics by enabling experimental ECMAScript module interoperability through require(), adding native TypeScript execution, and integrating Web Storage APIs. Version 24 further extended the platform’s capabilities with the V8 13.6 engine, expanded native Web API support, a stabilized permission model, and improvements in core tooling such as the test runner and HTTP client.

These cumulative changes demonstrate a deliberate progression toward unifying server-side JavaScript with contemporary web standards and security paradigms. The features introduced in these releases provide developers with increased expressiveness, improved performance, and finer control over runtime behavior. Future directions indicate continued enhancement of module interoperability, expanded Web API adoption, and refined security mechanisms.