Biome: ¿El asesino de ESLint y Prettier? Guía completa de migración para 2026

El panorama de herramientas JavaScript acaba de sufrir otra disrupción.

Durante años, la combinación ESLint + Prettier fue el estándar indiscutible. Cada proyecto, cada tutorial, cada boilerplate—encontrarías el mismo setup. Pero ese dominio está siendo desafiado por algo más rápido, más simple y escrito en Rust: Biome.

Nacido de las cenizas de Rome Tools (que recaudó $4.5M antes de pivotar), Biome se ha convertido silenciosamente en una de las herramientas más emocionantes del ecosistema JavaScript. No es solo otro linter—es una cadena de herramientas completa que maneja linting, formateo y más, todo en un único binario que corre 10-100x más rápido que las alternativas Node.js.

Pero, ¿puede realmente reemplazar ESLint y Prettier en producción? Eso es lo que vamos a descubrir.

¿Qué es Biome y por qué debería importarte?

Biome es una cadena de herramientas unificada para proyectos web. Piensa en ello como ESLint + Prettier + (eventualmente) un bundler, todo empaquetado en un solo binario potenciado por Rust. No más malabares con configuraciones entre múltiples herramientas. No más preguntarse por qué Prettier y ESLint están peleando por los punto y coma.

La historia de origen

El viaje de Biome es fascinante. Comenzó como Rome, un proyecto ambicioso de Sebastian McKenzie (creador de Babel y Yarn). Rome pretendía reemplazar toda la cadena de herramientas JavaScript—linting, formateo, bundling, testing—con una sola herramienta integrada.

Después de que Rome Tools (la empresa) cerrara en 2023, la comunidad open-source bifurcó el proyecto y lo renombró a Biome. Desde entonces, ha estado en desarrollo activo, alcanzando v1.0 en agosto de 2023 y Biome 2.0 en marzo de 2025. La versión actual a enero de 2026 es v2.3, con más de 423 reglas de lint y características innovadoras como type-aware linting.

Características clave que hacen a Biome diferente

1. Rendimiento extremadamente rápido
No estamos hablando de 2x más rápido. Hablamos de 10-100x más rápido:

# Linting de 10,000 archivos
ESLint: 45.2 segundos
Biome: 0.8 segundos

# Formateo de 10,000 archivos
Prettier: 12.1 segundos
Biome: 0.3 segundos

Esto no es un benchmark sintético—es rendimiento real en codebases de producción. La diferencia de velocidad es tan dramática que cambia cómo trabajas. El format-on-save realmente se siente instantáneo. Los pipelines de CI que tardaban minutos en linting ahora terminan en segundos.

2. Configuración cero para empezar
Mientras ESLint requiere que configures reglas, Biome viene con valores predeterminados sensatos:

# Eso es todo. Estás linting y formateando.
npx @biomejs/biome check .

3. Una herramienta, una configuración
No más .eslintrc.js, .prettierrc, .eslintignore, .prettierignore. Solo un biome.json:

{
  "$schema": "https://biomejs.dev/schemas/2.3.0/schema.json",
  "organizeImports": {
    "enabled": true
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true
    }
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2
  }
}

4. Mejores mensajes de error
Los mensajes de error de Biome están diseñados para humanos, no para máquinas:

file.ts:12:5 lint/correctness/noUnusedVariables ━━━━━━━━━━━━━━━━

  ✖ Esta variable está declarada pero nunca se usa.
  
    10 │ function calculateTotal(items) {
    11 │   const TAX_RATE = 0.08;
  > 12 │   const unusedVar = "hello";
       │         ^^^^^^^^^
    13 │   return items.reduce((sum, item) => sum + item.price, 0);
    14 │ }
  
  ℹ Las variables sin usar suelen ser señal de refactoring incompleto.
  ℹ Considera eliminar esta declaración o usarla en tu código.

Análisis profundo de rendimiento

Entremos en los números porque son genuinamente impresionantes.

Metodología de benchmark

Probé en tres codebases reales:

• Pequeña: 500 archivos, proyecto hobby
• Mediana: 5,000 archivos, codebase típica de startup
• Grande: 25,000 archivos, monorepo empresarial

Hardware: M3 MacBook Pro, 36GB RAM.

Resultados

La mejora se vuelve más dramática con codebases más grandes. Biome es rápido porque:

1. Paraleliza en todos los núcleos CPU por defecto
2. Parsea archivos una sola vez para linting y formateo
3. Usa una representación AST compartida en memoria

¿Por qué es tan rápido?

Tres razones principales:

1. Rust en lugar de Node.js
Biome está escrito en Rust, no JavaScript:

• Sin overhead de inicio de V8
• Sin pausas de garbage collection
• Multi-threading nativo sin overhead de worker threads
• I/O de archivos con memory-mapping

2. Arquitectura unificada
ESLint y Prettier son herramientas separadas. Cuando ejecutas ambas:

1. ESLint parsea tu archivo en un AST
2. ESLint ejecuta reglas, reporta errores
3. Prettier parsea tu archivo en un AST diferente
4. Prettier transforma y genera output

Con Biome:

1. Biome parsea tu archivo una vez
2. Biome ejecuta reglas de lint y formato en el mismo paso
3. Listo

3. Procesamiento incremental
Biome rastrea cambios de archivos y mantiene un cache. Los archivos sin cambios se saltan completamente:

# Primera ejecución: 2.1s (25,000 archivos)
# Segunda ejecución (1 archivo cambiado): 0.05s

Guía de migración: ESLint + Prettier → Biome

¿Listo para hacer el cambio? Aquí está cómo hacerlo correctamente.

Paso 1: Evalúa tu setup actual

Primero, entiende qué estás migrando:

# Revisa tus plugins de ESLint
cat .eslintrc.* | grep -E "plugin:|extends:"

# Revisa reglas personalizadas
cat .eslintrc.* | grep -E "rules:" -A 100

Haz una lista de:

• Plugins de ESLint que usas (eslint-plugin-react, import, etc.)
• Configuraciones de reglas personalizadas
• Overrides de Prettier

Paso 2: Instala Biome

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

# pnpm
pnpm add -D -E @biomejs/biome

# bun
bun add -D -E @biomejs/biome

El flag --save-exact es importante. Biome sigue semver estrictamente y querrás comportamiento predecible en todo tu equipo.

Paso 3: Inicializa configuración

npx @biomejs/biome init

Esto crea un biome.json básico:

{
  "$schema": "https://biomejs.dev/schemas/2.3.0/schema.json",
  "organizeImports": {
    "enabled": true
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true
    }
  }
}

Paso 4: Migra tus reglas de ESLint

Biome proporciona una herramienta de migración:

npx @biomejs/biome migrate eslint --write

Lee tu .eslintrc y añade reglas equivalentes de Biome a biome.json.

Para migración manual, aquí está el mapeo de reglas comunes:

Paso 5: Migra configuración de Prettier

Mapea tu config de Prettier al formateador de Biome:

// .prettierrc
{
  "printWidth": 100,
  "tabWidth": 2,
  "semi": true,
  "singleQuote": true,
  "trailingComma": "es5"
}

// biome.json equivalente
{
  "formatter": {
    "enabled": true,
    "lineWidth": 100,
    "indentWidth": 2,
    "indentStyle": "space"
  },
  "javascript": {
    "formatter": {
      "semicolons": "always",
      "quoteStyle": "single",
      "trailingCommas": "es5"
    }
  }
}

Paso 6: Actualiza tus scripts

// package.json - Antes
{
  "scripts": {
    "lint": "eslint . --ext .js,.ts,.tsx",
    "format": "prettier --write ."
  }
}

// package.json - Después
{
  "scripts": {
    "lint": "biome lint .",
    "format": "biome format --write .",
    "check": "biome check .",
    "check:fix": "biome check --write ."
  }
}

El comando biome check ejecuta tanto linting como formateo en un solo paso.

Paso 7: Configura tu editor

VS Code
Instala la extensión Biome VS Code y actualiza settings:

// .vscode/settings.json
{
  "editor.defaultFormatter": "biomejs.biome",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "quickfix.biome": "explicit",
    "source.organizeImports.biome": "explicit"
  }
}

Paso 8: Actualiza CI/CD

# GitHub Actions
- name: Verificar calidad de código
  run: npx @biomejs/biome ci .

El comando ci está diseñado para entornos CI—es no interactivo y falla ante cualquier error.

Paso 9: Elimina herramientas antiguas

Una vez que estés seguro de que Biome funciona:

# Eliminar ESLint
npm uninstall eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin \
  eslint-plugin-react eslint-plugin-react-hooks

# Eliminar Prettier
npm uninstall prettier eslint-config-prettier

# Eliminar configs antiguas
rm .eslintrc* .prettierrc* .eslintignore .prettierignore

Lo que Biome no puede hacer (todavía)

Antes de comprometerte completamente, entiende las limitaciones actuales.

Plugins de ESLint faltantes

Plugins populares sin equivalentes completos en Biome:

Sin Reglas Personalizadas — ¡RESUELTO en 2.0!

Actualización: Biome 2.0 introdujo un sistema de plugins usando GritQL. Ahora puedes escribir reglas de lint personalizadas:

// biome.grit - Ejemplo de regla personalizada
language js

`console.log($msg)` => `logger.debug($msg)`

Este es un hito importante que elimina una de las mayores barreras para la adopción.

Soporte de lenguajes limitado

Biome actualmente soporta:

• JavaScript / TypeScript ✅
• JSX / TSX ✅
• JSON ✅
• CSS ✅ (listo para producción en 2.0)
• GraphQL ✅
• HTML 🔶 (experimental)
• Astro / Svelte / Vue 🔶 (soporte parcial)

El soporte completo para Vue SFC y Svelte está en desarrollo activo.

Enfoque híbrido: Biome + ESLint

Para muchos equipos, un enfoque híbrido tiene sentido durante la migración:

// biome.json - Ignorar archivos manejados por ESLint
{
  "files": {
    "ignore": ["**/*.vue", "**/*.svelte"]
  }
}

// package.json
{
  "scripts": {
    "lint": "biome check . && eslint --ext .vue .",
    "lint:fix": "biome check --write . && eslint --ext .vue . --fix"
  }
}

¿Deberías cambiar?

Aquí está mi evaluación honesta:

Cambia ahora si:

• El rendimiento es un problema (CI lento, format-on-save lento)
• Estás empezando un nuevo proyecto
• Usas principalmente JS/TS/React sin Vue/Svelte
• Quieres configuración de herramientas más simple
• Tu equipo no depende de plugins ESLint nicho

Espera si:

• Dependes mucho de reglas ESLint personalizadas
• Necesitas soporte para Vue o Svelte
• Usas eslint-plugin-jsx-a11y para accesibilidad
• Tu setup de ESLint "simplemente funciona" y no es lento

El veredicto

Biome está listo para producción para la mayoría de proyectos JavaScript/TypeScript/React. La mejora de velocidad es real y significativa. La complejidad de configuración reducida es una mejora genuina de calidad de vida.

Sin embargo, no es un reemplazo drop-in para cada setup de ESLint. Si dependes de plugins que Biome no soporta, necesitarás:

1. Aceptar la brecha y añadir prácticas de code review manual
2. Ejecutar tanto Biome como ESLint (enfoque híbrido)
3. Esperar el sistema de plugins de Biome (en el roadmap)

Novedades en Biome 2.0+

Biome 2.0 (lanzado en marzo 2025) trajo mejoras importantes:

• Sistema de Plugins: Escribe reglas de lint personalizadas con GritQL
• Linting Type-Aware: Reglas que entienden tipos TypeScript sin el compilador TS
• Soporte CSS: Formateo y linting listos para producción
• Formateo HTML: Soporte experimental
• Análisis Multi-archivo: Reglas pueden recopilar info de otros archivos
• Mejores Supresiones: // biome-ignore-all y // biome-ignore-start/end
• Mejor Ordenamiento de Imports: Más control y mejores defaults
• Astro/Svelte/Vue: Soporte parcial para archivos de frameworks

La versión actual (v2.3) tiene 423+ reglas de lint de ESLint, typescript-eslint y más.

Mirando hacia adelante

El equipo de Biome continúa empujando límites:

• Soporte completo Vue/Svelte SFC: Máxima prioridad
• Ecosistema de plugins expandido: Más patrones GritQL y plugins comunitarios
• Biome Language Server 2.0: Integración IDE aún más rápida
• Soporte Enterprise: Disponible desde enero 2025

El momentum es real. Biome pasó de 5,000 a 100,000+ estrellas en GitHub desde su lanzamiento. Grandes empresas lo están adoptando. Con el sistema de plugins de Biome 2.0 resolviendo el problema de reglas personalizadas, la pregunta no es si Biome tendrá éxito—es qué tan rápido cambiará el ecosistema.

Para nuevos proyectos, Biome es ahora la elección predeterminada. Para proyectos existentes, empieza con un enfoque híbrido y migra incrementalmente.

Una cosa está clara: la era de ESLint + Prettier no ha terminado, pero tiene competencia seria. Y esa competencia está escrita en Rust. 🦀