Case Bun — Como Zig Impulsiona o Runtime JavaScript Mais Rápido do Mundo

O Bun é o projeto Zig mais bem-sucedido e visível até o momento. Com mais de 70.000 estrelas no GitHub, milhões de downloads mensais e $7 milhões em investimento da Oven (sua empresa desenvolvedora), o Bun provou que Zig pode ser usado para construir software de nível mundial que compete diretamente com projetos estabelecidos como Node.js e Deno.

A História

Jarred Sumner, o criador do Bun, começou o projeto em 2021 frustrado com a performance do tooling JavaScript existente. Como engenheiro de software com experiência em Stripe, ele entendia o impacto que ferramentas lentas tinham na produtividade dos desenvolvedores: instalações de pacotes demoradas, transpilação lenta, startup pesado.

Sumner escolheu Zig para construir o Bun por razões técnicas específicas: performance de C sem a insegurança de C, interoperabilidade nativa com JavaScriptCore (o motor JS do WebKit, escrito em C++), e compilação cruzada para todas as plataformas alvo.

Arquitetura Técnica

O Bun é construído em camadas, com Zig permeando todas elas:

Motor JavaScript: JavaScriptCore

O Bun usa o JavaScriptCore (JSC) do WebKit como motor de execução JavaScript, em vez do V8 usado pelo Node.js e Deno. O JSC é linkado estaticamente e chamado diretamente do Zig sem FFI:

// Exemplo conceitual da integração Zig-JSC
const jsc = @cImport({
    @cInclude("JavaScriptCore/JavaScript.h");
});

const JsRuntime = struct {
    ctx: jsc.JSGlobalContextRef,
    vm: jsc.JSContextGroupRef,

    pub fn init() !JsRuntime {
        const vm = jsc.JSContextGroupCreate();
        const ctx = jsc.JSGlobalContextCreateInGroup(vm, null);
        return .{ .ctx = ctx, .vm = vm };
    }

    pub fn executar(self: *JsRuntime, codigo: []const u8) !jsc.JSValueRef {
        const script = jsc.JSStringCreateWithUTF8CString(codigo.ptr);
        defer jsc.JSStringRelease(script);

        var exception: jsc.JSValueRef = null;
        const resultado = jsc.JSEvaluateScript(
            self.ctx, script, null, null, 0, &exception
        );

        if (exception != null) return error.JsError;
        return resultado;
    }
};

Servidor HTTP

O servidor HTTP do Bun é implementado inteiramente em Zig, otimizado para I/O assíncrono:

• io_uring no Linux para I/O sem bloqueio
• kqueue no macOS
• IOCP no Windows
• Parser HTTP zero-copy
• TLS nativo via BoringSSL

Gerenciador de Pacotes

O bun install é dramaticamente mais rápido que npm, pnpm e yarn porque:

• Resolução de dependências em Zig com algoritmo otimizado
• Download paralelo usando pool de conexões HTTP/2
• Linking de pacotes usando hard links quando possível
• Parsing de package.json com parser JSON otimizado

Bundler/Transpiler

O bundler do Bun suporta TypeScript, JSX, CSS e mais, tudo implementado em Zig:

• Parser de JavaScript/TypeScript em Zig puro
• Transformação AST sem alocações desnecessárias
• Tree shaking e dead code elimination
• Source maps de alta fidelidade

Performance em Números

Servidor HTTP

// Benchmark: requests por segundo
Bun.serve({
    port: 3000,
    fetch() {
        return new Response("Hello World");
    },
});

Instalação de Pacotes

Para um projeto Next.js típico (~300 dependências):

Transpilação TypeScript

Execução de Testes

# Benchmark com 1000 testes unitários
bun test        # 1.2s
vitest          # 4.5s
jest            # 8s

Por Que Zig Fez a Diferença

Controle de Memória

O Bun usa alocadores customizados de Zig para diferentes partes do sistema:

• Arena allocator para processamento de requisições (liberação em bloco)
• Pool allocator para objetos JavaScript frequentemente criados/destruídos
• mimalloc (via interop C) para alocação geral

Ausência de GC no Runtime

Enquanto o GC do JavaScriptCore gerencia objetos JavaScript, toda a infraestrutura do Bun (I/O, networking, file system) opera sem GC, eliminando pausas imprevisíveis.

Otimizações SIMD

O Bun usa vetores SIMD do Zig para operações de texto:

// Busca otimizada de caracteres com SIMD
fn encontrarNovaLinha(dados: []const u8) ?usize {
    const vec_size = 16;
    const target: @Vector(vec_size, u8) = @splat('\n');

    var i: usize = 0;
    while (i + vec_size <= dados.len) : (i += vec_size) {
        const chunk: @Vector(vec_size, u8) = dados[i..][0..vec_size].*;
        const cmp = chunk == target;
        const mask = @as(u16, @bitCast(cmp));
        if (mask != 0) {
            return i + @ctz(mask);
        }
    }

    // Fallback escalar
    while (i < dados.len) : (i += 1) {
        if (dados[i] == '\n') return i;
    }
    return null;
}

Comptime

O Bun usa comptime extensivamente para gerar código otimizado:

• Lookup tables para parsing de HTTP headers
• State machines para tokenização de JavaScript
• Tabelas de hash perfeito para keywords

Impacto no Ecossistema

Para JavaScript

• Forçou Node.js a priorizar performance (Node.js 22+ tem melhorias inspiradas no Bun)
• Estabeleceu novo baseline de performance para tooling JS
• Demonstrou que GC não é obstáculo para runtimes rápidos

Para Zig

• Trouxe visibilidade global para o Zig
• Milhões de desenvolvedores JS conheceram Zig
• Criou demanda por desenvolvedores Zig no mercado
• Validou Zig para projetos de grande escala (~300.000 linhas)

Modelo de Negócio

A Oven, empresa por trás do Bun, recebeu $7M em funding para:

• Manter e desenvolver o Bun como open source
• Oferecer Bun Cloud (plataforma de deploy) como serviço pago
• Empregar desenvolvedores Zig em tempo integral

Esse modelo demonstra que software construído com Zig pode sustentar negócios viáveis.

Contribuições ao Zig

O time do Bun contribui ativamente:

• Bug reports detalhados para o compilador
• Patches de performance
• Documentação de edge cases
• Validação de novas versões do compilador

Lições Aprendidas

1. Performance é feature: Velocidade 10x maior não é incremental, é transformacional
2. Zig escala para projetos grandes: 300K+ linhas de Zig em produção
3. Interop C é produtiva: A integração com JSC é natural e performática
4. Comptime é superpoder: Gerar código otimizado em compilação é único do Zig
5. Comunidade importa: O sucesso do Bun impulsiona todo o ecossistema Zig

Próximos Passos

Explore o ecossistema Bun para mais detalhes técnicos, conheça outros cases como TigerBeetle e Ghostty, e consulte nossa seção de carreira para oportunidades em projetos Zig. Para aprender Zig, visite nossos tutoriais.