Rust Coreutils 0.12 улучшает совместимость с Ubuntu и устраняет ключевые ошибки

Проект uutils Coreutils выпустил версию 0.12 — очередное крупное обновление альтернативной реализации стандартных Unix-утилит, написанной на Rust. На этот раз основное внимание разработчики уделили не столько новым возможностям, сколько совместимости с Ubuntu. Это особенно важно на фоне постепенного перехода Ubuntu от традиционных GNU Coreutils к Rust-реализации.

Новый выпуск появился 17 сентября 2026 года, всего через несколько дней после выхода GNU Coreutils 9.12. Разработчики uutils прямо называют релиз ориентированным на исправление проблем, обнаруженных пользователями и сопровождающими Ubuntu. В результате были устранены ошибки, способные проявляться в обычных сценариях администрирования, сборки пакетов и работы с файловой системой.

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

Совместимость с Ubuntu стала главным приоритетом

Версия 0.12 создавалась прежде всего с учетом практических проблем Ubuntu. Это важный этап для проекта: когда альтернативная реализация заменяет привычные системные инструменты, совместимость становится гораздо важнее добавления новых команд или экспериментальных возможностей.

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

Основные исправления в Rust Coreutils 0.12 включают:

• исправление падения rm при работе с очень глубоко вложенными каталогами;
• устранение проблемы потери данных при параллельном использовании install -D;
• добавление необходимой поддержки du для 32-битных архитектур;
• исправление конфликтов имен при использовании cp -R;
• исправление многочисленных расхождений в поведении отдельных команд относительно GNU Coreutils;
• дополнительные исправления для различных платформ и файловых систем.

Для обычного пользователя большая часть этих изменений останется незаметной. Однако для серверов, систем сборки, CI/CD, контейнеров и автоматизированных сценариев даже редкая ошибка базовой команды может привести к серьезным последствиям. Именно поэтому совместимость с GNU Coreutils измеряется не только количеством поддерживаемых параметров, но и корректностью поведения в нестандартных ситуациях.

Почему это особенно важно для Ubuntu

Ubuntu последовательно расширяет использование Rust в низкоуровневых компонентах системы. Rust Coreutils стали одним из наиболее заметных примеров такого перехода. В Ubuntu 25.10 Rust Coreutils уже используются в качестве стандартного набора базовых системных утилит, а дальнейшее продвижение этого подхода связано с исправлением оставшихся несовместимостей.

На практике пользователю по-прежнему важно понимать, что команды cp, mv, rm, ls, sort, du, install и другие привычные инструменты сохраняют свои имена и назначение. Меняется внутренняя реализация: вместо традиционного кода GNU Coreutils на C используется реализация на Rust.

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

Исправления в rm, cp, install и du

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

Также была исправлена проблема в install -D, которая могла приводить к потере данных при параллельных операциях. Для команды, часто используемой сценариями установки программного обеспечения и системами сборки, корректность таких операций особенно важна.

Команда du получила необходимые исправления для 32-битных архитектур. Несмотря на то что современные серверы и настольные компьютеры преимущественно используют 64-битные процессоры, поддержка 32-битных платформ остается значимой для некоторых встроенных систем, старого оборудования и специализированных окружений.

Еще одно исправление относится к рекурсивному копированию с помощью cp -R. Разработчики устранили проблему, связанную с коллизиями имен. Подобные ошибки особенно неприятны тем, что проявляются только при определенной структуре исходных каталогов и могут быть незаметны во время обычного тестирования.

Последняя зависимость от C удалена

Rust Coreutils 0.12 принес не только исправления совместимости с Ubuntu. В новой версии проект избавился от своей последней зависимости от языка C в реализации expr.

Это символически важный этап для проекта. Одна из главных целей uutils Coreutils заключается в создании набора системных инструментов на Rust, поэтому сохранение отдельных C-компонентов постепенно становилось техническим долгом. Теперь и этот элемент был удален.

При этом переход с C на Rust нельзя автоматически трактовать как гарантию отсутствия ошибок. Безопасность памяти является одним из преимуществ Rust, однако корректность системного инструмента зависит также от алгоритмов, обработки ошибок, взаимодействия с операционной системой и точного воспроизведения поведения существующих реализаций.

В случае Coreutils особенно важна именно последняя часть. Эти команды используются настолько давно и широко, что их поведение фактически стало частью инфраструктуры Unix-подобных систем.

Безопасность также получила внимание

В Rust Coreutils 0.12 продолжилась работа над безопасностью. Для системных утилит файловой системы это имеет особое значение, поскольку команды вроде cp, mv и rm работают непосредственно с объектами файловой системы и правами доступа.

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

В результате работа над безопасностью в uutils Coreutils включает не только предотвращение классических ошибок памяти, но и корректную обработку файлов, символических ссылок, рекурсивных операций, конкурентного доступа и системных вызовов.

Производительность продолжает улучшаться

Хотя главной темой версии 0.12 стала совместимость, разработчики не забыли о производительности. Оптимизации получили, в частности, sort, du и cp.

Производительность Coreutils особенно интересна потому, что эти программы часто являются небольшими, но чрезвычайно часто запускаемыми компонентами. Например, sort может обрабатывать огромные текстовые файлы, cp используется при развертывании программ и резервном копировании, а du регулярно применяется системными инструментами мониторинга и обслуживания.

Даже небольшое ускорение отдельной команды может давать заметный эффект в больших конвейерах обработки данных. При этом разработчикам приходится балансировать между скоростью и точным соответствием поведению GNU Coreutils.

Совместимость с GNU Coreutils остается ключевым показателем

Одной из главных характеристик uutils Coreutils является сравнение с GNU Coreutils. Проект продолжает демонстрировать уровень совместимости примерно на отметке 95 процентов по используемому набору тестов.

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

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

Что это означает для пользователей Linux

Для большинства пользователей переход на Rust Coreutils не требует изменения привычек. Команды остаются практически теми же, а основная задача проекта заключается в том, чтобы приложения и shell-скрипты продолжали работать без изменений.

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

• сложные shell-скрипты;
• автоматизированные системы сборки;
• CI/CD-конвейеры;
• контейнерные образы;
• резервное копирование;
• массовая обработка файлов;
• системные скрипты, рассчитанные на конкретное поведение GNU Coreutils.

Если программа жестко зависит от особенностей GNU-реализации, переход на Rust Coreutils может обнаружить скрытую зависимость, которая раньше оставалась незаметной. Поэтому исправления совместимости в версии 0.12 важны не только для Ubuntu, но и для экосистемы Linux в целом.

Rust постепенно проникает в базовый слой Ubuntu

Rust Coreutils — лишь один из примеров более широкой тенденции. Ubuntu уже использует и другие Rust-проекты для замены или дополнения традиционных системных компонентов. Например, sudo-rs представляет собой реализацию sudo на Rust.

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

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

Итоги

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

В новой версии исправлены ошибки в rm, cp, install и du, улучшена совместимость с GNU Coreutils, продолжена работа над безопасностью и производительностью, а реализация expr больше не зависит от C.

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

Таким образом, Rust Coreutils 0.12 не меняет привычную командную строку Linux радикально, но делает следующий шаг к тому, чтобы Rust-реализация могла безболезненно выполнять ту же роль, которую десятилетиями выполняли GNU Coreutils.

Дополнительные сведения, см. журнал изменений.

Часто задаваемые вопросы