Vite and the Future of JavaScript Tooling, by Evan You

Summary (Technological concepts, product features, analysis)

What Evan You (creator of Vite/V) says about V’s adoption

• V (Vite) is presented as a build/dev tool for quickly developing single-page applications, while also supporting multiple higher-level frameworks.
• Since its early release, V has seen major growth:
  • Created 4 years ago (2020)
  • Crossed 15M+ weekly npm downloads
  • Adoption growth “almost doubled in the past year”
• V began as an experiment to make the Vue dev server faster, but evolved into a framework-agnostic development tool.
• Many frameworks—especially those involving SSR (server-side rendering)—adopt V, contributing to wider V’s adoption as a shared foundation.

Testing ecosystem: Vitest (“vest”) and what it achieved

• A unit testing tool called Vitest (subtitle: “vest”) is described as originating from frustration with unit test tooling that properly works with V/SFC (Vue component) formats.
• In the State of JS survey, Vitest and V were highly ranked:
  • V
    • #1 most adopted
    • #1 highest retention
    • #2 highest interest
    • most loved library overall
  • Vitest
    • #3 most adopted
    • #2 highest retention
    • #1 highest interest

Ecosystem convergence: frameworks increasingly treat V as the default foundation

Examples mentioned:

• Vue and framework-adjacent projects that default tooling to V.
• Svelte / Preact / Solid / PReact / etc. (mentioned as examples using V as default tooling)
• React: not default to V, but many new SPA projects increasingly create via V instead of CRA.
• Angular: uses V as its dev server since v16.
• Meta-frameworks built on V: Astro, SvelteKit, SolidStart, Remix, and “Next-like” analogs (names appear in subtitles; theme is “many meta frameworks build on V”).

Core thesis: The web tooling ecosystem is converging on reusing a common foundation rather than reinventing separate toolchains.

---

Why V needs improvement: limitations of “toolchain stitching”

Evan explains that V’s internal approach was forced to “hack together” a toolchain from multiple existing JS ecosystem tools because there wasn’t a single all-in-one solution.

Current V pipeline uses multiple tools for different tasks

• esbuild
  • bundling and default TypeScript transform
  • minification/lowering transforms
• Rollup
  • production bundling (better chunking/control than esbuild; more aligned with application bundling)
• SWC
  • provides React fast refresh transform (via SWC transforms)
• Babel
  • also used for React fast refresh, but is slower because Babel is JS-based

Problems created by combining different tools

1. Inconsistencies between bundlers

   • Dependency pre-bundling uses esbuild, but production bundling uses Rollup.
   • This can cause differences in behavior for edge cases involving legacy/CommonJS/ESM modules.
   • Such inconsistencies are only reliably discovered after shipping to production.

2. Pipeline inefficiency / duplicated parsing

   • With certain configurations (e.g., SWC enabled), the same source may be transformed multiple times by different parsers (example described: dev transforms → Rollup → esbuild minify/transform).
   • This creates redundant parsing/transform/serialization work and wastes build time.

3. Dev server bottleneck for huge apps: network overhead

   • V’s dev server uses an unbundled dev server approach leveraging native ESM.
   • It works well for moderate module counts (~1,000 modules), but for very large apps (example: 10,000+ modules):
     • Browser network/request overhead becomes the bottleneck.
     • Even with optimizations like HTTP/2, many requests can block dev page load.
   • Evan argues that a faster, consistent bundler for dev+prod could help these users.

---

Proposed direction: a unified high-performance toolchain (“unified tool chain”)

Evan argues the underlying cause is broader than V: the JS ecosystem relies on many separate tools (parser, transformer, bundler, minifier, linker, unit test integration) that:

• use different parsers
• don’t share a common source of truth
• require heavy configuration/coordination by developers
• lead to complexity, inconsistency, and inefficiency

Desired properties of a future tooling stack

Evan lists key requirements for a toolchain that could replace the stitched pipeline:

• Unified
  • same module resolution + transforms across bundler and test runner
  • one shared “source of truth” for aliases/resolution/transform outputs
• High performance
  • prefer tooling written in native languages (Rust/Go/etc.) for speed
• Composability
  • individual pieces exposed as crates / npm packages rather than one closed “black box”
• Runtime-agnostic DX
  • same dev experience regardless of target runtime (browser, Cloudflare Workers, etc.)
  • avoid vendor-locking to one runtime

“Why now?”

• Earlier, JS tools were easier to iterate on.
• But today requirements have stabilized enough to justify investing in slower-to-build, higher-performance native tooling.

---

Company and roadmap: “oxc” + “rnodale/rolldown” + V integration

Evan says he started a company called V (subtitles also reference “Vozero” / “void zero”) and raised $4.6M seed funding to pursue the vision of unifying tooling layers under the V ecosystem.

Main projects

1. Oxc

• A language toolchain composed of composable Rust crates / npm packages
• Includes: parser, semantic analysis, transformer, minifier, resolver, linker, formatter
• Highlight: ECMA 262 100% compliance for the parser
• Also supports parsing TypeScript + TSX
• Transformer includes analysis such as control flow graph, and emits TypeScript definition files without needing TypeScript itself.
• React fast refresh transform is referenced as part of the transformer work.

2. Rolldown (subtitles: “rowdown” / “rod down”)

• A bundler built on top of Oxc
• Designed to become a future bundler inside V to make dev/prod more consistent and faster
• Features called out:
  • handles mixed CJS/ESM graphs
  • source maps
  • outputs multiple formats
  • tree shaking
  • ~90% Rollup plugin compatibility
  • advanced chunking/control “Rollup-like”
  • built-in Node.js/package resolution
  • built-in TypeScript/JSX transforms support

Progress status and benchmarks

• Oxc: parser/resolver/linker/transformer mostly available; minifier/formatter still in progress but prototypes exist.
• Evan claims Oxc is fastest in multiple categories, with comparisons mainly to native-language tools (esbuild/SWC equivalents).
• Mentions memory and binary size improvements:
  • example claim: Babel-based transforms can involve downloading ~21MB across many packages, while Oxc provides a single binary < ~2MB for the platform.

V integration status

• “Rolldown integration” into V is underway. Evan describes:
  • V branch using rolldown instead of esbuild + Rollup for production bundling
  • tests running with >90% test pass rate
  • plans for a V version where rolldown becomes a production replacement, with beta later this year
• Architecture plan:
  • replace the “native side” in V with a vertically integrated Rust toolchain (Oxc + Rolldown) so everything is handled consistently.

Large-app dev mode improvement: “full bundon mode” concept

• Evan describes a prototype shifting V away from fully-unbundled dev-server mode for very large apps (over ~5,000 non-bundled modules).
• Goal: improve server startup and page load time, including HMR performance.
• Described as currently prototype-stage.

---

Q&A highlights (selected technical points)

• Next.js / Turbopack integration: Evan suggests it’s unlikely to externally support Next.js tooling changes soon due to Next/Vercel investing heavily in its own pipeline.
• Syntax lowering definition
  • Transform newer syntax into older browser-supported syntax (example: lowering to ES2015-compatible output).
• Portability with Bun / Deno
  • V should be usable in Bun/Deno since Node APIs are reportedly supported there.
• Correctness strategy
  • run rolldown/oxc against rollup/esbuild test suites; keep cases aligned with expected correctness and distinguish correctness vs behavioral differences.

---

Main speakers / sources

• Main speaker: Evan You (author/creator of Vite and Vue)
• Referenced sources/tools:
  • Vite (Vite ecosystem)
  • Vitest (“vest” in subtitles)
  • Oxc (toolchain)
  • Rolldown (bundler)
  • esbuild, Rollup, SWC, Babel
  • State of JS survey
  • Mentioned frameworks: Vue, Angular, React, Astro, SvelteKit, SolidStart, Remix (and others)