Cloud Parts

Rolldown

A JavaScript bundler written in Rust that keeps Rollup’s plugin API at esbuild’s speed; the bundler inside Vite since Vite 8.

What it is
Bundlers and dev servers
Type
Open source
Made by
VoidZero (now part of Cloudflare)
License
MIT
Facts checked
9 October 2026
Website Source code

What it is

Rolldown takes entry files, builds the module graph and writes bundles, like Rollup or esbuild. It accepts the same plugin API as Rollup and Vite, so existing plugins mostly work, and its own benchmarks put it on par with esbuild and 10 to 30 times faster than Rollup. Its feature set is closer to esbuild’s than Rollup’s: TypeScript and JSX transforms, syntax lowering, Node-style module resolution, mixed ES module and CommonJS graphs, define and minification are built in rather than added through plugins. Parsing, transforming, resolving and minifying are done by Oxc.

It was built so that Vite could drop its two bundlers (esbuild in development, Rollup in production) for one, and it has been Vite’s default bundler since Vite 8 (March 2026). It also works on its own: npx rolldown -c reads a rolldown.config.js. Version 1.0 (May 2026) froze the public API under semantic versioning. Because plugins written in JavaScript run outside the Rust core, Rolldown adds hook filters, which let a plugin declare which files it cares about so the bundler skips the call into JavaScript for everything else.

Why teams pick it

  • esbuild-class speed with Rollup’s plugin API; early adopters of the Rolldown-powered Vite reported production builds 3 to 16 times faster
  • Batteries included: TypeScript, JSX, CommonJS interop and Node-style resolution need no plugins
  • Fine control over chunks with webpack-style codeSplitting groups, the feature behind Framer’s 67% cut in chunk count
  • Shares Oxc with Vite’s other tools, so parsing and transforms behave the same across the stack

Watch out for

  • Output details (dead-code elimination, chunking and inlining heuristics, option defaults) may still change within 1.x; only the API is frozen
  • JavaScript plugins pay for each hop from Rust into JavaScript; plugins without hook filters slow the build down as you add them
  • Some features are still experimental, such as watch mode, native MagicString and lazy barrel optimization
  • Doesn’t polyfill Node.js built-ins for the browser; that needs a separate plugin

Alternatives

What all bundlers and dev servers have in common →
ViteOpen sourceThe dev server and build tool most JavaScript frameworks now build on: native ES modules with instant HMR while you code, a Rolldown bundle for production.

How it fits with other technologies

Bundle a small TypeScript app on its own (run with Rolldown 1.2) · js

// rolldown.config.js
// src/main.ts imports add() from ./math.ts (which also exports an unused function)
// and loads ./chart.ts with a dynamic import()
import { defineConfig } from 'rolldown'

export default defineConfig({
  input: 'src/main.ts',
  output: { dir: 'dist', minify: true },
})

// $ npx rolldown -c
// <DIR>/chart-gJLzF7kj.js  chunk │ size: 0.04 kB
// <DIR>/main.js            chunk │ size: 0.10 kB
//
// dist/main.js: types stripped, the unused export dropped, add() inlined,
// chart.ts split into its own chunk:
// console.log(((e,t)=>e+t)(2,3));const{draw:e}=await import(`./chart-gJLzF7kj.js`);console.log(e());
//
// $ node dist/main.js
// 5
// a chart

See it in a real stack

No architecture uses Rolldown yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2024–2026

Vite started with two bundlers: esbuild, written in Go, for speed in development, and Rollup, written in JavaScript, for its plugin API and careful production output. The pair worked, but it meant two transformation pipelines, two plugin systems and glue code to keep them aligned, and esbuild couldn’t be customised enough to take over everything. Evan You and the Vite team decided to build one bundler with Rollup’s API and esbuild’s speed, written in Rust.

Rolldown was open-sourced in 2024, its first public release (0.10.1) coming in April, and in October Evan You founded VoidZero, which holds the project’s copyright and funds a full-time team, to finish it together with the Oxc compiler it is built on. In May 2025 a rolldown-vite package let people try it as a drop-in replacement for Vite; GitLab cut a build from 2.5 minutes to 40 seconds and Excalidraw from 22.9 to 1.4 seconds. Vite 8’s beta made it the default in December 2025, Vite 8 shipped in March 2026, and Rolldown reached 1.0 in May 2026 with about 200 contributors.

Why it’s built this way

The whole pipeline in Rust, not Rust pieces inside a JavaScript bundler
Moving parts of a JavaScript tool to Rust often loses the gain to the cost of passing data between the two, as Rollup 4 found with its Rust parser. Parse, transform and code generation all stay native and run in parallel.
Rollup’s plugin API
Vite’s whole plugin ecosystem was written against it. Without compatibility, every Vite user would have had to rewrite plugins to upgrade.
Build on Oxc and parse each file once
Vite sometimes parsed the same TypeScript file five times at different layers of the stack. Sharing one parser and syntax tree removes repeated parsing and lets AST work such as emitting type declarations run in parallel during bundling.
Hook filters for JavaScript plugins
Calling into JavaScript for every file is the main cost of a JS plugin in a native bundler. A plugin that declares an id, code or moduleType filter is skipped entirely for files that don’t match.

Timeline

  1. 2024

    First public release, 0.10.1, in April

  2. 2024

    VoidZero founded in October to fund Rolldown and Oxc; 1.0 beta in December

  3. 2025

    rolldown-vite technical preview in May

  4. 2025

    Vite 8 beta makes Rolldown the default bundler in December

  5. 2026

    Release candidate (January), Vite 8 stable (March), Rolldown 1.0 (May)

  6. 2026

    VoidZero joins Cloudflare in June; Rolldown stays MIT-licensed

Sources6 · facts checked 9 October 2026

Improve this page on GitHub