VoidZero: Rust Toolchain Unifies Vite, Vitest, Oxc and Rolldown in 2026

Hello HaWkers, Evan You, creator of Vue and Vite, announced VoidZero: a JavaScript toolchain completely in Rust that unifies build, test, lint and bundle. It's the definitive answer to the JavaScript ecosystem's "fragmentation tax".

The public preview is expected for early 2026. Let's understand what it is and why it matters.

The Fragmentation Problem

Why we need VoidZero.

JavaScript Tooling Today

Tools you need to configure:

For a typical project:
├── Bundler (Webpack/Vite/Rollup/esbuild)
├── Transpiler (Babel/SWC/TypeScript)
├── Linter (ESLint + plugins)
├── Formatter (Prettier)
├── Test Runner (Jest/Vitest/Mocha)
├── Type Checker (TypeScript)
└── Package Manager (npm/yarn/pnpm)

Problems with this fragmentation:

• Inconsistent configurations
• Incompatible versions
• Wasted performance
• Fragmented DX
• Costly maintenance

The Real Cost

Impact on productivity:

Aspect	Current Cost
Initial setup	2-4 hours
Conflict debugging	5-10h/month
Deps update	4-8h/quarter
Dev server cold start	5-30s
Production build	30s-5min

What Is VoidZero

The proposed solution.

Unified Components

What VoidZero includes:

1. Oxc (JavaScript Tooling):

• JavaScript/TypeScript parser
• Linter (replaces ESLint)
• Formatter (replaces Prettier)
• Transformer (replaces Babel/SWC)
• Experimental type checker

2. Rolldown (Bundler):

• Bundler in Rust
• Compatible with Rollup plugins
• Integrated with Vite
• Optimized code splitting

3. Vite (Dev Server):

• Ultra-fast dev server
• Instant HMR
• Maintained plugin ecosystem
• Framework agnostic

4. Vitest (Test Runner):

• Unit and integration tests
• Shares config with Vite
• Smart watch mode
• Integrated coverage

Unified Architecture

How everything connects:

VoidZero Unified Toolchain
├── Core (Rust)
│   ├── Parser (Oxc)
│   ├── Transformer (Oxc)
│   └── Bundler (Rolldown)
├── Dev Server (Vite)
├── Test Runner (Vitest)
├── Linter (Oxc Lint)
└── Formatter (Oxc Format)

Everything shares:
- AST (Abstract Syntax Tree)
- Cache
- Configuration
- Plugin system

Expected Performance

The promised numbers.

Preliminary Benchmarks

Comparison with current tooling:

Operation	Current	VoidZero	Improvement
Cold start	8s	0.3s	26x
HMR	200ms	15ms	13x
Lint (medium project)	12s	0.8s	15x
Production build	45s	3s	15x
Tests (500 specs)	30s	4s	7.5x

Why Rust?

The language choice:

Rust advantages:

• Performance close to C
• Memory safety
• Safe parallelism
• No garbage collector
• Compiles to native binary

Practical impact:

// Before: JavaScript tooling
// - Single-threaded by default
// - Garbage collection overhead
// - VM cold start

// After: Rust tooling
// - Native multi-threaded
// - Zero GC pause
// - Binary ready to execute

Oxc In Detail

VoidZero's heart.

Parser

Foundation for everything:

// Oxc parse: ~3x faster than acorn
// Complete support for:
// - ESNext
// - TypeScript
// - JSX/TSX
// - Decorators

Linter

ESLint replacement:

Advantages:

• 50-100x faster
• ESLint compatible rules
• Less configuration
• Smart suggestions

Usage example:

# ESLint
npx eslint src/ --fix
# Time: 12 seconds

# Oxc Lint
npx oxlint src/ --fix
# Time: 0.3 seconds

Formatter

Prettier replacement:

# Prettier
npx prettier --write src/
# Time: 8 seconds

# Oxc Format
npx oxc format src/
# Time: 0.2 seconds

Rolldown: The New Bundler

Replacing Rollup and esbuild.

Compatibility

What works:

// rolldown.config.js
// API compatible with Rollup
export default {
  input: 'src/main.js',
  output: {
    dir: 'dist',
    format: 'esm',
  },
  plugins: [
    // Most Rollup plugins work
    nodeResolve(),
    commonjs(),
    // Vite plugins too
  ],
};

Vite + Rolldown

Native integration:

// vite.config.js
export default {
  // In 2026, Rolldown is the default bundler
  build: {
    // rolldownOptions instead of rollupOptions
    rolldownOptions: {
      output: {
        manualChunks: {
          vendor: ['react', 'react-dom'],
        },
      },
    },
  },
};

Optimized Code Splitting

Smarter chunks:

// Rolldown better analyzes dependencies
// Result: smaller and more efficient bundles

// Before (Rollup/Webpack)
// vendor.js: 450KB
// main.js: 120KB

// After (Rolldown)
// vendor.js: 320KB (better tree-shaking)
// main.js: 95KB

Practical Migration

How to adopt VoidZero.

New Projects

Starting from scratch:

# Preview available in 2026
npm create voidzero@latest my-app

# Generated structure
my-app/
├── void.config.js    # Unified config
├── src/
│   └── main.ts
├── tests/
│   └── main.test.ts
└── package.json

Migration from Vite

For those already using Vite:

// vite.config.js → void.config.js
// Most config is compatible

export default {
  // Existing Vite config
  plugins: [vue()],

  // New VoidZero options
  toolchain: {
    linter: true,      // Activates Oxc Lint
    formatter: true,   // Activates Oxc Format
    typeCheck: true,   // Integrated type checking
  },
};

Gradual Migration

Adopting in parts:

Phase 1: Linter

# Replace ESLint with Oxc Lint
npm remove eslint eslint-plugin-*
npm install oxlint

Phase 2: Formatter

# Replace Prettier with Oxc Format
npm remove prettier
# Oxc format already included

Phase 3: Bundler

# When Rolldown is stable
# Update Vite to version with Rolldown
npm update vite@latest

Ecosystem Impact

What changes for the community.

Frameworks Adapting

How frameworks respond:

Vue:

• VoidZero creator is Vue creator
• Native integration guaranteed
• First-class support

React/Next.js:

• Vercel watching closely
• Turbopack competes directly
• Possible future integration

Svelte:

• SvelteKit already uses Vite
• Natural migration to VoidZero
• Rich Harris following

Angular:

• Experimental Vite builder
• Potential future adoption
• Depends on stability

Competition

Other approaches:

Tool	Language	Status
VoidZero	Rust	Preview 2026
Turbopack	Rust	Beta
Bun	Zig	Production
Farm	Rust	Early
Rspack	Rust	Beta

Unified Configuration

The end of fragmented configuration.

Before vs After

Configuration files:

Before (typical project):

├── vite.config.js
├── vitest.config.js
├── .eslintrc.js
├── .prettierrc
├── tsconfig.json
├── babel.config.js
└── jest.config.js

After (VoidZero):

├── void.config.js    # Everything unified
└── tsconfig.json     # Just types

Unified Config Example

One config for everything:

// void.config.js
import { defineConfig } from 'voidzero';
import vue from '@vitejs/plugin-vue';

export default defineConfig({
  // Framework
  plugins: [vue()],

  // Dev server
  server: {
    port: 3000,
    open: true,
  },

  // Build
  build: {
    target: 'es2022',
    minify: true,
    sourcemap: true,
  },

  // Linter
  lint: {
    rules: {
      'no-console': 'warn',
      'no-unused-vars': 'error',
    },
  },

  // Formatter
  format: {
    printWidth: 100,
    tabWidth: 2,
    singleQuote: true,
  },

  // Tests
  test: {
    include: ['tests/**/*.test.ts'],
    coverage: {
      provider: 'v8',
      reporter: ['text', 'html'],
    },
  },
});

Timeline and Adoption

When to use.

Expected Roadmap

Probable timeline:

Q1 2026:

• Public preview
• Early adopters testing
• Initial documentation

Q2 2026:

• Stable beta
• Main plugins ported
• Adoption in new projects

Q3-Q4 2026:

• Version 1.0
• Migration of existing projects
• Enterprise support

2027+:

• Mainstream adoption
• Mature ecosystem
• Other frameworks adopting

When To Migrate

Recommendations:

Migrate now if:

• New project
• Want maximum performance
• Accept early adopter risks
• Use Vue/Vite

Wait if:

• Critical production project
• Dependency on specific plugins
• Team not familiar with Vite
• Need guaranteed stability

Conclusion

VoidZero represents the JavaScript ecosystem's maturity. After years of fragmented tools, we finally have a unified vision - and implemented in Rust for maximum performance.

The "fragmentation tax" that cost hours of configuration and debugging will decrease significantly. One config, one toolchain, one consistent experience.

For Vue/Vite developers, the migration will be natural. For the rest of the ecosystem, it's worth watching closely - this could be the new JavaScript tooling baseline.

If you want to understand other JavaScript trends, check out our article on Signals in TC39 to see more important language changes.

Let's go! 🦅

💻 Master JavaScript for Real

The knowledge you gained in this article is just the beginning. Understanding modern tools requires a solid language foundation.

Invest in Your Future

I've prepared complete material for you to master JavaScript:

Payment options:

• 1x of $4.90 no interest
• or $4.90 at sight

📖 View Complete Content