ESLint vs Biome in 2026: Is the Linter Landscape Changing?

Biome lints 10,000 files in 0.8 seconds. ESLint takes 45 seconds. That's not a typo — it's a 56x performance difference.

ESLint still dominates with 79.3 million weekly downloads. Biome has 2 million. But Biome's growth rate tells a different story: it surpassed 15 million monthly downloads in 2025 and shows no signs of slowing. Meanwhile, ESLint v10 just shipped in February 2026 — the most significant release in years.

We compared both tools using real data from PkgPulse. Here's what the numbers say.

At a Glance: The Numbers

| Metric | ESLint | Biome | |--------|--------|-------| | Weekly Downloads | 79.3M | 2.0M | | GitHub Stars | 25K+ | 16K+ | | Performance (10K files) | ~45 seconds | ~0.8 seconds | | Language | JavaScript (Node.js) | Rust (native binary) | | Built-in Formatter | No (needs Prettier) | Yes (97% Prettier-compatible) | | Lint Rules | 300+ (core) + thousands via plugins | 423+ | | Config Files Needed | 2-4 (ESLint + Prettier + configs) | 1 (biome.json) | | npm Dependencies | 127+ packages (with Prettier) | 0 (single binary) | | Current Version | 10.x | 2.x | | License | MIT | MIT |

See the full live comparison — download trends and health scores — at pkgpulse.com/compare/eslint-vs-@biomejs/biome

The headline stat: ESLint started 2025 with 42.7M weekly downloads and ended with 70.7M — a 65% increase. It's still growing. But Biome is growing faster in percentage terms, and for a specific reason: developers are tired of configuring four tools when one will do.

Performance: Rust vs Node.js

The performance difference isn't incremental. It's a different order of magnitude.

| Operation | ESLint + Prettier | Biome | |-----------|------------------|-------| | Lint 10K files | 45.2s | 0.8s | | Format 10K files | 12.1s (Prettier) | 0.3s | | Lint 500-file project | 30s+ | 2-3s | | 10K-line monorepo | 3-5s | ~200ms |

Biome is written in Rust and compiled to a native binary. ESLint runs in Node.js and processes files through a JavaScript AST parser. The performance gap is inherent to the architecture.

For small projects, this difference is academic — a few seconds either way. For monorepos with thousands of files, it transforms the development experience. CI pipelines run faster. Pre-commit hooks stop being a bottleneck. Editor feedback becomes near-instant.

The practical impact: at Biome speeds, linting stops being something you wait for. That changes how often you run it — which changes code quality.

Configuration: Four Tools vs One

The classic JavaScript linting setup requires multiple tools:

ESLint + Prettier Stack

eslint.config.js       # Linting rules
.prettierrc            # Formatting rules
.prettierignore        # Formatting ignore patterns
eslint-config-prettier # Disable ESLint rules that conflict with Prettier
eslint-plugin-prettier # Run Prettier as an ESLint rule (optional)

That's 2-4 config files, 127+ npm packages in your dependency tree, and a configuration surface that's caused countless team debates. The ESLint-Prettier integration alone has multiple approaches, each with trade-offs.

Biome

{
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "complexity": { "noForEach": "warn" }
    }
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2
  }
}

One file. One tool. One binary. No plugin conflicts, no config compatibility issues, no "which Prettier integration do we use?" debates.

The trade-off: Biome's configuration is simpler because it offers fewer options. ESLint's complexity exists because it's more configurable. For teams that need custom lint rules or niche plugin support, ESLint's extensibility is a feature, not a bug.

Rule Coverage and Ecosystem

ESLint: The Plugin Ecosystem

ESLint's core ships roughly 300 rules. But the real power is the plugin ecosystem:

eslint-plugin-react — React-specific rules
eslint-plugin-import — import/export validation
@typescript-eslint — TypeScript support (essential)
eslint-plugin-jsx-a11y — accessibility linting
eslint-plugin-testing-library — test pattern enforcement
Thousands more — for Vue, Angular, GraphQL, Tailwind, etc.

ESLint v10 (released February 2026) brings significant improvements: better performance, improved flat config support, and the new language plugins API that enables first-class support for non-JavaScript languages.

Biome: Growing Fast

Biome v2.x ships 423+ lint rules, including many equivalents to popular ESLint plugins. Rule coverage in 2026:

| Category | Biome Coverage | |----------|---------------| | ESLint core rules | ~90% equivalent | | TypeScript rules | Strong (built-in, no plugin needed) | | React/JSX rules | Good coverage | | Import organization | Built-in | | Accessibility (a11y) | Partial | | Vue/Angular | Not yet |

Biome also added type-aware linting — rules that understand your TypeScript types, not just syntax. This was previously only possible with @typescript-eslint's type-checked rules, which are notoriously slow because they invoke the TypeScript compiler.

The gap: Biome covers roughly 80% of what most JavaScript/TypeScript projects need. The remaining 20% — framework-specific plugins, niche rules, custom rule authoring — is where ESLint still has no competition.

Migration: The Practical Path

New Projects

For new projects in 2026, Biome is the path of least resistance. One install, one config file, instant linting and formatting. No ecosystem decisions to make.

npx @biomejs/biome init

Done. You're linting and formatting.

Existing Projects

For existing ESLint projects, migration depends on your plugin usage:

Easy migration (1-2 hours):

Using ESLint core rules + Prettier only
Standard TypeScript setup with @typescript-eslint
React projects with basic plugin-react rules

Moderate migration (1 day):

Custom ESLint rules you've written
Heavy import-order configuration
Framework-specific plugins (React, but common rules)

Hard or not yet possible:

Vue or Angular plugin rules — Biome doesn't support these yet
Custom ESLint plugins your team maintains
Niche plugins with no Biome equivalent

Biome provides a migration command that maps ESLint rules to their equivalents:

npx @biomejs/biome migrate eslint

It handles most standard configurations automatically.

CI and Editor Integration

Both tools have strong editor support. ESLint's VS Code extension is ubiquitous. Biome's VS Code extension is polished and fast — format-on-save with Biome is noticeably snappier than Prettier.

In CI pipelines, the performance difference compounds. A monorepo running ESLint + Prettier might spend 2-3 minutes on linting. Biome can do the same job in under 10 seconds. Over thousands of CI runs per month, that's real time and cost savings.

When to Choose ESLint

You need framework-specific plugins — Vue, Angular, Svelte, or niche ecosystem rules
You maintain custom ESLint rules — Biome's rule authoring API is newer and less mature
Your team has an established ESLint config — migration costs may outweigh Biome's benefits
You need maximum rule coverage — ESLint + plugins still covers more edge cases
You use ESLint v10 — the latest release is the most capable ESLint has ever been

When to Choose Biome

Starting a new JavaScript/TypeScript project — zero configuration friction
Performance matters — monorepos, large codebases, or slow CI pipelines
You want one tool instead of ESLint + Prettier + configs
You're tired of config complexity — one file, one tool, fewer debates
You're on React + TypeScript — Biome's coverage is excellent for this stack

The Verdict

ESLint isn't dying — 79M weekly downloads and a fresh v10 release prove that. It remains the most extensible, most compatible linting tool in the JavaScript ecosystem.

But Biome is changing what developers expect from their tooling. The combination of 25x performance, built-in formatting, and zero-config setup is compelling. For React/TypeScript projects, Biome is already feature-complete enough to replace ESLint + Prettier entirely.

The linter landscape is changing. It's just changing gradually — one new project at a time.

Compare ESLint vs Biome on PkgPulse →

Frequently Asked Questions

Can Biome replace ESLint and Prettier?

For most JavaScript and TypeScript projects, yes. Biome handles both linting (423+ rules) and formatting (97% Prettier-compatible) in a single tool. The main gaps are framework-specific rules for Vue and Angular, and niche ESLint plugins. For React + TypeScript projects, Biome is a full replacement. See the live comparison on PkgPulse for current data.

How much faster is Biome than ESLint?

Biome is 10-56x faster depending on the operation. Linting 10,000 files takes ~0.8 seconds with Biome vs ~45 seconds with ESLint. Formatting 10,000 files takes ~0.3 seconds vs ~12 seconds with Prettier. The difference comes from Biome being a compiled Rust binary vs ESLint running in Node.js.

Should I migrate from ESLint to Biome?

It depends on your project. If you're on React + TypeScript with standard rules, migration is straightforward — run npx @biomejs/biome migrate eslint and verify. If you rely on framework-specific plugins (Vue, Angular) or custom rules, stay on ESLint until Biome adds support. For new projects, Biome is the simpler starting point.

Explore more comparisons: Prettier vs Biome, ESLint vs dprint, or Vitest vs Jest on PkgPulse.

Stay Updated