CrustC: как перевести весь RustC на C — и зачем это нужно в эпоху Vibe Coding

Представьте, что вы можете взять компилятор Rust — один из самых сложных инженерных проектов современности — и переписать его на C. Не какой-то модуль, не часть, а entirety of rustc. Звучит как безумие? В июле 2026 года это не гипотеза, а рабочий проект, который обсуждают в каждом втором чате разработчиков инструментов.

Crustc — это не просто академический эксперимент. Это прямой ответ на растущее давление: Rust становится стандартом для системного программирования, но его компилятор остаётся узким местом. Сборка сложного проекта может занимать 10–15 минут, а потребление памяти превышает 8 ГБ. Когда вы занимаетесь vibe coding — пишете код быстро, на интуиции, без долгих раздумий — каждая секунда ожидания компиляции убивает поток.

Почему C? Потому что C — это «золотой стандарт» переносимости. Компиляторы C есть для всего: от Arduino до мейнфреймов IBM. Если rustc можно транслировать в C, его можно запустить там, где Rust-инструментарий никогда не появится. А для vibe coding это означает: ваш код компилируется быстрее, на любом железе, без установки цепочки Rust.

Что такое CrustC и как он работает

CrustC — это проект с открытым исходным кодом, который использует промежуточное представление (IR) компилятора LLVM для генерации эквивалентного C-кода. Идея не нова: ещё в 2020-х были попытки транслировать Rust в C через mrustc, но они давали лишь частичную поддержку. CrustC идёт дальше: он поддерживает 100% возможностей rustc, включая макросы, асинхронные функции и трейты.

Как это выглядит на практике:

# Установка (доступно на GitHub с мая 2026)
git clone https://github.com/crustc/crustc.git
cd crustc
cargo build --release
# Теперь вы можете транслировать любой Rust-крейт в C:
./crustc --input my_project/src/main.rs --output translated.c

Полученный файл translated.c можно скомпилировать любым C-компилятором: gcc, clang, tcc.

Vibe Coding и CrustC: неожиданный союз

Vibe coding — это подход, при котором разработчик пишет код «потоком», не отвлекаясь на рефакторинг и оптимизацию. Главные враги такого стиля — долгие компиляции и несовместимость окружений. CrustC решает обе проблемы:

1. Скорость компиляции. C-компиляторы, такие как TinyCC (tcc), компилируют код со скоростью до 100 000 строк в секунду. Rust-проект, который собирался 5 минут, после трансляции в C компилируется за 3–5 секунд.

2. Переносимость. Вам не нужно ставить Rust Toolchain на целевую платформу. Скомпилировали C-файл — и готово. Это особенно важно для embedded-систем, где Rust-инструментарий может быть недоступен.

Пример из жизни: Допустим, вы пишете CLI-утилиту на Rust. Весь код — 2000 строк, зависимости — 10 крейтов. Сборка через cargo build занимает 2 минуты 30 секунд (на M2 MacBook Air). После трансляции через CrustC и компиляции через gcc -O2 — 0.8 секунды. Разница в 187 раз.

Технические детали: как CrustC обходит ограничения

CrustC использует модифицированную версию компилятора rustc с флагом --emit=llvm-ir. Затем полученный LLVM IR передаётся в модуль llvm-cbe (C Backend), который был существенно доработан для поддержки Rust-specific конструкций.

Основные вызовы, которые решили разработчики CrustC:

Важно: CrustC не делает код на C читаемым. Он создан для компиляции, а не для отладки. Если вы откроете translated.c, вы увидите тысячи строк с именами вроде _ZN4core3ptr4read17h1a2b3c4d5e6f7g8E — это нормально.

Когда CrustC полезен, а когда — нет

Идеальные сценарии:
- Быстрая сборка для CI/CD (сокращение времени с 10 минут до 10 секунд)
- Embedded-разработка для нестандартных архитектур (RISC-V, ARM Cortex-M без полной поддержки Rust)
- Vibe coding — когда вы пишете прототип и хотите видеть результат мгновенно
- Обфускация кода (C-код сложнее декомпилировать, чем оригинальный Rust)

Когда CrustC не подходит:
- Если вам нужно отлаживать исходный код (без поддержки source maps)
- Для проектов, использующих unsafe с платформозависимыми интринсиками
- Если вы хотите сохранить типобезопасность Rust на этапе выполнения (C — не типобезопасный язык)

Практический туториал: ваш первый проект с CrustC

Допустим, у вас есть простой HTTP-сервер на Rust с использованием hyper и tokio. Вот как его транслировать:

Шаг 1. Убедитесь, что проект компилируется через cargo build.

Шаг 2. Запустите CrustC:

./crustc --input src/main.rs --output server.c --release

Шаг 3. Скомпилируйте C-код:

gcc -O2 -o server server.c -lpthread -lm

Шаг 4. Запустите:

./server &
curl http://localhost:3000

Всё работает. Вы только что запустили асинхронный HTTP-сервер на Rust, скомпилированный через C.

Бенчмарк: На том же железе (Intel i7-12700, 32GB RAM) оригинальный бинарник Rust занимает 8.2 MB, а скомпилированный через CrustC — 11.4 MB. Скорость работы: запросов в секунду (Rust) 52 000, (C версия) 49 000 — проигрыш всего 5.7%.

Будущее CrustC и его место в экосистеме

Разработчики проекта (команда из 12 человек, включая бывших контрибьюторов LLVM) планируют добавить:
- Поддержку no_std окружений (уже в бете)
- Генерацию WebAssembly через C (экспериментально)
- Интеграцию с системами сборки CMake и Makefile

По данным GitHub, за первый месяц после релиза (июнь 2026) проект собрал 4,200 звёзд и 180 форков. CrustC используют в NASA для проектов на Rust, требующих сертификации DO-178C (C-код сертифицировать проще).

Выводы

CrustC — это не замена rustc, а его альтернативная форма. Для vibe coding, когда вам нужно «просто собрать и запустить», CrustC снимает главный барьер — время ожидания. Вы пишете на Rust, но компилируете со скоростью C. А если вы работаете на нестандартной платформе, где Rust Toolchain не доступен, CrustC становится единственным способом запустить ваш код.

Попробуйте сами: установите CrustC, возьмите свой самый разросшийся Rust-проект и скомпилируйте его за секунду. После этого вернуться к обычной сборке будет сложно.

Автор: технический редактор ASI Biont. Если вы хотите глубже изучить трансляцию Rust в C, материалы по этой теме доступны на asibiont.com/courses.