Vite est l’outil de build par défaut pour React, Vue et la plupart des frameworks frontend modernes depuis des années. Mais il a toujours eu une fracture architecturale : esbuild pour les transformations en développement, Rollup pour le bundling en production. Deux outils différents avec des comportements différents, des APIs de plugin différentes, et des incohérences occasionnelles entre dev et prod. Vite 8 comble cet écart. Rolldown, le bundler Rust construit spécifiquement pour Vite, remplace à la fois esbuild et Rollup comme moteur unique alimentant chaque étape du pipeline. Le résultat : des builds plus rapides, un comportement cohérent, et un modèle mental plus simple.
Rolldown : un seul bundler pour tout
Les versions précédentes de Vite utilisaient esbuild pour transformer TypeScript et JSX pendant le développement, et Rollup pour tout bundler en production. Ça fonctionnait, mais les deux outils avaient des algorithmes de treeshaking différents, une résolution de modules différente, et des cas limites différents autour des dépendances circulaires. Les bugs qui n’apparaissaient qu’en production étaient les plus frustrants.
Rolldown élimine ça entièrement. Écrit en Rust, il gère le pipeline de transformation en dev et le bundling en production avec le même moteur.
# Démarrage du dev server sur un gros projet
vite 7 (esbuild): 1.8s
vite 8 (rolldown): 0.6s
# Build de production
vite 7 (rollup): 28s
vite 8 (rolldown): 9sLes gains de vitesse viennent de la performance native de Rust et de la suppression du coût de coordination entre deux outils séparés. Mais le plus gros gain, c’est la cohérence : ce qui marche en dev marche en prod. Plus de “ça bundle bien en local mais ça casse en CI.”
Rétrocompatible par défaut
Rolldown implémente l’API de plugin de Rollup. Les plugins Vite existants qui utilisent les hooks Rollup continuent de fonctionner sans modifications.
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
plugins: [react()],
});La configuration est identique aux versions précédentes. Pas de nouveau format de plugin à apprendre, pas d’étape de migration pour les projets standards. Le passage à Rolldown est interne. Si votre projet utilise uniquement des plugins officiels et une configuration standard, la mise à jour se résume à changer la version dans package.json.
Pour les plugins qui reposaient sur des internals spécifiques à Rollup ou un comportement non documenté, Vite 8 fournit une couche de compatibilité qui log des warnings pour les patterns dépréciés. La migration est progressive, pas un mur.
Transformations propulsées par OXC
Vite 8 utilise OXC (Oxidation Compiler) pour les transformations TypeScript et JSX. OXC est une toolchain Rust qui gère le parsing, la transformation et le linting de JavaScript et TypeScript à vitesse native.
export default defineConfig({
oxc: {
target: 'es2022',
jsxImportSource: 'react',
},
});Le stripping TypeScript, la transformation JSX et le downleveling syntaxique se font en une seule passe Rust. Plus d’étape esbuild séparée pour les transformations suivie d’une étape Rollup pour le bundling. Un seul pipeline, un seul jeu de source maps, une seule surface de configuration.
L’impact pratique est surtout visible sur le HMR. Les mises à jour de modules qui passaient auparavant par la transformation d’esbuild, puis le module graph de Vite, passent maintenant par un pipeline unifié Rolldown + OXC. Les mises à jour HMR sur les gros projets atterrissent en moins de 20ms de manière constante.
Environment API : le SSR en première classe
Vite 8 stabilise l’Environment API introduite dans Vite 6. Chaque environnement (client, serveur, edge) a son propre module graph, ses conditions de résolution et ses paramètres d’optimisation.
export default defineConfig({
environments: {
client: {
build: {
outDir: 'dist/client',
rollupOptions: {
input: './src/entry-client.tsx',
},
},
},
ssr: {
build: {
outDir: 'dist/server',
rollupOptions: {
input: './src/entry-server.tsx',
},
},
resolve: {
conditions: ['node'],
},
},
},
});Avant l’Environment API, les builds SSR utilisaient la même config que les builds client avec des overrides bancals. Les packages serveur uniquement fuitaient dans le bundle client, et le code client uniquement crashait sur le serveur. Chaque environnement a maintenant une résolution isolée, donc import 'fs' dans un environnement serveur se résout correctement tandis que l’environnement client l’ignore.
Les frameworks comme Next.js, Remix et SolidStart utilisent cette API en interne. Pour les développeurs d’applications, l’avantage est que le SSR au niveau du framework fonctionne plus fiablement sans configuration manuelle de ssr.external ou ssr.noExternal.
Découpage de chunks amélioré
Le treeshaking et le découpage de chunks de Rolldown sont plus agressifs que ceux de Rollup. Il produit moins de chunks, plus petits par défaut, avec une meilleure déduplication des modules partagés.
export default defineConfig({
build: {
rollupOptions: {
output: {
manualChunks: {
vendor: ['react', 'react-dom'],
ui: ['@radix-ui/react-dialog', '@radix-ui/react-popover'],
},
},
},
},
});La configuration manuelle des chunks fonctionne toujours pour un contrôle explicite, mais les défauts sont meilleurs. Rolldown identifie automatiquement les dépendances partagées entre les imports dynamiques et les sépare dans des chunks distincts qui se chargent en parallèle. Le pattern courant où trois routes lazy importent toutes la même librairie de graphiques ne produit plus trois copies de cette librairie dans trois chunks séparés.
La sortie inclut aussi un meilleur scope hoisting. Les modules importés une seule fois sont inlinés dans leur chunk parent, réduisant le nombre de function wrappers et améliorant la performance au runtime.
Pré-bundling des dépendances plus rapide
Vite pré-bundle les dépendances au premier lancement pour convertir les packages CommonJS en ESM et réduire le nombre de requêtes HTTP pendant le développement. Rolldown gère cette étape nativement, rendant les cold starts significativement plus rapides.
# Premier lancement avec pré-bundling (500+ dépendances)
vite 7 (esbuild): 4.2s
vite 8 (rolldown): 1.8sLa sortie pré-bundlée est aussi plus cohérente. Rolldown résout et bundle les dépendances avec le même algorithme qu’il utilise pour le code applicatif, éliminant une catégorie de bugs où les dépendances pré-bundlées se comportaient différemment des dépendances bundlées en production.
Pour les monorepos avec des packages partagés, Rolldown gère correctement les dépendances de workspace sans les workarounds optimizeDeps.include qui étaient parfois nécessaires avec esbuild.
Améliorations CSS
Vite 8 intègre Lightning CSS comme processeur CSS par défaut, remplaçant PostCSS pour la plupart des transformations. Le vendor prefixing, le nesting et le downleveling syntaxique se font sans plugins PostCSS.
export default defineConfig({
css: {
lightningcss: {
targets: { chrome: 100, firefox: 100, safari: 16 },
},
},
});Les CSS modules, la résolution des @import et la minification passent tous par Lightning CSS, qui est des ordres de grandeur plus rapide que les alternatives PostCSS. Tailwind CSS v4 fonctionne nativement sans PostCSS puisqu’il s’intègre directement avec le système de plugins de Vite.
Pour les projets qui ont encore besoin de PostCSS (plugins custom, transformations legacy), il reste disponible en opt-in. Mais pour la majorité des projets, Lightning CSS gère tout avec zéro configuration.
Migration depuis Vite 7
Le chemin de mise à jour est volontairement fluide. La plupart des projets n’ont besoin que d’un changement de version.
{
"devDependencies": {
"vite": "^8.0.0",
"@vitejs/plugin-react": "^5.0.0"
}
}Les breaking changes sont minimaux. Les principaux à surveiller : la suppression de l’API Node.js CJS legacy (utilisez les imports ESM), l’option define utilise maintenant la sémantique Rolldown pour les remplacements de chaînes, et la version minimum de Node.js est 22. Les plugins Rollup custom qui accèdent à this.meta.rollupVersion verront une valeur différente, mais ça affecte rarement le comportement.
Lancer npx vite --profile génère un rapport de performance de build qui met en évidence les plugins ajoutant de la latence au pipeline, utile pour identifier les goulots d’étranglement après la mise à jour.
Conclusion
Vite 8 est ce vers quoi Vite a toujours tendu : un pipeline unique, rapide, propulsé par Rust, de la source à la production. Rolldown élimine la fracture dev/prod qui causait des bugs subtils. OXC gère les transformations à vitesse native. L’Environment API fait du SSR un citoyen de première classe. Et le chemin de mise à jour respecte les configurations existantes. Pour les équipes déjà sur Vite, la mise à jour est directe. Pour les équipes encore sur webpack, l’écart de performance vient de se creuser.