Vite 6 et Rolldown : le build passe en Rust

[khalilbenaz]

---

lede: Vite 6 remplace esbuild et Rollup par Rolldown, un bundler écrit en Rust, promettant d'unifier dev et prod tout en effaçant l'écart de vitesse sur les gros projets.
lede_en: Vite 6 replaces esbuild and Rollup with Rolldown, a Rust-written bundler, promising to unify dev and prod while erasing the speed gap on large projects.
title_en: Vite 6 and Rolldown: the build goes Rust

Le problème que Vite avait laissé ouvert

Vite a gagné le front-end en 2020 avec une idée brillante : en développement, servir les modules ES natifs sans bundler, pour un démarrage instantané. Mais Vite cachait une double personnalité. En dev, il utilisait esbuild (Go) pour le pré-bundling des dépendances. En production, il basculait sur Rollup (JavaScript) pour le build final. Deux bundlers aux comportements subtilement différents — d'où le classique bug « ça marche en dev, ça casse en prod ». Et Rollup, écrit en JS, devenait le goulot d'étranglement sur les gros projets : des builds de plusieurs minutes. Rolldown est la réponse à ces deux problèmes.

Rolldown : Rollup réécrit en Rust

Rolldown est un bundler écrit en Rust, conçu par l'équipe Vite (mené par Evan You via VoidZero) pour être compatible avec l'API de Rollup tout en visant la vitesse d'esbuild. L'ambition est double :

• Unifier — un seul bundler pour le dev et la prod, éliminant l'incohérence de comportement entre les deux modes.
• Accélérer — remplacer le JS par du Rust natif sur le chemin critique du build, là où Rollup plafonnait.

La compatibilité API est le pari clé : Rolldown vise à comprendre les plugins Rollup existants, pour que l'immense écosystème (le p de plugins) ne parte pas à la poubelle. C'est ce qui distingue une migration réaliste d'une réécriture qui casse tout.

// vite.config.js — la surface de config bouge peu
import { defineConfig } from 'vite';

export default defineConfig({
  build: {
    // Rolldown reprend l'essentiel des options Rollup
    rollupOptions: {
      output: { manualChunks: { vendor: ['react', 'react-dom'] } },
    },
  },
});

Ce que ça change concrètement

• Builds de prod plus rapides — le gain se voit surtout sur les gros codebases où Rollup traînait. Sur un petit projet, la différence est marginale ; sur un monorepo lourd, elle peut être spectaculaire.
• Moins de surprises dev/prod — un bundler unique réduit la classe de bugs liés à la divergence de résolution ou de transformation entre modes.
• Bundling en dev optionnel — l'approche « no-bundle » de Vite avait ses limites à grande échelle (cascade de requêtes de modules). Rolldown ouvre la porte à un mode dev bundlé plus rapide sur très gros projets.

Le paysage des outils Rust en 2026

Rolldown ne surgit pas seul. Le front-end vit une rustification massive de son outillage :

Outil	Rôle	Langage
Rolldown	Bundler	Rust
Oxc	Parser/linter/transformer	Rust
Turbopack	Bundler (Next.js)	Rust
Biome	Lint + format	Rust
esbuild	Bundler/transformer	Go
SWC	Transformer	Rust

La logique est partout la même : le JavaScript est excellent pour écrire des applis, médiocre pour écrire des outils qui parsent et transforment des millions de lignes. Rust (et Go pour esbuild) apporte le parallélisme et l'absence de GC là où ça compte.

Pièges et limites

• La compatibilité plugin n'est jamais totale au jour un. Un plugin Rollup qui touche des API internes ou repose sur des comportements non documentés peut casser. Testez vos plugins critiques avant de migrer un projet en prod.
• La maturité se gagne dans le temps. Un bundler est un logiciel d'une complexité redoutable (tree-shaking, source maps, code splitting, HMR). Les cas limites se découvrent en production, pas en démo.
• « Plus rapide » dépend de votre projet. Le gain est réel sur les gros builds ; sur un petit site, esbuild suffisait déjà. Ne migrez pas pour la hype.
• Écosystème en mouvement — VoidZero consolide plusieurs outils (Oxc, Rolldown, Vite) ; la trajectoire est cohérente mais encore en cours de stabilisation.

Verdict

En 2026, Vite 6 avec Rolldown corrige la faille architecturale la plus ancienne de Vite : deux bundlers pour un seul projet. Pour la majorité, la migration est transparente et le gain sur les gros builds bienvenu. Adoptez-la avec la prudence normale d'un changement de moteur de build : testez vos plugins et vos source maps avant la prod. Au-delà de Vite, retenez la tendance de fond — l'outillage front-end passe méthodiquement au Rust, et c'est une bonne nouvelle pour tous ceux qui attendent la fin d'un build.

The problem Vite had left open

Vite won the frontend in 2020 with a brilliant idea: in development, serve native ES modules without bundling, for instant startup. But Vite hid a split personality. In dev it used esbuild (Go) to pre-bundle dependencies. In production it switched to Rollup (JavaScript) for the final build. Two bundlers with subtly different behavior — hence the classic "works in dev, breaks in prod" bug. And Rollup, written in JS, became the bottleneck on large projects: multi-minute builds. Rolldown is the answer to both problems.

Rolldown: Rollup rewritten in Rust

Rolldown is a bundler written in Rust, built by the Vite team (led by Evan You via VoidZero) to be compatible with Rollup's API while targeting esbuild's speed. The ambition is twofold:

• Unify — a single bundler for both dev and prod, eliminating behavioral inconsistency between modes.
• Accelerate — replace JS with native Rust on the build's critical path, where Rollup plateaued.

API compatibility is the key bet: Rolldown aims to understand existing Rollup plugins, so the huge ecosystem (the p in plugins) isn't thrown away. That is what separates a realistic migration from a rewrite that breaks everything.

// vite.config.js — the config surface barely moves
import { defineConfig } from 'vite';

export default defineConfig({
  build: {
    // Rolldown carries over most Rollup options
    rollupOptions: {
      output: { manualChunks: { vendor: ['react', 'react-dom'] } },
    },
  },
});

What it changes in practice

• Faster prod builds — the gain shows mostly on large codebases where Rollup dragged. On a small project the difference is marginal; on a heavy monorepo it can be dramatic.
• Fewer dev/prod surprises — a single bundler shrinks the class of bugs from divergent resolution or transformation between modes.
• Optional dev bundling — Vite's "no-bundle" approach had limits at scale (a cascade of module requests). Rolldown opens the door to a faster bundled dev mode on very large projects.

The Rust tooling landscape in 2026

Rolldown doesn't appear alone. The frontend is living a massive rustification of its tooling:

Tool	Role	Language
Rolldown	Bundler	Rust
Oxc	Parser/linter/transformer	Rust
Turbopack	Bundler (Next.js)	Rust
Biome	Lint + format	Rust
esbuild	Bundler/transformer	Go
SWC	Transformer	Rust

The logic is the same everywhere: JavaScript is excellent for writing apps, mediocre for writing tools that parse and transform millions of lines. Rust (and Go for esbuild) brings parallelism and no GC where it counts.

Pitfalls and limits

• Plugin compatibility is never total on day one. A Rollup plugin touching internal APIs or relying on undocumented behavior may break. Test your critical plugins before migrating a production project.
• Maturity is earned over time. A bundler is fearsomely complex software (tree-shaking, source maps, code splitting, HMR). Edge cases surface in production, not in demos.
• "Faster" depends on your project. The gain is real on large builds; on a small site esbuild already sufficed. Don't migrate for hype.
• A moving ecosystem — VoidZero is consolidating several tools (Oxc, Rolldown, Vite); the trajectory is coherent but still stabilizing.

Verdict

In 2026, Vite 6 with Rolldown fixes Vite's oldest architectural flaw: two bundlers for one project. For most, the migration is transparent and the gain on large builds welcome. Adopt it with the normal caution of a build-engine change: test your plugins and source maps before prod. Beyond Vite, note the underlying trend — frontend tooling is methodically moving to Rust, and that is good news for everyone waiting on a build to finish.