Bun vs Node.js : faut-il vraiment migrer en 2026 ?

On a passé Bun en prod sur 3 projets clients en 2026. Verdict après 6 mois : ça marche, mais pas partout. Voici le guide honnête, avec les vrais chiffres et les vrais pièges.

Le contexte 2026

Bun 1.2 est sorti en mars. Node.js 24 LTS est arrivé en avril. Les deux runtimes sont matures, performants, et viables en prod. Mais ils ne servent pas le même usage.

Les promesses de Bun :

• Runtime ultra rapide (basé sur JavaScriptCore, pas V8)
• Bundler intégré (rivalise avec esbuild)
• Test runner natif (compatible Jest)
• Package manager 25x plus rapide que npm
• TypeScript natif (zéro config)
• Hot reload instantané

Les promesses de Node :

• Stabilité éprouvée depuis 15 ans
• Écosystème complet (tout marche)
• LTS sérieuses, support entreprise
• Test runner natif depuis Node 20
• --watch intégré, plus besoin de nodemon
• TypeScript natif depuis Node 23

Le benchmark qui compte (vrai prod)

On a buildé exactement la même API REST avec Bun 1.2 et Node.js 24, déployée sur le même VPS Hetzner (4 vCPU, 8 Go RAM). Charge : 10 000 requêtes via bombardier.

Test 1 : HTTP server simple

// Bun
import { serve } from 'bun';
serve({
  port: 3000,
  fetch(req) {
    return new Response('Hello');
  },
});

// Node.js (avec Hono)
import { serve } from '@hono/node-server';
import { Hono } from 'hono';
const app = new Hono();
app.get('/', (c) => c.text('Hello'));
serve({ fetch: app.fetch, port: 3000 });

Résultats :

| Runtime | req/s | Latency p99 | Memory | |---------|-------|-------------|--------| | Bun 1.2 | 47 230 | 4.2ms | 38 MB | | Node 24 | 22 410 | 8.7ms | 67 MB | | Node 22 | 19 800 | 9.4ms | 71 MB |

Bun gagne nettement. Mais c'est le cas le plus favorable.

Test 2 : API avec PostgreSQL

// Bun + driver natif
import { sql } from 'bun';
const users = await sql`SELECT * FROM users LIMIT 10`;

// Node + postgres-js
import postgres from 'postgres';
const sql = postgres(process.env.DATABASE_URL!);
const users = await sql`SELECT * FROM users LIMIT 10`;

Résultats sur endpoint GET /users (1000 lignes returned) :

| Runtime | req/s | Latency p99 | |---------|-------|-------------| | Bun 1.2 | 8 240 | 18ms | | Node 24 | 7 890 | 21ms |

Écart minime. La DB est le bottleneck, pas le runtime.

Test 3 : Workload CPU intensif (crypto + JSON)

import { createHash } from 'crypto';

async function processData(data: any[]) {
  return data.map((item) => ({
    ...item,
    hash: createHash('sha256').update(JSON.stringify(item)).digest('hex'),
  }));
}

| Runtime | ops/sec | |---------|---------| | Bun 1.2 | 2 870 | | Node 24 | 3 420 |

Node gagne. V8 reste très fort sur le CPU pur.

Test 4 : Cold start + dev experience

| Métrique | Bun | Node | |----------|-----|------| | bun install (Next.js project) | 4.2s | 38s (npm) | | Cold start API | 80ms | 220ms | | File watch reload | 60ms | 180ms | | Run TS file | 110ms | 340ms |

Bun écrase en DX.

Le test runner Bun : sérieux concurrent à Vitest

import { describe, expect, test } from 'bun:test';
import { add } from './math';

describe('add', () => {
  test('adds two numbers', () => {
    expect(add(2, 3)).toBe(5);
  });

  test('handles negatives', () => {
    expect(add(-1, 1)).toBe(0);
  });
});

bun test
# 2 tests passed in 12ms

Vitest sur le même fichier : 340ms. C'est pas du marketing, c'est mesuré.

Bun comme package manager (même si vous gardez Node)

Même si vous restez sur Node en prod, Bun comme package manager change la donne :

bun install   # 4-25x plus rapide que npm
bun add react # ajoute une dépendance
bun outdated  # liste les packages obsolètes

Lockfile binaire (bun.lockb), compatible avec package.json standard. On l'utilise depuis 8 mois, zéro souci.

Les pièges Bun en 2026

Piège 1 : Compatibilité Node API

Bun implémente 95% des API Node. Les 5% qui manquent sont sales :

• vm.Script partiel (pose souci avec certains ORM)
• worker_threads : implémentation différente, attention aux libs qui dépendent dessus
• Quelques edge cases sur crypto Node-specific

Testez votre stack avant de migrer.

Piège 2 : Hosting limité

• Vercel : Bun supporté en build, pas en runtime serverless
• AWS Lambda : pas de runtime Bun officiel
• Cloudflare Workers : non, c'est V8 isolé
• Railway, Render, Fly.io : oui, runtime Bun complet
• VPS : oui, sans souci

Si vous êtes serverless-first, ce n'est pas pour vous.

Piège 3 : Debugging

Les outils de profiling sont moins matures côté Bun. Les flame graphs Node via Clinic.js sont irremplaçables.

💡 Vous voulez qu'on benchmark Bun vs Node sur votre stack pour vous ? On en discute 15 minutes : rdv.lenobot.com.

Notre recommandation par cas d'usage

| Cas | Recommandation | |-----|----------------| | Nouvelle API REST/GraphQL | Bun, sauf si serverless | | Microservices internes | Bun, gain de perf et coût | | Next.js / Remix en SSR | Node, encore (Bun pas 100% prêt) | | Scripts CI/CD | Bun, vitesse imbattable | | CLI tools | Bun, single binary génial | | Serverless (Lambda, Vercel) | Node, Bun pas supporté | | Stack legacy critique | Node, ne touchez pas ce qui marche | | Test runner | Bun (ou Vitest 3) | | Package manager | Bun, partout |

Comment on a migré un projet en 2 jours

Sur un client SaaS (API Express + 40 routes), voici le diff :

// package.json (avant)
{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "start": "node dist/index.js",
    "build": "tsc"
  }
}

// package.json (après)
{
  "scripts": {
    "dev": "bun --hot src/index.ts",
    "start": "bun src/index.ts",
    "build": "bun build src/index.ts --outdir=dist --target=bun"
  }
}

Dockerfile :

# Avant : Node
FROM node:24-alpine
WORKDIR /app
COPY . .
RUN npm ci && npm run build
CMD ["node", "dist/index.js"]

# Après : Bun
FROM oven/bun:1.2-alpine
WORKDIR /app
COPY . .
RUN bun install --frozen-lockfile
CMD ["bun", "src/index.ts"]

Résultats prod après 30 jours :

• Latence p99 : 240ms vers 95ms
• CPU usage moyen : 45% vers 22%
• RAM steady state : 380 MB vers 160 MB
• Coût VPS : downsized de 4 vCPU à 2 vCPU, économie 24€/mois

Verdict 2026

Bun n'est plus une promesse, c'est un outil prod-ready. On le recommande dès qu'il y a un VPS ou un container. On ne le recommande pas en serverless ou pour les stacks Next.js full SSR (encore).

Node reste imbattable en stabilité, écosystème, et hosting. Pour 70% des projets entreprise, Node 24 LTS est le bon choix par défaut.

La vraie question 2026 : est-ce que votre équipe a 2 jours à investir pour économiser 30% de coût infra et doubler les perfs ? Si oui, testez Bun.

Prêt à évaluer une migration Bun sur votre stack en 2026 ? Notre équipe de devs seniors vous accompagne. Réservez votre appel découverte gratuit sur rdv.lenobot.com, 15 minutes pour évaluer votre projet, devis ferme sous 48h, sans engagement.

Article rédigé par L'équipe Lenobot.