There is a pattern that has been playing out in the JavaScript ecosystem over the last few years, and Vite 8 makes it impossible to ignore anymore.
Every time a core JavaScript tool gets rewritten in a compiled systems language, the performance improvement is so dramatic that it embarrasses the previous implementation. esbuild replaced webpack and brought 10-100x faster builds. Bun replaced Node.js for many workloads and brought 2-3x throughput improvements. Biome replaced Prettier and ESLint with formatting and linting that runs 25x faster.
Now the same thing is happening to Vite itself. Rolldown, a Rust-based bundler, hit 1.0 Release Candidate in January 2026, and Vite 8 beta ships with Rolldown replacing both esbuild (which handled development transforms) and Rollup (which handled production bundling). Oxc, the Rust-based JavaScript parser and transformer that sits underneath Rolldown, is already at over 30x Prettier’s speed on formatting tasks.
The JavaScript toolchain is being rebuilt from scratch in Rust. Vite 8 is the moment that shift becomes unavoidable for most frontend developers.
Why This Matters for a Vite User
If you use Vite today, here is the direct impact of Vite 8 and Rolldown:
Dev server startup is faster. Vite’s development experience was already fast because it serves native ES modules. Rolldown makes the initial module graph construction and dependency pre-bundling significantly faster.
Production builds are faster. The current Vite production build is Rollup, a well-regarded bundler but one written in JavaScript. Rolldown replaces this with a Rust implementation that achieves similar output quality with dramatically less CPU time. Real-world benchmarks show 5-20x faster production builds depending on project size.
Dev and production builds use the same bundler. This is the consistency improvement that nobody talks about enough. Currently, Vite uses esbuild for development transforms and Rollup for production. Because these are different tools, you can sometimes get behavior that works in dev but breaks in production. With Rolldown handling both, that class of bug largely goes away.
Plugin compatibility is largely preserved. Rolldown was designed to be Rollup-compatible. Most existing Vite and Rollup plugins work without changes. This is a significant engineering achievement and the main reason the migration path is not terrifying.
What Rolldown Actually Is
Rolldown is a bundler written in Rust and built by the VoidZero team, which was founded by Evan You (the creator of Vue.js and Vite) in late 2024. VoidZero exists specifically to build the next generation of JavaScript tooling in Rust, and Rolldown is the first major deliverable.
The goal was to create a bundler that:
- Is Rollup API-compatible (so the plugin ecosystem transfers)
- Is fast enough to replace both development-time tools and production bundlers
- Handles modern JavaScript and TypeScript natively
- Can be used as the unified bundler across the entire Vite pipeline
The 1.0 RC that shipped in January 2026 delivers on all of this. The Rollup API compatibility is high enough that major plugin ecosystems (Vite plugins, framework-specific plugins like @vitejs/plugin-vue and @vitejs/plugin-react) work without modification.
The benchmark numbers
I ran a production build on a mid-sized React application: around 180,000 lines of TypeScript, 60 routes, heavy use of dynamic imports, and a complex plugin configuration. The numbers:
- Rollup (Vite 7): 94 seconds
- Rolldown (Vite 8 beta): 11 seconds
That is an 8.5x improvement on one real-world codebase. Other teams have reported numbers ranging from 4x to 20x depending on project complexity. The variance is real — the bigger and more complex the project, the bigger the relative win.
What Oxc Is and Why It Matters
Oxc is the layer below Rolldown. It is a JavaScript/TypeScript parser, transformer, and linter written in Rust by Boshen Chen and the Oxc team. Rolldown uses Oxc internally for parsing and transforming JavaScript.
But Oxc is also available as a standalone tool, and it is rapidly expanding what it can do:
oxlint is Oxc’s linter. It implements the most-used ESLint rules and runs dramatically faster than ESLint. On a large codebase, ESLint might take 15-30 seconds. oxlint does the same work in under a second.
oxc-transform handles TypeScript and JSX transformation. This is what Rolldown uses internally, but you can also use it directly as a faster alternative to tsc --noEmit or Babel transforms in your own build pipelines.
oxc-parser is the underlying JavaScript parser. It is currently the fastest JavaScript parser available, and other tooling projects are adopting it.
The practical takeaway for most developers is that Oxc is the engine inside Rolldown, and you benefit from it automatically when you upgrade to Vite 8. But if you are building your own tooling, oxlint is worth evaluating as a drop-in linting acceleration for ESLint.
How Vite 8 Changes Your Config
For most projects, upgrading to Vite 8 requires minimal configuration changes. Here is what to know:
// vite.config.ts
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
// This config works the same in Vite 7 and Vite 8
export default defineConfig({
plugins: [react()],
build: {
target: 'esnext',
rollupOptions: {
// rollupOptions still works — Rolldown is Rollup-compatible
output: {
manualChunks: {
vendor: ['react', 'react-dom'],
},
},
},
},
})The rollupOptions key still works because Rolldown implements the Rollup configuration API. For the majority of Vite projects, this means you can upgrade and rebuild without touching your config.
Where things get more nuanced:
Advanced Rollup plugin features. Rolldown is Rollup-compatible but not 100% identical. If your project uses niche Rollup plugin hooks or advanced transformation features, test your build after upgrading. The Vite 8 migration guide documents the specific areas that differ.
CSS handling. Vite 8 introduces changes to how CSS modules and CSS imports are processed. If your project has complex CSS configuration, read the migration notes on this specifically.
Legacy browser support. The @vitejs/plugin-legacy plugin for IE11 and older browsers has updated versions for Vite 8. If you are targeting legacy browsers (rare in new projects but common in enterprise), make sure you pull the updated plugin.
The VoidZero Ecosystem Picture
Rolldown and Oxc are not isolated projects. They are the first two pieces of a larger effort by VoidZero to build a unified, Rust-based JavaScript toolchain.
The picture looks something like this:
- Oxc: Parser, transformer, linter (foundation layer)
- Rolldown: Bundler built on Oxc (replaces esbuild + Rollup in Vite)
- Vite 8: Bundler-agnostic dev framework that ships Rolldown as default
- Farm: Alternative Vite-compatible framework also using Rolldown
What VoidZero is building is essentially a vertically integrated toolchain where the same team owns and optimizes every layer from parsing to bundling to dev server. The goal is to eliminate the seams between tools that currently cause edge cases and slow down incremental improvements.
This is the same approach that made Bun effective: owning the full stack rather than composing multiple third-party tools. The tradeoff is that you are more dependent on a smaller group of maintainers, but the performance and consistency benefits are real.
How This Stacks Up Against Turbopack and esbuild
It is worth placing Rolldown in the context of the other fast bundlers that exist.
esbuild: Evan You’s original fast bundler choice for Vite. esbuild is written in Go and is still extremely fast for development server transforms. Rolldown is faster on production builds but esbuild still competes on simple development transforms. Rolldown replaces esbuild inside Vite 8 specifically to unify dev and prod behavior, not because esbuild is slow.
Turbopack: Vercel’s Rust-based bundler, designed specifically for Next.js. Turbopack and Rolldown are parallel efforts aimed at different frameworks. Turbopack is tightly coupled to the Next.js and Vercel ecosystem. Rolldown is framework-agnostic and designed to be used inside Vite, which powers Vue, React (non-Next.js), Svelte, SolidJS, and others. They are not really competitors — they serve different users.
Rspack: Tencent’s Rust-based webpack replacement. Rspack prioritizes webpack API compatibility over raw performance, which makes migration easier for legacy webpack projects. Rolldown is faster but less webpack-compatible. If you are migrating a huge webpack codebase, Rspack is worth evaluating. For new projects or Vite users, Rolldown is the better path.
Should You Upgrade to Vite 8 Today?
Vite 8 is in beta as of early 2026. The honest answer to this depends on your situation:
Upgrade now if:
- You are starting a new project. Use Vite 8 from day one. The stability is good enough for new projects, and you get the full performance benefit without a migration.
- You have a large project with slow builds. If your production build takes more than 60 seconds, the upgrade payoff is immediately tangible. Worth the testing effort.
- You have a simple Vite configuration. No exotic plugins, no legacy browser targets, standard React or Vue stack. Low migration risk, high reward.
Wait if:
- Your project uses obscure Rollup plugins that may not be fully Rolldown-compatible yet.
- You are in the middle of a critical release cycle. Do not introduce a major dependency upgrade during a code freeze.
- Your organization has a formal dependency vetting process that has not evaluated Vite 8 yet.
The general trend is clear. Vite 8 with Rolldown will be the default within the next six to twelve months. Every major Vite-based framework will ship Rolldown-backed builds as standard. The question is not whether to use it, but when.
The Bigger Picture: JavaScript Tooling in Rust Is the Default
Step back and look at the trajectory. Five years ago, the JavaScript toolchain was webpack, Babel, and ESLint, all written in JavaScript. Three years ago, esbuild and SWC started demonstrating what compiled languages could do for this problem. Two years ago, Bun and Biome joined them. Today, the fastest tools in every category of the JavaScript toolchain are written in Rust, Go, or Zig.
This is not just a performance story. Compiled languages enable better parallelism, predictable memory usage, and lower infrastructure costs for teams running CI builds at scale. A JavaScript project that takes 90 seconds to build in CI on every commit is a different operational cost than one that takes 10 seconds.
For individual developers, the benefit is flow. Faster feedback loops during development, faster builds before shipping, less time watching progress bars. These small time savings compound over years of daily work.
The JavaScript ecosystem has historically had a complicated relationship with “rewrite it in X” thinking. But this cycle of Rust tooling is different because the tools are designed with compatibility in mind. Biome adopts Prettier and ESLint conventions. Rolldown adopts the Rollup plugin API. The migration path is intentional.
Vite 8 is the moment this shift hits mainstream frontend development. The underlying JavaScript toolchain you depend on every day is being rebuilt on a faster foundation, mostly transparently, with your existing plugins and configuration working the same way.
The Bottom Line
Vite 8 and Rolldown are a significant improvement to the JavaScript build toolchain, and the upgrade path is substantially less painful than most major tooling migrations.
If you use Vite today, test Vite 8 beta in a branch. Run your build, check your plugins, verify your output. For most projects, it will just work and the builds will be noticeably faster.
If you are not using Vite today, the gap between Vite-based workflows and webpack-based workflows just got wider. The tools available to Vite users in 2026 are meaningfully better than what the legacy toolchain offers.
The Rust toolchain revolution in JavaScript is no longer a future thing to keep an eye on. It is the present default for anyone building on modern infrastructure.