La réécriture de Bun en Rust : La trahison qui a tué Zig ?

Un simple push GitHub de Jarred Sumner, créateur du runtime JavaScript ultra-rapide Bun, a déclenché une tempête au sein de la communauté des développeurs. Sumner a poussé une branche nommée 'Claude Code (Phase) A port', détaillant une réécriture ambitieuse et expérimentale du cœur de Bun de Zig vers Rust. Ce portage, méticuleusement décrit dans un document de 600 lignes, a mappé chaque type, idiome et modèle Zig à son équivalent Rust, évitant spécifiquement les frameworks natifs Rust comme Tokio et Rayon en faveur de callbacks purs et de machines d'état.

La réaction d'internet a été immédiate et explosive. La nouvelle de la branche 'Claude Code (Phase) A port' a déferlé sur Hacker News, recueillant plus de 700 votes positifs et suscitant plus de 500 commentaires en quelques heures. Les plateformes de médias sociaux ont également éclaté en un débat intense, alors que les développeurs se débattaient avec les implications d'un tel changement monumental de Zig, le langage que Bun a si brillamment défendu.

Sumner a rapidement clarifié la réécriture comme étant « juste une expérience » avec une « très forte chance que tout ce code soit complètement abandonné ». Cependant, la communauté des développeurs embrasse rarement la nuance. Cette « expérience » a instantanément été perçue comme une profonde trahison et un coup dur pour la communauté Zig, qui avait célébré Bun comme son projet phare incontesté et le principal évangéliste de la viabilité du langage dans les systèmes à grande échelle.

La récente acquisition de Bun par Anthropic le 2 décembre 2025 a fourni les ressources et l'impulsion nécessaires à une entreprise d'une telle envergure. L'acquisition permet à Bun de prendre en charge Claude Code et le Claude Agent SDK, donnant accès à des tokens et à des outils avancés pour des expériences complètes de migration de code comme ce portage Rust. Ce contexte présente l'expérience comme une exploration sérieuse, et non comme une diversion occasionnelle.

Ce développement transcende une simple curiosité technique. Il représente une bataille à enjeux élevés pour l'avenir de la programmation système, opposant deux langages montants dans le creuset de la performance réelle. La comparaison côte à côte vise à disséquer des facteurs critiques : la performance brute, l'utilisation de la mémoire, la maintenabilité à long terme et l'expérience globale du développeur, préparant le terrain pour un moment charnière dans l'adoption des langages.

Bun a fait irruption sur la scène en tant que runtime JavaScript, gestionnaire de paquets et exécuteur de tests révolutionnaire. Poussé par l'objectif ambitieux de devenir un remplacement tout-en-un, significativement plus rapide pour Node.js, Bun a rapidement captivé l'attention des développeurs. Il promettait de rationaliser l'ensemble du flux de travail de développement JavaScript, offrant une vitesse inégalée pour des tâches telles que l'installation de paquets, le rendu côté serveur et l'exécution de tests, le tout alimenté par le moteur JavaScriptCore hautement optimisé d'Apple.

Dès sa conception, les architectes de Bun ont reconnu le besoin d'un langage système capable de fournir des performances sans compromis. Leur choix s'est porté sur Zig, un concurrent relativement nouveau qui gagnait rapidement la réputation d'être un « meilleur C ». La philosophie de Zig s'alignait parfaitement avec les exigences de Bun : il offrait un contrôle direct sur le matériel, une gestion manuelle de la mémoire pour une efficacité maximale, et une surcharge d'exécution minimale. Cela a permis à Bun d'extraire chaque once de performance du système sous-jacent, un différenciateur critique par rapport aux runtimes établis.

L'interopérabilité exceptionnelle de Zig avec le C s'est avérée un autre facteur décisif. Cela a permis à Bun de s'intégrer sans effort aux bibliothèques C et aux API système existantes, une nécessité pour un projet interagissant profondément avec le système d'exploitation et la pile réseau. Les développeurs ont pu tirer parti de composants de bas niveau éprouvés sans subir de pénalités de performance significatives, accélérant le développement tout en maintenant des performances élevées.

Bun a magistralement exploité les fonctionnalités avancées de Zig, en particulier ses robustes capacités de métaprogrammation à la compilation, incarnées par `comptime`. Cela a permis à Bun de générer des chemins de code hautement optimisés et spécialisés au moment de la compilation, éliminant efficacement la surcharge d'exécution pour de nombreuses opérations. De plus, Zig a fourni un contrôle précis sur les allocateurs de mémoire, permettant à Bun de mettre en œuvre des stratégies de mémoire personnalisées adaptées précisément à sa charge de travail, améliorant encore sa vitesse et réduisant son empreinte mémoire.

L'ascension fulgurante et la livraison constante de benchmarks de performance impressionnants de Bun ont servi de validation puissante et concrète du potentiel de Zig. Le projet a à lui seul élevé le profil de Zig, démontrant sa viabilité pour la construction d'applications complexes et performantes. Le succès de Bun est devenu, à bien des égards, une démonstration phare de la puissance de Zig, prouvant que ses principes de conception uniques pouvaient effectivement offrir une alternative moderne et performante aux langages système traditionnels.

Jarred Sumner a initié la branche « Claude Code (Phase) A port », signalant une expérience ambitieuse de migration de code à grande échelle. Cette entreprise monumentale est devenue réalisable suite à l'acquisition de Bun par Anthropic le 2 décembre 2025, qui a fourni les ressources nécessaires, y compris des agents Claude et des outils étendus, pour mener une réécriture aussi complexe. Cette décision a immédiatement suscité un débat généralisé au sein de la communauté des développeurs.

Au centre de ce port expérimental se trouvait un document de 600 lignes, véritable pierre de Rosette cartographiant l'intégralité de la base de code Zig de Bun. Ce document méticuleux décrivait chaque type, idiome et modèle architectural de Zig, les traduisant précisément dans leurs équivalents Rust. Il a fourni le plan fondamental de la transformation, assurant un processus de conversion direct et systématique plutôt qu'une refonte complète.

Un port idiomatique direct utilisant des rappels purs et des machines à états a constitué l'objectif architectural très spécifique de la réécriture. Cette approche a délibérément reflété le modèle d'exécution de bas niveau de la version originale de Zig, évitant notamment les bibliothèques d'exécution asynchrones Rust de haut niveau populaires comme Tokio et Rayon, se concentrant plutôt sur une traduction « bare-metal » de la logique existante.

La « Phase A » initiale a privilégié la capture fidèle de la logique plutôt que la compilation ou l'optimisation immédiate. Cette approche méthodique visait à garantir que la version Rust reproduise avec précision le comportement complexe de Bun avant l'optimisation des performances. De manière impressionnante, après seulement six jours, la réécriture Rust aurait réussi 99,8 % de la vaste suite de tests existante de Bun sur Linux x64 glibc, un jalon précoce significatif.

Jarred Sumner a rapidement précisé que l'effort n'était « qu'une expérience », et non une réécriture engagée, déclarant qu'il y avait une « très forte probabilité que ce code soit complètement abandonné ». L'objectif reste une comparaison côte à côte des versions viables de Rust et Zig en termes de performances, d'utilisation de la mémoire et de maintenabilité. Ce travail en cours, visible sur le GitHub du projet, invite à l'examen et à la discussion de la part de la communauté des développeurs au sens large, qui peut explorer davantage la base de code de Bun GitHub - oven-sh/bun: Incredibly fast JavaScript runtime, bundler, test runner, and package manager – all in one.

Jarred Sumner, le créateur de Bun, a articulé une motivation claire et pragmatique derrière la réécriture expérimentale en Rust : il en avait « marre de s'inquiéter et de passer beaucoup de temps à corriger les fuites de mémoire et les plantages ». Cette frustration, partagée par de nombreux programmeurs système, souligne les défis inhérents à la gestion manuelle de la mémoire dans une application complexe et critique en termes de performances comme Bun. Le projet, initialement salué pour sa fondation en Zig, a été confronté aux réalités du développement à grande échelle.

Zig, tout en offrant un contrôle de bas niveau exceptionnel et une surcharge d'exécution minimale, place la responsabilité de la gestion de la mémoire directement sur le développeur. Les programmeurs doivent explicitement allouer, désallouer et gérer les durées de vie de la mémoire, un processus sujet à des erreurs subtiles qui se manifestent par des plantages d'exécution difficiles à diagnostiquer et des fuites de mémoire insidieuses. Ce contrôle direct, pierre angulaire de la philosophie de Zig, favorise l'optimisation mais introduit également une charge cognitive significative.

Rust présente une alternative frappante avec son révolutionnaire ownership model et son borrow checker. Ces fonctionnalités linguistiques fondamentales imposent des règles strictes concernant l'accès à la mémoire au moment de la compilation, éliminant ainsi toute une catégorie d'erreurs de programmation courantes avant même que le code ne s'exécute. Le système suit qui « possède » une donnée et assure un accès sûr et concurrent sans avoir besoin d'un ramasse-miettes ou d'appels manuels de mémoire.

Cette approche rigoureuse produit de puissantes compile-time guarantees, prévenant les bugs critiques comme les data races, les vulnérabilités use-after-free et de nombreuses formes de fuites de mémoire. Le débogage de tels problèmes dans des langages comme Zig ou C peut consommer un temps de développement disproportionné, impliquant des outils complexes et des plongées profondes dans les dumps de mémoire. Rust déplace ce fardeau du débogage à l'exécution vers la résolution de problèmes au moment de la compilation, exigeant plus de discipline en amont mais promettant une plus grande stabilité.

L'exploration de Sumner remet directement en question le compromis fondamental : le contrôle brut inégalé de Zig vaut-il la charge cognitive supplémentaire et le risque persistant de problèmes de stabilité pour un projet aussi ambitieux et largement adopté que Bun ? Bun vise à être un remplacement tout-en-un, plus rapide et direct pour Node.js, faisant de la stabilité à toute épreuve et des performances prévisibles des exigences non négociables. Le potentiel d'une fondation plus robuste en Rust, malgré l'effort de migration, a clairement pesé sur Sumner.

En fin de compte, l'expérience avec « Claude Code (Phase) A port » reflète une réévaluation stratégique de la maintenabilité et de la fiabilité à long terme de Bun. Passer à un langage qui prévient proactivement les pièges liés à la mémoire pourrait réduire considérablement les coûts de débogage futurs et améliorer l'expérience globale des développeurs pour l'équipe Bun, même si cela signifie renoncer à certaines des libertés de bas niveau uniques de Zig.

Le pivot ambitieux de Bun vers Rust trouve sa fondation dans une décision stratégique cruciale : son acquisition par Anthropic le 2 décembre 2025. Cette acquisition a fourni les ressources essentielles — des jetons de calcul aux outils avancés comme les Claude AI agents — nécessaires à Jarred Sumner pour entreprendre une réécriture expérimentale aussi massive. Cela a signalé une intégration plus profonde de Bun dans l'écosystème d'Anthropic, permettant au projet de prendre en charge Claude Code et le Claude Agent SDK.

Pour mener à bien cette entreprise, les Claude AI agents traduisent activement des centaines de milliers de lignes de code Zig en Rust. Le processus a commencé avec la branche « Claude Code (Phase) A port », guidée par un document de 600 lignes méticuleusement élaboré. Ce document mappe chaque type, idiome et modèle Zig à son équivalent Rust, garantissant que le code généré par l'IA maintient l'architecture originale, y compris les rappels purs et les machines d'état, évitant délibérément les frameworks comme Tokio ou Rayon.

La raison d'utiliser des LLMs pour une réécriture en Rust, plutôt que d'affiner le Zig existant, se concentre sur le compilateur rigoureux et le système de types robuste de Rust. Les théoriciens suggèrent qu'il est intrinsèquement plus facile pour les grands modèles linguistiques de générer du code Rust correct et sûr en mémoire que de produire du code Zig d'une fiabilité équivalente. La rigueur de Rust agit comme une puissante barrière de sécurité, forçant les LLMs à adhérer à des règles de sécurité précises, réduisant ainsi la probabilité de fuites de mémoire et de plantages – une frustration majeure citée par Jarred Sumner concernant l'implémentation de Zig.

Cette réécriture constitue l'une des premières démonstrations publiques majeures de AI-driven code migration à grande échelle au sein d'un projet open-source populaire. Les progrès rapides sont remarquables ; la réécriture en Rust aurait passé 99,8 % de la suite de tests existante de Bun sur Linux x64 glibc en seulement six jours. Cet accomplissement sans précédent souligne le potentiel transformateur de l'IA en ingénierie logicielle complexe, repoussant les limites de ce qui est possible en matière de modernisation et de maintenance de code à grande échelle.

Au-delà de la frustration de Jarred Sumner concernant les fuites de mémoire et les plantages, Rust offre une série d'avantages convaincants que Zig, malgré ses promesses, ne peut pas encore égaler. La décision d'explorer une réécriture complète en Rust va bien au-delà de la simple stabilité ; elle s'appuie sur un écosystème mature et étendu. Rust dispose d'une vaste collection de bibliothèques de haute qualité, souvent appelées crates, qui accélèrent le développement en fournissant des solutions éprouvées pour des problèmes complexes.

L'écosystème d'outils de Rust est exceptionnellement robuste, avec en tête Cargo, son gestionnaire de paquets et système de construction intégré. Cargo simplifie la gestion des dépendances, les tests et le déploiement, offrant une expérience développeur à la fois puissante et intuitive. Cette infrastructure complète réduit considérablement les frais généraux et permet aux développeurs de se concentrer sur la logique métier plutôt que sur les préoccupations d'infrastructure. Zig, en revanche, possède un écosystème beaucoup plus jeune, avec moins de bibliothèques facilement disponibles et des outils moins matures, bien qu'en évolution rapide.

Les considérations de capital humain influencent également fortement ce pivot stratégique. Rust dispose d'un talent pool significativement plus grand et en croissance rapide par rapport à Zig. Cette plus grande disponibilité de développeurs qualifiés se traduit directement par des processus de recrutement plus faciles pour Anthropic, assurant la croissance et la maintenance continues d'un projet aussi critique que Bun. Une communauté plus large favorise également un développement plus actif et un plus grand volume de contributions open-source potentielles, enrichissant la viabilité à long terme du projet.

Zig, bien que célébré pour son contrôle de bas niveau et sa C interoperability, fonctionne avec une communauté plus petite, bien que passionnée. Cette échelle plus réduite limite intrinsèquement l'étendue de l'expertise disponible et le rythme du développement d'outils piloté par la communauté. L'expérience de portage Claude Code (Phase) A, qui a récemment atteint 99,8 % de compatibilité de test sur Linux x64 glibc en Rust, souligne la préparation pratique du langage pour un projet de la complexité de Bun. Les lecteurs peuvent explorer les discussions en cours et les détails techniques entourant cette entreprise ambitieuse ici : Bun's experimental Rust rewrite hits 99.8% test compatibility on Linux x64 glibc | Hacker News.

L'attrait de Rust pour Bun est donc multifacette. Il représente un mouvement calculé vers un langage qui offre non seulement la memory safety, mais aussi un écosystème florissant, des outils supérieurs et un talent pool facilement accessible, tous des facteurs critiques pour un projet désormais soutenu par les ressources significatives d'Anthropic. Cet avantage global positionne Rust comme un choix pragmatique pour l'évolution future de Bun.

Les partisans de Zig ont rapidement monté une défense sur Hacker News et d'autres forums de développeurs, contestant le récit d'une migration inévitable vers Rust. Beaucoup ont exprimé leur choc et leur déception, arguant que la branche expérimentale « Claude Code (Phase) A port » de Jarred Sumner signalait une trahison du langage que Bun avait élevé au rang de proéminence. La communauté a rejeté l'idée que Zig était devenu un goulot d'étranglement, soulignant plutôt ses forces inhérentes.

La performance constitue un contre-argument majeur. Alors que Rust vante la sécurité de la mémoire et une concurrence robuste, la conception de Zig permet un contrôle explicite inégalé sur le matériel et l'agencement de la mémoire. Cette granularité de bas niveau, affirment les défenseurs de Zig, permet aux développeurs de créer des chemins critiques (hot paths) qui pourraient potentiellement surpasser même les implémentations Rust hautement optimisées. Les gains de vitesse initiaux de Bun étaient, après tout, un témoignage des capacités de Zig.

Des questions de maturité ont également été soulevées. Les critiques se sont demandé si Bun avait réellement dépassé Zig, ou si l'équipe de Bun avait involontairement créé une prophétie auto-réalisatrice. Au lieu de contribuer activement à la bibliothèque standard évolutive ou à l'écosystème plus large de Zig, l'argument est que Bun a souvent développé ses propres solutions internes. Cette approche pourrait avoir limité l'utilité perçue de Zig pour Bun, plutôt que de refléter une limitation réelle du langage lui-même.

L'alignement philosophique a constitué une autre défense fondamentale. L'éthos de Zig privilégie la simplicité, le contrôle explicite et un runtime minimal, offrant aux programmeurs une connexion directe à la machine. Cette philosophie de conception fondamentale a initialement attiré Bun, positionnant Zig comme un choix idéal pour un runtime haute performance. La communauté soutient que l'abandon de ce principe au profit de l'approche plus dogmatique, bien que plus sûre, de Rust représente un changement idéologique significatif.

En fin de compte, de nombreux passionnés de Zig considèrent l'expérience de réécriture non pas comme une accusation contre Zig, mais comme un sous-produit des nouvelles ressources de Bun. L'acquisition par Anthropic fin 2025 a fourni les tokens et les outils substantiels, comme les Claude agents, nécessaires à une entreprise aussi massive. Cette perspective suggère que le mouvement est moins lié aux lacunes de Zig qu'à l'exploitation des capacités de migration assistée par l'IA dans le cadre d'une stratégie d'entreprise plus large, négligeant potentiellement l'efficacité allégée de Zig.

Des chiffres étonnants ont émergé de la branche « Claude Code (Phase) A port » : la réécriture en Rust aurait passé 99,8 % de la suite de tests existante de Bun sur Linux x64 glibc en seulement six jours. Cette vélocité sans précédent, confirmée par Jarred Sumner, suggère fortement l'intervention directe d'outils d'IA avancés, spécifiquement les agents d'Anthropic. Une migration aussi rapide remet en question les délais de développement logiciel conventionnels.

Cependant, la définition de « tests réussis » exige un examen minutieux. Cette phase initiale s'est principalement concentrée sur la capture fidèle de la logique et l'équivalence fonctionnelle, pas nécessairement sur une optimisation complète des performances ou des comparaisons d'empreinte mémoire. Un test réussi pourrait simplement indiquer que la version Rust ne plante pas ou ne renvoie pas de valeurs incorrectes, une première étape cruciale mais loin d'être un benchmark prêt pour la production.

Les analyses approfondies des régressions de performance, des cas limites subtils ou de l'utilisation comparative de la mémoire restent largement non abordées par les affirmations initiales. Les ingénieurs devront valider si le code Rust généré par l'IA maintient l'avantage de vitesse et l'efficacité des ressources caractéristiques de Bun sur diverses charges de travail. La véritable mesure du succès s'étend au-delà de la simple parité fonctionnelle.

Les implications à long terme de l'utilisation de code généré par l'IA pour un projet de l'ampleur de Bun sont profondes. Des questions se posent concernant la maintenabilité et la lisibilité ; le débogage d'interactions complexes dans du code principalement écrit par une IA présente un nouveau défi. Les ingénieurs humains doivent développer de nouvelles compétences pour examiner, comprendre et itérer efficacement sur le code dérivé des grands modèles linguistiques.

Ce changement pourrait redéfinir le rôle du développeur, le faisant passer d'auteur principal à éditeur et validateur sophistiqué des sorties de l'IA. La promesse de cycles de développement plus rapides doit être mise en balance avec le potentiel d'une complexité accrue dans le traçage et la résolution de problèmes profondément enracinés qu'aucun humain n'avait initialement conceptualisés.

En fin de compte, la communauté des développeurs attend le billet de blog promis par Jarred Sumner. Cette prochaine publication contiendra des benchmarks détaillés, offrant la comparaison définitive entre les implémentations Zig et Rust. Ce n'est qu'alors que nous pourrons véritablement évaluer la viabilité de l'expérience, en allant au-delà des pourcentages impressionnants pour atteindre des métriques de performance concrètes et exploitables, et une voie claire pour Bun.

La réécriture de Bun n'est pas seulement un développement interne ; c'est un test A/B très public et à enjeux élevés qui se déroule en temps réel. La branche « Claude Code (Phase) A port » de Jarred Sumner a involontairement préparé le terrain pour une comparaison directe et rigoureuse entre Zig et Rust dans une application système critique. Toute la communauté des développeurs, des utilisateurs de Node.js aux passionnés de langages de bas niveau, observe attentivement comment Bun, un projet qui a initialement mis Zig sur la carte, envisage maintenant ouvertement un avenir propulsé par Rust.

Le succès repose sur des résultats méticuleusement évalués et mesurables. L'équipe de Bun analysera plusieurs métriques cruciales, en comparant les versions Zig et Rust côte à côte : - Performances brutes sur divers benchmarks, des temps de démarrage à l'exécution complexe de JavaScript. - Utilisation globale de la mémoire, une préoccupation constante pour les runtimes haute performance. - La taille finale du binaire du runtime compilé. - Maintenabilité à long terme et expérience développeur pour une base de code croissante et complexe. Ce niveau de transparence sans précédent, soutenu par les ressources d'Anthropic et les outils d'IA avancés, promet un ensemble de données définitif.

Le résultat de cette expérience s'étend bien au-delà des limites de Bun lui-même. Si le port Rust démontre des avantages significatifs et indéniables — peut-être en termes de stabilité, de sécurité, ou même de gains de performance supplémentaires — cela pourrait orienter d'innombrables futurs projets de programmation système vers Rust. Inversement, si Zig tient bon, ou même s'avère supérieur dans des domaines spécifiques et critiques, cela renforcerait sa réputation d'alternative robuste et viable pour les applications haute performance, défiant le récit actuel.

Ce n'est pas seulement un exercice académique ; c'est un point de données tangible et réel dans l'un des débats linguistiques les plus animés de la technologie. Les développeurs ont longtemps débattu des mérites de la sécurité mémoire et des outils robustes de Rust face au contrôle explicite, au compilateur plus simple et aux atouts d'interopérabilité C de Zig. L'expérience Bun offre une étude de cas unique et à grande échelle, fournissant des informations inestimables pour les futures décisions architecturales à travers l'industrie. Pour des détails fondamentaux sur le langage, l'exploration de ressources comme Home ⚡ Zig Programming Language offre un aperçu plus approfondi de sa philosophie de conception.

Jarred Sumner, le créateur visionnaire de Bun, ne se contente pas d'expérimenter avec Rust ; il postule un avenir provocateur : l'IA écrira la majorité du code des projets open source. Ce n'est pas une spéculation abstraite. L'expérience du « portage Claude Code (Phase) », une entreprise monumentale rendue possible par l'acquisition de Bun par Anthropic, en est le terrain d'essai. Un agent IA avancé, plutôt qu'une équipe de développeurs humains, a généré la réécriture initiale en Rust qui a remarquablement passé 99,8 % de la suite de tests étendue de Bun sur Linux x64 en seulement six jours. Cette vitesse sans précédent offre un aperçu d'un modèle de développement radicalement différent.

Ce changement profond reconfigure l'essence même de la maintenance open source. Sumner envisage un avenir où les développeurs humains passeront de la création de code complexe à la définition de plans architecturaux globaux, à l'affinement méticuleux des invites pour des agents IA sophistiqués, et à l'évaluation critique des demandes de tirage générées par l'IA. Le travail principal passe de l'exécution à la conception de haut niveau et à la validation rigoureuse, exigeant un nouveau type d'expertise axée sur la clarté, la supervision stratégique et un examen judicieux.

Une telle philosophie de développement axée sur l'IA entre inévitablement en conflit avec les principes établis de l'open source, notamment l'interdiction stricte de Zig concernant les contributions rédigées par des LLM. Cette division idéologique pose une question fondamentale : la recherche d'efficacité par l'IA l'emportera-t-elle sur les principes de l'artisanat humain et de la propriété directe des développeurs ? L'expérience Bun force la communauté de la programmation système à confronter cette tension émergente entre l'accélération technologique et les valeurs fondamentales.

En fin de compte, le choix final du langage de Bun – qu'il revienne à Zig ou s'engage pleinement envers Rust – devient presque secondaire par rapport aux profondes implications de cette expérience. Le « portage Claude Code (Phase) » démontre une nouvelle capacité puissante : la migration et le développement de code à grande échelle, accélérés par l'IA. Son taux de réussite initial quasi parfait en moins d'une semaine établit un précédent étonnant. Cette entreprise alimentée par l'IA a irrévocablement modifié les attentes en matière de développement open source, signalant une nouvelle ère pour la façon dont le code est écrit, maintenu et évolué. Le jeu a changé pour toujours.

Pourquoi Bun envisage-t-il de passer de Zig à Rust ?

Le créateur de Bun, Jarred Sumner, a cité un désir d'une meilleure sécurité de la mémoire et d'une plus grande stabilité. Il vise à passer moins de temps à corriger les fuites de mémoire et les plantages, en tirant parti des garanties de sécurité au moment de la compilation de Rust.

La réécriture en Rust est-elle officielle et permanente ?

Non. Jarred Sumner a déclaré que ce n'était « qu'une expérience » pour créer une version Rust viable à comparer côte à côte avec la version Zig en termes de performances, de mémoire et de maintenabilité. Il y a de fortes chances que le code Rust soit abandonné.

Quel rôle l'IA a-t-elle joué dans cette expérience de réécriture ?

Un rôle significatif. L'expérience, appelée le « portage Claude Phase A », utilise massivement des agents IA d'Anthropic (qui a acquis Bun) pour traduire automatiquement des centaines de milliers de lignes de code Zig en Rust.

Zig est-il un langage mort maintenant à cause de Bun ?

Non, Zig n'est pas mort. Cependant, cette expérience très médiatisée de son projet le plus célèbre a suscité un débat majeur et est considérée comme un défi significatif pour l'élan et la perception de l'écosystème Zig.