Node.js 24.x (LTS): What's New, Release History & Support Lifecycle

What JavaScript Engine Changes Come with Node.js 24?

Node.js 24 ships V8 13.6, one of the most feature-rich engine upgrades in recent memory. This single update unlocks several long-awaited language proposals that were previously only available behind flags or polyfills.

The most impactful additions for production code:

• Explicit Resource Management -- the using and await using keywords from TC39, enabling deterministic cleanup of resources without try/finally boilerplate.
• Float16Array -- a new typed array for 16-bit floating point data, useful for ML inference workloads and GPU-adjacent compute tasks.
• RegExp.escape() -- finally a built-in way to escape a string for use inside a regular expression, replacing years of hand-rolled utility functions.
• Error.isError() -- a reliable cross-realm check for Error instances, removing the need for instanceof hacks in sandboxed or VM contexts.
• WebAssembly Memory64 -- Wasm modules can now address more than 4 GB of linear memory, unblocking large-scale Wasm workloads.

In practice, the using keyword is the change most teams will reach for immediately. Database connections, file handles, and lock objects are all natural fits. Watch out for TypeScript configs that may need "lib": ["ES2025"] or equivalent to recognize the syntax without errors.

// Explicit resource management -- now native in Node.js 24
class DatabaseConnection {
  [Symbol.dispose]() {
    this.close();
  }
}

{
  using conn = new DatabaseConnection();
  // conn.close() is called automatically at the end of this block
  await conn.query('SELECT 1');
}

How Does AsyncLocalStorage Change in Node.js 24?

AsyncLocalStorage now defaults to using AsyncContextFrame as its underlying implementation, replacing the previous async_hooks-based approach. For most applications this is transparent, but the performance and correctness improvements are meaningful in high-throughput services.

The new default is more efficient because context propagation no longer relies on the async hooks infrastructure for every async operation. In practice, teams running request-tracing or per-request logging middleware in Express or Fastify should see lower overhead at scale.

Two new constructor options have also been added: defaultValue sets the value when no store is active, and name gives the instance a label useful for debugging and heap snapshots. These small additions make multi-store setups -- common in layered middleware architectures -- considerably easier to reason about.

import { AsyncLocalStorage } from 'node:async_hooks';

const requestContext = new AsyncLocalStorage({
  name: 'requestContext',
  defaultValue: { requestId: 'unknown' }
});

// Context flows correctly through async boundaries without any
// manual propagation -- now backed by AsyncContextFrame by default
app.use((req, res, next) => {
  requestContext.run({ requestId: req.headers['x-request-id'] }, next);
});

What Breaking Changes and Removals Should You Audit Before Upgrading to Node.js 24?

Node.js 24 ships a significant number of removals that have been deprecated for multiple releases. Any upgrade plan should include a dedicated audit pass against these items before moving to production.

The highest-risk removals for existing codebases:

• tls.createSecurePair() removed -- this has been deprecated since Node.js 0.11. If anything in your dependency tree still calls it, the process will throw at startup.
• http.OutgoingMessage._headers and ._headerNames removed -- these undocumented properties were used by some older middleware. Replace with getHeaders(), getHeader(), and setHeader().
• fs.truncate() with a file descriptor -- passing an fd to fs.truncate() is gone. Use fs.ftruncate(fd, len) instead.
• fs.dirent.path removed -- replaced by dirent.parentPath, which was introduced in Node.js 21.4.
• test() and t.test() no longer return Promises -- if any test suite awaits the return value of a top-level test() call, that code must be updated. The runner now handles subtest sequencing automatically.
• MSVC dropped on Windows -- native addon authors targeting Windows must switch to ClangCL. Pre-built binaries via node-pre-gyp are unaffected, but any CI pipeline that compiles addons on Windows needs updating.

The runtime deprecation of url.parse() is worth calling out separately. It will emit a DeprecationWarning on every call now. Teams with high-traffic services that parse URLs in hot paths will want to migrate to new URL(input) before upgrading, to avoid log noise and prepare for eventual removal.

// Before -- now triggers DeprecationWarning at runtime in Node.js 24
const parsed = require('url').parse('https://example.com/path?q=1');

// After -- use the WHATWG URL API
const parsed = new URL('https://example.com/path?q=1');
console.log(parsed.pathname); // '/path'
console.log(parsed.searchParams.get('q')); // '1'

How Has the Built-in Test Runner Improved in Node.js 24?

The built-in test runner received several developer-experience improvements that reduce the gap between it and third-party frameworks. The most impactful change is that subtests now automatically complete before the parent test finishes -- you no longer need to await t.test(...) everywhere, and forgetting to do so no longer causes silent failures.

Global setup and teardown are now supported via a dedicated API, making it practical to use the built-in runner for integration test suites that need shared infrastructure like database connections or test servers spun up once per run. Per-test timeout via --test-timeout is now applied on a per-test basis rather than globally, giving finer-grained control over slow tests. JSON module mocking is also now supported.

// node:test -- global setup/teardown, new in Node.js 24
import { before, after, test } from 'node:test';
import assert from 'node:assert/strict';

let db;

before(async () => {
  db = await connectToTestDatabase();
});

after(async () => {
  await db.close();
});

test('user lookup returns correct record', async (t) => {
  // Subtests no longer need explicit await -- runner handles ordering
  t.test('by id', async () => {
    const user = await db.findById(1);
    assert.equal(user.name, 'Alice');
  });

  t.test('by email', async () => {
    const user = await db.findByEmail('[email protected]');
    assert.equal(user.id, 1);
  });
});

What Improvements Come to the SQLite and HTTP APIs in Node.js 24?

The built-in SQLite module, introduced experimentally in Node.js 22, continues to mature rapidly in the 24.x branch. This release adds support for custom aggregate functions via createAggregateFunction(), a location method to retrieve the database file path, timeout options on DatabaseSync to handle lock contention gracefully, and a setReturnArrays() method on prepared statements for scenarios where array-indexed results are more convenient than objects.

On the HTTP side, fetch() now respects proxy configuration through the NODE_USE_ENV_PROXY environment variable. This is a frequently requested feature for teams operating behind corporate or infrastructure proxies. Undici, Node.js's underlying HTTP client, was upgraded to version 7.x bringing further improvements to connection handling and HTTP feature support.

import { DatabaseSync } from 'node:sqlite';

const db = new DatabaseSync(':memory:', { timeout: 5000 });

db.exec('CREATE TABLE sales (region TEXT, amount REAL)');

// New in Node.js 24 -- custom aggregate functions
db.createAggregateFunction('sum_region', {
  start: 0,
  step: (acc, val) => acc + val,
  result: (acc) => acc
});

const stmt = db.prepare('SELECT region, sum_region(amount) FROM sales GROUP BY region');
// New in Node.js 24 -- return arrays instead of objects
stmt.setReturnArrays(true);
for (const row of stmt.iterate()) {
  console.log(row); // ['APAC', 42000]
}