What Is Vite? Modern Frontend Build Tool

Photo: Daniil Komov / Pexels
Vite (pronounced "veet," French for fast) is a frontend build tool created by Evan You, the developer behind Vue.js, with its first release on April 20, 2020 (Vite on Wikipedia). It splits its job into two halves: a dev server that uses native browser ES modules plus esbuild for near-instant startup and hot reloads, and a production build pipeline that has run on Rollup since 2020 and is migrating to Rolldown, a Rust-based rewrite, as of 2026. As of July 2025, Vite is downloaded roughly 31 million times a week (Vite 7.0 announcement), and it now sits underneath most of the frameworks a working frontend developer touches, including Nuxt, SvelteKit, Astro, and Remix.
This piece walks through why Vite exists, how its dev and production modes actually work under the hood, how it stacks up against webpack, Turbopack, Rspack, and esbuild in practice, and where it still falls short. If you have ever waited 45 seconds for a webpack dev server to boot, you will understand exactly why this tool spread as fast as it did.
The problem Vite was built to solve
Before Vite, nearly every JavaScript build tool worked the same way in development: bundle first, serve second. Webpack, Browserify, and early Parcel all walked your entire module graph, resolved every import, and stitched the result into one or more bundles before the browser ever saw a byte of your app.
That approach made sense when apps were small. It stopped making sense once single-page applications routinely shipped thousands of modules. A large webpack app could take 20 to 60 seconds to cold-start a dev server, and every file save re-triggered enough of that graph-walking work that hot module replacement (HMR, the technique of swapping a changed file into a running app without a full page reload) could lag by seconds. Developers were spending real portions of their day watching a spinner.
Evan You's insight, described in his own account of building the tool, was narrower and more mechanical than it sounds: modern browsers had shipped native support for ES modules (<script type="module">) years earlier, so a dev server did not need to bundle anything at all. It could serve source files directly and let the browser request each module as the app actually needed it. According to a GitNation talk retrospective on Vite's origins, the earliest prototype was a side project called Vue Dev Server from 2019 that You shelved, then picked back up once he figured out how to make HMR work reliably over that unbundled model (Vite: Rethinking Frontend Tooling, GitNation). Getting HMR right, in his telling, was the hardest and most important part of making the whole approach viable.
How Vite actually works, mechanism by mechanism
Vite is not one thing. It is two genuinely different systems that share a config file and a plugin API. Understanding why they're different is the key to understanding the whole tool.
The dev server: no bundling, just on-demand transforms
When you run vite dev, Vite starts a lightweight HTTP server and serves your index.html almost unmodified. The browser reads that file, hits a <script type="module" src="/src/main.tsx"> tag, and requests that one file. Vite intercepts the request, transforms the file on the fly (stripping TypeScript types, compiling JSX, resolving the import specifier) using esbuild, a bundler and transpiler written in Go that is roughly 10 to 100 times faster than JavaScript-based transpilers like Babel or tsc for this kind of work, and streams the result back.
The browser then sees that transformed module's own import statements, and requests those files individually too. This cascades outward one file at a time, but because each request is small and each transform is nearly instant, the total perceived cost is close to zero even in apps with thousands of modules. Nothing is bundled. Nothing is pre-walked. The dev server literally does not know your full module graph until the browser asks for it.
This is the same trick a good analogy makes obvious: a bundler-first dev server is like reading an entire cookbook cover to cover before you're allowed to cook one recipe. Vite's dev server is like grabbing just the one recipe card you need, then grabbing the next card only when the first one tells you to. You start cooking immediately, and you only ever hold the pages you're actually using.
Hot Module Replacement: why it stays fast as apps grow
HMR works because Vite tracks a dependency graph of which modules import which, built lazily as requests come in, not upfront. When you save a file, Vite's dev server uses the OS file watcher to detect the change, invalidates just that module (and, if needed, walks up the graph to find the nearest "HMR boundary," a component that knows how to accept a hot update), and pushes a small WebSocket message to the browser telling it which module to re-fetch and re-execute.
Because the invalidation is scoped to the changed module and its immediate consumers rather than the whole bundle, HMR update speed in Vite stays roughly constant as an app grows from 100 modules to 10,000. That constant-time property is the single biggest practical difference developers notice day to day, more than the cold-start number that gets quoted in marketing copy.
Production builds: why Vite still bundles here
Vite's unbundled dev approach does not carry over to production, and that is intentional, not a compromise. Serving thousands of individual module requests over HTTP works fine on localhost with no network latency, but it would be a real performance problem on a public network with round-trip latency per request, even with HTTP/2 multiplexing.
So for vite build, Vite switches engines entirely and uses Rollup, a bundler built specifically around efficient tree-shaking (removing code that is imported but never used) and clean code-splitting. Rollup produces the kind of output a production site actually wants: a handful of hashed, cacheable chunks instead of thousands of tiny files, CSS extracted into its own file, and dynamic import() calls turned into separate lazy-loaded chunks automatically.
H3: How does Vite differ from a traditional bundler like webpack?
Traditional bundlers like webpack build a complete dependency graph and produce bundles before serving anything, even in development. Vite skips that step in dev by serving native ES modules on demand and only bundles for the production build, which is why its dev server starts almost instantly regardless of app size.
H3: Does Vite replace Rollup?
No. Vite's production build has run on Rollup internally since 2020, and most Rollup plugins work in Vite unchanged because Vite's plugin API is a superset of Rollup's. What's changing in 2026 is that Rolldown, a Rust rewrite of Rollup's core, is becoming the default engine for both dev and prod, unifying the two halves under one bundler instead of two.
The 2026 build tool landscape: Vite vs everyone else
Vite did not invent unbundled development. Snowpack, released in 2019, proved the concept first, and WMR and esbuild's own serve mode explored similar territory around the same time. Vite won the category anyway, and the reason is worth understanding because it explains a lot about how developer tools actually gain adoption: Evan You paired the unbundled-dev idea with a batteries-included production pipeline, a plugin API that was largely compatible with the existing Rollup ecosystem so plugin authors didn't have to start from zero, and immediate first-class support for Vue, followed quickly by React, Svelte, and Solid. Snowpack solved the dev-speed problem but never matched that breadth, and its maintainers eventually recommended migrating to Vite.
The following table reflects the state of the field as of mid-2026.
Table: build tools compared, 2026
| Tool | Dev engine | Prod bundler | Language | Best for |
|---|---|---|---|---|
| Vite | esbuild/Rolldown + native ESM | Rollup/Rolldown | TypeScript (core), Rust (Rolldown) | Any new frontend project |
| Webpack | webpack (bundled dev) | webpack | JavaScript | Legacy apps, deep custom config |
| Turbopack | Rust, built by Vercel | incremental Rust | Rust | Next.js apps specifically |
| Rspack | Rust port of webpack | Rust | Rust | Migrating off webpack with minimal rewrite |
| esbuild | Go | Go | Go | Libraries, simple bundling tasks |
| Parcel | Rust-based | Rust-based | Rust/JS | Zero-config prototypes |
| Bun bundler | Zig | Zig | Zig | Projects already using the Bun runtime |
For a deeper breakdown of benchmarks and ecosystem trade-offs across this whole table, see our build tools comparison. If you're choosing a JavaScript runtime to pair with any of these, our Bun vs Node vs Deno piece covers that separate decision.
Where Vite wins in practice
Vite wins on developer feedback loop speed for anything that is not already deeply invested in webpack's plugin ecosystem or locked into Next.js's Turbopack pipeline. Component libraries benefit from Vite's library mode, which emits ESM, CJS, and TypeScript declaration files without a hand-written Rollup config. Teams building with Astro, SvelteKit, or Nuxt 3 are already running Vite underneath their framework whether they know it or not, so learning Vite's config directly pays off the moment something needs debugging.
Where Vite loses
Existing webpack codebases with years of accumulated custom loaders and plugins face a real migration cost, and that cost sometimes exceeds the speed payoff. Rspack, a Rust-based bundler designed to be webpack-config-compatible, is frequently the smoother migration path for teams in that position because it can often ingest an existing webpack config with minimal changes rather than requiring a rewrite.
Next.js apps are the clearest case where Vite is simply not an option: Next.js ships its own Rust-based bundler, Turbopack, and mixing Vite into a Next.js project is not a supported configuration. Heavy non-JavaScript pipelines, like large Rust or WASM (WebAssembly) monorepos, sometimes fit better with a dedicated build system like Bazel or Nx that is designed for polyglot builds from the ground up. And for a server-only Node.js library with no browser target at all, a lighter tool like tsup or plain tsc does the job with less configuration surface than Vite provides.
What developers actually think of it: the satisfaction gap
Usage and satisfaction tell two very different stories, and the gap between them is unusually wide for a developer tool. According to the State of JS 2025 survey, webpack still holds a narrow usage lead over Vite, at roughly 86% versus 84% of respondents, and that usage gap has been shrinking steadily: it was around 17 percentage points in 2023 and down to about 8 points by 2024 (State of JS 2025, Build Tools).
Satisfaction is where the two tools diverge sharply. The same 2025 survey found Vite at roughly 56% positive sentiment against just 1% negative, a net score around +55, while webpack posted around 14% positive against 37% negative, a net score around -23. That's a swing of roughly 78 percentage points between the two tools on the same survey. Respondents pointed to configuration complexity as the single biggest pain point in build tooling generally, which tracks with why a tool that mostly works with a 10 to 30 line config file has pulled so far ahead on sentiment even while usage numbers are still catching up.
That gap matters practically because usage numbers lag adoption decisions by years, given how many existing production apps are still running whatever bundler they were built with. Satisfaction numbers are a better leading indicator of what teams choose when they start something new, and on that measure Vite has been the default choice for new frontend projects for several years running.
The Vite release history, and where Rolldown fits
Vite's version history is a useful lens on how the project matured from a Vue-specific tool into framework-agnostic infrastructure.
Table: Vite major release timeline
| Version | Release | Key change |
|---|---|---|
| Vite 2 | February 2021 | First framework-agnostic release, Rollup-compatible plugin API introduced |
| Vite 3 | July 2022 | Improved SSR support, began deprecating CommonJS in favor of ESM |
| Vite 4 | December 2022 | Rollup 3 upgrade, faster cold starts |
| Vite 5 | November 2023 | Rollup 4, dropped Node.js 16 support |
| Vite 6 | November 2024 | Environment API introduced for multi-environment builds (browser, edge, workers) |
| Vite 7 | June 24, 2025 | Requires Node.js 20.19+/22.12+, ESM-only distribution, Rolldown available as an opt-in preview bundler |
| Vite 8 | March 12, 2026 | Rolldown and Oxc-based tooling become the stable default for everyone, replacing esbuild and Rollup as the default engines |
Sources: version history compiled from the Vite official migration guide, the Vite 7.0 announcement, and the Vite Wikipedia entry, which lists 8.2.0 as the latest stable release as of July 30, 2026.
Rolldown, the Rust port of Rollup that now underpins Vite 8, exists to close a long-standing architectural gap: for years, Vite used two different bundling engines for two different jobs, esbuild in dev and Rollup in prod, which meant subtle output differences could exist between what a developer saw locally and what actually shipped. Rolldown is built and maintained by VoidZero Inc., a company Evan You founded specifically to build unified, Rust-based JavaScript tooling infrastructure. Unifying dev and prod under one Rust-based bundler is meant to eliminate that mismatch entirely while also making both modes faster, since Rust-based tooling has generally outperformed JavaScript-based tooling for CPU-bound compilation work across the ecosystem (the same reasoning that made esbuild faster than Babel in the first place, and Rspack faster than webpack).
H3: Is Vite 8 a breaking change from Vite 7?
Vite 8 makes Rolldown the default bundler for everyone rather than an opt-in, which is the headline change, but the migration guide describes it as a relatively small step for most projects since Rolldown is designed to be a near drop-in replacement for Rollup's plugin API and output format. Projects that used custom Rollup-specific plugin hooks not yet supported by Rolldown are the main group that may need adjustments.
A minimal Vite config, and why it stays small
Here is a working vite.config.ts for a typical React and TypeScript app in 2026:
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
export default defineConfig({
plugins: [react()],
server: { port: 5173 },
build: {
target: "es2022",
sourcemap: true,
},
});
That covers most real-world React projects for their entire lifetime. A comparable webpack setup handling the same responsibilities (dev server, JSX/TypeScript transform, HMR, production bundling, code splitting, CSS handling) commonly runs 150 to 300 lines once loaders, plugins, and mode-specific overrides are accounted for. The size difference is not cosmetic. Every additional line of build config is a line a new team member has to read before they can safely change it, and it's a line that can silently drift out of date as dependencies update.
Core features worth knowing
- Instant dev server start, even on apps with 5,000-plus modules, because nothing is bundled upfront.
- Fast, module-scoped HMR with React Fast Refresh and Vue's HMR API both working without extra setup.
- TypeScript support via transpilation only. esbuild strips types but does not check them, so you still need
tsc --noEmitorvue-tscin CI (and your editor) to catch actual type errors. - JSX, Vue single-file components, Svelte, and Solid support through official framework plugins.
- CSS handling including PostCSS, CSS Modules, the
?inlineand?urlquery suffixes for importing raw content, and Lightning CSS as an alternative processor. - Glob imports, letting you write
import.meta.glob('./pages/*.tsx')to dynamically pull in a whole directory of modules. - First-class SSR mode, the underlying API that Nuxt, SvelteKit, Astro, and Remix all build their server-rendering pipelines on top of.
- The Environment API, introduced in Vite 6, for building against multiple runtime targets (browser, Cloudflare Workers, edge functions) from one config.
- Library mode, which builds a publishable npm package (ESM, CJS, and type declarations) without a hand-rolled Rollup config.
Vitest: the testing half of the story
The Vite core team also built Vitest, a Jest-compatible test runner that reuses your existing vite.config.ts rather than requiring a separate test configuration file. Vitest runs assertions in Node by default, or in jsdom/happy-dom when you need DOM APIs for component tests, and it supports ESM and TypeScript natively rather than needing a transform layer bolted on. Because it shares Vite's transform pipeline, watch mode re-runs affected tests close to instantly, the same constant-time property that makes Vite's dev-server HMR fast. Vitest has become the default test runner scaffolded by npm create vite@latest, and for a project starting from scratch in 2026, choosing it over Jest avoids maintaining two separate build pipelines for the same codebase.
The plugin ecosystem, and why so much of it already existed
Vite's plugin API is a superset of Rollup's, meaning most existing Rollup plugins work in Vite without modification, and Vite layers a handful of dev-server-specific hooks on top: configureServer for adding custom middleware, transformIndexHtml for injecting content into the HTML entry point, and handleHotUpdate for controlling exactly how HMR behaves for specific file types. That compatibility decision, made early in the project, meant Vite launched with a functioning plugin ecosystem instead of needing years to build one from nothing, which is a real part of why adoption moved as fast as it did.
Commonly used plugins in production apps today include @vitejs/plugin-react, @vitejs/plugin-vue, and @sveltejs/vite-plugin-svelte for framework integration; vite-plugin-pwa for generating a service worker and web app manifest; unplugin-icons and unplugin-auto-import for reducing import boilerplate; vite-tsconfig-paths for respecting the paths mapping already defined in tsconfig.json; @vitejs/plugin-legacy for generating an ES5 fallback bundle for older browsers; and vite-plugin-inspect for visualizing exactly what each plugin does to a module as it passes through the transform pipeline, which is genuinely useful the first time a build does something unexpected and you need to find out which plugin caused it.
What people get wrong about Vite
The most common misunderstanding is treating Vite as "just a faster webpack." It is not a faster version of the same architecture; it is a structurally different architecture for development that happens to still produce a conventional bundled output for production. Confusing the two leads people to expect dev-mode behavior (unbundled, instant, per-file) to match production-mode behavior (bundled, code-split, optimized), and then being confused when a bug only reproduces in one mode and not the other. That gap is exactly the mismatch Rolldown is designed to shrink by unifying the two engines.
A second common mistake is assuming Vite type-checks your code. It does not, by design: esbuild strips TypeScript syntax fast because it does not verify it. Projects that skip a separate tsc --noEmit step in CI can ship with type errors that never surfaced because nothing in the Vite pipeline was ever checking for them. This is a deliberate speed trade-off, not an oversight, but it catches teams by surprise if they assume "TypeScript support" means "type checking."
A third misconception is that Vite and Next.js's Turbopack are competitors you choose between on a level playing field. They are not comparable in that way: Turbopack is bundled specifically into Next.js and is not usable outside it, while Vite is framework-agnostic and explicitly not supported inside Next.js. The decision is really "are you using Next.js or not," not "which bundler is faster," and benchmark comparisons between the two tend to obscure that they solve for different constraints (Turbopack optimizes for Next.js's specific rendering model; Vite optimizes for being usable everywhere else).
Finally, some developers assume "Vite" and "Vue" are more tightly coupled than they are because of Evan You's dual role creating both projects. In practice Vite has been framework-agnostic since version 2 in February 2021, and Vue's own tooling (create-vue) is just one of many official scaffolding templates Vite ships, alongside React, Svelte, Solid, Lit, Preact, and vanilla JavaScript and TypeScript templates.
FAQs
Q: Is Vite a bundler? A: For production builds, yes, via Rollup or, as of Vite 8, Rolldown. In development it is not a bundler at all; it serves your source files unbundled over native ES modules and transforms each one on request with esbuild.
Q: Does Vite work with React?
A: Yes. Running npm create vite@latest -- --template react-ts scaffolds a working TypeScript and React app in seconds, and it is the tooling the React team itself points to as a replacement for the now-deprecated Create React App.
Q: Vite vs Turbopack, which is faster? A: They are not really competing for the same use case. Turbopack ships bundled inside Next.js and only works there; Vite is framework-agnostic and covers everything Turbopack does not. If you're building a Next.js app, Turbopack is what you get by default; for anything else, Vite is the relevant option.
Q: Does Vite type-check TypeScript?
A: No. esbuild transpiles TypeScript by stripping types, but it never validates them. Run tsc --noEmit (or vue-tsc for Vue single-file components) separately, typically in CI, to catch real type errors. Most code editors already run a type checker in the background independent of Vite.
Q: Can Vite build a library, not just an app?
A: Yes, using library mode. Setting build.lib in vite.config.ts produces ESM, CJS, and UMD output along with TypeScript declaration files, which covers what most npm packages need without a hand-written Rollup config.
Q: Is Vite production-ready? A: Yes. Vue, Astro, SvelteKit, Nuxt 3, Remix, and Storybook 8 and later all build on Vite, and the tool is downloaded roughly 31 million times a week as of mid-2025 according to its own release notes, which reflects a large base of production deployments rather than experimental use.
Q: What is Rolldown and why is Vite switching to it? A: Rolldown is a Rust rewrite of Rollup, built by VoidZero, the company Evan You founded to build unified JavaScript tooling. Vite is adopting it to replace both esbuild (dev) and Rollup (prod) with a single bundler, closing the gap where dev-mode and production-mode builds could behave slightly differently, and taking advantage of Rust's speed for CPU-bound compilation work.
Q: When did Rolldown become Vite's default bundler? A: Rolldown was available as an opt-in preview starting with Vite 7 in June 2025, and became the stable default for all users with Vite 8 on March 12, 2026, per Vite's own migration documentation.
Q: Does Vite replace the need for a JavaScript framework? A: No. Vite is build tooling, not a UI framework; it doesn't render components or manage state. It pairs with a framework (React, Vue, Svelte, Solid, or none at all for vanilla projects) rather than replacing one. Teams weighing whether they need a client framework at all in the first place should look at approaches like htmx vs React, which is a separate architectural question from which bundler you use.
Q: Why did webpack lose ground to Vite if it's still used more overall? A: Usage numbers reflect years of existing production apps that haven't migrated, while satisfaction numbers reflect what developers choose for new projects. The State of JS 2025 survey found webpack still narrowly ahead on total usage but Vite far ahead on satisfaction, roughly +55 net positive versus webpack's roughly -23, which is a strong signal about where new projects are heading even before the usage numbers fully catch up.
The takeaway
Vite's real innovation was not raw speed for its own sake. It was recognizing that browsers had already solved a problem developers were still building complicated tools around, native ES module loading, and that unbundled development plus a proper bundled production build could coexist behind one config file and one plugin API. That architecture is why the tool spread from Vue's ecosystem into React, Svelte, Solid, and the frameworks built on top of all of them. The move to Rolldown in 2026 is the next logical step in the same direction: instead of stitching together two different bundling engines for two different jobs, unify them and let a faster underlying language handle both. Whether or not you ever touch Vite's config directly, if you're shipping a frontend app in 2026 there is a decent chance it's running underneath you already.
Read next:
Follow new articles
Add SciHub101 to your feed reader to see new science and technology stories.
About the Author
SciHub101 is an independent science and technology publication founded and edited by Buğra Sözeri, a software engineer and app developer based in Türkiye. AI tools assist with drafting and research. Source documentation in the existing archive is uneven, and articles are being reviewed and corrected. The Editorial Team byline identifies editorial responsibility; it does not certify specialist or independent human review. Where we compare products, anything built by our own team is labelled as such — see the editorial guidelines and About page for how corrections and disclosures work.
Related Articles

What Is HTMX? Hypermedia for Modern Web
HTMX explained: how this 14KB library lets you build dynamic web apps with HTML attributes instead of a JavaScript framework, plus how it actually works.

What Is Drizzle ORM? TypeScript SQL Builder
Drizzle ORM is a lightweight, type-safe TypeScript ORM with SQL-like syntax. Schema, queries, migrations, and comparison with Prisma.

Build Tools Compared 2026 — Vite, Webpack, Turbopack, Bun
Vite, webpack, Turbopack, Bun, Rspack and Rolldown compared for 2026: how each works, where each wins, and what the benchmarks do and do not show.

htmx vs React 2026 — When to Skip the JavaScript Framework
htmx vs React in 2026: how server-sent HTML fragments compare with client-rendered JavaScript, where each fits, and what a documented React-to-htmx port saved.

CSS Flexbox and Grid — Complete Layout Guide
Master CSS Flexbox and Grid with practical code examples. Learn when to use each, key properties, and common layout patterns every developer needs.

React Hooks Explained — useState and useEffect
React Hooks explained from scratch: how useState and useEffect work, the dependency array, cleanup, Strict Mode, common bugs, and when not to use an effect.