Vite 8: the biggest leap in Vite performance (and architecture) so far

Daniel Garcia – 20 Mar. 2026

Vite 8: the biggest leap in Vite performance (and architecture) so far

If you build modern React apps, you have probably used Vite already, or at least heard about its speed during development.

With Vite 8, though, this is not only about speed. It is a structural change in how Vite works under the hood.

And that changes a lot.

In this post, you will see what changed, why it matters, and what the real impact is in day-to-day work.

The problem (that you may have already felt)

Before Vite 8, there was a clear split:

  • Dev -> esbuild
  • Build -> Rollup

In practice, this worked well, but it had a classic problem:

Behavior in development and production was not always the same.

You have probably seen this before:

  • works in dev
  • breaks in build

This happens because those are different pipelines, with different rules and optimizations.

The most important change: goodbye Rollup (and esbuild), hello Rolldown

Vite 8 introduces Rolldown, a new bundler written in Rust.

Yes, Rust 👀

Here is the key point:

Vite now uses the same engine for dev and build.

Why is this so relevant?

Because this change solves several issues at once:

1) Consistency

You now get:

  • the same pipeline
  • the same rules
  • fewer surprises

In short:

If it works in dev, it is much more likely to work in build.

2) Insane performance

With Rolldown:

In large applications (like micro frontends or migrated legacy apps), this makes a big difference.

3) More predictable architecture

Before:

  • two engines
  • two mental models

Now:

  • one single pipeline
  • predictable behavior

This simplifies:

  • debugging
  • plugin behavior
  • optimization work

What about plugins? Will everything break?

Good news: no, in most cases.

Vite kept compatibility with the Rollup plugin API.

In practice:

  • most plugins continue to work
  • issues usually appear only when a plugin depends on deep internals

What else improved?

Besides the bundler change, there are other relevant improvements:

Better cache efficiency

  • smarter module-level cache
  • fewer unnecessary rebuilds

Better tree-shaking

  • smaller bundles
  • less dead code

Better code splitting

  • more efficient chunks
  • better loading behavior

Better support for large projects

Especially relevant if you work with:

  • micro frontends
  • monorepos
  • legacy applications

What does this unlock in the future?

This change is not only about performance.

It opens room for:

  • more aggressive optimizations
  • better Module Federation support
  • finer bundle control
  • faster ecosystem evolution

Is it worth migrating now?

It depends.

General rule:

  • small project -> you can wait for a bit more stabilization
  • large project -> it is worth testing sooner rather than later

It makes even more sense if you struggle with:

  • slow builds
  • inconsistencies between environments
  • complex configuration

Possible points of attention

Not everything is perfect:

  • some plugins may need adjustments
  • changes around manualChunks
  • optimization behavior can differ from previous versions

Nothing dramatic, but it is worth validating before pushing to production.

Conclusion

Vite 8 is not just an incremental update.

It is a strategic rewrite of Vite's foundation.

Faster? Yes.
But more importantly:

  • more predictable
  • more consistent
  • better prepared for scale

And above all:

less friction between dev and production.

More?

If you want to go deeper:

The official announcement is the best starting point because it clearly explains the reasoning behind this shift: the cost of maintaining two pipelines (esbuild + Rollup) and how Rolldown unifies everything into a single flow.

  • Have you tested Vite 8 in a real project?
  • Did you notice meaningful performance gains?

Send me a message and share your experience, it is always great to exchange this kind of insight.