Переписывание Bun на Rust: Предательство, убившее Zig?

Единственная публикация на GitHub от Jarred Sumner, создателя молниеносной среды выполнения JavaScript Bun, вызвала бурю в сообществе разработчиков. Самнер опубликовал ветку под названием 'Claude Code (Phase) A port', подробно описывающую амбициозное, экспериментальное переписывание ядра Bun с Zig на Rust. Этот порт, тщательно описанный в 600-строчном документе, сопоставлял каждый тип, идиому и шаблон Zig с их эквивалентами на Rust, специально избегая нативных для Rust фреймворков, таких как Tokio и Rayon, в пользу чистых колбэков и конечных автоматов.

Реакция интернета была немедленной и взрывной. Новости о ветке 'Claude Code (Phase) A port' быстро распространились по Hacker News, набрав более 700 голосов и вызвав более 500 комментариев за считанные часы. Платформы социальных сетей также взорвались жаркими дебатами, поскольку разработчики обсуждали последствия такого монументального перехода от Zig, языка, который Bun так активно продвигал.

Самнер быстро уточнил, что переписывание — это «просто эксперимент» с «очень высокой вероятностью того, что весь этот код будет полностью отброшен». Однако сообщество разработчиков редко воспринимает нюансы. Этот «эксперимент» мгновенно был воспринят как глубокое предательство и серьезный удар по сообществу Zig, которое считало Bun своим бесспорным флагманским проектом и главным евангелистом жизнеспособности языка в крупномасштабных системах.

Недавнее приобретение Bun компанией Anthropic 2 декабря 2025 года предоставило ресурсы и импульс для такого масштабного предприятия. Приобретение позволяет Bun поддерживать Claude Code и Claude Agent SDK, предоставляя доступ к токенам и передовым инструментам для комплексных экспериментов по миграции кода, таких как этот порт на Rust. Этот контекст представляет эксперимент как серьезное исследование, а не случайное отвлечение.

Это развитие выходит за рамки простого технического любопытства. Оно представляет собой битву с высокими ставками за будущее системного программирования, сталкивая два восходящих языка друг с другом в горниле реальной производительности. Параллельное сравнение призвано проанализировать критические факторы: чистую производительность, использование памяти, долгосрочную поддерживаемость и общий опыт разработчиков, подготавливая почву для поворотного момента в принятии языков.

Bun ворвался на сцену как революционная среда выполнения JavaScript, менеджер пакетов и тестовый раннер. Движимый амбициозной целью стать значительно более быстрой, универсальной заменой для Node.js, Bun быстро привлек внимание разработчиков. Он обещал оптимизировать весь рабочий процесс разработки на JavaScript, предлагая беспрецедентную скорость для таких задач, как установка пакетов, рендеринг на стороне сервера и запуск тестов, все это на базе высокооптимизированного движка JavaScriptCore от Apple.

С самого начала архитекторы Bun осознали необходимость в системном языке, который мог бы обеспечить бескомпромиссную производительность. Их выбор пал на Zig, относительно нового претендента, быстро завоевывающего репутацию «лучшего C». Философия Zig идеально соответствовала требованиям Bun: он обеспечивал прямой контроль над оборудованием, ручное управление памятью для максимальной эффективности и минимальные накладные расходы во время выполнения. Это позволило Bun выжать каждую унцию производительности из базовой системы, что является критическим отличием от существующих сред выполнения.

Исключительная совместимость Zig с C оказалась еще одним решающим фактором. Это позволило Bun без труда интегрироваться с существующими C libraries и system APIs, что было необходимо для проекта, глубоко взаимодействующего с operating system и network stack. Разработчики могли использовать проверенные низкоуровневые компоненты без значительных потерь производительности, ускоряя разработку при сохранении высокой производительности.

Bun мастерски использовал передовые функции Zig, в частности его мощные возможности метапрограммирования на этапе компиляции, воплощенные в `comptime`. Это позволило Bun генерировать высокооптимизированные, специализированные пути кода во время сборки, эффективно устраняя накладные расходы во время выполнения для многих операций. Кроме того, Zig предоставил точный контроль над memory allocators, что позволило Bun реализовать пользовательские стратегии управления памятью, точно адаптированные к его рабочей нагрузке, что еще больше повысило его скорость и уменьшило объем используемой памяти.

Последующий стремительный взлет Bun и последовательная демонстрация впечатляющих performance benchmarks послужили мощным, реальным подтверждением потенциала Zig. Проект в одиночку поднял авторитет Zig, продемонстрировав его жизнеспособность для создания сложных, высокопроизводительных приложений. Успех Bun во многом стал флагманской демонстрацией мощи Zig, доказав, что его уникальные принципы проектирования действительно могут предложить современную, производительную альтернативу традиционным системным языкам.

Джарред Самнер инициировал ветку «Claude Code (Phase) A port», что ознаменовало амбициозный, крупномасштабный эксперимент по миграции кода. Это монументальное предприятие стало возможным после приобретения Bun компанией Anthropic 2 декабря 2025 года, которая предоставила необходимые ресурсы, включая Claude agents и обширные tooling, для проведения такого сложного переписывания. Этот шаг немедленно вызвал широкие дебаты в сообществе разработчиков.

Центральным элементом этого экспериментального port был документ объемом 600 строк, фактически Rosetta Stone, отображающий всю Zig codebase Bun. Этот скрупулезный документ описывал каждый Zig type, idiom и architectural pattern, точно переводя их в их Rust equivalents. Он послужил основополагающим планом для трансформации, обеспечивая прямой и систематический процесс преобразования, а не перепроектирование с нуля.

Прямой, идиоматический port с использованием чистых callbacks и state machines стал весьма специфической архитектурной целью переписывания. Этот подход намеренно отражал низкоуровневую модель выполнения оригинальной версии Zig, заметно избегая популярных высокоуровневых асинхронных runtime libraries Rust, таких как Tokio и Rayon, сосредоточившись вместо этого на «bare-metal» переводе существующей логики.

Начальная «Phase A» отдавала приоритет точному захвату логики над немедленной компиляцией или оптимизацией. Этот методический подход был направлен на то, чтобы версия Rust точно воспроизводила сложное поведение Bun перед настройкой производительности. Впечатляюще, всего через шесть дней переписанная на Rust версия, как сообщается, прошла 99,8% обширного существующего test suite Bun на Linux x64 glibc, что является значительным ранним достижением.

Джарред Самнер быстро пояснил, что это «просто эксперимент», а не окончательное переписывание, заявив о «очень высокой вероятности того, что этот код будет полностью отброшен». Целью остается параллельное сравнение жизнеспособных версий Rust и Zig по производительности, использованию памяти и удобству поддержки. Эта текущая работа, видимая на GitHub проекта, приглашает к изучению и обсуждению со стороны широкого сообщества разработчиков, которые могут более подробно изучить codebase Bun GitHub - oven-sh/bun: Incredibly fast JavaScript runtime, bundler, test runner, and package manager – all in one.

Джарред Самнер, создатель Bun, сформулировал четкую, прагматичную мотивацию для экспериментальной переработки на Rust: он «устал беспокоиться и тратить много времени на исправление утечек памяти и сбоев». Это разочарование, разделяемое многими системными программистами, подчеркивает присущие сложности ручного управления памятью в сложном, критически важном для производительности приложении, таком как Bun. Проект, изначально высоко оцененный за его основу на Zig, столкнулся с реалиями крупномасштабной разработки.

Zig, предлагая исключительный низкоуровневый контроль и минимальные накладные расходы во время выполнения, полностью возлагает ответственность за управление памятью на разработчика. Программисты должны явно выделять, освобождать и управлять временем жизни памяти, что является процессом, подверженным тонким ошибкам, которые проявляются как труднодиагностируемые сбои во время выполнения и коварные утечки памяти. Этот прямой контроль, краеугольный камень философии Zig, способствует оптимизации, но также создает значительную когнитивную нагрузку.

Rust представляет собой резкую альтернативу с его революционной ownership model и borrow checker. Эти основные особенности языка обеспечивают строгие правила доступа к памяти во время компиляции, устраняя целую категорию распространенных ошибок программирования еще до запуска кода. Система отслеживает, кто «владеет» фрагментом данных, и обеспечивает безопасный, параллельный доступ без необходимости использования сборщика мусора или ручных вызовов памяти.

Этот строгий подход обеспечивает мощные compile-time guarantees, предотвращая критические ошибки, такие как состояния гонки, уязвимости use-after-free и многие формы утечек памяти. Отладка таких проблем в языках, как Zig или C, может отнимать непропорционально много времени разработчика, требуя сложных инструментов и глубокого анализа дампов памяти. Rust переносит это бремя с отладки во время выполнения на решение проблем во время компиляции, требуя большей предварительной дисциплины, но обещая большую стабильность.

Исследование Самнера напрямую ставит под сомнение фундаментальный компромисс: стоит ли беспрецедентный низкоуровневый контроль Zig дополнительной когнитивной нагрузки и постоянного риска проблем со стабильностью для такого амбициозного и широко используемого проекта, как Bun? Bun стремится стать универсальной, более быстрой заменой Node.js, что делает абсолютную стабильность и предсказуемую производительность не подлежащими обсуждению требованиями. Потенциал более надежной основы в Rust, несмотря на усилия по миграции, явно беспокоил Самнера.

В конечном итоге, эксперимент с «Claude Code (Phase) A port» отражает стратегическую переоценку долгосрочной поддерживаемости и надежности Bun. Переход на язык, который активно предотвращает ошибки, связанные с памятью, может значительно сократить будущие затраты на отладку и улучшить общий опыт разработчиков для команды Bun, даже если это означает отказ от некоторых уникальных низкоуровневых свобод Zig.

Амбициозный поворот Bun к Rust находит свою основу в решающем стратегическом шаге: его приобретении компанией Anthropic 2 декабря 2025 года. Это приобретение предоставило необходимые ресурсы — от вычислительных токенов до передовых инструментов, таких как Claude AI agents, — необходимые Джарреду Самнеру для начала такой масштабной, экспериментальной переработки. Это ознаменовало более глубокую интеграцию Bun в экосистему Anthropic, позволив проекту поддерживать Claude Code и Claude Agent SDK.

Обеспечивая это начинание, Claude AI agents активно переводят сотни тысяч строк кода Zig на Rust. Процесс начался с ветки «Claude Code (Phase) A port», руководствуясь тщательно разработанным 600-строчным документом. Этот документ сопоставляет каждый тип, идиому и шаблон Zig с их эквивалентами в Rust, гарантируя, что сгенерированный ИИ код сохраняет исходную архитектуру, включая чистые коллбэки и конечные автоматы, намеренно избегая таких фреймворков, как Tokio или Rayon.

Обоснование использования LLMs для переписывания на Rust, а не для доработки существующего Zig, сосредоточено на строгом компиляторе Rust и надежной системе типов. Теоретики предполагают, что большим языковым моделям по своей природе легче генерировать корректный, безопасный для памяти Rust, чем производить столь же надежный код на Zig. Строгость Rust действует как мощный ограничитель, заставляя LLMs придерживаться точных правил безопасности, тем самым снижая вероятность утечек памяти и сбоев — основное разочарование, которое Jarred Sumner привел в отношении реализации на Zig.

Это переписывание является одной из первых крупных публичных демонстраций миграции кода с помощью ИИ в большом масштабе в рамках популярного проекта с открытым исходным кодом. Быстрый прогресс примечателен; переписывание на Rust, как сообщается, прошло 99,8% существующего набора тестов Bun на Linux x64 glibc всего за шесть дней. Это беспрецедентное достижение подчеркивает преобразующий потенциал ИИ в сложном программном инжиниринге, расширяя границы возможного в крупномасштабной модернизации и поддержке кода.

Помимо разочарования Jarred Sumner утечками памяти и сбоями, Rust предлагает убедительный набор преимуществ, которым Zig, несмотря на свои обещания, пока не может соответствовать. Решение о полном переписывании на Rust выходит далеко за рамки простой стабильности; оно затрагивает зрелую, обширную экосистему. Rust может похвастаться огромной коллекцией высококачественных библиотек, часто называемых crates, которые ускоряют разработку, предоставляя проверенные решения для сложных проблем.

Экосистема инструментов Rust исключительно надежна, ее возглавляет Cargo, интегрированный менеджер пакетов и система сборки. Cargo упрощает управление зависимостями, тестирование и развертывание, предлагая разработчикам мощный и интуитивно понятный опыт. Эта комплексная инфраструктура значительно снижает накладные расходы и позволяет разработчикам сосредоточиться на основной логике, а не на проблемах инфраструктуры. Zig, напротив, обладает гораздо более молодой экосистемой, с меньшим количеством доступных библиотек и менее зрелыми, хотя и быстро развивающимися, инструментами.

Соображения человеческого капитала также сильно влияют на этот стратегический поворот. Rust обладает значительно большим и быстрорастущим пулом талантов по сравнению с Zig. Эта более широкая доступность квалифицированных разработчиков напрямую приводит к упрощению процессов найма для Anthropic, обеспечивая устойчивый рост и поддержку такого критически важного проекта, как Bun. Более крупное сообщество также способствует более активной разработке и большему объему потенциальных вкладов с открытым исходным кодом, обогащая долгосрочную жизнеспособность проекта.

Zig, хотя и ценится за низкоуровневый контроль и совместимость с C, работает с меньшим, но страстным сообществом. Этот меньший масштаб по своей сути ограничивает широту доступной экспертизы и темпы разработки инструментов, управляемых сообществом. Эксперимент по портированию Claude Code (Phase) A, который недавно достиг 99,8% совместимости тестов на Linux x64 glibc на Rust, подчеркивает практическую готовность языка для проекта такой сложности, как Bun. Читатели могут ознакомиться с текущими обсуждениями и техническими деталями этого амбициозного предприятия здесь: Bun's experimental Rust rewrite hits 99.8% test compatibility on Linux x64 glibc | Hacker News.

Привлекательность Rust для Bun, таким образом, многогранна. Это продуманный шаг к языку, который предлагает не только безопасность памяти, но и процветающую экосистему, превосходные инструменты и легкодоступный пул талантов — все это критически важные факторы для проекта, который теперь поддерживается значительными ресурсами Anthropic. Это всеобъемлющее преимущество позиционирует Rust как прагматичный выбор для будущей эволюции Bun.

Сторонники Zig быстро организовали защиту на Hacker News и других форумах для разработчиков, оспаривая нарратив о неизбежной миграции на Rust. Многие выразили шок и разочарование, утверждая, что экспериментальная ветка Jarred Sumner «Claude Code (Phase) A port» сигнализировала о предательстве языка, который Bun возвысил до известности. Сообщество отвергло идею о том, что Zig стал узким местом, вместо этого подчеркнув его присущие сильные стороны.

Производительность является основным контраргументом. В то время как Rust хвалится безопасностью памяти и надежной конкурентностью, дизайн Zig обеспечивает беспрецедентный явный контроль над аппаратным обеспечением и расположением памяти. Эта низкоуровневая детализация, как утверждают сторонники Zig, позволяет разработчикам создавать критически важные «горячие пути», которые потенциально могут превзойти даже высокооптимизированные реализации Rust. Первоначальные приросты скорости Bun, в конце концов, были свидетельством возможностей Zig.

Возникли также вопросы зрелости. Критики задавались вопросом, действительно ли Bun перерос Zig, или команда Bun непреднамеренно создала самоисполняющееся пророчество. Вместо того чтобы активно вносить вклад в развивающуюся стандартную библиотеку Zig или более широкую экосистему, утверждается, Bun часто разрабатывал свои собственные внутренние решения. Такой подход мог ограничить воспринимаемую полезность Zig для Bun, а не отражать фактическое ограничение самого языка.

Философское соответствие стало еще одним основным аргументом в защиту. Этос Zig отдает приоритет простоте, явному контролю и минимальному времени выполнения, предоставляя программистам прямую связь с машиной. Эта фундаментальная философия дизайна изначально привлекла Bun, позиционируя Zig как идеальный выбор для высокопроизводительной среды выполнения. Сообщество утверждает, что отказ от этого принципа в пользу более категоричного, хотя и более безопасного, подхода Rust представляет собой значительный идеологический сдвиг.

В конечном итоге, многие энтузиасты Zig рассматривают эксперимент по переписыванию не как обвинение Zig, а как побочный продукт новых ресурсов Bun. Приобретение Anthropic в конце 2025 года предоставило значительные токены и инструменты, такие как Claude agents, необходимые для такого масштабного предприятия. Эта перспектива предполагает, что этот шаг меньше связан с недостатками Zig и больше с использованием возможностей миграции с помощью AI в рамках более крупной корпоративной стратегии, потенциально упуская из виду бережливую эффективность Zig.

Поразительные цифры появились из ветки «Claude Code (Phase) A port»: переписывание на Rust, как сообщается, прошло 99.8% существующего набора тестов Bun на Linux x64 glibc всего за шесть дней. Эта беспрецедентная скорость, подтвержденная Jarred Sumner, убедительно свидетельствует о прямом вмешательстве передовых инструментов AI, в частности агентов Anthropic. Такая быстрая миграция бросает вызов традиционным срокам разработки программного обеспечения.

Однако определение «прохождения тестов» требует тщательного изучения. Эта начальная фаза в основном сосредоточилась на точном захвате логики и функциональной эквивалентности, а не обязательно на всесторонней оптимизации производительности или сравнении использования памяти. Прохождение теста может просто указывать на то, что версия Rust не падает и не возвращает неверные значения, что является важным первым шагом, но далеко не готовым к производству бенчмарком.

Глубокие исследования регрессий производительности, тонких граничных случаев или сравнительного использования памяти остаются в значительной степени неучтенными в первоначальных заявлениях. Инженерам потребуется проверить, сохраняет ли сгенерированный AI код Rust фирменное преимущество Bun в скорости и эффективности использования ресурсов при различных рабочих нагрузках. Истинная мера успеха выходит за рамки простого функционального паритета.

Долгосрочные последствия использования кода, сгенерированного AI, для проекта масштаба Bun являются глубокими. Возникают вопросы о поддерживаемости и читаемости; отладка сложных взаимодействий в коде, в основном написанном AI, представляет собой новую проблему. Инженеры-люди должны развивать новые навыки для эффективного анализа, понимания и итерации кода, полученного от больших языковых моделей.

Этот сдвиг может переопределить роль разработчика, превратив его из основного автора в сложного редактора и валидатора результатов AI. Обещание более быстрых циклов разработки должно быть сопоставлено с потенциальным увеличением сложности в отслеживании и исправлении глубоко укоренившихся проблем, которые изначально не были задуманы человеком.

В конечном итоге, сообщество разработчиков ожидает обещанный пост в блоге Jarred Sumner. Этот предстоящий релиз будет содержать подробные бенчмарки, предлагая окончательное сравнение между реализациями Zig и Rust. Только тогда мы сможем по-настоящему оценить жизнеспособность эксперимента, выйдя за рамки впечатляющих процентов к конкретным, действенным метрикам производительности и четкому пути развития для Bun.

Переписывание Bun — это не просто внутренняя разработка; это очень публичный, высокорисковый A/B-тест, разворачивающийся в реальном времени. Ветка Jarred Sumner "Claude Code (Phase) A port" непреднамеренно подготовила почву для прямого, строгого сравнения между Zig и Rust в критически важном системном приложении. Все сообщество разработчиков, от пользователей Node.js до энтузиастов низкоуровневых языков, внимательно наблюдает, как Bun, проект, который изначально сделал Zig известным, теперь открыто рассматривает будущее, основанное на Rust.

Успех зависит от тщательно оцененных, измеримых результатов. Команда Bun проанализирует несколько ключевых метрик, сравнивая версии Zig и Rust бок о бок: - Сырая производительность по различным бенчмаркам, от времени запуска до сложного выполнения JavaScript. - Общее использование памяти, постоянная проблема для высокопроизводительных сред выполнения. - Окончательный размер бинарного файла скомпилированной среды выполнения. - Долгосрочная поддерживаемость и опыт разработчиков для растущей, сложной кодовой базы. Этот беспрецедентный уровень прозрачности, поддерживаемый ресурсами Anthropic и передовыми инструментами AI, обещает окончательный набор данных.

Результат этого эксперимента выходит далеко за рамки самого Bun. Если порт на Rust продемонстрирует значительные, неоспоримые преимущества — возможно, в стабильности, безопасности или даже в дальнейшем приросте производительности — это может склонить бесчисленные будущие проекты системного программирования в сторону Rust. И наоборот, если Zig удержит свои позиции или даже окажется превосходящим в конкретных, критических областях, это укрепит его репутацию как надежной, жизнеспособной альтернативы для высокопроизводительных приложений, бросая вызов текущему нарративу.

Это не просто академическое упражнение; это осязаемая, реальная точка данных в одном из самых жарких языковых дебатов в сфере технологий. Разработчики давно спорят о преимуществах безопасности памяти и надежных инструментов Rust против явного контроля Zig, более простого компилятора и сильных сторон C-interop. Эксперимент Bun предлагает уникальное, крупномасштабное тематическое исследование, предоставляя бесценные идеи для будущих архитектурных решений в отрасли. Для получения фундаментальных сведений о языке изучение таких ресурсов, как Home ⚡ Zig Programming Language, предлагает более глубокое понимание его философии дизайна.

Джарред Са́мнер, дальновидный создатель Bun, не просто экспериментирует с Rust; он предсказывает провокационное будущее: ИИ будет писать большую часть кода проектов с открытым исходным кодом. Это не абстрактные спекуляции. Эксперимент «Claude Code (Phase) port», монументальное начинание, ставшее возможным благодаря приобретению Bun компанией Anthropic, служит его испытательным полигоном. Продвинутый ИИ-агент, а не команда человеческих разработчиков, сгенерировал первоначальный переписанный код на Rust, который удивительно успешно прошел 99,8% обширного набора тестов Bun на Linux x64 всего за шесть дней. Эта беспрецедентная скорость дает представление о радикально иной модели разработки.

Этот глубокий сдвиг перестраивает саму суть поддержки открытого исходного кода. Са́мнер предвидит будущее, в котором человеческие разработчики перейдут от создания сложного кода к определению общих архитектурных планов, тщательному уточнению запросов для сложных ИИ-агентов и критической оценке AI-generated pull requests. Основная работа смещается от выполнения к высокоуровневому проектированию и строгой проверке, требуя нового вида экспертизы, ориентированной на ясность, стратегический надзор и проницательный анализ.

Такая философия разработки, ориентированная на ИИ, неизбежно вступает в противоречие с устоявшимися принципами открытого исходного кода, в частности, со строгим запретом Zig на LLM-authored contributions. Этот идеологический раскол ставит фундаментальный вопрос: перевесит ли стремление к эффективности через ИИ принципы человеческого мастерства и прямой ответственности разработчика? Эксперимент Bun вынуждает сообщество системного программирования столкнуться с этим возникающим напряжением между технологическим ускорением и основополагающими ценностями.

В конечном итоге, окончательный выбор языка для Bun — вернется ли он к Zig или полностью перейдет на Rust — становится почти второстепенным по сравнению с глубокими последствиями этого эксперимента. «Claude Code (Phase) port» демонстрирует новую, мощную возможность: крупномасштабную, ускоренную ИИ миграцию и разработку кода. Его почти идеальный показатель прохождения первоначальных тестов менее чем за неделю создает поразительный прецедент. Это предприятие, основанное на ИИ, безвозвратно изменило ожидания в отношении разработки открытого исходного кода, сигнализируя о новой эре в том, как код пишется, поддерживается и развивается. Игра изменилась навсегда.

Почему Bun рассматривает переход с Zig на Rust?

Создатель Bun, Джарред Са́мнер, сослался на желание улучшить безопасность памяти и стабильность. Он стремится тратить меньше времени на исправление утечек памяти и сбоев, используя гарантии безопасности Rust во время компиляции.

Является ли переписывание на Rust официальным и постоянным?

Нет. Джарред Са́мнер заявил, что это «просто эксперимент» по созданию жизнеспособной версии на Rust для сравнения бок о бок с версией на Zig по производительности, памяти и удобству поддержки. Существует высокая вероятность того, что код на Rust будет отброшен.

Какую роль сыграл ИИ в этом эксперименте по переписыванию?

Значительную. Эксперимент, названный «Claude Phase A port», активно использует ИИ-агентов от Anthropic (которая приобрела Bun) для автоматического перевода сотен тысяч строк кода Zig на Rust.

Является ли Zig теперь мертвым языком из-за Bun?

Нет, Zig не мертв. Однако этот громкий эксперимент от его самого известного проекта вызвал серьезные дебаты и рассматривается как значительный вызов для импульса и восприятия экосистемы Zig.