Node.js 24 LTS: why and how to upgrade to Krypton

In short: As of September 5, 2026, Node.js 24 Krypton is the LTS release to choose for a new project. The branch has been in Active LTS since October 28, 2025, is scheduled to enter Maintenance on October 20, 2026, and remains supported until April 30, 2028 according to the official release schedule. For an existing Node.js 22 project, plan the upgrade after testing dependencies, native modules, and deprecated APIs.

Node.js 24 modernizes the JavaScript engine, npm, asynchronous context tracking, and several native APIs. The migration is usually progressive, but it deserves targeted validation rather than an automatic production rollout.

What really changed between Node.js 22 and Node.js 24?

The initial Node.js 24.0.0 release, published on May 6, 2025, brings V8 13.6, npm 11, AsyncContextFrame by default, and global URLPattern.

V8 13.6: the engine running faster

Node.js 24 moves the JavaScript engine to V8 13.6. The official release notes list Float16Array, explicit resource management, RegExp.escape, WebAssembly Memory64, and Error.isError among the additions.

// Float16Array — half the memory for large tensors
const data = new Float16Array(1024 * 1024); // 2 MB instead of 4 MB

// RegExp.escape — no more manual escaping hacks
const safe = RegExp.escape("hello.world?+*"); // "hello\\.world\\?\\+\\*"

// Error.isError — reliable cross-realm error checking
if (Error.isError(thing)) {
  // thing is definitely an error, even from an iframe or vm context
}

// Explicit Resource Management — RAII finally comes to JS
function processFile(path) {
  using file = await fs.open(path, 'r');
  // File will be automatically closed, even on error
}

V8 13.6 also brings internal optimizations. Their impact depends on your workload: measure startup time, hot paths, and memory usage in your own application before claiming a gain.

npm 11: faster, more secure

Node.js 24 ships npm 11. Its official release notes confirm in particular that:

• --ignore-scripts covers all lifecycle scripts, including prepare
• npm no longer falls back to the old audit endpoint if the bulk advisory request fails
• npm 11 requires Node.js ^20.17.0 || >=22.9.0

Install times depend on the cache, registry, file system, and dependency tree. Compare npm ci on your own CI before drawing conclusions.

AsyncContextFrame: painless context tracking

The AsyncLocalStorage API now uses AsyncContextFrame by default, replacing the older async_hooks-based mechanism.

import { AsyncLocalStorage } from 'node:async_hooks';

const context = new AsyncLocalStorage();

// No more --experimental-async-context-frame flag needed
// It's the default now, and it's faster
context.run({ requestId: 'abc-123' }, async () => {
  await someAsyncWork();
  // Context survives through ALL async operations
  console.log(context.getStore().requestId); // 'abc-123'
});

This implementation aims for more efficient and more robust context tracking. It matters most for distributed tracing, correlated logs, and request ID propagation.

Permission Model: what are the security limits?

The Permission Model is stable and enabled with --permission. It controls access to files, child processes, workers, native addons, WASI, and the inspector, among other resources.

# Allow only the reads and writes you need
node --permission \
  --allow-fs-read=/app/data \
  --allow-fs-write=/app/logs \
  server.js

The documentation describes it as a seat belt for trusted code, not as isolation against malicious code. Do not treat it as a replacement for a container or a sandbox.

URLPattern goes global

No more explicit imports:

// Node 24 — available everywhere
const pattern = new URLPattern({ pathname: '/blog/:slug' });
console.log(pattern.test('https://mysite.com/blog/node-24')); // true

This standard API simplifies routing and URL pattern validation without an explicit import.

Undici 7: the engine behind fetch() evolves

Node.js 24 ships Undici 7 and continues improving the HTTP client used by fetch().

// Undici powers fetch() under the hood
const res = await fetch('https://api.example.com/data');

Test runner: more intuitive

The native test runner now automatically waits for subtests:

import { describe, it } from 'node:test';

describe('Users API', () => {
  // Before Node 24: you had to manually await
  // Now: auto-waiting, just like Jest or Vitest
  it('should create a user', async () => {
    const res = await fetch('/api/users', { method: 'POST' });
    assert.strictEqual(res.status, 201);
  });
});

Native SQLite: what does Node.js 24 gain?

The node:sqlite module, introduced in Node.js 22, keeps progressing in Node.js 24. As of September 5, 2026, the branch 24 documentation still classifies it as a “release candidate”: evaluate its stability and API before replacing a battle-tested dependency.

import { DatabaseSync } from 'node:sqlite';

const db = new DatabaseSync(':memory:');
db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)');
db.prepare('INSERT INTO users (name) VALUES (?)').run('Dedimarco');
const users = db.prepare('SELECT * FROM users').all();
console.log(users); // [{ id: 1, name: 'Dedimarco' }]

How do Node.js 22 and Node.js 24 compare?

Feature	Node.js 22 (Jod)	Node.js 24 (Krypton)
npm at branch launch	10.x	11.x
Float16Array	No	Yes
RegExp.escape	No	Yes
Error.isError	No	Yes
Global URLPattern	No	Yes
AsyncContextFrame	Available, not enabled by default	Default
Permission Model	Stable on recent releases	Stable (--permission)
node:sqlite	Introduced in the branch	Richer API, still release candidate
Planned end of support	April 30, 2027	April 30, 2028

Which friction points should you check?

Native addons and build platforms

A major version bump can require recompiling native addons. The Node.js 24 release notes also state that compiling Node.js on Windows now requires ClangCL; MSVC is no longer supported for that task.

32-bit architectures

The release notes indicate that ARMv7 support becomes experimental and that some 32-bit architectures, including s390 and ppc, are no longer supported. Check the binaries actually published for your platform before migrating.

url.parse(): should you replace the legacy API?

The Node.js 24 release notes add a runtime deprecation for url.parse(). The URL documentation recommends the WHATWG API:

// ❌ Deprecated in Node.js 24
const parsed = url.parse('https://example.com/path?q=1');

// ✅ WHATWG API
const parsed = new URL('https://example.com/path?q=1');

A global search followed by a manual review is enough for most codebases. Then check the properties you use, because the WHATWG URL object does not mirror every property of the legacy format.

How do you install Node.js 24 without surprises?

Distribution repositories do not all ship the same version at the same time. Start with the official download page, then pick the method that fits your environment instead of assuming the system package is current.

On Windows

Method 1: official installer

Download the LTS installer from the official download page, then run the package matching your architecture.

Method 2: fnm (recommended for developers)

fnm (Fast Node Manager) is written in Rust — fast, cross-platform:

# Install via winget
winget install Schniz.fnm

# Then install Node 24
fnm install 24
fnm use 24
fnm default 24

Method 3: Volta or nvm-windows

# With Volta
winget install Volta.Volta
volta install node@24

# With nvm-windows
nvm install 24
nvm use 24

On macOS

# fnm (my recommendation)
brew install fnm
fnm install 24
fnm default 24

# Or via nvm
nvm install 24
nvm alias default 24

# Or directly via Homebrew
brew install node@24

On Linux

Method 1: NodeSource

NodeSource provides APT and RPM repositories for the 24 branch. Always review the downloaded script before running it with administrator privileges.

Ubuntu / Debian:

# Download and run the NodeSource setup script
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -

# Install Node.js 24
sudo apt install -y nodejs

# Verify the version actually installed
node -v
npm -v

Fedora / RHEL / Rocky Linux:

# Configure the NodeSource repository
curl -fsSL https://rpm.nodesource.com/setup_24.x | sudo -E bash -
sudo dnf install -y nodejs

Arch Linux:

# Check the available version before installing
pacman -Si nodejs
sudo pacman -S nodejs npm

Method 2: NVM (recommended for development)

NVM installs Node in your home directory. Ideal when you juggle multiple projects with different versions.

# Install NVM
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.7/install.sh | bash

# Reload your shell or open a new terminal, then:
nvm install 24
nvm alias default 24

# Pin the version per project
echo "24" > .nvmrc
nvm use

Warning: NVM installs Node inside your user’s home directory. For a systemd service or another user, prefer a controlled package, an official binary, or a container image.

Method 3: fnm (my personal favorite)

Faster than NVM, supports .node-version and .nvmrc, and handles multiple versions without slowing down shell startup:

# Install fnm
curl -fsSL https://fnm.vercel.app/install | bash

# Install Node 24
fnm install 24
fnm default 24

# Projects with .node-version or .nvmrc auto-switch
fnm use

Method 4: official binaries (tarball)

For environments without direct repository access, grab the archive from the latest published 24 release. As of September 5, 2026, that is 24.20.0:

cd /usr/local
sudo curl -fsSL https://nodejs.org/dist/v24.20.0/node-v24.20.0-linux-x64.tar.xz | sudo tar -xJ --strip-components=1
node -v  # v24.20.0

Method 5: Docker / Podman

If you containerize your applications, simply update the base image:

# Dockerfile
FROM node:24-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
CMD ["node", "server.js"]

The official images provide the node:24, node:24-alpine, and node:24-slim tags, along with the matching Krypton aliases.

What does my migration experience show?

Between January and March 2026, I migrated my personal projects and two client projects from Node.js 22 to Node.js 24.

What went smoothly:

• Express apps, Astro projects, and common scripts ran without notable changes
• Automatic subtest waiting makes the native test runner nicer to use
• npm 11 installs behaved without incident on my environments
• node:sqlite covered the simple needs of several projects

What required attention:

• A native addon built with node-gyp needed recompilation
• Replacing url.parse() with the WHATWG API took a search pass plus a few property adjustments
• The full test suites took longer than expected on the oldest CI setup

My advice: if you are on Node.js 22, don’t aim for the April 30, 2027 deadline. Update dependencies, rerun the test suite, recompile native addons, and validate url.parse() usage before switching.

Verdict

Node.js 24 LTS is a solid release. The runtime gains more useful standard APIs, npm 11, better async context tracking, and a stable Permission Model. The main caution remains targeted validation of native addons, build platforms, and deprecated APIs.

If you’re starting a new project today, go with Node.js 24. If you’re maintaining a Node.js 22 project, plan the migration before its April 30, 2027 end of support.

Sources

• Node.js 24.0.0 — initial release notes
• Node.js 24.11.0 — Krypton LTS entry
• Node.js 24.20.0 — latest 24 release consulted on September 5, 2026
• Official Node.js release schedule
• Permission Model documentation
• SQLite module documentation
• URL API documentation
• npm 11.0.0 release notes
• Official Node.js downloads
• fnm — Fast Node Manager
• nvm — Node Version Manager
• Official Node.js Docker image