The Unified Toolchain Vision

The Problem

JavaScript tooling in 2024 was fragmented:

Parsing:      Babel, SWC, TypeScript compiler
Linting:      ESLint (slow, JS-based)
Bundling:     Webpack, Rollup (slow), esbuild (fast but limited)
Testing:      Jest (slow transforms), Vitest (Vite-native)
Minification: Terser (slow), esbuild (fast but less optimal)
Formatting:   Prettier (slow)

Each tool parses your code independently. A typical CI pipeline parses every file 4-6 times: once for TypeScript, once for ESLint, once for the bundler, once for tests, once for minification. Each tool has its own AST format, its own config, its own plugin system.

VoidZero’s Answer

Build one set of core primitives in Rust, share them across all tools:

Shared Core (Rust):
  oxc_parser     - Parse JS/TS/JSX once, reuse everywhere
  oxc_ast        - Single AST format
  oxc_semantic   - Scope analysis, symbol resolution
  oxc_transformer - JSX, TS, syntax lowering
  oxc_minifier   - Dead code elimination, mangling
  oxc_codegen    - AST back to source code
  oxfmt          - Code formatter (approaching Prettier compatibility)

Built on top:
  oxlint     = oxc_parser + oxc_semantic + rule engine
  rolldown   = oxc_parser + oxc_transformer + chunk splitting + tree shaking
  vite       = rolldown (build) + dev server + HMR + plugin system
  vitest     = vite (transforms) + test runner + assertion library

The key insight: if one Rust parser handles all the parsing, and one bundler handles all the bundling, you eliminate redundant work across your entire toolchain.

How They Connect Today (March 2026)

The major integration milestones are done. Vite 8.0.0 shipped on March 12, 2026, completing the Rolldown and Oxc transitions:

What This Means for You

Today:

• Vite 8 ships with Rolldown as the default bundler for both dev and production
• Oxc handles transforms in Vite’s dev server via oxcPlugin, replacing esbuild
• Vitest and Vite remain tightly coupled (same config, same plugin system)
• Oxlint is standalone (runs independently, complements ESLint, 725+ rules)

Soon:

• Environment API maturation (multi-environment dev and build workflows)
• Full bundle dev mode stabilization (experimental in Vite 8)
• tsdown approaching stability as a Rolldown-based tsup replacement
• Your markdown-task-planner (electron-vite) gets Vite 8 upgrades for free

Eventually:

• One vite.config.ts controls parsing, linting, bundling, testing, minification
• Linting integrated directly into the Vite pipeline (no separate oxlint pass)
• The entire pipeline shares a single parse of your source code

The Rust Factor

All four tools are either written in Rust or built on Rust foundations:

This means:

• Contributing to Oxc or Rolldown internals requires Rust
• Contributing to Vite or Vitest requires TypeScript
• Contributing to Rolldown’s plugin system or CLI can be TypeScript
• You write both Rust and TypeScript, so you can contribute anywhere

Why Not Just Use One Big Tool?

Tools like Bun try to be everything in one binary. VoidZero’s approach is different:

• Modularity - Each tool works standalone. You can use oxlint without Vite, or Vitest without Rolldown.
• Compatibility - Vite has the Rollup plugin API. Oxlint implements ESLint rules. Vitest is Jest-compatible. You can migrate incrementally.
• Specialization - Each tool focuses on doing one thing well, while sharing infrastructure underneath.

The bet is that shared infrastructure (Oxc’s parser) gives you the speed of a monolithic tool, while the modular design gives you the flexibility of separate tools.