Ishan Bagchi for Byte-Sized News

Posted on May 25

ESLint is Dead, Long Live Biome?

#webdev #javascript #devops #programming

In the world of JavaScript and TypeScript development, ESLint has long been the undisputed champion of linting. For over a decade, it has helped developers catch bugs, enforce style consistency, and ensure code quality across teams and open-source projects. But in 2025, a new contender is shaking the foundations of frontend tooling: Biome.

So, is ESLint really dead? And what makes Biome worthy of replacing it?

Let's dig in.

What is Biome?

Biome is an all-in-one toolkit for formatting, linting, and more. Developed by the same minds behind Rome (a now-discontinued full-stack JavaScript toolchain), Biome is laser-focused on performance, speed, and simplicity. It's written in Rust, making it blazing fast compared to its JavaScript-based counterparts.

Key Features of Biome:

Built-in Formatter (like Prettier)
Built-in Linter (like ESLint)
Zero Config Setup
Rust-powered speed
Typed lint rules with native TypeScript support
Single binary, zero dependencies

Why Are Devs Moving Away from ESLint?

While ESLint is powerful and deeply entrenched in modern JS tooling, it's also become complex and fragile:

Plugin Hell: ESLint setups often depend on a forest of plugins and shared configs. Conflicts are common, especially with newer frameworks or language features.
Performance: Written in JavaScript, ESLint can feel sluggish on large codebases.
Toolchain Overload: Many projects use ESLint for linting, Prettier for formatting, and TypeScript for type-checking — leading to redundant rules, duplicated effort, and slow CI pipelines.

How Biome Solves These Problems

Biome’s core philosophy is to reduce complexity and boost performance:

No more plugin juggling — Biome ships with sensible defaults.
The formatter and linter share a unified AST, avoiding conflicts.
It processes both JS and TS natively, without needing separate configs.
Being written in Rust, it's lightning-fast, even on large monorepos.

In-Depth Cool Features of Biome:

1. Autofix on Save by Default

Biome comes with powerful autofix capabilities that trigger automatically. No need to configure extra scripts — it just works.

2. Integrated Project Linting

Biome is aware of your project context — meaning it can lint based on workspace rules, project structure, and TS config with minimal setup.

3. High Parallelization

Thanks to Rust’s concurrency model, Biome can lint and format files in parallel with blazing speed, outperforming JS-based tools even on multicore systems.

4. JSON & TOML Support

Beyond JS and TS, Biome also supports linting and formatting for JSON and TOML files, making it a true monorepo-friendly tool.

5. Built-in CI Reporter

Biome offers built-in CI-friendly output formats and summary flags to cleanly integrate with your pipeline logs without third-party tooling.

6. No Need for Prettier

Biome’s built-in formatter provides deterministic formatting without needing to pair it with Prettier — eliminating a major point of friction.

7. Actionable, Fixable Suggestions

Biome doesn't just show you problems — it fixes them safely. Take this real-world example:

complexity/useFlatMap.js:2:1 lint/complexity/useFlatMap  FIXABLE

  ✖ The call chain .map().flat() can be replaced with a single .flatMap() call.

    1 │ const array = ["split", "the text", "into words"];
  > 2 │ array.map(sentence => sentence.split(' ')).flat();
      │ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    3 │

  ℹ Safe fix: Replace the chain with .flatMap().

    1  │ const array = ["split", "the text", "into words"];
    2  │ - array.map(sentence => sentence.split(' ')).flat();
       │ + array.flatMap(sentence => sentence.split(' '));
    3  │

This level of feedback, combined with inline fix previews, makes Biome feel less like a linter and more like a coding assistant.

Biome vs ESLint + Prettier

Feature	ESLint + Prettier	Biome
Setup Time	Moderate to High	Very Low
Config Complexity	High	Low
Performance	Moderate	High (Rust)
Plugin Dependency	High	None / Built-in
Formatting Support	Separate tool (Prettier)	Built-in
TS Integration	Indirect (via parser)	Native
JSON/TOML Support	Limited	Built-in
Fix Suggestions	Varies	Safe, Built-in, Inline

Is It Ready for Production?

As of mid-2025, Biome is stable and production-ready for many use cases. Major projects are adopting it — especially those that value fast CI pipelines and simple developer onboarding. However, there are still some caveats:

ESLint still offers more mature plugin ecosystems, especially for niche frameworks.
If your team has heavy custom rule requirements, Biome might still be catching up.
Migrating an existing ESLint setup may take some tweaking.

Should You Switch?

Here’s a quick decision guide:

Use Biome If...	Stick with ESLint If...
You're starting a new project	You rely on advanced, custom lint rules
You want a fast, single-tool setup	You need specific ESLint plugins
Your team prefers convention over config	You have deeply integrated ESLint workflows
You’re working with JSON/TOML formats	You rely heavily on ESLint plugin ecosystem
You want smart autofixes and reports	Your team has invested heavily in ESLint

Final Thoughts

Biome represents the next wave of frontend tooling — fast, unified, and zero-config. While ESLint isn’t dead (yet), it’s no longer the only serious player in the game. If Biome’s growth continues and its ecosystem expands, it could very well become the new standard in JavaScript linting.

So, is ESLint dead?

Not quite.

But the future? It might just be Biome.

Have you tried Biome yet? Share your experience with the community — or tell us why you're still team ESLint.

DEV Community