Bun: o runtime JavaScript mais rápido que o Node.js

O que é o Bun

O Bun é um runtime JavaScript de alta performance lancado em versão estável em setembro de 2023. Criado por Jarred Sumner é desenvolvido pela empresa Oven.sh, ele nasceu com uma proposta direta: ser mais rápido que o Node.js em praticamente tudo que você faz no dia a dia como desenvolvedor JavaScript ou TypeScript.

O que diferencia o Bun dos runtimes tradicionais é a escolha das bases tecnológicas. Enquanto o Node.js usa o motor V8 (o mesmo do Chrome) é APIs escritas em C++, o Bun foi escrito em Zig é usa o motor JavaScriptCore, que é o mesmo motor que alimenta o Safari da Apple. O JavaScriptCore tem um tempo de inicializacao muito menor que o V8, o que explica grande parte do ganho de performance em tarefas de linha de comando é scripts.

Além de ser um runtime, o Bun ve-lo como um kit completo: ele já inclui bundler, transpiler de TypeScript, gerenciador de pacotes compatível com npm, é runner de testes. Tudo em um único binário, sem precisar instalar Webpack, esbuild, tsx ou Jest separadamente.

Como funciona

O Bun implementa as APIs do Node.js de forma compatível, o que significa que a maioria dos pacotes npm funciona sem modificacao. Você pode usar require(), import, process.env, fs, path é dezenas de outras APIs que você já conhece. Para a maior parte dos projetos, a transição é transparente.

O motor JavaScriptCore do Bun tem uma característica importante: ele inicia muito mais rápido que o V8. Para scripts de linha de comando, ferramentas de build ou tarefas cron, essa diferença é significativa. Em benchmarks de HTTP, o Bun consegue processar mais requisicoes por segundo que o Node.js na maioria dos cenários, especialmente em workloads com muita É/S.

O gerenciador de pacotes do Bun (bun install) usa um lockfile binário próprio é um cache local agressivo. Em projetos que você já instalou uma vez, reinstalar é praticamente instantâneo porque os pacotes vem do cache local em vez de baixar da internet novamente. Em comparacao com npm install, a diferença de velocidade é consistentemente de 5x a 20x dependendo do tamanho do projeto.

Principais recursos

O Bun vai muito além de ser apenas um runtime. O que vem embutido por padrão:

• Runtime JavaScript é TypeScript: executa arquivos .js, .ts, .jsx é .tsx diretamente sem configuração adicional - não precisa de ts-node nem tsx
• Bundler: gera bundles de produção com suporte a code splitting, tree shaking é minificacao - alternativa ao Webpack, Vite é esbuild
• Gerenciador de pacotes: instala dependências do package.json com velocidade muito maior que npm é yarn - compatível com o ecossistema npm
• Runner de testes: API compatível com Jest, suporte a snapshots, mocks é testes asincronos - sem precisar instalar Jest separadamente
• Transpiler: converte TypeScript, JSX é importacoes para JavaScript compatível em tempo de execução
• Servidor HTTP nativo: API Bun.serve() para criar servidores HTTP de alta performance com suporte a WebSockets
• Hot reload: flag --hot reinicia o processo automaticamente ao detectar mudanças nos arquivos, sem matar o estado do servidor

Como começar: instalação passo a passo

A instalação do Bun é feita com um único comando no terminal. No Linux é macOS, basta rodar: curl -fsSL https://bun.sh/install | bash. O script baixa o binário e adiciona o Bun ao PATH automaticamente. No Windows, o Bun está disponível via npm: npm install -g bun ou pelo Windows Subsystem for Linux.

Depois de instalar, confirme que funcionou com bun --version. Para criar um novo projeto do zero, use bun init - ele vai perguntar o nome do projeto é gerar um package.json é um index.ts pra você. Para adicionar ao projeto existente, apenas substitua npm install por bun install é node arquivo.js por bun arquivo.js.

Para rodar um servidor HTTP simples, crie um arquivo server.ts com: Bun.serve({ port: 3000, fetch(req) { return new Response('Ola, mundo!'); } }); e execute com bun server.ts. Nada mais necessário - sem compilar TypeScript, sem configurar bundler, sem instalar dependências.

Exemplo prático: API com TypeScript sem configuração

Imagine que você quer criar uma API REST simples com TypeScript. No Node.js, você precisaria: inicializar projeto, instalar Express, instalar TypeScript, instalar ts-node ou tsx, criar tsconfig.json, é só então escrever o código. Com o Bun, você pula todas essas etapas.

Crie um arquivo api.ts e escreva diretamente em TypeScript: importe os tipos, defina as rotas com Bun.serve() e use o objeto Request nativo do browser (Bun implementa as Web APIs padrão). Execute com bun api.ts é a API está no ar. Sem tsconfig.json, sem scripts de build, sem transpilar manualmente.

Para adicionar o Hono (um framework HTTP leve e rápido compatível com Bun), basta bun add hono. O Hono foi projetado especificamente para runtimes modernos é aproveita ao máximo a performance nativa do Bun. O resultado é um servidor HTTP que inicia em menos de 10ms e processa requests com latência mínima.

Comparacao com Node.js é Deno

O Node.js ainda é o runtime mais usado no mundo é tem o ecossistema mais maduro. A vantagem do Bun sobre o Node é principalmente performance de inicializacao, velocidade do gerenciador de pacotes é o fato de incluir ferramentas que antes exigiam instalação separada. Para projetos existentes em Node.js, a migração geralmente é simples mas pode encontrar incompatibilidades em módulos que usam APIs nativas do Node.

O Deno, criado pelo mesmo criador do Node.js, Ryan Dahl, tem uma abordagem diferente: foca em segurança por padrão (permissões explicitas), usa URLs para importar módulos é tem compatibilidade parcial com npm. O Bun tem compatibilidade com Node muito maior que o Deno, o que facilita migrar projetos existentes. Para projetos novos, tanto Bun quanto Deno são opcoes validas dependendo da prioridade: performance máxima (Bun) ou segurança por padrão (Deno).

Em benchmarks de HTTP, o Bun geralmente supera o Node.js em throughput puro. Mas benchmarks microscópicos nem sempre refletem o workload real de uma aplicação. O gargalo de performance da maioria das aplicações web está no banco de dados ou em chamadas de API externas, não no runtime em si. Escolha o Bun pelo ecossistema embutido é pela experiência de desenvolvimento, não apenas pelos números de benchmark.

Pontos Positivos e Limitações

O grande ponto positivo do Bun é a experiência de desenvolvimento. Ter runtime, bundler, gerenciador de pacotes é runner de testes em um único binário elimina muito do trabalho de configuração inicial de um projeto JavaScript ou TypeScript. O ciclo de desenvolvimento fica mais rápido, especialmente em projetos novos.

As limitacoes aparecem em casos específicos. Alguns pacotes npm que dependem de binários nativos compilados para o Node.js podem não funcionar diretamente no Bun. O suporte ao Windows ainda é mais recente (chegou na versão 1.1) e pode ter quirks em alguns cenários. Para produção em sistemas críticos, o Node.js tem anos de battle-testing que o Bun ainda está acumulando.

O Bun ainda não suporta todas as APIs do Node.js 100%. A página de compatibilidade em bun.sh/docs/runtime/nodejs-apis lista o que está implementado é o que ainda está em progresso. Antes de migrar um projeto grande, vale verificar se as APIs que você usa estao suportadas.

Casos de uso reais

Scripts é ferramentas de automação: o tempo de inicializacao ultra-rápido do Bun faz dele o runtime ideal para scripts que rodam com frequência no terminal ou em pipelines CI/CD. O que leva 300ms no Node pode levar menos de 50ms no Bun.

Projetos novos em TypeScript: começar um projeto TypeScript com Bun é dramaticamente mais simples. Sem tsconfig.json, sem setup de transpiler, sem configurar Jest. Você escreve o código é sai executando.

APIs é microsserviços: para serviços HTTP de alta performance que precisam processar muitas requisicoes com baixa latência, o Bun com Hono ou Elysia é uma das combinacoes mais rápidas disponivas no ecossistema JavaScript.

Bundling de frontend: o bundler do Bun é uma alternativa ao esbuild é Vite para projetos que precisam de build rápido sem configuração complexa. Para projetos simples, pode substituir toda a cadeia de build do webpack.

Dicas e Boas Práticas

Use bun --hot durante o desenvolvimento para ter hot reload sem perder o estado do servidor. Diferente do nodemon que reinicia o processo inteiro, o --hot do Bun recarrega os módulos modificados é mantem o servidor rodando.

Para testes, substitua Jest por bun test. A API é compatível com Jest (describe, it, expect, mock, spyOn) mas o runner é muito mais rápido. Para projetos que já tem Jest configurado, a migração geralmente é trocar npx jest por bun test no package.json sem mudar os arquivos de teste.

Aproveite o bun install mesmo que você use Node.js em produção. O lockfile do Bun (bun.lockb) pode coexistir com o package-lock.json. Instalar dependências com Bun no CI é deployar com Node em produção é um padrão valido para quem quer velocidade de CI sem mudar a infraestrutura de produção ainda.

Vale a pena migrar do Node.js para o Bun?

Para projetos novos, a resposta é quase sempre sim. A experiência de desenvolvimento é genuinamente melhor: menos configuração, mais velocidade, TypeScript de graça. O ecossistema npm está amplamente suportado é a curva de aprendizado é mínima para quem já conhece Node.js.

Para projetos em produção, a decisão depende do risco tolerado. O Bun evolui rápido é cada versão expande a compatibilidade com o Node.js. Se você pode testar em um serviço não-crítico primeiro, essa é a estratégia recomendada. Para scripts internos é ferramentas de desenvolvimento, a migração é de baixo risco é alto ganho imediato.

Bun 1.0 is here

Bun is disrupting JavaScript land - Fireship

JavaScript just got way faster - Fireship

Bun Crash Course - JavaScript Runtime, Bundler and Transpiler