Biome 2.0: O Linter e Formatter Rust Que e 25x Mais Rapido

Olá HaWkers, uma das ferramentas mais promissoras do ecossistema JavaScript acaba de receber uma atualização massiva. O Biome 2.0 chegou com suporte a type-aware linting, trazendo funcionalidades que antes só eram possíveis com typescript-eslint, mas com performance até 25x superior.

Você ainda está esperando segundos para seu linter rodar? Talvez seja hora de conhecer o Biome.

O Que e o Biome

Biome é uma ferramenta unificada que substitui ESLint e Prettier em um único pacote, escrito completamente em Rust. O projeto nasceu do Rome (agora descontinuado) e evoluiu para se tornar uma alternativa viável e cada vez mais popular.

Destaques do Biome 2.0

Type-aware linting: Regras que entendem tipos TypeScript
25x mais rápido: Que Prettier para formatação
15x mais rápido: Que ESLint para linting
Zero configuração: Funciona out of the box
Plugin ecosystem: Suporte a plugins em desenvolvimento

Contexto importante: Em junho de 2025, Biome já era usado por mais de 50.000 projetos no GitHub, com crescimento de 300% em relação ao ano anterior.

Benchmarks de Performance

Os números do Biome 2.0 são impressionantes.

Comparativo de Velocidade

Operação	ESLint + Prettier	Biome 2.0	Melhoria
Format 1000 arquivos	12.5s	0.5s	25x
Lint 1000 arquivos	8.3s	0.55s	15x
Format + Lint	20.8s	0.9s	23x
Watch mode (re-check)	2.1s	0.08s	26x

Uso de Memória

Cenário	ESLint	Biome	Redução
Projeto pequeno	180MB	45MB	75%
Projeto grande	850MB	120MB	86%
Monorepo	2.5GB	280MB	89%

💡 Por que tão rápido? Biome é escrito em Rust, usa paralelização eficiente, e não depende do runtime JavaScript. Cada arquivo é processado em threads separados com overhead mínimo.

Novidades do Biome 2.0

A versão 2.0 traz recursos que faltavam para competir completamente com o ecossistema ESLint.

Type-Aware Linting

Agora o Biome pode analisar tipos TypeScript para regras mais inteligentes:

// biome.json
{
  "linter": {
    "rules": {
      "nursery": {
        // Regras que entendem tipos
        "noFloatingPromises": "error",
        "noMisusedPromises": "error",
        "awaitThenable": "error"
      }
    }
  },
  // Necessário para type-aware linting
  "javascript": {
    "jsxRuntime": "reactClassic"
  }
}

// Antes: ESLint com typescript-eslint
// Agora: Biome detecta o mesmo problema

async function fetchData() {
  // Biome avisa: Promise não tratada
  fetch('/api/data');

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

function processItems(items: string[]) {
  // Biome avisa: map retorna Promise[], não string[]
  items.map(async (item) => {
    return await processItem(item);
  });
}

Novas Regras de Segurança

// Regras para detectar problemas comuns de segurança

// noSecrets: Detecta credenciais hardcoded
const apiKey = "sk_live_abc123"; // Aviso!

// noUnsafeRegex: Detecta regex vulneráveis a ReDoS
const regex = /^(a+)+$/; // Aviso: potencial ReDoS

// noEval: Bloqueia uso de eval
eval("alert('xss')"); // Erro!

Formatação Melhorada

// Antes do Biome 2.0: formatação inconsistente em edge cases

// Agora: formatação mais inteligente para objetos complexos
const config = {
  server: {
    host: "localhost",
    port: 3000,
    options: {
      cors: true,
      helmet: true,
    },
  },
  database: {
    url: process.env.DATABASE_URL,
    pool: { min: 2, max: 10 },
  },
};

// Imports organizados automaticamente
import { useEffect, useState } from "react";
import { api } from "@/lib/api";
import { Button } from "@/components/ui";
import type { User } from "@/types";

Migração do ESLint Para Biome

A migração é mais simples do que você imagina.

Passo 1: Instalação

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

# yarn
yarn add --dev @biomejs/biome

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

Passo 2: Inicialização

# Criar configuração inicial
npx @biomejs/biome init

# Migrar configuração do ESLint
npx @biomejs/biome migrate eslint --write

Passo 3: Configuração

// biome.json gerado
{
  "$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
  }
}

Passo 4: Scripts

// package.json
{
  "scripts": {
    "lint": "biome check .",
    "lint:fix": "biome check --apply .",
    "format": "biome format --write .",
    "check": "biome check --apply --formatter-enabled=true ."
  }
}

Comparação de Regras

Veja como as regras do ESLint mapeiam para o Biome.

Regras Equivalentes

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)

Regras Exclusivas do Biome

// useSortedClasses: Ordena classes Tailwind automaticamente
<div className="p-4 flex bg-white shadow-lg items-center" />
// Torna-se:
<div className="flex items-center bg-white p-4 shadow-lg" />

// noAccumulatingSpread: Detecta spreads ineficientes
function merge(items) {
  return items.reduce((acc, item) => ({ ...acc, ...item }), {});
  // Aviso: O(n²) complexity - use Object.assign
}

Integração Com Editores

Biome tem suporte excelente para os principais editores.

VS Code

// .vscode/settings.json
{
  "editor.defaultFormatter": "biomejs.biome",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.organizeImports.biome": true,
    "quickfix.biome": true
  },
  // Desativar extensões conflitantes
  "eslint.enable": false,
  "prettier.enable": false
}

Extensão Biome

# Instalar extensão
code --install-extension biomejs.biome

CI/CD Com Biome

Integrar Biome em pipelines é simples e rápido.

GitHub Actions

# .github/workflows/ci.yml
name: CI

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Biome
        uses: biomejs/setup-biome@v2
        with:
          version: latest

      - name: Run Biome
        run: biome ci .

Performance no CI

Ferramenta	Tempo (1000 arquivos)	Resultado
ESLint + Prettier	45s	Passa
Biome	2s	Passa

Quando Usar Biome

Biome é ideal para certos cenários.

Casos de Uso Ideais

Projetos novos:

Comece com Biome desde o início
Sem bagagem de configuração ESLint
Performance desde o dia 1

Monorepos:

Performance é crítica
Configuração unificada
Redução drástica de tempo no CI

Times grandes:

Menos tempo esperando ferramentas
Configuração simples
Onboarding rápido

Quando Talvez Esperar

Plugins ESLint específicos:

Plugins de frameworks (eslint-plugin-vue, etc.)
Regras customizadas complexas
Integrações específicas

Conclusão

Biome 2.0 representa uma mudança significativa no ecossistema de ferramentas JavaScript. Com type-aware linting e performance 25x superior, a ferramenta está pronta para substituir ESLint e Prettier em muitos projetos.

Se você está começando um projeto novo ou tem a flexibilidade de migrar, Biome oferece uma experiência de desenvolvimento mais rápida e simplificada. A economia de tempo no CI sozinha pode justificar a migração.

Se você quer entender mais sobre como Rust está transformando as ferramentas JavaScript, recomendo dar uma olhada em nosso artigo sobre Vite 8 e Rolldown onde discutimos outra ferramenta revolucionária escrita em Rust.