Rolldown vs Rollup vs esbuild: What Should a Vite Project Use?
The short answer: Rolldown, Rollup, or esbuild?
- A conventional Vite application should follow the bundler path supported by its installed Vite release before attempting a manual replacement.
- Rollup is strong when a library needs precise output control, multiple formats, code splitting, and mature plugins.
- esbuild is strong when fast JavaScript and TypeScript transformation is the main need.
- Rolldown is a Rust-based tool targeting a unified scope: Rollup/Vite API compatibility with an esbuild-like feature set.
- Benchmark results are not enough. Compare plugins, source maps, dynamic imports, CSS, assets, and reproducible CI output.
Vite is not the same thing as a bundler
Vite combines development server, HMR, plugins, and production build integration. Rollup, esbuild, and Rolldown are engines that analyze modules, transform code, and produce bundles. A Vite project does not need to manage every underlying engine directly.
Rolldown describes its goal as unifying roles historically served by esbuild and Rollup in Vite. For a normal application, check the integration supported by the Vite version you actually run before trying to replace a bundler by hand.
Rollup: deliberate output control
Rollup is an ES-module-focused bundler with multiple output formats, code splitting, deep execution-path tree-shaking, and a broad plugin API. It is a strong option for libraries shipped as ESM, CJS, UMD, or other deliberate targets.
That flexibility comes with more configuration to own. Building a conventional application from raw Rollup settings can recreate work that higher-level tooling already handles.
esbuild: a fast transformation engine
esbuild is widely used for rapid JavaScript and TypeScript transformation and bundling. It fits tools that must process source quickly and projects with simple build needs. It is not automatically the best answer for every specialized publishing pipeline; complex output and plugin requirements may call for additional tooling.
Rolldown: compatibility plus integration
Rolldown is written in Rust and targets the Rollup and Vite plugin API. Its documented built-in scope includes TypeScript and JSX transforms, Node-compatible module resolution, ESM/CJS interop, and code splitting. Reusing many Rollup plugins can lower migration cost.
Compatibility still requires project-level proof. Legacy configuration, nonstandard plugins, hook order, and generated assets should be verified against real source and output.
| Situation | Start with | Why |
|---|---|---|
| Conventional Vite application | Vite's supported path | Dev server, HMR, and plugins stay integrated |
| Library with special or multiple outputs | Rollup | Mature output and plugin control |
| Fast transformations or lightweight tools | esbuild | Strong compilation and bundling speed |
| Vite-compatible unified-bundler evaluation | Rolldown | It targets Rollup/Vite compatibility with an integrated scope |
Verify before migration
- Test every plugin, not only the build exit code.
- Compare ESM/CJS output, dynamic imports, source maps, CSS, and asset paths.
- Measure cold CI builds and reproducibility, not one local run.
- Run a separate CI comparison before changing the default path.
Conclusion
Keep Vite's integrated path for most applications; use Rollup for controlled library output and esbuild for fast transformations. Rolldown is an important option, but your own plugin and output tests should make the final decision.