Перейти к содержанию
Публикация AiManual

rust-anything: как переписать приложение на Rust по частям с помощью ИИ-агентов

rust-anything записывает поведение исходного приложения и сверяет с ним каждый переписанный на Rust модуль. Разбираем, как это работает с Claude Code и Codex, д

Коротко

Что будет в материале

  1. 01

    Что такое rust-anything и зачем он нужен

  2. 02

    Как устроен процесс: запись поведения и поэтапная сверка

  3. 03

    Для каких проектов подход подходит, а для каких нет

  4. 04

    Как запустить миграцию на практике

rust-anything - открытый проект на GitHub для переписывания приложений и игр на Rust с других языков. Инструмент работает в связке с ИИ-агентами: Claude Code, Codex и другими. Агент пишет код на Rust, а rust-anything фиксирует поведение исходного приложения и сверяет с этой записью каждую переписанную часть.

Миграция идет модуль за модулем: пока переписанный кусок не совпал с эталоном поведения, следующего шага нет. Цикл повторяется, пока всё приложение не станет чистым Rust. Это главное отличие от схемы «дай агенту репозиторий и попроси переписать».

Код на Rust может писать и сам разработчик без агента, ручной режим тоже предусмотрен. Поддержаны CLI, HTTP-серверы и библиотеки. В отдельных тестах авторы заявляют ускорение переписанных решений до 20 раз, но к этой цифре стоит относиться как к результату конкретных замеров, а не к обещанию для любого проекта.

Что такое rust-anything и зачем он нужен

Задача знакома каждому, кто пробовал переводить проект на Rust: язык другой, идиомы другие, а поведение менять нельзя. Клиенты, скрипты и интеграции рассчитывают на прежние ответы, прежние коды ошибок и прежний формат файлов.

Список исходных языков: TypeScript/JavaScript (включая Node.js), Python, Go, Ruby, Java, PHP и C# в статусе preview. Поддержка C# помечена как ранняя, поэтому возможны пробелы и изменения в поведении инструмента. В публикации о запуске проекта перечислены те же языки и те же типы поддерживаемых приложений: консольные утилиты, HTTP-серверы, библиотеки.

Отдельно про авторство кода. Rust-файлы пишет ИИ-агент или сам разработчик, инструмент отвечает за процесс и проверку. Из этого следует практический вывод: rust-anything не заменяет знание Rust, он задает дисциплину перехода.

Чем подход отличается от «просто попросить агента переписать код»

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

Эталон в такой схеме отсутствует. rust-anything его добавляет: поведение исходного приложения записывается, и каждая переписанная часть сверяется с записью до перехода к следующей. Тихие регрессии, когда код компилируется, тесты зеленеют, а один сценарий поехал, ловятся раньше.

Полной гарантии нет. Сверка работает по тем сценариям, которые попали в запись, а сценарий вне записи остается зоной риска. Как такая регрессия выглядит на практике, разобрано в материале про магазин за два вечера: после добавления скидки пропадает самовывоз, и ни один автотест об этом не сообщает.

Как устроен процесс: запись поведения и поэтапная сверка

Последовательность шагов выглядит так:

  1. Записывается поведение текущего приложения на Node.js (TypeScript/JavaScript), Python, C, Go, Ruby или Java.
  2. ИИ-агент переписывает очередной модуль на Rust.
  3. Переписанная часть сверяется с записью.
  4. После совпадения работа переходит к следующему модулю.
  5. Цикл повторяется, пока всё приложение не станет чистым Rust.

Запись здесь выступает эталоном, а не пожеланием к результату. Описание проекта формулирует это буквально: сверка с записью происходит до того, как работа двинется дальше.

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

Формат записи, внутренние команды и структуру служебных файлов открытое описание не раскрывает. Если планируете запускать на реальном проекте, сверяйтесь с README в репозитории на GitHub: детали меняются быстрее, чем статьи о них.

Почему сверка по поведению важнее сверки по коду

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

Общий знаменатель - наблюдаемое поведение: вывод CLI, код ответа и тело HTTP, возвращаемое значение функции библиотеки. Именно его можно записать и сравнить автоматически.

Границы подхода видны сразу. Поведение, не попавшее в запись, никто не проверит. Сетевые тайминги, конкурентность, реакция на сбои внешних сервисов воспроизводятся плохо. Чем больше в приложении скрытого состояния, тем меньше пользы от эталонной записи.

Проверки стоит проектировать как часть среды, в которой работает агент: средовой подход к ИИ-агентам описывает ровно этот принцип, когда код принимают по проверкам, а не по обещаниям модели.

Для каких проектов подход подходит, а для каких нет

Подходит там, где у приложения есть воспроизводимый интерфейс:

  • CLI-утилиты с понятными командами, флагами и выводом;
  • HTTP-серверы с фиксированными маршрутами, кодами и форматами ответов;
  • библиотеки с публичным API и предсказуемыми возвращаемыми значениями.

Не подходит или требует много ручной работы: приложения с тяжелым UI, где поведение определяется пикселями и жестами; проекты, плотно завязанные на конкретное окружение, драйверы, железо или внешние сервисы с нестабильными ответами.

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

Что значит статус preview для C#

Preview означает раннюю поддержку языка. Часть конструкций может не покрываться, поведение инструмента еще меняется, документация отстает от кода. Для продакшн-миграции это сигнал проверить C#-проект на одном небольшом модуле и одном сценарии, прежде чем переносить весь репозиторий.

Практический ориентир: если запись поведения для C#-модуля не строится или сверка падает на пустом месте, дальше двигаться рано. Сначала стоит понять причину, а не гнать агента на следующий модуль.

Как запустить миграцию на практике

Порядок работ, который следует из описания проекта:

  1. Подготовить проект и сценарии поведения, по которым можно проверить результат.
  2. Подключить ИИ-агента: Claude Code, Codex или другой.
  3. Запустить setup, который разворачивает процесс переписывания.
  4. Пройти модуль за модулем, сверяя каждый шаг с записью поведения.

Один факт про безопасность файлов: перед изменением существующего файла setup сохраняет резервную копию рядом с ним, в файле <file>.rust-anything.bak. Это позволяет откатиться, если результат не устроил, не полагаясь только на историю git. Полезно, когда часть файлов живет вне версионного контроля.

Команды установки, флаги и версии в открытом описании не приводятся. Сверяйтесь с README в репозитории на GitHub, там же смотрите актуальные требования к окружению и ограничения по типам проектов.

Когда выбирать ручной режим по шагам

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

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

Выбор агента влияет на результат не меньше, чем сам инструмент. Разница между Claude Code и Codex по типам задач, объему контекста и уровню автономности разобрана в материале Claude Code или Codex для разработки в 2026 году.

Ограничения и риски миграции на Rust с ИИ-агентами

  • Полнота записи. Непокрытые сценарии останутся незамеченными: сверка покажет совпадение там, где его проверяли.
  • Качество Rust-кода. Агент может выдать код, который компилируется и проходит сверку, но игнорирует идиомы языка: лишние клоны, обход borrow checker через clone(), ручное дублирование логики вместо трейтов.
  • Ответственность. За код и его поддержку отвечает разработчик, а не инструмент. Ревью и тесты никуда не деваются.
  • Preview-языки. C# требует ручной доработки и проверки на малом объеме.
  • Сложные проекты. Чем больше скрытого состояния и внешних зависимостей, тем чаще цикл придется вести вручную.

Отдельный риск лежит в плоскости процессов. Рост объема сгенерированного кода добавляет работу на ревью и разбор чужого кода, а часть разработчиков не готова отдавать реализацию агенту по причинам авторства и контроля. Эта позиция разобрана в тексте про сопротивление разработчиков ИИ-агентам.

Что делать с производительностью после миграции

Цифра «до 20 раз» встречается в описании проекта, и у нее есть оговорка: это отдельные тесты авторов. Публикация о запуске приводит ее как заявление, а не как гарантию для произвольного проекта.

Откуда берется выигрыш в принципе: Rust обходится без сборщика мусора, предсказуемо работает с памятью и не тратит время на интерпретатор. Сколько получит ваш проект, зависит от задачи, исходного кода и качества переписанного Rust-кода.

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

Стоит ли использовать rust-anything в вашем случае

Инструмент подходит, если сходятся три условия: у приложения есть воспроизводимое поведение, проект достаточно крупный, чтобы частичная миграция имела смысл, команда готова ревьюить Rust-код и нести за него ответственность.

Кнопкой «переписать всё» он не работает. rust-anything задает процесс: запись эталона, пошаговая сверка, переход к следующему модулю только после совпадения. Экспертизу по Rust и тестирование он не заменяет.

Код на Rust может писать и сам разработчик без агента. Агент ускоряет рутину, а спорные решения по языку и архитектуре все равно принимает человек.

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

Подписаться на канал