Ferramentas Rust para JavaScript em 2025: Por que Biome, Oxc e Rolldown Mudam Tudo

O cenário de ferramentas JavaScript está passando por uma transformação significativa, impulsionada pelas vantagens práticas de Rust. No final de 2025, estamos vendo essas ferramentas baseadas em Rust amadurecerem, oferecendo ganhos de desempenho tangíveis e uma experiência de desenvolvimento mais robusta. Tendo passado um tempo considerável testando Biome.js, Oxc e Rolldown em projetos complexos, posso dizer que a mudança não é apenas hype; é uma evolução sólida de nossa infraestrutura central de desenvolvimento, muito parecido com como Modern CLI Deep Dive: Why Rust and GPU Terminals Change Everything in 2025 explora o espaço do terminal.

O apelo de Rust neste domínio é direto: seu foco em segurança de memória, abstrações de custo zero e modelos de concorrência robustos se traduz diretamente em ferramentas mais rápidas e confiáveis. Onde as ferramentas baseadas em JavaScript frequentemente atingem tetos de desempenho devido à sobrecarga do runtime e da coleta de lixo, os binários compilados em Rust são executados em velocidades próximas às nativas. Isso é particularmente crítico para tarefas que consomem muita CPU, como análise sintática, linting, formatação e empacotamento, que são onipresentes nos fluxos de trabalho frontend modernos.

Deixe-me mostrar os desenvolvimentos recentes e como essas ferramentas estão remodelando praticamente nossas rotinas diárias, desde o desenvolvimento local até os pipelines de CI/CD.

Biome.js 2.0: A Toolchain Unificada Amadurece

Biome.js sempre teve como objetivo ser a toolchain frontend tudo-em-um, consolidando formatação, linting e organização de importações. Com o lançamento beta da versão 2.0 em março de 2025 e sua estabilização por volta de junho de 2025, solidificou sua posição como uma alternativa atraente a configurações JavaScript fragmentadas como ESLint e Prettier.

A vantagem arquitetônica central do Biome reside em sua abordagem unificada. Em vez de várias ferramentas analisando seu código independentemente, o Biome analisa o código apenas uma vez, constrói uma única Árvore de Sintaxe Abstrata (AST) e, em seguida, reutiliza essa AST para todas as operações subsequentes – linting, formatação e classificação de importações. Essa estratégia de "uma análise, múltiplas passagens" elimina uma grande sobrecarga computacional, razão pela qual consistentemente oferece melhorias de velocidade impressionantes.

Um dos avanços mais significativos no Biome 2.0 é a introdução de um sistema de plugins, permitindo que os desenvolvedores escrevam regras de lint personalizadas usando GritQL. Isso atende a uma solicitação antiga da comunidade, estendendo as capacidades do Biome além de seu conjunto de regras integrado. Além disso, regras com reconhecimento de tipo, como noFloatingPromises, foram implementadas, fornecendo um nível mais profundo de análise estática sem exigir o compilador TypeScript completo, embora a integração com a API do TypeScript esteja no roadmap para aprimoramentos futuros.

Você pode usar este JSON Formatter para verificar sua estrutura ao editar seu arquivo biome.json. Vamos analisar uma configuração prática, demonstrando como habilitar esses novos recursos e adaptar o Biome ao seu projeto.

{
  "$schema": "https://biomejs.dev/schemas/2.0.5/schema.json",
  "organizeImports": {
    "enabled": true
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "style": {
        "useSingleVarDeclarator": "error",
        "noVar": "error"
      },
      "complexity": {
        "noExtraBooleanCast": "warn"
      },
      "suspicious": {
        "noFloatingPromises": "error"
      }
    },
    "ignore": ["node_modules/", "dist/"]
  },
  "formatter": {
    "enabled": true,
    "indentStyle": "space",
    "indentWidth": 2,
    "lineWidth": 100,
    "quoteStyle": "single"
  },
  "javascript": {
    "formatter": {
      "quoteStyle": "single",
      "jsxQuoteStyle": "double"
    }
  },
  "vcs": {
    "enabled": true,
    "clientKind": "git",
    "root": "./"
  },
  "overrides": [
    {
      "include": ["**/*.test.ts", "**/*.spec.ts"],
      "linter": {
        "rules": {
          "security": {
            "noConsoleLog": "off"
          }
        }
      }
    }
  ]
}

Este snippet biome.json ilustra vários pontos. Habilitamos a organização de importações, o linter com regras recomendadas e regras de estilo específicas como useSingleVarDeclarator e noVar. Criticamente, a regra noFloatingPromises é habilitada em suspicious, aproveitando as novas capacidades de informações de tipo para detectar rejeições de promessas não tratadas. O formatador é configurado para indentação de 2 espaços e largura de linha de 100 caracteres, com substituições específicas do JavaScript para estilos de aspas. A seção vcs habilita a varredura com reconhecimento do Git, permitindo que o Biome processe apenas arquivos alterados, uma economia de tempo enorme em repositórios grandes. Finalmente, o array overrides demonstra como desabilitar seletivamente regras para padrões de arquivo específicos, como permitir instruções console.log dentro de arquivos de teste. Este nível de controle granular, combinado com seu desempenho, torna o Biome uma escolha sólida para manter a qualidade do código.

Oxc: A Fundação de Alto Desempenho

Oxc, ou o Oxidation Compiler, não é uma ferramenta voltada diretamente para o usuário da mesma forma que Biome ou Rolldown são. Em vez disso, serve como uma coleção de ferramentas JavaScript e TypeScript de alto desempenho escritas em Rust, formando uma camada fundamental para outros projetos. É o motor sob o capô de muitas ferramentas de próxima geração, incluindo Rolldown.

A arquitetura do Oxc é construída com base em princípios de desempenho, correção, experiência do desenvolvedor e composibilidade modular. Isso significa que seus componentes – como oxc-parser, oxc-linter, oxc-transform, oxc-minify e oxc-resolver – podem ser usados independentemente ou compostos em toolchains completos. O parser, por exemplo, é notavelmente rápido, capaz de fazer linting em mais de 4800 arquivos no repositório VS Code em aproximadamente 0,7 segundos. Essa velocidade é alcançada por meio de engenharia de desempenho rigorosa, incluindo análise sintática de cópia zero e aproveitamento da eficiência do Rust.

Vamos considerar oxlint, o componente linter independente do Oxc. Ele foi projetado para ser um linter pronto para produção com padrões sensatos, oferecendo uma alternativa rápida e opinativa ao ESLint.

Para fazer linting rápido de um projeto com oxlint:

npx oxlint@latest

Este comando executará oxlint com suas regras padrão e opinativas. Para mais controle, você pode gerar um arquivo de configuração:

npx oxlint@latest --init

Isso pode criar um .oxlintrc.json (ou similar, dependendo da versão estável mais recente) onde você pode habilitar ou desabilitar regras específicas. O verdadeiro poder do Oxc, no entanto, geralmente reside em suas APIs internas. Imagine que você está construindo uma ferramenta de transformação de código personalizada. Você poderia aproveitar oxc-parser para obter uma AST incrivelmente rápida:

import { parseSync } from 'oxc-parser';

const code = `
  function greet(name: string) {
    console.log(\`Hello, \${name}!\`);
  }
  greet("World");
`;

const ast = parseSync(code, { sourceType: 'module', typescript: true });
console.log(JSON.stringify(ast, null, 2));

Este exemplo conceitual destaca como oxc-parser fornece um caminho direto e de alto desempenho para uma AST JavaScript/TypeScript. Os desenvolvedores podem então construir ferramentas personalizadas com base nesta base robusta, permitindo análise estática avançada, modificações de código ou até mesmo linters personalizados que operam em velocidades anteriormente inatingíveis com parsers nativos JavaScript.

Rolldown & Vite: O Próximo Gerador de Bundles

A comunidade de desenvolvimento web tem observado atentamente a integração do Rolldown, um gerador de bundles JavaScript impulsionado por Rust, no Vite. Anunciado como um componente chave para o Vite 6, rolldown-vite entrou em visualização técnica por volta de maio de 2025, com o ambicioso objetivo de substituir tanto o esbuild (para pré-empacotamento de dependências) quanto o Rollup (para builds de produção) com uma única solução nativa Rust unificada.

A arquitetura do Rolldown é projetada desde o início em Rust para oferecer desempenho comparável ao do esbuild e significativamente mais rápido que o Rollup – muitas vezes 10 a 30 vezes mais rápido. Essa velocidade não se trata apenas de builds de produção mais rápidos; trata-se de melhorar fundamentalmente a experiência de desenvolvimento. O roadmap do Rolldown no Vite envolve três fases: um pacote rolldown-vite independente para feedback inicial, mesclagem no código base principal do Vite com um modo "Full Bundle" opcional para desenvolvimento e, eventualmente, tornar-se o gerador de bundles padrão.

O "Full Bundle Mode" é particularmente interessante. Ele visa unificar as experiências de desenvolvimento e produção, servindo arquivos agrupados durante o desenvolvimento, mantendo os tempos de inicialização rápidos e o Hot Module Replacement (HMR) eficiente do Vite na saída ESM. Isso promete um comportamento consistente entre desenvolvimento e produção, reduzindo a sobrecarga de rede em atualizações de página, especialmente para aplicativos maiores.

Para ter uma ideia de rolldown-vite, você normalmente o aliasaria em seu package.json:

{
  "name": "my-vite-app",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  },
  "devDependencies": {
    "@vitejs/plugin-react": "^4.2.1",
    "vite": "^5.0.0",
    "rolldown-vite": "^0.3.0"
  },
  "pnpm": {
    "overrides": {
      "vite": "npm:rolldown-vite@latest"
    }
  }
}

Neste package.json, estamos usando pnpm overrides para dizer ao gerenciador de pacotes para usar rolldown-vite sempre que vite for solicitado. Isso permite que você teste o gerador de bundles com tecnologia Rust como uma substituição direta.

Embora o Rolldown seja projetado para ser amplamente compatível com a API de plugin Rollup existente, alguns plugins que dependem do esbuild para transformações internas podem precisar de atualizações, pois rolldown-vite agora aproveita o Oxc para todas as transformações e minificações internas, tornando o esbuild uma dependência opcional. Isso consolida a camada fundamental, levando a mais ganhos de desempenho.

Para vite.config.js, o Rolldown respeita amplamente as configurações existentes do Vite, mas você pode ver novas opções surgindo especificamente para ajustar seu comportamento de agrupamento, especialmente em torno da divisão de chunks e otimizações avançadas.

import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';

export default defineConfig({
  plugins: [react()],
  build: {
    minify: 'oxc',
    rollupOptions: {
      output: {
        manualChunks(id) {
          if (id.includes('node_modules')) {
            return id.toString().split('node_modules/')[1].split('/')[0].toString();
          }
        }
      }
    }
  }
});

Ligando a Lacuna: NAPI-RS e WebAssembly

A integração perfeita de ferramentas baseadas em Rust no ecossistema JavaScript é amplamente facilitada por projetos como NAPI-RS. NAPI-RS é uma estrutura que permite construir addons Node.js em Rust, fornecendo uma ponte robusta e eficiente entre as duas linguagens. Ele abstrai as complexidades da Node-API (N-API), permitindo que desenvolvedores Rust exponham funcionalidades de alto desempenho ao JavaScript com sobrecarga mínima.

A importância do NAPI-RS não pode ser exagerada. Ele permite que partes críticas de desempenho do web tooling – como parsers, transformadores e bundlers – sejam escritas em Rust, compiladas em código nativo e, em seguida, consumidas diretamente em ambientes Node.js. Isso nos dá o melhor dos dois mundos: a velocidade e a segurança de memória do Rust para trabalhos pesados e a flexibilidade e o vasto ecossistema do JavaScript para a camada de orquestração.

Uma vantagem fundamental do NAPI-RS é sua capacidade de "build sem configuração", simplificando o processo de compilação e vinculação em diferentes plataformas. Ele suporta uma ampla gama de plataformas de runtime Node.js, garantindo ampla compatibilidade. Além disso, o NAPI-RS expandiu suas capacidades para suportar a compilação para WebAssembly, o que significa que esses addons nativos com tecnologia Rust podem ser executados não apenas no Node.js, mas potencialmente diretamente no navegador, abrindo novas vias para o desempenho do lado do cliente.

Vamos analisar um binding NAPI-RS conceitual para entender como uma função Rust pode ser exposta ao JavaScript:

use napi_derive::napi;

#[napi]
pub fn calculate_heavy_computation(input: u32) -> u32 {
  let mut result = 0;
  for i in 0..input {
    result += i;
  }
  result
}

E no seu código JavaScript/TypeScript:

const { calculateHeavyComputation } = require('./my-rust-addon.node');

console.time('Rust computation');
const rustResult = calculateHeavyComputation(1_000_000_000);
console.timeEnd('Rust computation');

Análise Profunda de Desempenho: Benchmarks e Ganhos do Mundo Real

O tema consistente em Biome.js, Oxc e Rolldown é um salto dramático no desempenho em comparação com seus predecessores nativos JavaScript. Esses não são ganhos incrementais; estamos falando de ordens de magnitude de execução mais rápida para muitas tarefas críticas.

Para o Biome, benchmarks da comunidade e testes internos mostram consistentemente que ele tem um desempenho 10x mais rápido que ESLint e Prettier combinados, com alguns relatórios indicando até 25x mais rápido na formatação e 15x mais rápido no linting. Essa velocidade decorre diretamente das vantagens centrais do Rust:

Segurança de Memória sem Sobrecarga de GC: O sistema de propriedade e empréstimo do Rust garante a segurança da memória em tempo de compilação, eliminando a necessidade de um coletor de lixo em tempo de execução.
Abstrações de Custo Zero: As abstrações do Rust são compiladas em código de máquina altamente otimizado sem custo em tempo de execução.
Concorrência e Paralelismo: O sistema de tipos forte do Rust permite concorrência segura e eficiente, permitindo que as ferramentas aproveitem vários núcleos de CPU.

Os benchmarks iniciais do Rolldown são igualmente impressionantes. Empresas como a GitLab relataram tempos de build reduzidos de 2,5 minutos para 40 segundos, juntamente com uma redução impressionante de 100x no uso de memória. Excalidraw viu seu tempo de build cair de 22,9 segundos para 1,4 segundos.

Vamos ilustrar a arquitetura paralelizada que torna isso possível:

Esta arquitetura paralelizada é a razão fundamental para as dramáticas melhorias de desempenho. Para tarefas inerentemente vinculadas à CPU e que podem ser divididas em unidades independentes, o modelo de concorrência do Rust fornece uma vantagem clara.

Domínio da Configuração: Desbloqueando o Potencial Total

Embora essas ferramentas baseadas em Rust se vangloriem de princípios de "configuração mínima", entender suas opções de configuração é crucial para adaptá-las às necessidades específicas do projeto. O arquivo biome.json é o hub central do Biome, oferecendo uma interface unificada para formatação, linting e organização de importações.

Além do básico de habilitação de ferramentas e regras, o Biome fornece recursos avançados como integração vcs e overrides granulares. A configuração vcs, quando habilitada, permite que o Biome detecte automaticamente seu cliente e raiz do Git, permitindo que os comandos operem apenas em arquivos alterados.

{
  "$schema": "https://biomejs.dev/schemas/2.0.5/schema.json",
  "vcs": {
    "enabled": true,
    "clientKind": "git",
    "root": "./"
  },
  "files": {
    "ignore": [
      "**/legacy-code/**/*",
      "*.d.ts"
    ],
    "include": ["src/**/*.ts", "src/**/*.tsx"]
  },
  "overrides": [
    {
      "include": ["components/**/*.tsx"],
      "linter": {
        "rules": {
          "a11y": {
            "noSvgWithoutTitle": "off"
          }
        }
      },
      "formatter": {
        "lineWidth": 120
      }
    }
  ]
}

Para execução de linha de comando, o Biome oferece vários flags poderosos:

biome check . --write: Executa formatação, linting e classificação de importações e aplica correções.
biome ci .: Um comando de verificação somente leitura, ideal para pipelines de CI.
biome format --write --staged: Formata apenas as alterações do Git preparadas.
biome lint --since=origin/main: Faz linting apenas dos arquivos alterados desde o branch origin/main.

Realidades Atuais e Trajetórias Futuras

Embora a Rustificação das ferramentas frontend traga vantagens inegáveis, é importante manter uma visão realista. Essas ferramentas, embora estejam amadurecendo rapidamente, ainda estão evoluindo.

O que funciona bem:

Desempenho: Os ganhos de velocidade são reais e imediatamente perceptíveis.
Experiência Unificada: A configuração única do Biome para várias tarefas simplifica a configuração.
Estabilidade Fundamental: O Oxc fornece uma camada de análise de alto desempenho e estável.
Integração Vite: A integração do Rolldown com o Vite está em um caminho claro para se tornar um padrão.

O que ainda é complicado ou experimental:

Maturidade do Ecossistema: O ecossistema de plugins para ferramentas nativas Rust ainda é incipiente.
Suporte Completo à Linguagem: O Biome 2.0 tem um roadmap para HTML e CSS, mas ainda não é totalmente abrangente.
Depuração: A depuração do código Rust via NAPI-RS pode ter uma curva de aprendizado mais acentuada.
Paridade Total de Recursos do Rolldown: Garantir a paridade total com todos os plugins Rollup esotéricos será um esforço contínuo.

> [!IMPORTANT]

Insight de Especialista: Previsão de Tendência

Minha previsão para o final de 2025 e para 2026 é uma convergência e especialização contínuas. Veremos mais frameworks e ferramentas de build adotando componentes Rust fundamentais como o Oxc diretamente, não apenas para análise sintática, mas para transformação e minificação, reduzindo ainda mais a dependência do esbuild ou Babel. O conceito de uma "toolchain unificada" se expandirá além do linting/formatação para se integrar profundamente com o empacotamento e até mesmo testes, criando loops de desenvolvimento com tecnologia Rust altamente otimizados de ponta a ponta. Isso levará a uma nova geração de ferramentas CLI específicas do framework que aproveitam esses primitivos Rust para oferecer desempenho incomparável e uma experiência de desenvolvedor perfeita.

Em conclusão, a onda de ferramentas baseadas em Rust não é apenas uma tendência passageira; é uma mudança fundamental em direção a um desenvolvimento frontend mais eficiente, confiável e de alto desempenho. Biome.js, Oxc e Rolldown estão na vanguarda desse movimento, oferecendo melhorias tangíveis hoje e lançando as bases para um futuro ainda mais rápido e integrado.