Node.js 24 is here: What’s new and what to expect

Node.js 24 officially launched on May 6, 2025, bringing fresh updates focused on innovation and long-term stability. It’s set to enter LTS (Long-Term Support) in October 2025, making it a key version for developers to adopt in production environments.

In this article, we’ll break down Node.js’s release cycle, highlight the most important new features, and walk you through what you need to do to get your projects ready for the update.

Node.js release strategy: Stability vs. innovation

Node.js has a dual-track system: even vs. odd versioning. Even versions (like 20.x and 22.x) are candidates for LTS (Long-Term Support) and get 30 months of support, making them the safest choice for most teams. Odd versions (like 21.x and 23.x ) are short-term and ideal for testing new features, but aren’t meant for long-term use.

Node.js release goes through three stages: Current, Active LTS, and Maintenance LTS. Let’s break it down based on the release schedule as of May 2025:

We can see that Node.js 23 is the current stage. It’s for early adopters who want access to the newest JavaScript features and V8 engine updates. That sounds pretty cool, but this version is short-lived , supported for only 6 months,  and may include breaking changes, making it unsuitable for production. On the other hand, Node.js 22.x is in the Active LTS stage. It’s fully stable, receives security patches and critical bug fixes, and is the right choice for any production system or long-term project. Lastly, Node.js 20.x has entered the Maintenance LTS stage, meaning it only gets security fixes. It’s time to consider upgrading if you’re still running on it.

Node.js’s release model may look confusing at first, but it’s carefully designed to balance stability and innovation. Enterprises get access to stable, long-term supported versions, while developers can safely explore and test new features without risking production systems.

With Node.js 24 now available and LTS just around the corner, this release brings meaningful updates that reflect the platform’s continued evolution. From performance improvements to enhanced language features, Node.js 24 introduces tools that make modern development faster, more secure, and more efficient. Here’s a look at what’s new.

What’s new in Node.js 24?

Node.js 24 is a major release packed with exciting new features, including a V8 Engine upgrade to v13.6. Let’s walk through the key updates, grouped by V8 engine upgrade, performance, security, developer experience, and stability, so you can prioritize what matters most for your projects.

V8 Engine upgraded to v13.6

A key highlight of Node.js 24 is upgrading the V8 engine to version 13.6. The V8 engine in Node.js is a high-performance JavaScript engine developed by Google that executes JavaScript code.

Below are the new features offered in the V8 upgrade:

1. Enhanced typed arrays—  The introduction of Float16Array enables more efficient storage and manipulation of 16-bit floating-point numbers, which is particularly useful for machine learning, graphics processing, and other computing tasks where memory efficiency is critical.
2. Explicit resource management  —  Supports the using and await using features from a TC39 proposal. The feature simplifies handling cleanup operations (like closing files or releasing memory), making code simpler and lowering the chance of memory leaks.
3. RegExp improvements  —   RegExp.escape provides a convenient way to escape special characters in regular expressions, making pattern construction safer, especially when dealing with dynamic input.
4. WebAssembly advancements  —  WebAssembly Memory64 extends WebAssembly’s capabilities by supporting 64-bit memory addressing, enabling larger and more complex apps to run efficiently.
5. Error handling enhancements  —   Error.isError offers a standardized way to check if an object is an Error instance. It is helpful in apps that deal with errors from different execution contexts.

These new features in the V8 upgrade bring Node.js closer to the latest ECMAScript proposals, delivering better performance, safety, and developer experience.

Performance optimizations

Undici 7.0

The built-in Undici HTTP client is upgraded to version 7.0 in Node.js 24. Undici is built-in HTTP client in Node.js developed by Node.js developers to improve the HTTP stack performance without breaking the existing API.

The new version introduces significant performance improvements and features, including enhanced connection pooling and better HTTP/2 support. The update brings measurable speed boosts, with benchmarks showing up to 30% faster requests than previous versions.

Other key additions include improved WebSocket client capabilities, more stable retry mechanisms, and smarter load balancing across connections. These changes make Undici v7 a more powerful tool for high-performance HTTP communication in Node.js apps.

AsyncLocalStorage performance improved

Node.js 24 introduces an important under-the-hood improvement for AsyncLocalStorage . It now defaults to using the new AsyncContextFrame implementation. This change brings performance benefits while maintaining the existing API. It is good news for developers working on a distributed tracing/logging system or dealing with request context propagation.

Security Enhancements

Stable permission model

Node.js 24 has officially promoted its permission model out of experimental status. The once --experimental-permission flag, now becomes --permission. It is a clear signal that this security feature is ready for production.

The permission model is Node.js’s answer to modern security challenges, allowing us to restrict filesystem, network, and environment access.

---

Over 200k developers use LogRocket to create better digital experiences

Learn more →

---

Here is a simple example:

// Run your Node.js application with permissions enabled
$ node --permission --allow-fs-read=/allowed/path app.js

After running the above command, our application can only read from /allowed/path, and all other filesystem access is denied by default.

This stabilization marks an important milestone in Node.js’s security evolution.

Safer child_process argument handling

Now, the way to pass arguments to child_process.spawn() and execFile() has changed to disallow string arguments. Instead, Node.js enforces explicit array-based argument passing to prevent shell injection risks and improve consistency.

npm 11

Node.js 24 ships with npm v11, bringing a number of improvements in performance and security.
Some notable changes are:

• Faster Installs and better performance.
• Enhanced security check: Npm no longer falls back to the old advisory endpoint if bulk requests fail, ensuring consistent security reporting
• Lifecycle script hardening :  The  -- ignore-scripts flag now applies to all lifecycle scripts, preventing potentially unsafe script execution.
• Supports node version ^20.17.0 || >=22.9.0, keeping npm aligned with recent Node.js LTS releases.

Developer experience improvements

Global URL pattern

Node.js 24 brings an improvement for web developers: URLPattern is now available as a global object, just like its cousin URL. This means no more pesky imports cluttering up our routing files!

A URL pattern is like regular expressions for URLs, but with a much cleaner syntax that’s easier to read and maintain.

// No need to import anything!
const userRoute = new URLPattern({ pathname: '/users/:id' });

// Test a URL
const match = userRoute.exec('https://example.com/users/42');
console.log(match.pathname.groups.id); // Outputs: "42"

This feature helps with API endpoint validation by matching and handling specific route patterns. Developers can use it to create simple, custom routing systems without relying on large libraries. It’s also useful in web scrapers for processing and extracting data from structured URLs.

Test runner enhancement

The built-in Node.js test runner now automatically waits for all subtests to complete.

// before Node.js v24
test('API test suite', async (t) => {
  const api = await setupTestAPI();
  // Had to remember to await each subtest
  await t.test('GET /users', async () => {
    const response = await api.get('/users');
    deepStrictEqual(response.status, 200);
  });
});

// after Node.js v24
test('API test suite', async (t) => {
  const api = await setupTestAPI();
  // No awaits needed - runner handles it automatically
  t.test('GET /users', async () => {
    const response = await api.get('/users');
    deepStrictEqual(response.status, 200);
  });
});

This enhancement makes Node.js’s test runner more intuitive. It’s one of those quality-of-life improvements that will quietly improve our testing experience.

Stability & modernization

Deprecated/removed legacy APIs

There are a few legacy APIs deprecated or removed in this release.

URL parsing

url.parse() is deprecated. It is recommended that the WHATWG URL API to be used as it is more standards-compliant and secure.

// Deprecated (throws runtime warning)
const parsed = require('url').parse('https://example.com');// alternative
const parsed = new URL('https://example.com');

TLS security upgrade

The deprecated tls.createSecurePair is removed.

// Removed (no longer available)
require('tls').createSecurePair();

// Use TLSSocket instead
new tls.TLSSocket(socket, options);

Deprecation of SlowBuffer

SlowBuffer is deprecated now. If it is used, a runtime warning will be thrown.

// Deprecated (use Buffer.allocUnsafeSlow)
const slow = new SlowBuffer(10);

// Modern alternative
const slow = Buffer.allocUnsafeSlow(10);

Mandatory new keyword for REPL/Zlib classes

It is now runtime-deprecated to create a REPL instance or use Zlib classes without the new keyword. This change aims to better align with standard JavaScript class conventions.

Upgrade to V24

As you plan your upgrade, keep in mind that some APIs and patterns have been deprecated. These changes may require updates to legacy code, especially if your project uses features like REPL or Zlib without the new keyword, or passes arguments incorrectly to child_process methods. Reviewing the official Node.js 24 release notes and using tools like node --trace-deprecation during testing can help you spot and fix these issues early.

To upgrade, you can use a version manager like nvm. You can install it pretty easily with the code below:

nvm install 24
nvm use 24

That, or you can download the latest version directly from the Node.js website.

Since Node.js 24 will enter LTS in October 2025, now’s the time to explore its new features. Whether you’re maintaining node apps or building new projects, getting ahead of the curve will help keep your stack secure, stable, and future-ready.

Summary

Node.js 24 reflects the community’s ongoing commitment to balancing cutting-edge features with long-term stability. Now’s the perfect time to explore what’s new, test your code, and prepare for the upcoming LTS release. Your future-ready projects start here—happy coding!

200s only Monitor failed and slow network requests in production

Deploying a Node-based web app or website is the easy part. Making sure your Node instance continues to serve resources to your app is where things get tougher. If you’re interested in ensuring requests to the backend or third-party services are successful, try LogRocket.

LogRocket lets you replay user sessions, eliminating guesswork around why bugs happen by showing exactly what users experienced. It captures console logs, errors, network requests, and pixel-perfect DOM recordings — compatible with all frameworks.

LogRocket's Galileo AI watches sessions for you, instantly identifying and explaining user struggles with automated monitoring of your entire product experience.

LogRocket instruments your app to record baseline performance timings such as page load time, time to first byte, slow network requests, and also logs Redux, NgRx, and Vuex actions/state. Start monitoring for free.