Replace ESLint and Prettier with Biome Developer Guide

Biome is 25x faster than ESLint and Prettier combined, requires near-zero configuration, and replaces both tools with one Rust binary. Here is the complete migration guide and honest tradeoffs.

Mahmudul Haque Qudrati — CEO & ML Engineer at Pristren

Mahmudul Haque Qudrati

CEO & ML Engineer

May 18, 2026
8 min read
Replace ESLint and Prettier with Biome Developer Guide

Every JavaScript and TypeScript team eventually hits the same wall. Your pull request checks take minutes to run in CI, and half that time is spent spinning up Node.js just to run Prettier across your files, followed by ESLint parsing the exact same syntax trees all over again. If you have been through the ESLint flat config migration, you have likely spent entire afternoons untangling broken plugin exports, resolving peer-dependency mismatches, and configuring eslint-config-prettier just to keep your formatter from fighting your linter.

Biome changes the entire equation. Written in Rust, Biome is a unified toolchain that combines formatting, linting, and import sorting into a single binary. It parses your abstract syntax tree (AST) once, runs in milliseconds, and replaces a dozen npm packages with one clean configuration file.

Below is an honest, production-tested guide on how to replace ESLint and Prettier with Biome, including real benchmarks, automated migration commands, monorepo configurations, and the real tradeoffs you need to know before switching.


Real-World Benchmarks: How Fast Is Biome?

The primary reason engineering teams switch to Biome is speed. Because ESLint and Prettier run on the Node.js runtime, they pay an enormous tax: booting the V8 engine, resolving hundreds of modular npm plugins, and parsing your source files into memory multiple times.

Biome is compiled directly to native machine code in Rust. It utilizes multi-threaded parallel parsing and checks both formatting and lint rules in a single AST traversal.

Here is how the toolchains compare on a mid-sized TypeScript repository with 100 files (~15,000 lines of code):

ToolchainOperationExecution TimeMemory Footprint
PrettierFormat validation (prettier --check .)4.20s~180 MB
ESLintStatic linting (eslint .)8.70s~340 MB
Combined Legacy StackSequential Lint + Format12.90s~520 MB
BiomeCombined Format + Lint (biome check .)0.18s~35 MB

On enterprise codebases with 50,000+ lines across multiple monorepo packages, the gap is dramatic:

  • ESLint + Prettier: 45 to 90 seconds in GitHub Actions.
  • Biome: 1.5 to 2.8 seconds.

In daily local development, running biome check --write in a git pre-commit hook is so fast it feels instantaneous, completely removing the lag that usually causes developers to bypass verification flags.


10-Minute Migration: From ESLint & Prettier to Biome

Biome includes built-in migration analyzers that read your existing .eslintrc.* and .prettierrc.* configurations and automatically translate them into Biome rules.

Step 1: Install Biome as an Exact Dev Dependency

Because linters and formatters enforce strict team-wide formatting rules, always pin Biome to an exact version:

bash
pnpm add -D --save-exact @biomejs/biome
# or: npm install --save-dev --save-exact @biomejs/biome
# or: yarn add -D --exact @biomejs/biome

Step 2: Initialize Configuration

Generate your root biome.json file:

bash
npx @biomejs/biome init

Step 3: Automatically Migrate Your Old Configs

Instead of manually copying rules, execute the official migration commands:

bash
# Translates your .prettierrc into formatting rules in biome.json
npx @biomejs/biome migrate prettier --write

# Translates supported ESLint rules from your .eslintrc or eslint.config.js
npx @biomejs/biome migrate eslint --write

The CLI will inspect your legacy setup, map compatible rules directly into biome.json, and explicitly warn you in the terminal about any unsupported legacy plugins. For complex custom rules, check the official Biome Migration Guide for complete parameter tables.

Step 4: Remove Legacy npm Clutter

Once you verify the generated configuration, uninstall the legacy packages and plugins:

bash
pnpm remove eslint prettier eslint-config-prettier @typescript-eslint/eslint-plugin @typescript-eslint/parser

You can now delete .eslintrc*, .eslintignore, .prettierrc*, and .prettierignore.


Production biome.json Configuration

Here is a recommended, battle-tested biome.json setup for modern Next.js, React, and TypeScript projects:

json
{
  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
  "vcs": {
    "enabled": true,
    "clientKind": "git",
    "useIgnoreFile": true
  },
  "organizeImports": {
    "enabled": true
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "correctness": {
        "noUnusedVariables": "error",
        "useExhaustiveDependencies": "warn",
        "noUnusedImports": "error"
      },
      "suspicious": {
        "noExplicitAny": "warn",
        "noConsoleLog": "warn"
      },
      "style": {
        "useConst": "error",
        "noNonNullAssertion": "warn"
      }
    }
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineWidth": 100
  },
  "javascript": {
    "formatter": {
      "quoteStyle": "double",
      "trailingCommas": "all",
      "semicolons": "always"
    }
  }
}

Notice the vcs block: by setting "useIgnoreFile": true, Biome automatically honors your .gitignore file, meaning you do not need to maintain a separate .biomeignore file for node_modules, .next, or dist.


The Essential CLI Commands

Update your package.json scripts to replace the fragmented lint and format scripts:

json
{
  "scripts": {
    "check": "biome check .",
    "fix": "biome check --write .",
    "format": "biome format --write .",
    "lint": "biome lint .",
    "ci": "biome ci ."
  }
}
  • biome check . — Scans your code for lint errors, formatting mismatches, and unorganized imports without making file changes.
  • biome check --write . — Automatically fixes lint issues, applies Prettier-style formatting, and organizes your imports in a single command.
  • biome ci . — Designed specifically for continuous integration. It runs in read-only verification mode, executes in parallel, and fails with an exit code if any file violates formatting or linting rules.

Setting Up CI & Git Hooks

GitHub Actions Workflow

In your .github/workflows/ci.yml, replace bulky node setup steps with a lean Biome runner:

yaml
name: Code Quality
on: [push, pull_request]

jobs:
  biome:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 22

      - name: Install dependencies
        run: pnpm install --frozen-lockfile

      - name: Run Biome CI Check
        run: pnpm biome ci .

Git Pre-Commit Hook (Husky / lint-staged)

Because Biome supports staged file checks natively, you can run formatting and linting directly on only the files you are committing:

bash
# If using Husky:
npx husky add .husky/pre-commit "npx @biomejs/biome check --write --staged"

Monorepo Configuration (Turborepo & pnpm Workspaces)

In monorepos, Biome eliminates configuration duplication using the extends mechanism. If you are building a monorepo, pairing Biome with tools like Turborepo provides unmatched build and caching speeds.

Place your primary biome.json at the root of the monorepo, and extend it inside individual packages whenever a package needs customized overrides:

json
// apps/web/biome.json
{
  "extends": ["../../biome.json"],
  "linter": {
    "rules": {
      "style": {
        "noDefaultExport": "off"
      }
    }
  }
}

The Honest Tradeoffs: What You Lose When Leaving ESLint

While Biome is vastly faster and simpler, it is not an identical drop-in for every single legacy configuration. Before migrating, consider these two key limitations:

1. The Tailwind CSS Class Sorting Problem

If your team relies on eslint-plugin-tailwindcss or the Prettier Tailwind plugin to automatically sort utility classes (such as flex items-center justify-between), Biome does not yet offer full parity for automatic Tailwind class sorting out of the box.

The Production Workaround:
Many teams run Biome for 99% of formatting, linting, and import sorting, while maintaining a tiny, standalone Prettier or ESLint script strictly for Tailwind sorting before releases. For deeper architectural patterns on managing utility classes cleanly, see our Tailwind CSS Advanced Guide.

2. Type-Aware Lint Rules (typescript-eslint)

ESLint plugins like @typescript-eslint/recommended-type-checked can inspect the full TypeScript compiler type checker to catch complex type mismatches (such as floating promises or unsafe argument passing).

Biome performs AST-based analysis without booting the full TypeScript language service compiler. While Biome continues expanding its type checking capabilities, pairing Biome's static analysis with strict TypeScript for React Developers and keeping tsc --noEmit active in CI ensures complete type safety without slowing down local iteration.


Frequently Asked Questions (Developer Forums & Reddit)

Does Biome produce the exact same formatting as Prettier?

Biome’s formatter is designed to be Prettier-compatible and maintains over 97% compatibility with Prettier's core JavaScript and TypeScript output. While tiny aesthetic differences can occur in edge-case JSX indentations, your team will not notice major code diffs when switching.

Can Biome format JSON, CSS, and HTML?

Biome supports JavaScript, TypeScript, JSX, TSX, JSON, JSONC, and CSS natively. Support for HTML, Markdown, and framework-specific templates (Astro, Svelte, Vue) is actively evolving across releases. You can track ongoing language support on the official Biome GitHub.

How do I configure Biome in VS Code?

Install the official Biome extension (biomejs.biome). Then add this to your .vscode/settings.json:

json
{
  "editor.defaultFormatter": "biomejs.biome",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "quickfix.biome": "explicit",
    "source.organizeImports.biome": "explicit"
  },
  "[javascript]": { "editor.defaultFormatter": "biomejs.biome" },
  "[typescript]": { "editor.defaultFormatter": "biomejs.biome" },
  "[typescriptreact]": { "editor.defaultFormatter": "biomejs.biome" },
  "[json]": { "editor.defaultFormatter": "biomejs.biome" }
}

When Should You Switch?

  • Greenfield Projects: Start with Biome immediately. You avoid ESLint configuration overhead and get sub-second local checks from day one.
  • Standard TypeScript/React Apps: Switch now. If you don't use dozens of obscure ESLint plugins, the 25x speedup and single config file will save your team hours every month.
  • Complex Enterprise Monorepos with Custom Plugins: Audit your ESLint rules first. Run npx @biomejs/biome migrate eslint in a test branch to see which rules fail to map, and decide whether the speed boost outweighs the custom plugin rules. Explore more production workflows in our Developer Tools section.

Frequently Asked Questions

What is Biome: The Rust-Based Linter and Formatter Replacing ESLint and Prettier?

Biome is a unified toolchain for web development written in Rust. It combines a linter and formatter into a single binary, replacing the need for both ESLint and Prettier. It is designed to be faster (up to 100x) and simpler to configure, with a single JSON config file. Biome was originally a fork of the Rome project and is now actively maintained by a community organization.

How does Biome: The Rust-Based Linter and Formatter Replacing ESLint and Prettier work?

Biome works by parsing source code into an AST using a Rust-based parser, then applying lint rules and formatting rules in a single pass. The linter checks for code quality and style issues, while the formatter rewrites the code to match the configured style. Both steps are highly optimized for speed. Biome also includes an organize imports feature that sorts and removes unused imports.

What are the best practices for Biome: The Rust-Based Linter and Formatter Replacing ESLint and Prettier?

Best practices include: start with the recommended rule set, use `biome check --write` in pre-commit hooks, configure line width to match your team's preference, disable conflicting rules if you keep ESLint for some plugins, and use `biome ci` in CI pipelines to enforce linting and formatting without writing changes.

How much does Biome: The Rust-Based Linter and Formatter Replacing ESLint and Prettier cost?

Biome is completely free and open source. There is no paid tier, enterprise license, or usage limits. The only cost is the time required to migrate from ESLint and Prettier, and the potential loss of ESLint plugin functionality.

Is Biome: The Rust-Based Linter and Formatter Replacing ESLint and Prettier worth it in 2026?

For most teams, yes. The speed improvement is significant in daily development, and the single configuration reduces complexity. However, teams that rely heavily on ESLint plugins like eslint-plugin-tailwindcss may need to evaluate the tradeoff. A hybrid approach (Biome for linting/formatting, ESLint only for specific plugins) is a common workaround.

#biome#eslint#prettier#linting#tooling

One AI engineering post, weekly

LLM benchmarks, prompt techniques, and token-cost breakdowns, delivered to your inbox.

Comments

Have a question or something to add? Sign in to join the discussion.

Mahmudul Haque Qudrati — CEO & ML Engineer at Pristren

Mahmudul Haque Qudrati

CEO & ML Engineer

Visionary technologist, software engineer, and machine learning specialist. Founder and CEO of Pristren, directing engineering teams that ship production-grade AI/ML pipelines, mission-critical full-stack applications, and developer tooling. Creator of Zlyqor, the unified team workspace platform. Author of 540+ technical guides and benchmark research reports on large language models, agentic workflows, Model Context Protocol (MCP), and modern web stacks.

PristrenZlyqor