Bun: O Runtime JavaScript que Substituiu 15 Ferramentas por Uma Só

Jarred Sumner, criador do Bun, resumiu assim a proposta da ferramenta: "Não construímos o Bun pra substituir o Node.js. Construímos pra substituir as 15 ferramentas que você precisa junto com o Node.js."

npm. webpack. babel. jest. ts-node. nodemon. tsc. Um binário único substitui tudo isso — e ainda roda TypeScript nativo, sem compilação prévia.

Em dezembro de 2025, a Anthropic adquiriu o Bun. O Claude Code, o Claude Agent SDK e futuros produtos de AI coding da Anthropic rodam sobre ele. Com 7.2 milhões de downloads mensais antes da aquisição e crescimento de 85% ano a ano, o Bun deixou de ser curiosidade pra virar infraestrutura.

Por que o Bun é mais rápido

Node.js usa o motor V8 do Chrome, otimizado para processos de longa duração. Bun usa o JavaScriptCore do Safari, otimizado para startup rápido. Essa diferença arquitetural explica a maioria dos resultados de benchmark.

Além do motor, o Bun foi escrito em Zig — uma linguagem de sistemas de baixo nível — e usa io_uring no Linux para I/O assíncrono eficiente. Sem transpilação de TypeScript. Sem camadas de compatibilidade desnecessárias. Menos trabalho por operação.

Instalação

# macOS / Linuxcurl -fsSL https://bun.sh/install | bash# Windowspowershell -c "irm bun.sh/install.ps1 | iex"# Verificarbun --version

TypeScript nativo — sem configuração

Essa é a primeira diferença que desenvolvedores sentem no dia a dia. Com Node.js, rodar TypeScript exige ts-node, ou compilar com tsc, ou configurar tsx, ou usar --experimental-strip-types (que só remove tipos, não faz type-check).

Package manager — 25x mais rápido que o npm

O Bun tem seu próprio package manager que é compatível com o formato do npm mas usa uma estratégia diferente: um cache binário global e hard-links direto para o node_modules. Sem re-download. Sem re-validação em cada install.

# Instalar dependências (substitui npm install)bun install# Adicionar pacotebun add zodbun add -d typescript# Removerbun remove lodash# Executar scripts do package.jsonbun run devbun run buildbun run test# Executar arquivo sem instalar globalmentebunx create-hono meu-app

Servidor HTTP nativo

O Bun tem um servidor HTTP built-in baseado nas Web Standard APIs — a mesma interface de Request e Response que você já conhece do browser e do Cloudflare Workers.

// server.tsBun.serve({  port: 3000,  fetch(req) {    const url = new URL(req.url);    if (url.pathname === '/') {      return new Response('Olá do Bun!');    }    if (url.pathname === '/json') {      return Response.json({ runtime: 'bun', fast: true });    }    return new Response('Not Found', { status: 404 });  },});console.log('Rodando em http://localhost:3000');

O servidor nativo do Bun atinge cerca de 68.000 req/s em benchmarks de hello world — competindo com frameworks Rust. Na camada de aplicação, frameworks como o Hono extraem o máximo desse throughput com routing otimizado, validação com Zod e RPC client tipado.

Test runner integrado

O Bun tem um test runner built-in com API compatível com Jest. Sem instalar @jest/core, sem configurar ts-jest, sem setup de environment. Funciona direto.

// math.test.tsimport { describe, it, expect, beforeEach } from 'bun:test';import { soma, media } from './math';describe('funções matemáticas', () => {  it('soma dois números', () => {    expect(soma(2, 3)).toBe(5);  });  it('calcula média corretamente', () => {    expect(media([1, 2, 3, 4])).toBe(2.5);  });  it('lança erro para array vazio', () => {    expect(() => media([])).toThrow('Array não pode ser vazio');  });});// Rodar// bun test// bun test --watch// bun test --coverage

Bundler nativo

O Bun inclui um bundler que substitui esbuild, webpack e rollup para os casos mais comuns. TypeScript, JSX, tree-shaking e minificação — nativos, sem plugins.

# CLI — build simplesbun build ./src/index.ts --outdir ./distbun build ./src/index.ts --outdir ./dist --minifybun build ./src/index.ts --outdir ./dist --sourcemap# Target diferentesbun build ./src/index.ts --outdir ./dist --target nodebun build ./src/index.ts --outdir ./dist --target browserbun build ./src/index.ts --outdir ./dist --target bun

// API programáticaawait Bun.build({  entrypoints: ['./src/index.ts'],  outdir: './dist',  minify: true,  splitting: true, // code splitting automático  target: 'browser',  define: {    'process.env.NODE_ENV': '"production"',  },});

APIs nativas úteis

O Bun expõe APIs de alto nível para operações comuns que no Node.js exigem módulos externos ou verbosidade desnecessária.

// Leitura e escrita de arquivos — sem fs.readFile callbackconst texto = await Bun.file('./dados.txt').text();const json = await Bun.file('./config.json').json();await Bun.write('./output.txt', 'conteúdo aqui');// Hashing nativo — sem bibliotecaconst hash = Bun.hash('minha string');const sha256 = new Bun.CryptoHasher('sha256').update('dados').digest('hex');// Spawn de processosconst proc = Bun.spawn(['ls', '-la'], {  stdout: 'pipe',});const output = await new Response(proc.stdout).text();// SQLite nativo — sem driverimport { Database } from 'bun:sqlite';const db = new Database('./meu.db');const users = db.query('SELECT * FROM users WHERE ativo = ?').all(1);// WebSocket nativo no servidorBun.serve({  port: 3000,  fetch(req, server) {    if (server.upgrade(req)) return; // upgrade pra WebSocket    return new Response('HTTP normal');  },  websocket: {    message(ws, msg) { ws.send(`Echo: ${msg}`); },    open(ws) { console.log('conectado'); },    close(ws) { console.log('desconectado'); },  },});

Compatibilidade com Node.js em 2026

O Bun afirma compatibilidade drop-in com Node.js. A realidade em 2026 é 95% de compatibilidade — o que é produção-ready para a maioria dos casos, mas com exceções importantes.

Bun como ferramenta de dev + Node.js em produção

Se você tem dúvidas sobre compatibilidade, há uma estratégia de adoção gradual que funciona bem: usar o Bun como tooling de desenvolvimento e manter Node.js em produção até ter confiança.

# package.json — usando Bun como tooling, deploy em Node.js{  "scripts": {    "dev": "bun --watch src/index.ts",    "test": "bun test",    "build": "bun build src/index.ts --outdir dist --target node",    "start": "node dist/index.js"  // produção ainda em Node.js  }}# A equipe ganha:# - TypeScript nativo no dev (sem ts-node)# - Install 25x mais rápido# - Tests muito mais rápidos# - Sem risco de incompatibilidade em produção

Quando usar o Bun em produção

O contexto maior: Bun + Anthropic

A aquisição do Bun pela Anthropic em dezembro de 2025 não foi por acaso. Claude Code, que roda inteiramente em Bun, precisa de um runtime com startup rápido, baixo consumo de memória e TypeScript nativo. O Bun resolve os três.

O projeto continua open-source sob licença MIT. O que mudou é o acesso a recursos — a Anthropic tem o incentivo direto de manter o Bun rápido e estável porque seus próprios produtos dependem dele.

O Bun não nasceu pra vencer benchmarks. Nasceu pra eliminar a fricção entre ter uma ideia e ter um servidor rodando.

Em 2026, essa fricção era real — e o Node.js acumulou 15 anos de ferramentas externas pra compensá-la. O Bun decidiu resolver na raiz.