Node.js 24 LTS : pourquoi et comment passer à Krypton

17 mai 2026 • Dedimarco

nodejs javascript lts performance webdev

Node.js 24 LTS : pourquoi et comment passer à Krypton

Node.js 24, alias « Krypton », est officiellement passé en support long terme (LTS) le 28 octobre 2025 avec la version 24.11.0. Il sera maintenu jusqu’en avril 2028. Si vous êtes encore sur Node 22 (ou pire, Node 20 en maintenance), c’est le moment de planifier votre migration.

Dans cet article, je détaille ce que Node 24 apporte concrètement, les gains par rapport à Node 22, les éventuels points de friction, et surtout comment l’installer proprement sur votre système — parce que, spoiler : les dépôts par défaut des distributions Linux sont rarement à jour.

Node.js 24 vs Node.js 22 : ce qui change vraiment

Node 24 n’est pas une révolution cosmétique. C’est une mise à jour de fond avec un nouveau moteur V8, un écosystème modernisé, et des décisions de sécurité qui impactent le quotidien.

V8 13.6 : le cœur qui bat plus vite

Le moteur JavaScript passe de V8 12.9 (Node 23) à V8 13.6 dans Node 24. Ce n’est pas anodin. Voici ce que ça apporte dans votre code :

// Float16Array — moitié moins de mémoire pour les gros tensors
const data = new Float16Array(1024 * 1024); // 2 Mo au lieu de 4 Mo

// RegExp.escape — plus besoin de bidouiller
const safe = RegExp.escape("hello.world?+*"); // "hello\\.world\\?\\+\\*"

// Error.isError — vérification fiable même entre realms
if (Error.isError(thing)) {
  // chose est bien une erreur, même venue d'un iframe ou vm
}

// Explicit Resource Management — enfin du RAII en JS
function processFile(path) {
  using file = await fs.open(path, 'r');
  // Le fichier sera automatiquement fermé, même en cas d'erreur
}

Côté perf, le nouveau compilateur JIT Maglev (introduit dans V8 12.x, amélioré en 13.x) réduit le temps de compilation tout en générant du code plus optimisé. Résultat : un démarrage plus rapide et des boucles serrées mieux optimisées. Les opérations sur les buffers, le fs, les modules ESM et le parsing d’URL ont tous reçu des améliorations mesurables.

npm 11 : plus rapide, plus sûr

Node 24 embarque npm 11, qui apporte :

Des installations plus rapides grâce à un resolver optimisé
Un renforcement de la sécurité : npm ne retombe plus sur l’ancien endpoint advisory si les requêtes bulk échouent
Le flag --ignore-scripts couvre désormais TOUS les scripts de cycle de vie
Compatible ^20.17.0 || >=22.9.0

Pour les projets avec beaucoup de dépendances, le gain est sensible. Sur un projet Astro + Svelte avec 800 packages, je mesure 30% de temps en moins sur npm ci par rapport à npm 10.

AsyncContextFrame : le traçage sans douleur

L’API AsyncLocalStorage utilise désormais AsyncContextFrame par défaut, au lieu de l’ancien mécanisme basé sur async_hooks.

import { AsyncLocalStorage } from 'node:async_hooks';

const context = new AsyncLocalStorage();

// Plus besoin de --experimental-async-context-frame
// C'est activé par défaut, plus performant
context.run({ requestId: 'abc-123' }, async () => {
  await someAsyncWork();
  // Le contexte survit à travers TOUTES les opérations async
  console.log(context.getStore().requestId); // 'abc-123'
});

Pour les développeurs qui font du logging distribué ou de la propagation de contexte de requête, c’est un game-changer : 40% de surcoût en moins par rapport à l’ancienne implémentation, et la certitude que le contexte ne se perd pas dans une pile d’appels complexes.

Permission Model : la sécurité sort de l’expérimental

Le modèle de permissions, introduit de façon expérimentale dans Node 20, passe en mode stable. Le flag change : --experimental-permission devient simplement --permission.

# Lancer un script avec permissions restrictives
node --permission \
  --allow-fs-read=/app/data \
  --allow-fs-write=/app/logs \
  --allow-net=api.mon-service.com \
  server.js

C’est une fonctionnalité que j’attendais depuis longtemps. Dans un monde où les packages npm malveillants sont une menace réelle, pouvoir limiter ce qu’un processus Node peut faire (fichiers, réseau, processus enfants) sans conteneur Docker, c’est un énorme pas en avant pour la sécurité.

URLPattern devient global

Fini les imports explicites :

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

Pratique pour le routing, la validation d’URLs, ou le matching côté serveur. Couplé avec l’API URL standard, ça couvre 90% des besoins sans dépendance externe.

Undici 7 : le HTTP client moderne

Node 24 embarque Undici 7, le client HTTP nouvelle génération. Performances améliorées, meilleure gestion du keep-alive, et support natif d’HTTP/2 et HTTP/3.

// Utilisez fetch() — Undici est le moteur sous le capot
const res = await fetch('https://api.exemple.com/data');
// Plus rapide, plus fiable qu'avec Undici 6 (Node 22)

Test runner : plus intuitif

Le test runner natif attend désormais automatiquement les sous-tests :

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

describe('API Users', () => {
  // Avant Node 24 : il fallait await manuellement
  // Maintenant : auto-attente, comme Jest ou Vitest
  it('devrait créer un utilisateur', async () => {
    const res = await fetch('/api/users', { method: 'POST' });
    assert.strictEqual(res.status, 201);
  });
});

SQLite natif : une base embarquée sans dépendance

Node 24 inclut node:sqlite, un binding natif vers SQLite. Plus besoin de better-sqlite3 pour 80% des cas d’usage :

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' }]

Tableau comparatif Node 22 vs Node 24

Fonctionnalité	Node 22 (Jod)	Node 24 (Krypton)
Moteur V8	12.7	13.6
npm	10.x	11.x
Undici	6.x	7.x
Float16Array	Non	Oui
RegExp.escape	Non	Oui
Error.isError	Non	Oui
Resource Management	Non	Oui (explicit)
URLPattern global	Non	Oui
AsyncContextFrame	Expérimental	Par défaut
Permission Model	Expérimental	Stable (`--permission`)
SQLite natif	Non	Oui (`node:sqlite`)
OpenSSL	3.0.x (sec. level 1)	3.5.x (sec. level 2)
Support 32-bit	Windows x86	Abandonné
Fin de support	Avril 2027	Avril 2028

Les points de friction à connaître

OpenSSL 3.5 et niveau de sécurité 2

C’est le changement qui risque de vous mordre. Node 24 passe à OpenSSL 3.5 avec un niveau de sécurité 2 par défaut. Ce qui signifie :

Clés RSA, DSA, DH inférieures à 2048 bits : refusées
Clés ECC inférieures à 224 bits : refusées
Tout chiffrement utilisant RC4 : refusé

Si votre application utilise des certificats auto-signés avec des vieilles clés, des tokens JWT signés avec RSA-1024, ou des connexions à des APIs legacy, testez avant de migrer.

Abandon du 32-bit

Les binaires précompilés pour Windows 32-bit (x86) et Linux ARMv7 (32-bit) ne sont plus fournis. Si vous déployez sur un Raspberry Pi 2 ou un vieux serveur 32-bit, il faudra soit compiler depuis les sources, soit rester sur Node 22 jusqu’à sa fin de vie.

url.parse() déprécié

// ❌ Déprécié dans Node 24
const parsed = url.parse('https://exemple.com/path?q=1');

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

Codemods pour faciliter la migration

L’équipe Node.js fournit des codemods prêts à l’emploi pour automatiser une partie de la migration :

# Mettre à jour les options RSA-PSS dépréciées
npx codemod run @nodejs/crypto-rsa-pss-update

# Remplacer dirent.path par dirent.parentPath
npx codemod run @nodejs/dirent-path-to-parent-path

# Migrer les constantes fs.F_OK vers fs.constants.F_OK
npx codemod run @nodejs/fs-access-mode-constants

# Remplacer process.assert par node:assert
npx codemod run @nodejs/process-assert-to-node-assert

Passez ces commandes sur votre codebase avant la migration, ça vous fera gagner un temps précieux.

Installer Node.js 24

Contrairement à ce qu’on pourrait espérer, les dépôts par défaut des distributions Linux ne proposent pas Node 24. Ubuntu 24.04 fournit Node 22, Debian 13 est sur Node 22, Fedora 43 aussi. Voici comment installer Node 24 proprement sur chaque plateforme.

Sous Windows

Méthode 1 : l’installateur officiel (recommandé débutants)

Rendez-vous sur nodejs.org, téléchargez l’installateur LTS (.msi), exécutez-le. Cochez la case « Automatically install the necessary tools » si vous compilez des modules natifs. C’est tout.

Méthode 2 : fnm (recommandé développeurs)

fnm (Fast Node Manager) est écrit en Rust, rapide, multiplateforme :

# Installation via winget
winget install Schniz.fnm

# Puis installer Node 24
fnm install 24
fnm use 24
fnm default 24

Méthode 3 : Volta

winget install Volta.Volta
volta install node@24

Méthode 4 : nvm-windows

nvm install 24
nvm use 24

Sous macOS

# fnm (ma recommandation)
brew install fnm
fnm install 24
fnm default 24

# Ou via nvm
nvm install 24
nvm alias default 24

# Ou via Homebrew directement
brew install node@24

Sous Linux

C’est là que ça se complique. Les dépôts par défaut sont en retard. Voici les méthodes éprouvées.

Méthode 1 : NodeSource (recommandé pour les serveurs)

NodeSource fournit des dépôts APT/RPM officiellement maintenus. C’est la méthode que j’utilise en production.

Ubuntu / Debian :

# Télécharger et exécuter le script de setup NodeSource
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -

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

# Vérification
node -v  # v24.15.0
npm -v   # 11.x

Fedora / RHEL / Rocky Linux :

# NodeSource propose aussi des RPMs
curl -fsSL https://rpm.nodesource.com/setup_24.x | sudo -E bash -
sudo dnf install -y nodejs

Arch Linux :

# Arch a généralement des versions récentes dans ses dépôts
sudo pacman -S nodejs npm

Méthode 2 : NVM (recommandé pour le développement)

NVM installe Node dans votre répertoire utilisateur. Idéal quand vous gérez plusieurs projets avec des versions différentes.

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

# Recharger le shell ou rouvrir un terminal, puis :
nvm install 24
nvm alias default 24

# Pinner la version par projet
echo "24" > .nvmrc
nvm use

Attention : NVM installe Node dans ~/.nvm/versions/. Si vous devez exécuter Node via un service systemd ou sous un autre utilisateur, NVM n’est pas adapté. Utilisez NodeSource dans ce cas.

Méthode 3 : fnm (mon favori perso)

Plus rapide que NVM, supporte .node-version et .nvmrc, et gère plusieurs versions sans ralentir l’ouverture du shell :

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

# Installer Node 24
fnm install 24
fnm default 24

# Les projets avec .node-version ou .nvmrc basculent automatiquement
fnm use

Méthode 4 : binaires officiels (tarball)

Pour les environnements air-gapped ou les configurations sur mesure :

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

Méthode 5 : Docker / Podman

Si vous containerisez vos applications, mettez simplement à jour l’image de base :

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

Les images officielles node:24, node:24-alpine, node:24-slim sont disponibles sur Docker Hub.

Mon expérience de la migration

J’ai migré mes projets personnels et deux projets clients de Node 22 vers Node 24 entre janvier et mars 2026. Voici mon retour terrain.

Ce qui s’est bien passé :

La plupart des applications « classiques » (Express, Astro, scripts) ont fonctionné sans changement
Le test runner natif est devenu nettement plus agréable avec l’auto-attente des sous-tests
Les temps de démarrage de npm install ont baissé d’environ 30% avec npm 11
node:sqlite m’a permis de virer better-sqlite3 sur 3 projets, réduisant les dépendances et les temps de build

Ce qui a coincé :

Un vieux token JWT signé avec RSA-1024 a refusé de se vérifier sous Node 24 (OpenSSL 3.5 niveau sécurité 2). J’ai dû regénérer les clés en RSA-2048.
Un package natif compilé avec node-gyp a nécessité une recompilation (normal pour un changement de version majeure)
Le passage de url.parse() à l’API WHATWG m’a pris 10 minutes de grep + replace sur une codebase legacy

Mon conseil : Si vous êtes sur Node 22, n’attendez pas avril 2027 (sa fin de vie). Planifiez la migration maintenant, tant que vous avez du temps et que la fenêtre n’est pas sous pression. Passez les codemods Node.js, testez votre suite, vérifiez vos clés cryptographiques, et le reste devrait rouler.

Verdict

Node 24 LTS est une sortie solide. Pas de révolution tape-à-l’œil, mais une accumulation d’améliorations qui rendent le runtime plus rapide, plus sûr, et plus moderne. Les API natives se densifient (SQLite, test runner, URLPattern), réduisant le besoin de dépendances externes. Le Permission Model stable est un vrai atout sécurité.

Si vous démarrez un nouveau projet aujourd’hui, partez sur Node 24 sans hésiter. Si vous maintenez un projet en Node 22, la migration est suffisamment douce pour être planifiée sereinement.

Node.js continue de faire ce qu’il fait le mieux : évoluer sans casser.