gik|iewicz

Dlaczego Bun przepisał runtime z Zig na Rust?

Przepisanie Buna w języku Rust zostało scalone z główną gałęzią repozytorium po zaledwie 9 dniach pracy. Jak relacjonuje The Register, projekt objął milion linii kodu przetłumaczonych przez agentów AI firmy Anthropic. Twórca Buna Jarred Sumner ogłosił, że wersja rustowa przechodzi 99,8% istniejącej suity testów na platformie Linux x64 glibc.

Zig był dotąd fundamentem Buna od samego początku projektu. Dlaczego zatem zdecydowano się na tak drastyczny krok? Otóż motywacja nie leżała w czystej wydajności – chodziło o ekosystem. Rust stał się de facto standardem programowania systemowego, co oznacza łatwiejszą rekrutację programistów i lepsze gwarancje bezpieczeństwa pamięci. Ponadto narzędzia Rusta są bardziej dojrzałe, a społeczność aktywnie rozwija biblioteki dla runtimeów JavaScript.

Zig pozostaje językiem stosunkowo niszowym. Choć oferuje niskopoziomową kontrolę, jego ekosystem jest znacznie mniejszy niż Rusta. Z kolei Rust ma za sobą adopcję w Firefox, Linux kernel, Android, Cloudflare Workers. Ta różnica w adopcji przekłada się na realne korzyści: więcej gotowych bibliotek, lepsze wsparcie narzędziowe, łatwiejszy onboarding nowych programistów. W rezultacie zespół Buna uznał, że długoterminowo Rust będzie lepszym fundamentem.

Ile kodu przepisano i jak szybko to zrobiono?

Milion linii kodu w 9 dni – tak podsumowuje skalę przedsięwzięcia ByteIota. To tempo jest możliwe wyłącznie dzięki wykorzystaniu agentów AI Anthropic, które przetwarzały kod Zig i generowały odpowiedniki w Ruście. Dla porównania, ręczne przepisanie projektu o tej skali zajęłoby miesiące, a nie dni.

Tempo pracy budzi jednak pytania o jakość. Automatyczne tłumaczenie kodu z jednego języka na drugi rzadko produkuje idiomatyczny wynik. Co więcej, agenty AI mogą powielać wzorce ze źródła, które nie są optymalne w języku docelowym. Zespół Buna musiał więc zaakceptować kompromis między szybkością a perfekcją kodu.

Warto tu wspomnieć o wcześniejszym eksperymencie opisanym na blogu gikiewicz.eu – eksperymentalne przepisanie Buna na Rust osiąga 99,8% kompatybilności testów na Linux x64 glibc. Już wtedy testy pokazały, że rustowa wersja zachowuje się niemal identycznie jak oryginał w Zig. Ten eksperyment prawdopodobnie dał zespołowi pewność, że pełne przepisanie jest wykonalne.

Jakie problemy techniczne niesie przepisanie Buna w Rust?

Największą kontrowersją wokół przepisania Buna w Rust jest liczba bloków unsafe. Według ByteIota, rustowa wersja zawiera około 13 000 bloków unsafe. To budzi poważne pytania o gwarancje bezpieczeństwa pamięci, które są głównym argumentem za wyborem Rusta.

Blok unsafe wyłącza pewne sprawdziany kompilatora Rust. W efekcie kod wewnątrz takiego bloku może wykonywać operacje niebezpieczne: dereferencję surowych wskaźników, wywoływanie funkcji unsafe, modyfikację zmiennych statycznych. Dlatego każdy blok unsafe wymaga ręcznej weryfikacji bezpieczeństwa. Przy 13 000 takich bloków powierzchnia ataku rośnie znacząco.

Jak zauważają komentatorzy na Lobsters, rustowa wersja Buna opiera się na wielu konstrukcjach unidiomatycznych. To naturalna konsekwencja automatycznego tłumaczenia z Ziga. Kod Zig ma inną semantykę zarządzania pamięcią niż Rust, toteż bezpośrednie mapowanie konstrukcji prowadzi do nienaturalnych wzorców.

Rozwiązanie tych problemów potrwa zapewne miesiące. Zespół będzie musiał stopniowo refaktorować kod, zastępując bloki unsafe idiomatycznymi wzorcami Rust. Temat bezpieczeństwa w Ruście poruszałem też w artykule Błędy, których Rust nie wyłapie – unsafe to jedno z miejsc, gdzie gwarancje kompilatora się kończą.

Jak wygląda porównanie Zig vs Rust dla runtime’u JavaScript?

Poniższa tabela zestawia kluczowe różnice między obydwoma językami w kontekście budowy runtime’u JavaScript:

Zig oferuje prostszą składnię i bezpośrednią kontrolę nad pamięcią bez ukrytych abstrakcji. Jednakże brak sprawdzianów kompilatora oznacza, że błędy pamięci wykrywa się w runtime. Rust z kolei wymaga więcej boilerplate’u, ale chroni przed całymi klasami błędów już na etapie kompilacji.

Dla runtime’u JavaScript bezpieczeństwo pamięci jest krytyczne. Runtime przetwarza niezaufany kod z sieci, toteż każda luka może prowadzić do zdalnego wykonania kodu. W tym kontekście Rust oferuje silniejsze gwarancje – przynajmniej w części kodu, która nie używa unsafe.

Jaką rolę odegrały agenty AI w przepisywaniu Buna na Rust?

Agenty AI Anthropic wykonały większość ciężkiej pracy przy tłumaczeniu kodu z Ziga na Rust. Według The Register, to właśnie one umożliwiły tempo miliona linii w 9 dni. Bez automatyzacji projekt tej skali wymagałby znacznie dłuższego zaangażowania zespołu programistów.

Wykorzystanie AI do tłumaczenia kodu między językami to nowy wzorzec w inżynierii oprogramowania. Tradycyjnie takie migracje wykonywano ręcznie, z dużą dozą ostrożności. W przypadku Buna zespół zaufał agentom AI, akceptując że wynik będzie wymagał dalszej obróbki. To podejście pozwoliło na błyskawiczne prototypowanie i weryfikację wykonalności migracji.

Kosztem tego podejścia jest jakość kodu. Automatycznie wygenerowany Rust zawiera dużo bloków unsafe, nienaturalne wzorce i bezpośrednie mapowania konstrukcji Ziga. Dlatego praca nad rustową wersją Buna nie kończy się na mergu – zespół będzie musiał iteracyjnie poprawiać kod. Temat roli Rust w nowoczesnych projektach poruszałem w artykule Rust w 2026: Od System Programming do AI/ML.

Co dalej z przepisaniem Buna w Rust po mergu?

Przepisanie Buna w języku Rust zostało scalone, ale to dopiero początek pracy. Kod znajduje się teraz w głównej gałęzi i czeka na optymalizacje. Najpilniejsze zadania obejmują:

• Redukcję liczby bloków unsafe z 13 000 do minimum
• Refaktoryzację kodu unidiomatycznego na wzorce naturalne dla Rusta
• Rozszerzenie testów na platformy macOS i Windows
• Optymalizację wydajnościową porównywalną z wersją w Zig
• Dokumentację architektury rustowej dla nowych współtwórców
• Integrację z crates.io i publikację wybranych modułów jako biblioteki
• Benchmarki porównawcze między wersją Zig i Rust

Zespół Buna będzie utrzymywał obie wersje przez okres przejściowy. Wersja Zig pozostaje stabilna i produkcyjna, natomiast rustowa będzie dojrzewać. Harmonogram przejścia w pełni na Rust nie został jeszcze podany.

Moim zdaniem kluczowym wskaźnikiem sukcesu będzie tempo redukcji bloków unsafe. Jeśli zespół zdoła zejść poniżej tysiąca w ciągu kilku miesięcy, będzie to sygnał, że migracja idzie w dobrym kierunku. Jeśli jednak liczba unsafe utrzyma się na wysokim poziomie – bezpieczeństwo pamięci rustowej wersji będzie wątpliwe.

Jak społeczność Rusta przyjęła przepisanie Buna?

Reakcja społeczności na przepisanie Buna w języku Rust jest mieszana. Według dyskusji na Lobsters, część programistów wyraża zadowolenie z adopcji Rusta, inni jednak martwią się jakością automatycznie wygenerowanego kodu. Główne obawy dotyczą dużej liczby bloków unsafe oraz nienaturalnych wzorców wynikających z bezpośredniego tłumaczenia z Ziga.

Społeczność Rusta ceni idiomatyczny kod, który wykorzystuje sprawdziany kompilatora. Tymczasem rustowa wersja Buna zawiera około 13 000 bloków unsafe według ByteIota. To budzi pytania, czy migracja faktycznie przyniesie gwarancje bezpieczeństwa, które są głównym argumentem za Rustem.

Komentatorzy zauważają też, że automatyczne tłumaczenie rzadko produkuje kod jakości produkcyjnej. Choć 99,8% testów przechodzi, testy nie weryfikują idiomatyczności ani utrzymywalności kodu. Dlatego społeczność z rezerwą podchodzi do deklaracji o sukcesie migracji.

Rustowa wersja Buna zawiera około 13 000 bloków unsafe według analizy ByteIota, co oznacza, że gwarancje bezpieczeństwa pamięci kompilatora są wyłączone w znacznej części kodu. Przy takiej liczbie bloków unsafe, ręczna weryfikacja bezpieczeństwa staje się zadaniem na miesiące.

Z kolei zwolennicy migracji argumentują, że pierwsza wersja nie musi być idealna. Ważne jest to, że fundament jest już w miejscu. Zespół Buna będzie mógł iteracyjnie poprawiać kod, zastępując unidiomatyczne konstrukcje wzorcami naturalnymi dla Rusta. To podejście jest spójne z filozofią „make it work, then make it beautiful”.

Jakie są koszty i korzyści migracji Buna na Rust?

Przepisanie Buna w języku Rust zostało scalone po 9 dniach pracy agentów AI Anthropic, jak relacjonuje The Register. Korzyści tej migracji są długoterminowe: lepszy ekosystem bibliotek, łatwiejsza rekrutacja programistów, dojrzalsze narzędzia. Koszty natomiast są natychmiastowe: 13 000 bloków unsafe, unidiomatyczny kod, konieczność długotrwałego refaktoringu.

Poniżej zestawienie głównych kosztów i korzyści:

• Koszty: 13 000 bloków unsafe wymagają ręcznej weryfikacji
• Koszty: Kod unidiomatyczny utrudnia code review
• Koszty: Utrzymanie dwóch wersji (Zig i Rust) przez okres przejściowy
• Koszty: Ryzyko regresji wydajnościowych w krótkim terminie
• Korzyści: Dostęp do ekosystemu crates.io z tysiącami bibliotek
• Korzyści: Łatwiejsza rekrutacja – Rust jest popularniejszy niż Zig
• Korzyści: Dojrzalsze narzędzia: rust-analyzer, cargo, clippy
• Korzyści: Gwarancje bezpieczeństwa pamięci (po refaktoringu unsafe)

Jak podaje StartupXO, migracja nie dotyczy wydajności – wersja Zig była już szybka. Chodzi o ekosystem i długoterminową utrzymywalność projektu. Rust jest de facto standardem programowania systemowego, co ułatwia współpracę z innymi projektami.

Według StartupXO, migracja Buna z Ziga na Rust nie jest kwestią wydajności, lecz ekosystemu – Rust oferuje lepsze narzędzia, większą pulę programistów i silniejsze gwarancje bezpieczeństwa jako de facto standard programowania systemowego.

Dlatego zespół Buna zaakceptował krótkoterminowe koszty w zamian za długoterminowe korzyści. To strategia typowa dla projektów open source, gdzie utrzymywalność kodu jest ważniejsza niż krótkoterminowa perfekcja.

Czego inne projekty mogą się nauczyć z migracji Buna?

Przepisanie Buna w języku Rust zostało scalone w 9 dni dzięki agentom AI Anthropic, co pokazuje nowe możliwości automatyzacji migracji kodu. Główne lekcje z tego projektu obejmują: automatyczne tłumaczenie jest szybkie, ale wymaga iteracyjnej poprawy, testy nie weryfikują jakości kodu, a kompromis między szybkością a idiomatycznością jest nieunikniony.

Projekty planujące podobne migracje powinny wziąć pod uwagę następujące czynniki:

• Automatyczne tłumaczenie kodu jest wykonalne na dużą skalę
• Wynik wymaga iteracyjnego refaktoringu
• Testy potwierdzają funkcjonalność, ale nie jakość kodu
• Bloki unsafe są nieuniknione przy bezpośrednim mapowaniu semantyki
• Okres przejściowy z dwiema wersjami jest konieczny

Jak zauważają komentatorzy na Lobsters, automatyczne tłumaczenie z Ziga na Rust prowadzi do kodu, który jest funkcjonalnie poprawny, ale nie idiomatyczny. To oznacza, że migracja nie kończy się na wygenerowaniu kodu – właściwa praca zaczyna się po mergu.

Analiza dyskusji na Lobsters pokazuje, że automatyczne tłumaczenie kodu z Ziga na Rust produkuje kod funkcjonalnie poprawny, ale unidiomatyczny, co wymaga iteracyjnego refaktoringu po mergu. Społeczność z rezerwą podchodzi do automatycznie wygenerowanych migracji na dużą skalę.

Temat roli Rust w nowoczesnych projektach systemowych poruszałem w artykule CUDA-oxide: oficjalny kompilator Nvidii z języka Rust do CUDA, gdzie opisuję, jak Rust staje się standardem w narzędziach programistycznych. Przykład Buna potwierdza ten trend – kolejny projekt systemowy wybiera Rust jako fundament.

Jak przepisanie Buna wpłynie na ekosystem JavaScript?

Przepisanie Buna w języku Rust zostało scalone, co może wpłynąć na decyzje innych projektów w ekosystemie JavaScript. Według StartupXO, Rust staje się preferowanym językiem dla narzędzi JavaScript, co już widać w projektach takich jak SWC, Turbopack czy Deno’s LSP. Migracja Buna wzmacnia ten trend.

Wpływ na ekosystem JavaScript można rozpatrywać w kilku wymiarach:

• Konwergencja technologiczna: Więcej narzędzi JS będzie pisanych w Ruście
• Współdzielenie bibliotek: Runtime’y mogą korzystać z tych samych crate’ów
• Standardyzacja: Rust staje się wspólnym mianownikiem dla narzędzi JS
• Rekrutacja: Programiści Rust mogą łatwiej przechodzić do projektów JS

Zatem migracja Buna to nie tylko zmiana w jednym projekcie. To sygnał dla całego ekosystemu, że Rust jest gotowy na bycie fundamentem narzędzi JavaScript. Temat ewolucji ekosystemu narzędziowego poruszałem w artykule Artifacts: wersjonowana pamięć, która mówi w języku Git, gdzie opisuję, jak nowe podejścia do infrastruktury zmieniają sposób budowania oprogramowania.

Według analizy StartupXO, Rust staje się preferowanym językiem dla narzędzi JavaScript, a migracja Buna wzmacnia trend zapoczątkowany przez SWC, Turbopack i Deno. Oznacza to konwergencję technologiczną wokół jednego języka systemowego.

Często zadawane pytania

Ile bloków unsafe zawiera rustowa wersja Buna?

Rustowa wersja Buna zawiera około 13 000 bloków unsafe według ByteIota – zespół musi je stopniowo refaktorować na idiomatyczne wzorce Rust.

Jaki procent testów przechodzi rustowa wersja Buna?

Wersja rustowa przechodzi 99,8% istniejącej suity testów na platformie Linux x64 glibc według twórcy Buna Jarreda Sumnera, cytowanego przez The Register.

Jak długo trwało przepisanie Buna na Rust?

Migracja miliona linii kodu z Ziga na Rust zajęła 9 dni dzięki agentom AI Anthropic według ByteIota – ręczne przepisanie zajęłoby miesiące.

Czy wersja rustowa Buna jest już produkcyjna?

Nie – wersja Zig pozostaje stabilna i produkcyjna, natomiast rustowa będzie dojrzewać w głównej gałęzi. Zespół utrzymuje obie wersje przez okres przejściowy według StartupXO.

Podsumowanie

Przepisanie Buna w języku Rust zostało scalone z główną gałęzią repozytorium, co oznacza początek nowego etapu rozwoju tego runtime’u JavaScript. Główne wnioski z tej migracji:

• Milion linii kodu przetłumaczono z Ziga na Rust w 9 dni dzięki agentom AI Anthropic
• Rustowa wersja przechodzi 99,8% testów, ale zawiera 13 000 bloków unsafe
• Migracja nie dotyczy wydajności – chodzi o ekosystem, rekrutację i bezpieczeństwo
• Kod wymaga iteracyjnego refaktoringu, aby stać się idiomatycznym Rustem
• Rust umacnia się jako de facto standard dla narzędzi systemowych JavaScript

Jeśli interesuje Cię temat bezpieczeństwa w Ruście, przeczytaj artykuł Błędy, których Rust nie wyłapie. Jeśli chcesz śledzić dalszy rozwój Buna i innych narzędzi systemowych – subskrybuj bloga gikiewicz.eu i zostaw komentarz z Twoją opinią o migracji na Rust.