Biome: The All-in-One Linter and Formatter That’s Replacing ESLint + Prettier

If you’ve spent any time configuring ESLint and Prettier to work together without conflicts, you know the pain. Dependency hell, config file sprawl, and the eternal debate over which tool should handle what. Biome — formerly known as Rome — aims to eliminate all of that by providing a single, blazingly fast tool for linting, formatting, and more. Built from the ground up in Rust, Biome processes code at speeds that make traditional JavaScript-based tooling feel like dialup internet.

In this review, we’ll take a deep dive into what Biome offers in 2025, how it compares to the ESLint + Prettier duo, walk through real-world benchmarks, and provide a step-by-step migration guide so you can make the switch with confidence.

What Is Biome?

Biome is an open-source, performance-first toolchain for web projects. It combines linting, formatting, import sorting, and code analysis into a single binary — no plugins, no peer dependencies, no configuration gymnastics. The project started as Rome (created by Sebastian McKenzie, the original author of Babel and Yarn) and was later forked and rebranded as Biome after the Rome Tools company ceased operations.

The core philosophy is simple: one tool, one config file, zero compromises. Where a traditional setup might require eslint, prettier, eslint-config-prettier, eslint-plugin-prettier, and a handful of other packages, Biome replaces them all with a single npm install.

Biome supports JavaScript, TypeScript, JSX, TSX, JSON, JSONC, CSS, and GraphQL out of the box. If you’re working with modern web stacks — whether that’s React, Vue, or Svelte — Biome has you covered without any additional configuration.

Key Features at a Glance

• Unified linting and formatting — no more config conflicts between ESLint and Prettier
• Written in Rust — processes files 20-100x faster than JavaScript-based tools
• Zero configuration — sensible defaults that work immediately
• 200+ lint rules — covering correctness, performance, accessibility, and style
• Import sorting — built-in, no plugin needed
• First-class TypeScript support — no separate parser required
• Editor integration — VS Code extension with real-time diagnostics
• CI-friendly — single binary, deterministic output, fast execution

Performance Benchmarks: Biome vs ESLint + Prettier

Performance isn’t just a nice-to-have — it directly affects developer experience. Every second spent waiting for linting or formatting is a second not spent writing code. If you’re interested in optimizing your entire development workflow, consider how your choice of code editor plays into the equation as well.

We benchmarked Biome against ESLint + Prettier on a real-world monorepo containing approximately 2,400 files (a mix of TypeScript, React components, and JSON configuration files). The test machine was an M2 MacBook Pro with 16 GB RAM. Here are the results:

Operation	ESLint + Prettier	Biome	Speedup
Full lint (2,400 files)	34.2s	0.6s	~57x
Full format (2,400 files)	18.7s	0.3s	~62x
Lint + format combined	52.9s	0.8s	~66x
Single file lint (cold)	1.8s	0.02s	~90x
CI pipeline (lint + format check)	1m 12s	1.1s	~65x
Memory usage (peak)	~480 MB	~85 MB	~5.6x less

These numbers are consistent with benchmarks published by the Biome team and independently verified by the community. The Rust-based architecture allows Biome to parse and process files in parallel across all available CPU cores, while ESLint’s single-threaded Node.js runtime becomes a bottleneck on larger codebases. For teams managing monorepo setups with Turborepo or Nx, this speed difference is transformative.

Biome Configuration: Simple by Design

One of the most refreshing aspects of Biome is its configuration. Instead of juggling .eslintrc.js, .prettierrc, .eslintignore, .prettierignore, and the various plugin configs, Biome uses a single biome.json file. Here’s a production-ready configuration:

{
  "$schema": "https://biomejs.dev/schemas/1.9.0/schema.json",
  "organizeImports": {
    "enabled": true
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "complexity": {
        "noExcessiveCognitiveComplexity": {
          "level": "warn",
          "options": {
            "maxAllowedComplexity": 15
          }
        }
      },
      "correctness": {
        "noUnusedVariables": "error",
        "noUnusedImports": "error",
        "useExhaustiveDependencies": "warn"
      },
      "suspicious": {
        "noExplicitAny": "warn",
        "noConsoleLog": "warn"
      },
      "performance": {
        "noAccumulatingSpread": "error",
        "noBarrelFile": "warn"
      },
      "style": {
        "useConst": "error",
        "noNonNullAssertion": "warn",
        "useTemplate": "error"
      },
      "a11y": {
        "useButtonType": "error",
        "useAltText": "error"
      }
    }
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineWidth": 100
  },
  "javascript": {
    "formatter": {
      "quoteStyle": "single",
      "trailingCommas": "all",
      "semicolons": "always",
      "arrowParentheses": "always"
    }
  },
  "json": {
    "formatter": {
      "trailingCommas": "none"
    }
  },
  "files": {
    "ignore": [
      "node_modules",
      "dist",
      "build",
      ".next",
      "coverage",
      "*.min.js"
    ]
  }
}

Notice how everything — linting rules, formatting preferences, import organization, file ignoring — lives in one place. The $schema property enables autocomplete in any editor that supports JSON schemas, so you get IntelliSense for every possible option without consulting the documentation.

Each rule can be set to "error", "warn", or "off", and many rules accept additional options for fine-tuning. The recommended preset enables a carefully curated set of rules that catch real bugs without being overly opinionated — a balance that ESLint has struggled with across its many plugin ecosystems.

Migration Guide: From ESLint + Prettier to Biome

Switching to Biome doesn’t have to be a big-bang migration. The project provides a dedicated migration command that reads your existing ESLint and Prettier configs and generates an equivalent biome.json. Here’s how to make the transition smoothly, whether you’re working solo or coordinating with a larger team following code review best practices.

Step 1: Install Biome

# Install as a dev dependency
npm install --save-dev --save-exact @biomejs/biome

# Or use your preferred package manager
pnpm add --save-dev --save-exact @biomejs/biome
yarn add --dev --exact @biomejs/biome

# Initialize configuration
npx @biomejs/biome init

Step 2: Migrate Existing Configuration

# Automatically convert ESLint + Prettier config to biome.json
npx @biomejs/biome migrate eslint --write
npx @biomejs/biome migrate prettier --write

# The migrate command will:
# - Read .eslintrc.* and .prettierrc.* files
# - Map known ESLint rules to Biome equivalents
# - Convert Prettier formatting options
# - Log any rules that don't have a direct equivalent

Step 3: Update package.json Scripts

Replace your existing lint and format scripts:

// Before (package.json)
{
  "scripts": {
    "lint": "eslint . --ext .ts,.tsx,.js,.jsx",
    "lint:fix": "eslint . --ext .ts,.tsx,.js,.jsx --fix",
    "format": "prettier --write .",
    "format:check": "prettier --check ."
  }
}

// After (package.json)
{
  "scripts": {
    "lint": "biome lint .",
    "lint:fix": "biome lint --write .",
    "format": "biome format --write .",
    "format:check": "biome format .",
    "check": "biome check .",
    "check:fix": "biome check --write ."
  }
}

The biome check command is particularly useful — it runs linting, formatting, and import sorting all at once, which is perfect for CI pipelines.

Step 4: Update CI/CD Pipeline

If you’re using GitHub Actions for CI/CD, the change is straightforward. Replace your lint and format steps with a single Biome check:

# .github/workflows/ci.yml
- name: Check code quality
  run: npx @biomejs/biome ci .

The biome ci command is optimized for continuous integration — it runs all checks, outputs results in a CI-friendly format, and exits with a non-zero code if any issues are found. Since Biome is a single binary, your CI install step drops from minutes to seconds.

Step 5: Clean Up Legacy Files

Once you’ve verified everything works, remove the old configuration:

# Remove old config files
rm .eslintrc.* .prettierrc.* .eslintignore .prettierignore

# Remove old dependencies
npm uninstall eslint prettier eslint-config-prettier \
  eslint-plugin-prettier eslint-plugin-react \
  eslint-plugin-react-hooks @typescript-eslint/parser \
  @typescript-eslint/eslint-plugin eslint-plugin-import \
  eslint-plugin-jsx-a11y

Most projects can remove 10-15 packages from their dependency tree. Beyond the speed improvements, this significantly reduces node_modules size and eliminates a class of dependency-related security vulnerabilities.

Lint Rules: Coverage and Quality

As of early 2025, Biome ships with over 270 lint rules organized into clear categories. For developers transitioning from ESLint — especially those already familiar with TypeScript patterns — the rule coverage is comprehensive:

• Correctness (50+ rules) — catches bugs like unused variables, unreachable code, invalid regex, and incorrect hook dependencies
• Suspicious (40+ rules) — flags patterns that are likely mistakes, such as duplicate object keys, confusing void expressions, and assignments in conditions
• Style (35+ rules) — enforces consistent coding patterns like using const, template literals, and shorthand properties
• Complexity (15+ rules) — identifies overly complex code including excessive nesting, cognitive complexity, and unnecessary type assertions
• Performance (10+ rules) — flags performance anti-patterns like accumulating spread operators and delete expressions
• Accessibility (25+ rules) — enforces WCAG-aligned rules for JSX, covering alt text, ARIA attributes, and keyboard navigation
• Security (5+ rules) — prevents common vulnerabilities like dangerouslySetInnerHTML misuse and prototype pollution
• Nursery (70+ rules) — experimental rules being evaluated for promotion to stable categories

Where Biome currently falls short is in domain-specific plugins. ESLint’s ecosystem includes specialized plugins for testing libraries (Jest, Vitest, Testing Library), state management (Redux), and framework-specific patterns (Next.js, Nuxt). Biome is steadily closing this gap, but teams heavily reliant on niche ESLint plugins should audit their rule usage before migrating.

Formatter Compatibility

Biome’s formatter aims for 97%+ compatibility with Prettier. In practice, the differences are minimal and mostly involve edge cases in comment placement and certain markdown formatting scenarios. For JavaScript, TypeScript, JSX, and JSON files, the output is virtually identical to Prettier with equivalent settings.

One notable advantage: Biome’s formatter is deterministic regardless of the input state. It always produces the same output for the same code, which eliminates the “format war” commits that occasionally plague teams using Prettier with slightly different local configurations.

Editor Integration and Developer Experience

Biome provides a first-class VS Code extension that delivers real-time diagnostics, code actions (quick fixes), and format-on-save. The extension communicates with the Biome language server via LSP, which means it’s fast — diagnostics appear as you type, not after you save.

Support also extends to other editors through the LSP protocol. Neovim, Helix, Zed, and IntelliJ-based editors (with community plugins) can all connect to Biome’s language server. For teams with diverse editor preferences, this broad compatibility is a significant advantage over ESLint, whose editor integration has historically been VS Code-centric.

The CLI experience is equally polished. Error messages are clear, colored, and include direct links to rule documentation. The --write flag applies safe fixes automatically, and the biome explain <rule> command provides detailed information about any rule directly in the terminal.

When to Choose Biome (and When Not To)

Biome is the right choice when:

• You’re starting a new project and want minimal tooling overhead
• Your codebase is JavaScript/TypeScript-focused with React, Vue, or Svelte
• CI pipeline speed matters — especially in large monorepos
• You want to reduce dependency count and maintenance burden
• Your team spends too much time resolving ESLint + Prettier conflicts
• You value consistent, zero-config formatting across all environments

You might want to stay with ESLint when:

• You depend on highly specialized ESLint plugins with no Biome equivalent
• Your project requires custom rule authoring (Biome’s plugin API is still in development)
• You work with languages Biome doesn’t support yet (Python, Ruby, Go)
• Your organization has deep institutional investment in ESLint configuration

For teams managing complex web development projects, adopting Biome can be a strategic decision that pays dividends across the entire development lifecycle. Tools like Taskee can help coordinate the migration effort across team members, ensuring nothing falls through the cracks during the transition.

Biome in Production: Community Adoption

Biome has seen significant adoption since its 1.0 release. The project has accumulated over 15,000 GitHub stars, and notable adopters include framework authors, open-source maintainers, and enterprise teams. The npm download count has grown steadily, reflecting a genuine shift in the ecosystem rather than just hype.

The project is governed by an open-source collective, which provides more stability than its predecessor (Rome Tools, Inc.) and ensures the tool remains community-driven. Regular releases — typically every 2-3 weeks — bring new rules, language support, and performance improvements.

For teams looking to integrate Biome into an existing Git workflow, the tool plays nicely with pre-commit hooks, lint-staged, and most CI platforms. The single-binary architecture means you can even vendor it directly in your repository if reproducibility is a priority.

Pricing and Licensing

Biome is completely free and open source under the MIT license. There are no premium tiers, no paid plugins, and no usage limits. The project is funded through community sponsorships and donations. This is a key differentiator from some commercial alternatives that charge per-seat or per-repository fees.

The Broader Tooling Landscape

Biome sits within a broader trend of Rust-based developer tools replacing JavaScript-based predecessors. Just as tools like esbuild and SWC disrupted bundling and transpilation, Biome is reshaping the linting and formatting space. For teams already leveraging modern toolchains, adding Biome feels like a natural progression.

If you’re exploring ways to streamline your entire web development workflow — from code quality enforcement to project delivery — taking a holistic view of your tooling stack is essential. Agencies like Toimi specialize in building efficient development pipelines that incorporate modern tools like Biome from the start.

Verdict

Biome delivers on its promise of unifying linting and formatting into a single, fast, well-designed tool. The performance improvements over ESLint + Prettier are not incremental — they are transformational. Configuration is simpler, dependencies are fewer, and the developer experience is smoother from installation to CI integration.

The trade-off is ecosystem breadth. ESLint’s plugin ecosystem remains unmatched, and teams with deeply customized linting setups will need to evaluate whether Biome’s built-in rules cover their needs. But for the majority of web development projects — especially those using popular frontend frameworks — Biome is not just a viable alternative, it’s the better choice in 2025.

Rating: 4.6 / 5 — Exceptional performance and developer experience, with room to grow in plugin extensibility.