OXC: The Rust-Powered JavaScript Toolchain Nobody Talks About Enough

Let me give you a number that should make every frontend engineer pay attention: OXC's parser runs TypeScript in 26.3 milliseconds. SWC takes 84.1. Biome takes 130.1. On the same hardware.

That's not a small improvement. That's 3x faster than SWC and 5x faster than Biome. And the project isn't just a parser — it's an entire toolchain being rebuilt in Rust from the ground up, with a linter that's 50 to 100x faster than ESLint, a formatter that's 3x faster than Biome, and a resolver that's 28x faster than enhanced-resolve.

I've been watching this project for a while, and the thing that finally made me write about it is Rolldown. That's Vite's future bundler — the one that's supposed to replace Rollup and make your builds dramatically faster — and it's built on OXC. When a tool that matters that much is betting on this infrastructure, you pay attention.

What OXC Actually Is

OXC is an umbrella project. It started as the Oxidation Compiler — a play on Rust's "oxidization" metaphor for rewriting JavaScript tools in Rust — and it has grown into a collection of tools that cover the full JavaScript toolchain: parser, linter, formatter, transformer, resolver, and minifier.

The architecture is interesting because it's not trying to be one thing. Each component is a separate, focused tool that can be used independently. You can adopt Oxlint (the linter) without adopting anything else. You can use the parser in isolation. This matters because the JavaScript ecosystem doesn't migrate monolithically — it migrates one tool at a time.

The project is foundationally tied to VoidZero, a company that's building what it calls a unified, high-performance toolchain for JavaScript. Rolldown, Vitest, Vite — these are all part of the same vision. OXC is the common infrastructure layer underneath all of them.

The Linter Is the Story

Here's where OXC gets interesting for most teams: Oxlint.

ESLint is a tool every JavaScript developer uses and every JavaScript developer complains about. It's slow. It blocks your editor. Running a full lint pass on a large codebase can take minutes. And the community has spent years trying to make it faster — with flat configs, with incremental caching, with parallel execution — without fundamentally solving the problem.

Oxlint solves it by rewriting the engine in Rust. 50 to 100x faster. It maintains compatibility with ESLint's rule surface, so existing ESLint configurations work. It has 700+ rules and supports ESLint JS plugins, which means the migration path from ESLint isn't "rewrite all your rules." It's "swap the engine."

I've been running it on some of my own projects. The first time you run oxlint --help and it comes back instantly, and then you run it on a codebase that ESLint would have taken 30 seconds to process and it finishes in under a second, it recalibrates your expectations for what linting should feel like.

The real test is editor integration. When linting is fast enough that it doesn't block you, it changes how you work. You stop treating it as a pre-commit check and start running it continuously. The tool becomes part of your flow instead of an interruption to it.

The Formatter Numbers Are Almost Wrong

Oxfmt, the formatter, benchmarks at 30x faster than Prettier and 3x faster than Biome. I want to be precise here because these numbers come from OXC's own benchmarks, and I always want to see independent verification before I fully trust performance claims.

But even if the actual speed advantage is half of what they claim — even if Oxfmt is only 15x faster than Prettier — that's still a dramatic improvement that changes the calculus for CI pipelines and pre-commit hooks.

The formatter is Prettier-compatible, which means it understands the same configuration surface and produces output in the same style. This is the right compatibility bet. Prettier won the formatter wars. Nobody wants a third incompatible formatter standard. Oxfmt's strategic move is to be faster Prettier, not a new style system.

Why Rolldown Makes This Worth Watching

Vite's current bundler is Rollup. Rolldown is the Rust-native replacement, built on OXC's infrastructure, and it's positioned as the future of Vite's build pipeline.

The performance implications are significant. Rollup is written in JavaScript and has the performance characteristics you'd expect from a mature JavaScript tool. Rolldown, drawing on Rust-level performance from OXC's parser, transformer, and resolver, is designed to be an order of magnitude faster.

If you're using Vite today — and if you're doing React or Vue or Svelte development in 2026, you probably are — this matters. The bundler is often the bottleneck in your build. A dramatically faster bundler means faster dev servers, faster CI builds, and faster deploy pipelines.

The Rolldown work is still in active development, and I'll be watching the migration story carefully. Large codebases with complex build configurations don't migrate bundlers casually. But the architectural direction is clear, and the performance target is credible given what OXC has already demonstrated with its standalone tools.

The Ecosystem Bet

Here's what I find most interesting about OXC strategically: it's not trying to win by building a better standalone tool. It's trying to win by being the infrastructure layer that multiple important tools share.

Rolldown, Vitest, and Vite are all being unified under the VoidZero banner, all using OXC underneath. If that unification succeeds — if OXC becomes the shared infrastructure for the next generation of JavaScript tooling — then its adoption isn't dependent on teams choosing OXC directly. It's dependent on teams choosing any tool in that ecosystem.

This is the same play that made Babel dominant for years: not a single tool, but the shared infrastructure that other tools were built on top of. The difference is that Babel was JavaScript all the way down, and OXC is betting that Rust-level performance is worth the complexity of a multi-language toolchain.

The Honest Caveat

OXC is not finished. The minifier is labeled alpha. The formatter is in beta. Some of the more advanced transformations are still being developed. If you're evaluating this for production use, you need to check the component maturity for your specific use case.

The ecosystem is also still forming. Tooling transitions in JavaScript are painful — we've all migrated from TSLint to ESLint, from multiple config formats to flat configs — and OXC's migration story is incomplete. The tool compatibility is strong (Oxlint works with ESLint configs, Oxfmt is Prettier-compatible), but the operational migration — how you integrate it into CI, editor hooks, and pre-commit workflows — is something you'll be building as you go.

That said, the trajectory is clear. If the performance numbers hold, and if the toolchain matures, OXC is going to be the infrastructure that a lot of JavaScript tooling runs on in three years.

The question isn't whether this matters. It's whether you want to be early or on-time.

OXC: JavaScript Oxidation Compiler. Parser 3x faster than SWC, linter 50-100x faster than ESLint, resolver 28x faster than enhanced-resolve. Powers Rolldown (Vite's future bundler), Vitest, and the broader VoidZero unified toolchain. Alpha minifier, beta formatter, 700+ lint rules.