Node.js is Growing Up: 3 Major Releases That Changed the Game

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. URLPattern structuredClone 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. V8 version 12.4 Array.fromAsync() Set For instance, the Array.fromAsync() function enables asynchronous collection and transformation of iterable or async iterable values: Array.fromAsync() 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] 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: union intersection difference 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} 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. Maglev JIT compiler 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: native WebSocket client implementation WebSocket ws 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); }; 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 fs 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. node:fs fs.glob() fs.globSync() import { globSync } from 'node:fs'; const files = globSync('src/**/*.test.js'); 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: watch mode --watch node --watch app.js node --watch app.js Optionally, the --watch-path flag may be used to restrict watch scope to specific directories: --watch-path node --watch-path=src --watch app.js 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. nodemon 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. highWaterMark 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. AbortSignal 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: Promise.withResolvers() const { promise, resolve, reject } = Promise.withResolvers(); setTimeout(() => resolve('Done'), 1000); const result = await promise; 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: node:util import { formatWithOptions, inspect } from 'node:util'; console.log(formatWithOptions({ colors: true }, '%O', { key: 'value' })); 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 require() 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. require() --experimental-require-module 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. experimental import --no-experimental-require-module // Example: requiring an ES module in CommonJS const esmModule = require('./module.mjs'); // 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. experimental native support for TypeScript file execution .ts node example.ts 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. --loader 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. experimental support for Web Storage APIs localStorage sessionStorage localStorage.setItem('token', 'abc123'); const token = localStorage.getItem('token'); 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.js test runner glob-pattern support node --test "tests/**/*.test.js" 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. Windows 32-bit architectures 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. deprecating engine-based options 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: V8 version 13.6 Float16Array: a typed array for 16-bit floating-point numbers, useful in performance-sensitive numerical computations. RegExp.escape(): a utility to safely escape strings for use within regular expressions. Error.isError(): a static method to determine if an object is an instance of an error. WebAssembly Memory64 support: enabling 64-bit memory addressing in WebAssembly modules. Support for using and await using declarations for deterministic resource management. Float16Array: a typed array for 16-bit floating-point numbers, useful in performance-sensitive numerical computations. Float16Array RegExp.escape(): a utility to safely escape strings for use within regular expressions. RegExp.escape() Error.isError(): a static method to determine if an object is an instance of an error. Error.isError() WebAssembly Memory64 support: enabling 64-bit memory addressing in WebAssembly modules. WebAssembly Memory64 support Support for using and await using declarations for deterministic resource management. using await using Example usage of RegExp.escape(): 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 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: browser-native Web APIs The URLPattern API is now globally accessible without import, allowing pattern matching on URL components according to standard URL pattern syntax: The URLPattern API is now globally accessible without import, allowing pattern matching on URL components according to standard URL pattern syntax: URLPattern const pattern = new URLPattern('/users/:id'); const result = pattern.exec('/users/42'); console.log(result.pathname.groups.id); // 42 const pattern = new URLPattern('/users/:id'); const result = pattern.exec('/users/42'); console.log(result.pathname.groups.id); // 42 Native implementations of ReadableStream, WritableStream, and TransformStream support the Web Streams specification, facilitating composable and interoperable stream processing. The structuredClone() function is provided globally to perform deep cloning of complex data structures, consistent with the browser environment. The introduction of MessagePort facilitates message passing and worker thread communication. Native implementations of ReadableStream, WritableStream, and TransformStream support the Web Streams specification, facilitating composable and interoperable stream processing. ReadableStream WritableStream TransformStream The structuredClone() function is provided globally to perform deep cloning of complex data structures, consistent with the browser environment. structuredClone() The introduction of MessagePort facilitates message passing and worker thread communication. MessagePort 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: permission model --permission node --permission=fs,env app.js 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: Node.js test runner automatic awaiting of subtests test('outer', (t) => { t.test('inner', () => { // No explicit await required }); }); 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. Undici version 7 The integrated package manager, npm, is upgraded to version 11, delivering faster installation, enhanced security auditing, and more predictable script execution behavior. npm F. Experimental Features Native support for .env files via the new loadEnvFile() method in the node:process module facilitates environment configuration without external dependencies. Continued improvements in WebAssembly and HTTP/3 protocol support further extend Node.js capabilities in emerging network technologies. Native support for .env files via the new loadEnvFile() method in the node:process module facilitates environment configuration without external dependencies. .env loadEnvFile() node:process Continued improvements in WebAssembly and HTTP/3 protocol support further extend Node.js capabilities in emerging network technologies. WebAssembly 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. require() 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: Web Storage Web Streams The Fetch API with extended HTTP/3 and caching capabilities. WebRTC support for real-time peer-to-peer communications. BroadcastChannel and additional message-passing interfaces for worker threads. The Fetch API with extended HTTP/3 and caching capabilities. Fetch API WebRTC support for real-time peer-to-peer communications. WebRTC BroadcastChannel and additional message-passing interfaces for worker threads. BroadcastChannel 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: Improved startup and steady-state execution times. Enhanced profiling APIs for better resource monitoring. Integration of distributed tracing standards to support microservices architectures. Improved startup and steady-state execution times. Enhanced profiling APIs for better resource monitoring. Integration of distributed tracing standards to support microservices architectures. 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. require() 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.