Oxlint vs Biome vs ESLint in 2026: The Rust Linter Showdown

For a decade, linting a JavaScript project meant ESLint, Prettier, and a small mountain of plugins that took 30 seconds to chew through a mid-size repo. In 2026 that assumption is finally breaking. Two Rust-based challengers, Oxlint and Biome, now run linting and formatting jobs an order of magnitude faster, and they have real production adopters to back the claims. If you're choosing tooling for a new project or wondering whether to migrate, the Oxlint vs Biome vs ESLint decision is one of the more consequential calls you'll make this year.

Here's the honest breakdown of where each tool stands, what the speed numbers actually mean, and which one fits your project.

The Speed Story Is Real (and It Matters)

The core pitch for both Rust tools is native-code speed, and the evidence is concrete.

When Oxlint hit 1.0 stable in June 2025 (per VoidZero's announcement), it shipped with documented adopter results that are hard to dismiss:

• Airbnb runs multi-file analysis across 126,000+ files that completes in about 7 seconds on CI.
• Mercedes-Benz reported a 71% drop in lint time after swapping ESLint for Oxlint.
• Shopify's front-end platform team uses Oxlint in the Shopify admin console.

VoidZero positions Oxlint as roughly 50-100x faster than ESLint. Biome, also written in Rust, is in the same league: community benchmarks cited by Better Stack and others put it at 10-25x faster than ESLint on large TypeScript codebases, with a 500-file project linting in 2-3 seconds versus 30+ for ESLint.

The practical effect isn't bragging rights. Faster linters mean you can run them on every save, on every commit hook, and on CI without anyone groaning about pipeline time. That changes how often the tool actually runs.

Meet the Three Contenders

ESLint: the incumbent with the deepest ecosystem

ESLint isn't going anywhere. As of 2026 it's on the ESLint 10 line (10.4.0 was current as of May 2026 per PkgPulse), and version 10, released February 2026, finally removed the legacy .eslintrc format, making flat config the standard. Its superpower remains the plugin ecosystem: framework-specific rules for Next.js, React, Vue, and Svelte, plus the strongest type-aware linting via typescript-eslint. If your project leans on react-hooks rules or deep type-aware checks, ESLint still has no full replacement.

Biome: the all-in-one formatter + linter

Biome's bet is consolidation. It replaces both Prettier and ESLint with a single tool and a single biome.json config, killing the .eslintrc / .prettierrc / ignore-file sprawl. Biome 2.0 landed in March 2025; the line is up to 2.4.x in 2026 (2.4.15 observed in May), and v2.x introduced type-aware linting plus 400+ lint rules. It also handles import organization out of the box. For teams that want one binary to format and lint, Biome is the most complete single answer.

Oxlint: the fastest, narrowest blade

Oxlint comes from VoidZero, the company founded by Vue and Vite creator Evan You, as part of the broader Oxc (JavaScript Oxidation Compiler) toolchain. It's a linter only (no formatting), but it's the fastest of the three and ships 500+ rules ported from ESLint core and popular plugins like eslint-plugin-unicorn, eslint-plugin-jsdoc, and eslint-plugin-react, with zero config to start. The 1.0 release was the work of 200+ contributors and it now has a dedicated full-time maintainer. Current line is 1.65.x as of May 2026 per PkgPulse.

Capability Comparison

Here's where the real trade-offs live:

• Formatting: Biome yes; Oxlint no; ESLint no (you pair it with Prettier).
• Type-aware TS rules: ESLint strong; Biome limited; Oxlint limited.
• Framework rules (Next.js, Vue, Svelte): ESLint strong; Biome built-in only; Oxlint limited.
• Plugin ecosystem: ESLint largest by far; Biome and Oxlint have none in the traditional sense.
• Raw speed: Oxlint fastest; Biome very fast; ESLint slowest on cold runs.
• Config files: Biome one file; Oxlint near-zero; ESLint flat config (one file in v9+).

The pattern is clear. ESLint trades speed for depth and ecosystem. Oxlint trades breadth for raw velocity. Biome sits in the middle as the consolidation play.

So Which One Should You Use?

New greenfield projects

Reach for Biome from day one. You get formatting and linting in a single fast tool with one config file. For React projects, add a minimal ESLint config purely for react-hooks, which remains the one rule set the Rust tools don't fully cover. This is the lowest-friction modern setup, and it pairs well with the best AI coding tools in 2026.

Large existing codebases with CI pain

The pragmatic 2026 pattern is a two-pass strategy: run Oxlint first for near-instant failures on the rules it covers, then run ESLint for the ecosystem-specific and type-aware rules Oxlint doesn't have. This is exactly how big shops like Shopify and Airbnb are adopting Oxlint without ripping out ESLint overnight. You get most of the speed win on most of your runs while keeping deep coverage.

Teams deeply invested in ESLint plugins

Stay on ESLint, but upgrade to flat config and add Oxlint as a fast pre-filter. You don't have to choose a single winner. Layering Oxlint in front of ESLint is a low-risk way to cut CI time today.

A Realistic Migration Path

If you want to modernize without a big-bang rewrite:

1. Benchmark on your own repo first. Speed claims vary; the only number that matters is yours.
2. Add Oxlint as a separate, fast CI step that runs before your existing lint job. Measure the time saved.
3. Trial Biome for formatting on a branch to see if it can replace Prettier cleanly for your style.
4. Keep ESLint for the rules that have no equivalent, especially react-hooks, Next.js, and type-aware checks.
5. Pin versions and upgrade intentionally. The Rust tools ship fast; ESLint 10 dropped legacy config, so coordinate the jump.

The Takeaway

The Oxlint vs Biome vs ESLint question no longer has a single answer, and that's a good thing. Oxlint gives you the fastest possible lint pass with serious enterprise validation from Airbnb, Mercedes-Benz, and Shopify. Biome gives you a unified, fast formatter-plus-linter for greenfield work. ESLint keeps the deepest ecosystem and the strongest type-aware rules. The smartest teams in 2026 aren't picking one and burning the others; they're layering Rust speed in front of ESLint's depth. Benchmark on your own code, adopt incrementally, and let CI time tell you which combination earns its place.