GitHub

Modern Build Tools

The VoidZero Toolchain: Vite + Rolldown + Oxc

The most significant shift in JavaScript tooling in 2026 is the consolidation of Vite, Rolldown, and Oxc into an end-to-end, performance-first toolchain under the VoidZero umbrella. Vite 8, released on March 12, 2026, marks the most important architectural change since Vite 2: it ships with Rolldown as its single, unified, Rust-based bundler — replacing the prior dual-bundler approach of esbuild (for dev) and Rollup (for production). This eliminates years of glue code, edge cases from inconsistent module handling between two pipelines, and separate plugin systems. The result: 10–30× faster builds than Rollup while maintaining full plugin compatibility. Vite now downloads 65 million times per week and was ranked the most popular tool in the 2025 State of JavaScript survey.

Rolldown, currently at RC status, was designed with three goals: native Rust performance matching esbuild, full compatibility with Rollup’s plugin API, and advanced features previously impossible — including full bundle mode for dev (3× faster dev server startup, 40% faster full reloads, 10× fewer network requests in preliminary benchmarks), more flexible chunk splitting, module-level persistent cache, and Module Federation support. For library authors, the companion tool tsdown provides Rolldown-powered library bundling.

Under the hood, both Vite and Rolldown rely on Oxc (the JavaScript Oxidation Compiler) for parsing, transforming, resolving, and minifying. This deep integration means the build tool, bundler, and compiler are all maintained by closely collaborating teams — a first for the JavaScript ecosystem. Vite 8’s @vitejs/plugin-react v5.0+ now uses Oxc’s React refresh transform by default, and internal Vite plugins (alias, resolve) have been converted to Rust. Vite 7 introduced baseline-widely-available as the default browser target, aligning with Web Platform Baseline — a shift from the earlier modules target.

Resources:

Oxc: Oxlint, Oxfmt, and the Rust Compiler Stack

Oxc is a collection of high-performance JavaScript/TypeScript tools written in Rust that powers the entire VoidZero stack. Its components can be used independently or together: a parser (the fastest JS/TS parser in Rust), a transformer (Babel-compatible for JSX, TypeScript, and modern JS downleveling), a minifier (Terser-compatible, still in beta), a resolver (webpack enhanced-resolve compatible), and two flagship developer-facing tools — Oxlint and Oxfmt.

Oxlint is 50–100× faster than ESLint in benchmarks, with 695+ rules implemented natively in Rust across 15 categories (including coverage of ESLint core, TypeScript-ESLint, React, Import, JSDoc, and more). As of March 2026, Oxlint has reached a major milestone with its JS Plugins Alpha release — an ESLint-compatible plugin API that lets teams run existing ESLint plugins within Oxlint without rewriting rules. This means most projects can now use Oxlint as a drop-in ESLint replacement. Critically, Oxlint leverages tsgo (TypeScript 7’s native Go-based compiler) for type-aware linting, providing full TypeScript type system compatibility for rules that require type information — and it’s 8–12× faster than typescript-eslint. Migration from ESLint is streamlined via @oxlint/migrate, which auto-generates .oxlintrc.json from existing ESLint flat configs.

Oxfmt is a Prettier-compatible code formatter that is 30× faster than Prettier and 3× faster than Biome. The February 2026 beta now passes 100% of Prettier’s JavaScript and TypeScript conformance tests. It formats JS, JSX, TS, TSX, JSON, YAML, TOML, HTML, Vue, CSS, SCSS, Markdown, MDX, GraphQL, and more — a single formatter for your entire project. Built-in features include import sorting, automatic Tailwind CSS class sorting (replacing prettier-plugin-tailwindcss), and package.json field sorting. Migration from Prettier is a single command: oxfmt --migrate prettier. Major projects already using Oxfmt include Vue.js core, Vercel Turborepo, Sentry JavaScript, and Hugging Face JS.

Resources:

TypeScript Go (tsgo): 10× Faster Type Checking

Microsoft’s TypeScript 7, codenamed “Project Corsa,” is a ground-up port of the TypeScript compiler and language service from TypeScript (running on Node.js) to Go — a natively compiled language. Announced in March 2025 by Anders Hejlsberg, the native implementation delivers ~10× faster builds across real-world projects through native code performance and shared-memory parallelism. The VS Code codebase (1.5 million lines) compiles in 8.74 seconds with tsgo versus 89 seconds with tsc — a 10.2× speedup. TypeScript became GitHub’s #1 language in August 2025, making this the right time to solve its biggest complaint: slow compilation at scale.

As of the December 2025 progress update, TypeScript 7’s type-checking is “very nearly complete” — out of ~20,000 compiler test cases, only 74 produce different results, all from known incomplete work or intentional changes. The tsgo CLI supports --build mode (project references), --incremental compilation, and parallel multi-project builds. Microsoft is targeting early 2026 for the release of both TypeScript 6.0 (a “bridge” release with deprecations to align with 7.0) and TypeScript 7.0 stable. Remaining gaps include incomplete JavaScript emit for older targets (currently only down to ES2021), no decorator compilation support yet, and a new Corsa API that replaces the existing Strada API (meaning tools that programmatically consume the TypeScript API will need to update).

The practical impact for build performance is enormous: install @typescript/native-preview today and use tsgo --noEmit for type-checking in CI while keeping tsc for emit. Oxlint already integrates with tsgo for type-aware linting. The combination of tsgo for type-checking + Oxc for transformation + Rolldown for bundling + Vite for orchestration represents a fully native-speed toolchain that dramatically reduces developer feedback loops.

Resources:

Rspack: The Webpack-Compatible Fast Lane

For teams with extensive webpack configurations who aren’t ready to migrate to Vite, Rspack provides a high-performance escape hatch. Built by ByteDance in Rust, Rspack v1.0 (October 2024) is production-ready and designed as a near-drop-in webpack replacement — 23× faster than webpack 5 + Babel in benchmarks, with ~85% webpack plugin compatibility and full loader compatibility (babel-loader, css-loader, ts-loader all work unchanged). ByteDance’s internal migrations achieved 5–10× build time improvements.

Rspack follows webpack’s architecture and configuration schema, making migration typically a 1–2 day effort: swap webpack for @rspack/core, update your imports, and most configs work with minimal changes. The project has also launched next-rspack, bringing Rspack support to Next.js as a community-driven alternative for teams not ready to adopt Turbopack. As of early 2026, next-rspack passes ~96% of Next.js integration tests. Rspack 1.3 introduced experimental persistent caching, circular dependency detection in Rust, faster code splitting, and improved memory usage. The companion Rsdoctor 1.0 provides build analysis with Rust-powered data processing.

Resources:

Turbopack: Next.js’s Default Bundler

Turbopack, Vercel’s Rust-based bundler, became the default bundler for all Next.js applications starting with Next.js 16 (October 2025). Unlike Rspack’s webpack-compatibility approach, Turbopack is a ground-up architectural redesign built around a “Turbo Engine” — a memoization and incremental computation system where every function call result is cached. This makes it exceptionally fast for incremental rebuilds in large projects, though it requires its own configuration model rather than reusing webpack configs.

Since Next.js 16.1 (December 2025), Turbopack handles production builds by default with stable File System Caching. It produces slightly smaller bundles than webpack thanks to improved tree-shaking. The trade-off is clear: Turbopack is deeply optimized for Next.js and provides the best possible experience within that ecosystem, but it’s not designed as a general-purpose bundler and lacks Rspack’s webpack plugin compatibility. Teams heavily invested in the webpack plugin ecosystem should consider Rspack; teams building with Next.js can benefit from Turbopack with zero configuration.

Resources:

Choosing the Right Build Tool

The build tool landscape in 2026 has consolidated around clear use cases:

Vite 8 + Rolldown is the default recommendation for new projects and the widest range of frameworks (React, Vue, Svelte, Solid, Astro, SvelteKit, React Router, Storybook). It offers the best balance of performance, ecosystem breadth, and developer experience. The Vite + Rolldown + Oxc stack provides a fully integrated, Rust-powered pipeline from source to production.

Rspack is the pragmatic choice for large existing webpack codebases (enterprise apps, monorepos, legacy projects) where a full migration to Vite is impractical. Its near-drop-in webpack compatibility and 5–23× speedup make it the lowest-effort performance win.

Turbopack is the best choice for Next.js applications, as it’s the default bundler with deep framework integration and the most optimized incremental rebuild performance.

For the linting/formatting layer, the recommended 2026 stack is Oxlint (replacing ESLint) + Oxfmt (replacing Prettier) — both integrate naturally with the Vite/Rolldown/Oxc pipeline and provide order-of-magnitude speed improvements that transform CI times and developer feedback loops. Biome remains a solid alternative that combines linting and formatting in a single Rust-based tool with its own rule set.

For type-checking, tsgo (@typescript/native-preview) provides 10× faster builds and can run alongside tsc during the transition period. Node.js 22.18+ also supports native TypeScript execution (type stripping) without any build step for development.

Resources: