O que é o Bun
O Bun é um runtime JavaScript de alta performance lancado em versão estavel em setembro de 2023. Criado por Jarred Sumner é desenvolvido pela empresa Oven.sh, ele nasceu com uma proposta direta: ser mais rapido 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 tecnologicas. 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.
Alem de ser um runtime, o Bun ve-lo como um kit completo: ele já inclui bundler, transpiler de TypeScript, gerenciador de pacotes compativel com npm, é runner de testes. Tudo em um único binario, sem precisar instalar Webpack, esbuild, tsx ou Jest separadamente.
Como funciona
O Bun implementa as APIs do Node.js de forma compativel, 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 transicao é transparente.
O motor JavaScriptCore do Bun tem uma caracteristica importante: ele inicia muito mais rapido 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 binario próprio é um cache local agressivo. Em projetos que você já instalou uma vez, reinstalar é praticamente instantaneo 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 alem 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 - compativel com o ecossistema npm
- Runner de testes: API compativel com Jest, suporte a snapshots, mocks é testes asincronos - sem precisar instalar Jest separadamente
- Transpiler: converte TypeScript, JSX é importacoes para JavaScript compativel 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
--hotreinicia o processo automaticamente ao detectar mudancas nos arquivos, sem matar o estado do servidor
Como comecar: instalacao passo a passo
A instalacao 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 binario é 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!'); } }); é execute com bun server.ts. Nada mais necessario - 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 é escreva diretamente em TypeScript: importe os tipos, defina as rotas com Bun.serve() é 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 é rapido compativel 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 é 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 instalacao 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 seguranca 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 sao opcoes validas dependendo da prioridade: performance máxima (Bun) ou seguranca por padrão (Deno).
Em benchmarks de HTTP, o Bun geralmente supera o Node.js em throughput puro. Mas benchmarks microscopicos 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 é limitacoes
O grande ponto positivo do Bun é a experiência de desenvolvimento. Ter runtime, bundler, gerenciador de pacotes é runner de testes em um único binario elimina muito do trabalho de configuração inicial de um projeto JavaScript ou TypeScript. O ciclo de desenvolvimento fica mais rapido, especialmente em projetos novos.
As limitacoes aparecem em casos específicos. Alguns pacotes npm que dependem de binarios 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) é 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-rapido 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: comecar 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 é microsservicos: 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 rapidas disponivas no ecossistema JavaScript.
Bundling de frontend: o bundler do Bun é uma alternativa ao esbuild é Vite para projetos que precisam de build rapido sem configuração complexa. Para projetos simples, pode substituir toda a cadeia de build do webpack.
Dicas é 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 é compativel com Jest (describe, it, expect, mock, spyOn) mas o runner é muito mais rapido. 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 rapido é 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 estrategia 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