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):
| Toolchain | Operation | Execution Time | Memory Footprint |
|---|---|---|---|
| Prettier | Format validation (prettier --check .) | 4.20s | ~180 MB |
| ESLint | Static linting (eslint .) | 8.70s | ~340 MB |
| Combined Legacy Stack | Sequential Lint + Format | 12.90s | ~520 MB |
| Biome | Combined 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:
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:
npx @biomejs/biome init
Step 3: Automatically Migrate Your Old Configs
Instead of manually copying rules, execute the official migration commands:
# 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:
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:
{
"$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:
{
"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:
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:
# 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:
// 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:
{
"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 eslintin 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.




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