A Reescrita de Bun em Rust: A Traição Que Matou o Zig?

Um único push no GitHub por Jarred Sumner, criador do runtime JavaScript ultrarrápido Bun, acendeu uma tempestade na comunidade de desenvolvedores. Sumner enviou um branch chamado 'Claude Code (Phase) A port,' detalhando uma reescrita ambiciosa e experimental do núcleo de Bun de Zig para Rust. Este port, meticulosamente delineado num documento de 600 linhas, mapeou cada tipo, idioma e padrão de Zig para o seu equivalente em Rust, evitando especificamente frameworks nativos de Rust como Tokio e Rayon em favor de callbacks puros e máquinas de estado.

A reação da internet foi imediata e explosiva. A notícia do branch 'Claude Code (Phase) A port' espalhou-se pelo Hacker News, obtendo mais de 700 upvotes e gerando mais de 500 comentários em poucas horas. As plataformas de redes sociais irromperam de forma semelhante com um intenso debate, enquanto os desenvolvedores lidavam com as implicações de uma mudança tão monumental do Zig, a linguagem que Bun famosamente defendeu.

Sumner rapidamente esclareceu a reescrita como "apenas uma experiência" com uma "chance muito alta de todo este código ser completamente descartado." No entanto, a comunidade de desenvolvedores raramente abraça a nuance. Esta "experiência" foi instantaneamente registada como uma profunda traição e um grande golpe para a comunidade Zig, que tinha celebrado Bun como o seu indiscutível projeto emblemático e principal evangelista da viabilidade da linguagem em sistemas de grande escala.

A recente aquisição de Bun pela Anthropic em 2 de dezembro de 2025, forneceu os recursos e o ímpeto para uma empreitada de tão grande escala. A aquisição permite que Bun suporte o Claude Code e o Claude Agent SDK, concedendo acesso a tokens e ferramentas avançadas para experimentos abrangentes de migração de código como este port em Rust. Este contexto enquadra o experimento como uma exploração séria, não uma diversão casual.

Este desenvolvimento transcende uma mera curiosidade técnica. Representa uma batalha de alto risco pelo futuro da programação de sistemas, colocando duas linguagens em ascensão uma contra a outra no cadinho do desempenho no mundo real. A comparação lado a lado visa dissecar fatores críticos: desempenho bruto, uso de memória, manutenibilidade a longo prazo e experiência geral do desenvolvedor, preparando o cenário para um momento crucial na adoção de linguagens.

Bun irrompeu na cena como um runtime JavaScript revolucionário, gerenciador de pacotes e executor de testes. Impulsionado pelo objetivo ambicioso de se tornar um substituto drop-in significativamente mais rápido e tudo-em-um para o Node.js, Bun rapidamente capturou a atenção dos desenvolvedores. Prometeu otimizar todo o fluxo de trabalho de desenvolvimento JavaScript, oferecendo velocidade incomparável para tarefas como instalação de pacotes, renderização do lado do servidor e execução de testes, tudo alimentado pelo motor JavaScriptCore altamente otimizado da Apple.

Desde a sua conceção, os arquitetos de Bun reconheceram a necessidade de uma linguagem de sistemas que pudesse oferecer desempenho intransigente. A sua escolha recaiu sobre Zig, um concorrente relativamente novo que rapidamente ganhava a reputação de um "C melhor". A filosofia de Zig alinhava-se perfeitamente com as exigências de Bun: fornecia controlo direto sobre o hardware, gestão manual de memória para máxima eficiência e sobrecarga mínima de runtime. Isso permitiu que Bun extraísse cada grama de desempenho do sistema subjacente, um diferenciador crítico contra runtimes estabelecidos.

A interoperabilidade C excepcional de Zig provou ser outro fator decisivo. Isso permitiu que Bun se integrasse sem esforço com bibliotecas C existentes e APIs de sistema, uma necessidade para um projeto que interage profundamente com o sistema operacional e a pilha de rede. Os desenvolvedores puderam aproveitar componentes de baixo nível testados em batalha sem incorrer em penalidades de desempenho significativas, acelerando o desenvolvimento enquanto mantinham alta performance.

Bun explorou magistralmente os recursos avançados de Zig, particularmente suas robustas capacidades de metaprogramação em tempo de compilação, epitomizadas por `comptime`. Isso permitiu que Bun gerasse caminhos de código altamente otimizados e especializados em tempo de construção, eliminando efetivamente a sobrecarga de tempo de execução para muitas operações. Além disso, Zig forneceu controle granular sobre alocadores de memória, permitindo que Bun implementasse estratégias de memória personalizadas e precisamente adaptadas para sua carga de trabalho, melhorando ainda mais sua velocidade e reduzindo o consumo de memória.

A subsequente ascensão meteórica de Bun e a entrega consistente de impressionantes benchmarks de desempenho serviram como uma validação poderosa e real do potencial de Zig. O projeto, por si só, elevou o perfil de Zig, demonstrando sua viabilidade para a construção de aplicações complexas e de alto desempenho. O sucesso de Bun tornou-se, de muitas maneiras, uma demonstração emblemática do poder de Zig, provando que seus princípios de design únicos poderiam de fato oferecer uma alternativa moderna e performática às linguagens de sistema tradicionais.

Jarred Sumner iniciou a branch "Claude Code (Phase) A port", sinalizando um ambicioso experimento de migração de código em larga escala. Este empreendimento monumental tornou-se viável após a aquisição de Bun pela Anthropic em 2 de dezembro de 2025, que forneceu os recursos necessários, incluindo Claude agents e ferramentas extensivas, para conduzir uma reescrita tão complexa. A mudança acendeu um debate imediato e generalizado em toda a comunidade de desenvolvedores.

Central para este port experimental foi um documento de 600 linhas, efetivamente uma Pedra de Roseta mapeando toda a base de código Zig de Bun. Este documento meticuloso delineou cada tipo, idiomatismo e padrão arquitetônico de Zig, traduzindo-os precisamente para seus equivalentes em Rust. Ele forneceu o projeto fundamental para a transformação, garantindo um processo de conversão direto e sistemático, em vez de um redesenho do zero.

Um port idiomático direto usando callbacks puros e máquinas de estado formou o objetivo arquitetônico altamente específico da reescrita. Essa abordagem espelhou deliberadamente o modelo de execução de baixo nível da versão original de Zig, notavelmente evitando bibliotecas de tempo de execução assíncronas de alto nível populares de Rust como Tokio e Rayon, focando em vez disso em uma tradução bare-metal da lógica existente.

A "Fase A" inicial priorizou a captura fiel da lógica em detrimento da compilação ou otimização imediata. Essa abordagem metódica visava garantir que a versão em Rust replicasse com precisão o comportamento intrincado de Bun antes do ajuste de desempenho. Impressionantemente, após apenas seis dias, a reescrita em Rust supostamente passou em 99,8% do extenso conjunto de testes existente de Bun no Linux x64 glibc, um marco inicial significativo.

Jarred Sumner rapidamente esclareceu que o esforço era "apenas um experimento", não uma reescrita comprometida, afirmando que há "uma chance muito alta de que este código seja completamente descartado". O objetivo permanece uma comparação lado a lado de versões viáveis de Rust e Zig em termos de desempenho, uso de memória e manutenibilidade. Este trabalho contínuo, visível no GitHub do projeto, convida ao escrutínio e à discussão da comunidade de desenvolvedores mais ampla, que pode explorar a base de código de Bun ainda mais GitHub - oven-sh/bun: Incredibly fast JavaScript runtime, bundler, test runner, and package manager – all in one.

Jarred Sumner, o criador do Bun, articulou uma motivação clara e pragmática por trás da reescrita experimental em Rust: ele se cansou de "se preocupar e gastar muito tempo corrigindo vazamentos de memória e falhas." Essa frustração, compartilhada por muitos programadores de sistemas, destaca os desafios inerentes ao gerenciamento manual de memória em uma aplicação complexa e crítica para o desempenho como o Bun. O projeto, inicialmente elogiado por sua base em Zig, enfrentou as realidades do desenvolvimento em larga escala.

O Zig, embora ofereça controle de baixo nível excepcional e sobrecarga mínima em tempo de execução, coloca a responsabilidade do gerenciamento de memória diretamente sobre o desenvolvedor. Os programadores devem alocar, desalocar e gerenciar explicitamente os ciclos de vida da memória, um processo propenso a erros sutis que se manifestam como falhas em tempo de execução difíceis de diagnosticar e vazamentos de memória insidiosos. Esse controle direto, um pilar da filosofia do Zig, permite a otimização, mas também introduz uma carga cognitiva significativa.

O Rust apresenta uma alternativa marcante com seu revolucionário ownership model e borrow checker. Esses recursos centrais da linguagem impõem regras estritas sobre o acesso à memória em tempo de compilação, eliminando uma categoria inteira de erros de programação comuns antes mesmo que o código seja executado. O sistema rastreia quem "possui" um pedaço de dados e garante acesso seguro e concorrente sem a necessidade de um coletor de lixo ou chamadas manuais de memória.

Essa abordagem rigorosa produz poderosas compile-time guarantees, prevenindo bugs críticos como condições de corrida (data races), vulnerabilidades de uso após liberação (use-after-free) e muitas formas de vazamentos de memória. Depurar tais problemas em linguagens como Zig ou C pode consumir um tempo desproporcional do desenvolvedor, envolvendo ferramentas complexas e análises profundas de despejos de memória. O Rust transfere esse fardo da depuração em tempo de execução para a resolução de problemas em tempo de compilação, exigindo mais disciplina inicial, mas prometendo maior estabilidade.

A exploração de Sumner questiona diretamente o trade-off fundamental: o controle bruto incomparável do Zig vale a carga cognitiva adicional e o risco persistente de problemas de estabilidade para um projeto tão ambicioso e amplamente adotado como o Bun? O Bun visa ser um substituto completo e mais rápido para o Node.js, tornando a estabilidade inabalável e o desempenho previsível requisitos inegociáveis. O potencial para uma base mais robusta em Rust, apesar do esforço de migração, claramente pesou sobre Sumner.

Em última análise, o experimento com "Claude Code (Phase) A port" reflete uma reavaliação estratégica da manutenibilidade e confiabilidade de longo prazo do Bun. Mudar para uma linguagem que previne proativamente armadilhas relacionadas à memória poderia reduzir significativamente os custos futuros de depuração e melhorar a experiência geral do desenvolvedor para a equipe do Bun, mesmo que isso signifique abrir mão de algumas das liberdades únicas de baixo nível do Zig.

A ambiciosa mudança do Bun para Rust encontra sua base em um movimento estratégico crucial: sua aquisição pela Anthropic em 2 de dezembro de 2025. Essa aquisição forneceu os recursos essenciais – desde tokens de computação até ferramentas avançadas como Claude AI agents – necessários para Jarred Sumner embarcar em uma reescrita experimental tão massiva. Isso sinalizou uma integração mais profunda do Bun no ecossistema da Anthropic, permitindo que o projeto suportasse o Claude Code e o Claude Agent SDK.

Impulsionando este empreendimento, os Claude AI agents estão traduzindo ativamente centenas de milhares de linhas de código Zig para Rust. O processo começou com o branch "Claude Code (Phase) A port", guiado por um documento meticulosamente elaborado de 600 linhas. Este documento mapeia cada tipo, idioma e padrão do Zig para seu equivalente em Rust, garantindo que o código gerado por IA mantenha a arquitetura original, incluindo pure callbacks e state machines, evitando deliberadamente frameworks como Tokio ou Rayon.

A lógica por trás do uso de LLMs para uma reescrita em Rust, em vez de refinar o Zig existente, centra-se no compilador rigoroso e no sistema de tipos robusto do Rust. Teóricos sugerem que é inerentemente mais fácil para grandes modelos de linguagem gerar Rust correto e seguro para a memória do que produzir código Zig igualmente confiável. A rigidez do Rust atua como um poderoso trilho de segurança, forçando os LLMs a aderir a regras de segurança precisas, reduzindo assim a probabilidade de vazamentos de memória e falhas — uma frustração primária que Jarred Sumner citou com a implementação em Zig.

Esta reescrita representa uma das primeiras grandes demonstrações públicas de migração de código impulsionada por IA em larga escala dentro de um projeto de código aberto popular. O rápido progresso é notável; a reescrita em Rust supostamente passou em 99,8% do conjunto de testes existente do Bun no Linux x64 glibc em apenas seis dias. Esta conquista sem precedentes sublinha o potencial transformador da IA na engenharia de software complexa, expandindo os limites do que é possível na modernização e manutenção de código em larga escala.

Além da frustração de Jarred Sumner com vazamentos de memória e falhas, o Rust oferece um conjunto atraente de vantagens que o Zig, apesar de sua promessa, ainda não consegue igualar. A decisão de explorar uma reescrita completa em Rust vai muito além da mera estabilidade; ela explora um ecossistema maduro e expansivo. O Rust possui uma vasta coleção de bibliotecas de alta qualidade, frequentemente chamadas de crates, que aceleram o desenvolvimento ao fornecer soluções testadas em batalha para problemas complexos.

O ecossistema de ferramentas do Rust é excepcionalmente robusto, liderado pelo Cargo, seu gerenciador de pacotes e sistema de construção integrado. O Cargo simplifica o gerenciamento de dependências, testes e implantação, oferecendo uma experiência de desenvolvedor que é poderosa e intuitiva. Esta infraestrutura abrangente reduz significativamente a sobrecarga e permite que os desenvolvedores se concentrem na lógica central, em vez de preocupações com a infraestrutura. O Zig, em contraste, possui um ecossistema muito mais jovem, com menos bibliotecas prontamente disponíveis e ferramentas menos maduras, embora em rápida evolução.

Considerações de capital humano também influenciam fortemente esta mudança estratégica. O Rust comanda um pool de talentos significativamente maior e em rápido crescimento em comparação com o Zig. Esta maior disponibilidade de desenvolvedores qualificados se traduz diretamente em processos de contratação mais fáceis para a Anthropic, garantindo o crescimento e a manutenção sustentados de um projeto tão crítico quanto o Bun. Uma comunidade maior também fomenta um desenvolvimento mais ativo e um maior volume de potenciais contribuições de código aberto, enriquecendo a viabilidade de longo prazo do projeto.

O Zig, embora celebrado por seu controle de baixo nível e interoperabilidade com C, opera com uma comunidade menor, embora apaixonada. Essa escala menor limita inerentemente a amplitude da expertise disponível e o ritmo de desenvolvimento de ferramentas impulsionado pela comunidade. O experimento de portabilidade Claude Code (Phase) A, que recentemente alcançou 99,8% de compatibilidade de testes no Linux x64 glibc em Rust, destaca a prontidão prática da linguagem para um projeto da complexidade do Bun. Os leitores podem explorar as discussões em andamento e os detalhes técnicos sobre este ambicioso empreendimento aqui: Bun's experimental Rust rewrite hits 99.8% test compatibility on Linux x64 glibc | Hacker News.

O fascínio do Rust para o Bun, portanto, é multifacetado. Ele representa um movimento calculado em direção a uma linguagem que oferece não apenas segurança de memória, mas também um ecossistema próspero, ferramentas superiores e um pool de talentos prontamente acessível, todos fatores críticos para um projeto agora apoiado pelos recursos significativos da Anthropic. Esta vantagem abrangente posiciona o Rust como uma escolha pragmática para a futura evolução do Bun.

Os defensores do Zig rapidamente montaram uma defesa no Hacker News e em outros fóruns de desenvolvedores, desafiando a narrativa de uma migração inevitável para Rust. Muitos expressaram choque e decepção, argumentando que o branch experimental “Claude Code (Phase) A port” de Jarred Sumner sinalizava uma traição à linguagem que Bun havia elevado à proeminência. A comunidade refutou a ideia de que o Zig havia se tornado um gargalo, destacando suas forças inerentes.

A Performance surge como um contra-argumento primário. Enquanto Rust ostenta segurança de memória e concorrência robusta, o design do Zig permite um controle explícito incomparável sobre o hardware e o layout da memória. Essa granularidade de baixo nível, argumentam os defensores do Zig, permite que os desenvolvedores criem caminhos críticos de alta demanda que poderiam potencialmente superar até mesmo implementações Rust altamente otimizadas. Os ganhos de velocidade iniciais do Bun foram, afinal, um testemunho das capacidades do Zig.

Questões de maturidade também surgiram. Críticos ponderaram se o Bun realmente superou o Zig, ou se a equipe do Bun inadvertidamente criou uma profecia autorrealizável. Em vez de contribuir ativamente para a biblioteca padrão em evolução do Zig ou para o ecossistema mais amplo, argumenta-se, o Bun frequentemente desenvolvia suas próprias soluções internas. Essa abordagem pode ter limitado a utilidade percebida do Zig para o Bun, em vez de refletir uma limitação real da própria linguagem.

O alinhamento filosófico formou outra defesa central. O ethos do Zig prioriza a simplicidade, o controle explícito e um runtime mínimo, capacitando os programadores com uma conexão direta com a máquina. Essa filosofia de design fundamental originalmente atraiu o Bun, posicionando o Zig como uma escolha ideal para um runtime de alto desempenho. A comunidade argumenta que abandonar este princípio pela abordagem mais opinativa, embora mais segura, do Rust representa uma mudança ideológica significativa.

Em última análise, muitos entusiastas do Zig veem o experimento de reescrita não como uma acusação ao Zig, mas como um subproduto dos novos recursos do Bun. A aquisição da Anthropic no final de 2025 forneceu os tokens e ferramentas substanciais, como os Claude agents, necessários para uma empreitada tão massiva. Essa perspectiva sugere que a mudança é menos sobre as deficiências do Zig e mais sobre o aproveitamento das capacidades de migração assistida por IA dentro de uma estratégia corporativa maior, potencialmente negligenciando a eficiência enxuta do Zig.

Números surpreendentes surgiram do branch "Claude Code (Phase) A port": a reescrita em Rust supostamente passou em 99,8% do conjunto de testes existente do Bun no Linux x64 glibc em apenas seis dias. Essa velocidade sem precedentes, confirmada por Jarred Sumner, sugere fortemente a intervenção direta de ferramentas avançadas de IA, especificamente os agentes da Anthropic. Uma migração tão rápida desafia os cronogramas convencionais de desenvolvimento de software.

No entanto, a definição de "passar nos testes" exige escrutínio. Esta fase inicial focou principalmente na captura fiel da lógica e na equivalência funcional, não necessariamente na otimização abrangente de desempenho ou em comparações de uso de memória. Um teste aprovado pode simplesmente indicar que a versão Rust não trava ou não retorna valores incorretos, um primeiro passo crucial, mas longe de ser um benchmark pronto para produção.

Análises aprofundadas sobre regressões de desempenho, casos de uso sutis ou uso comparativo de memória permanecem em grande parte não abordadas pelas alegações iniciais. Os engenheiros precisarão validar se o código Rust gerado por IA mantém a vantagem de velocidade e a eficiência de recursos características do Bun em diversas cargas de trabalho. A verdadeira medida de sucesso vai além da mera paridade funcional.

As implicações a longo prazo de depender de código gerado por IA para um projeto da escala de Bun são profundas. Surgem questões sobre manutenibilidade e legibilidade; depurar interações complexas em código primariamente escrito por uma IA apresenta um novo desafio. Engenheiros humanos devem desenvolver novas habilidades para efetivamente revisar, entender e iterar sobre código derivado de large language models.

Essa mudança poderia redefinir o papel do desenvolvedor, passando de autor primário para editor sofisticado e validador de saídas de IA. A promessa de ciclos de desenvolvimento mais rápidos deve ser ponderada contra o potencial de aumento da complexidade no rastreamento e correção de problemas profundamente enraizados que nenhum humano inicialmente conceituou.

Em última análise, a comunidade de desenvolvedores aguarda a prometida postagem de blog de Jarred Sumner. Este lançamento futuro conterá benchmarks detalhados, oferecendo a comparação definitiva entre as implementações de Zig e Rust. Somente então poderemos realmente avaliar a viabilidade do experimento, indo além de porcentagens impressionantes para métricas de desempenho concretas e acionáveis e um caminho claro para o futuro do Bun.

A reescrita do Bun não é meramente um desenvolvimento interno; é um teste A/B muito público e de alto risco se desenrolando em tempo real. O branch "Claude Code (Phase) A port" de Jarred Sumner inadvertidamente preparou o terreno para uma comparação direta e rigorosa entre Zig e Rust em uma aplicação de sistemas crítica. Toda a comunidade de desenvolvedores, desde usuários de Node.js até entusiastas de linguagens de baixo nível, observa atentamente enquanto Bun, um projeto que inicialmente colocou Zig no mapa, agora contempla abertamente um futuro impulsionado por Rust.

O sucesso depende de resultados meticulosamente avaliados e mensuráveis. A equipe do Bun analisará várias métricas cruciais, comparando as versões Zig e Rust lado a lado: - Desempenho bruto em vários benchmarks, desde tempos de inicialização até a execução complexa de JavaScript. - Uso geral de memória, uma preocupação perene para runtimes de alto desempenho. - O tamanho final do binário do runtime compilado. - Manutenibilidade a longo prazo e experiência do desenvolvedor para uma base de código crescente e complexa. Este nível de transparência sem precedentes, apoiado pelos recursos da Anthropic e ferramentas avançadas de IA, promete um conjunto de dados definitivo.

O resultado deste experimento se estende muito além dos limites do próprio Bun. Se o port de Rust demonstrar vantagens significativas e inegáveis — talvez em estabilidade, segurança ou até mesmo ganhos adicionais de desempenho — isso poderia influenciar inúmeros futuros projetos de programação de sistemas em direção ao Rust. Por outro lado, se Zig se mantiver firme, ou até mesmo se mostrar superior em áreas específicas e críticas, isso reforçaria sua reputação como uma alternativa robusta e viável para aplicações de alto desempenho, desafiando a narrativa atual.

Isso não é meramente um exercício acadêmico; é um dado tangível e do mundo real em um dos debates de linguagem mais acalorados da tecnologia. Desenvolvedores há muito tempo argumentam os méritos da segurança de memória e das ferramentas robustas do Rust contra o controle explícito do Zig, seu compilador mais simples e seus pontos fortes de interoperabilidade com C. O experimento Bun oferece um estudo de caso único e em larga escala, fornecendo insights inestimáveis para futuras decisões arquitetônicas em toda a indústria. Para detalhes fundamentais da linguagem, explorar recursos como Home ⚡ Zig Programming Language oferece uma visão mais profunda de sua filosofia de design.

Jarred Sumner, o criador visionário do Bun, não apenas experimenta com Rust; ele postula um futuro provocador: a IA escreverá a maioria do código de projetos de código aberto. Isso não é especulação abstrata. O experimento "Claude Code (Phase) port", um empreendimento monumental possibilitado pela aquisição do Bun pela Anthropic, serve como seu campo de provas. Um agente de IA avançado, em vez de uma equipe de desenvolvedores humanos, gerou a reescrita inicial em Rust que notavelmente passou em 99,8% do extenso conjunto de testes do Bun no Linux x64 em meros seis dias. Essa velocidade sem precedentes oferece um vislumbre de um modelo de desenvolvimento radicalmente diferente.

Essa mudança profunda reconfigura a própria essência da manutenção de código aberto. Sumner vislumbra um futuro onde desenvolvedores humanos passam de criar código intrincado para definir projetos arquitetônicos abrangentes, refinando meticulosamente os prompts para agentes de IA sofisticados e avaliando criticamente as solicitações de pull geradas por IA. O trabalho central muda da execução para o design de alto nível e validação rigorosa, exigindo um novo tipo de expertise focado em clareza, supervisão estratégica e revisão criteriosa.

Tal filosofia de desenvolvimento com prioridade à IA inevitavelmente colide com os princípios estabelecidos de código aberto, mais notavelmente a estrita proibição do Zig sobre contribuições autoradas por LLM. Essa divisão ideológica apresenta uma questão fundamental: a busca por eficiência através da IA irá sobrepor-se aos princípios de artesanato humano e propriedade direta do desenvolvedor? O experimento Bun força a comunidade de programação de sistemas a confrontar essa tensão emergente entre aceleração tecnológica e valores fundamentais.

Em última análise, a escolha final da linguagem do Bun — se ele retorna ao Zig ou se compromete totalmente com o Rust — torna-se quase secundária às profundas implicações deste experimento. O "Claude Code (Phase) port" demonstra uma nova e potente capacidade: migração e desenvolvimento de código em larga escala, acelerados por IA. Sua taxa de aprovação inicial quase perfeita em menos de uma semana estabelece um precedente surpreendente. Este empreendimento impulsionado por IA alterou irrevogavelmente as expectativas para o desenvolvimento de código aberto, sinalizando uma nova era para como o código é escrito, mantido e evoluído. O jogo mudou para sempre.

Por que o Bun está considerando uma mudança de Zig para Rust?

O criador do Bun, Jarred Sumner, citou o desejo por maior segurança de memória e estabilidade. Ele busca gastar menos tempo corrigindo vazamentos de memória e falhas, aproveitando as garantias de segurança em tempo de compilação do Rust.

A reescrita para Rust é oficial e permanente?

Não. Jarred Sumner afirmou que é 'apenas um experimento' para criar uma versão viável em Rust para comparar lado a lado com a versão em Zig em termos de desempenho, memória e manutenibilidade. Há uma grande chance de o código Rust ser descartado.

Que papel a IA desempenhou neste experimento de reescrita?

Um papel significativo. O experimento, chamado 'Claude Phase A port', utiliza intensamente agentes de IA da Anthropic (que adquiriu o Bun) para traduzir automaticamente centenas de milhares de linhas de código Zig para Rust.

Zig é uma linguagem morta agora por causa do Bun?

Não, Zig não está morta. No entanto, este experimento de alto perfil de seu projeto mais famoso gerou um grande debate e é visto como um desafio significativo para o ímpeto e a percepção do ecossistema Zig.