Biome 2.0: The Rust Linter and Formatter That is 25x Faster

Hello HaWkers, one of the most promising tools in the JavaScript ecosystem just received a massive update. Biome 2.0 arrived with type-aware linting support, bringing features that were previously only possible with typescript-eslint, but with up to 25x better performance.

Are you still waiting seconds for your linter to run? Maybe it's time to meet Biome.

What is Biome

Biome is a unified tool that replaces ESLint and Prettier in a single package, written entirely in Rust. The project was born from Rome (now discontinued) and evolved to become a viable and increasingly popular alternative.

Biome 2.0 Highlights

Type-aware linting: Rules that understand TypeScript types
25x faster: Than Prettier for formatting
15x faster: Than ESLint for linting
Zero configuration: Works out of the box
Plugin ecosystem: Plugin support in development

Important context: In June 2025, Biome was already used by more than 50,000 projects on GitHub, with 300% growth compared to the previous year.

Performance Benchmarks

Biome 2.0 numbers are impressive.

Speed Comparison

Operation	ESLint + Prettier	Biome 2.0	Improvement
Format 1000 files	12.5s	0.5s	25x
Lint 1000 files	8.3s	0.55s	15x
Format + Lint	20.8s	0.9s	23x
Watch mode (re-check)	2.1s	0.08s	26x

Memory Usage

Scenario	ESLint	Biome	Reduction
Small project	180MB	45MB	75%
Large project	850MB	120MB	86%
Monorepo	2.5GB	280MB	89%

💡 Why so fast? Biome is written in Rust, uses efficient parallelization, and doesn't depend on JavaScript runtime. Each file is processed in separate threads with minimal overhead.

Biome 2.0 New Features

Version 2.0 brings features that were missing to compete completely with the ESLint ecosystem.

Type-Aware Linting

Now Biome can analyze TypeScript types for smarter rules:

// biome.json
{
  "linter": {
    "rules": {
      "nursery": {
        // Rules that understand types
        "noFloatingPromises": "error",
        "noMisusedPromises": "error",
        "awaitThenable": "error"
      }
    }
  },
  // Required for type-aware linting
  "javascript": {
    "jsxRuntime": "reactClassic"
  }
}

// Before: ESLint with typescript-eslint
// Now: Biome detects the same problem

async function fetchData() {
  // Biome warns: Unhandled Promise
  fetch('/api/data');

  // Correct:
  await fetch('/api/data');
}

New Security Rules

// Rules to detect common security issues

// noSecrets: Detects hardcoded credentials
const apiKey = "sk_live_abc123"; // Warning!

// noUnsafeRegex: Detects regex vulnerable to ReDoS
const regex = /^(a+)+$/; // Warning: potential ReDoS

// noEval: Blocks eval usage
eval("alert('xss')"); // Error!

Migration from ESLint to Biome

Migration is simpler than you think.

Step 1: Installation

# npm
npm install --save-dev @biomejs/biome

# yarn
yarn add --dev @biomejs/biome

# pnpm
pnpm add --save-dev @biomejs/biome

Step 2: Initialization

# Create initial configuration
npx @biomejs/biome init

# Migrate ESLint configuration
npx @biomejs/biome migrate eslint --write

Step 3: Configuration

// generated biome.json
{
  "$schema": "https://biomejs.dev/schemas/1.9.0/schema.json",
  "organizeImports": {
    "enabled": true
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "complexity": {
        "noExtraBooleanCast": "error"
      },
      "correctness": {
        "noUnusedVariables": "warn"
      },
      "style": {
        "noNonNullAssertion": "warn"
      }
    }
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineWidth": 80
  }
}

Rule Comparison

See how ESLint rules map to Biome.

Equivalent Rules

ESLint	Biome	Status
no-unused-vars	noUnusedVariables	✅
no-console	noConsole	✅
prefer-const	useConst	✅
eqeqeq	useStrictEquality	✅
no-var	noVar	✅
@typescript-eslint/no-explicit-any	noExplicitAny	✅
@typescript-eslint/no-floating-promises	noFloatingPromises	✅ (2.0)

Biome-Exclusive Rules

// useSortedClasses: Sorts Tailwind classes automatically
<div className="p-4 flex bg-white shadow-lg items-center" />
// Becomes:
<div className="flex items-center bg-white p-4 shadow-lg" />

Editor Integration

Biome has excellent support for major editors.

VS Code

// .vscode/settings.json
{
  "editor.defaultFormatter": "biomejs.biome",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.organizeImports.biome": true,
    "quickfix.biome": true
  },
  // Disable conflicting extensions
  "eslint.enable": false,
  "prettier.enable": false
}

When to Use Biome

Biome is ideal for certain scenarios.

Ideal Use Cases

New projects:

Start with Biome from the beginning
No ESLint configuration baggage
Performance from day 1

Monorepos:

Performance is critical
Unified configuration
Drastic reduction of CI time

Large teams:

Less time waiting for tools
Simple configuration
Quick onboarding

When to Maybe Wait

Specific ESLint plugins:

Framework plugins (eslint-plugin-vue, etc.)
Complex custom rules
Specific integrations

Conclusion

Biome 2.0 represents a significant shift in the JavaScript tools ecosystem. With type-aware linting and 25x better performance, the tool is ready to replace ESLint and Prettier in many projects.

If you're starting a new project or have the flexibility to migrate, Biome offers a faster and simpler development experience. CI time savings alone can justify the migration.

If you want to understand more about how Rust is transforming JavaScript tools, I recommend checking out our article on Vite 8 and Rolldown where we discuss another revolutionary tool written in Rust.