Latest

Technology

Ubuntu brings Rust to the heart of Linux with its coreutils

Ubuntu 26.10 completes the migration of coreutils to Rust and brings safer, more modern code to the heart of the Linux terminal

Ubuntu brings Rust to the heart of Linux with its coreutils
Ubuntu brings Rust to the heart of Linux with its coreutils

Ubuntu finished what it announced seventeen months ago. Version 26.10, in development this September 2026, completes the migration of the GNU utilities to their Rust reimplementation, so every ls or cat you type now runs a Rust binary instead of a C one, as OMG Ubuntu reported on September 13.

The news marks the close of a cycle that began in April 2025, when the Foundations team proposed on Ubuntu Discourse migrating to rust-coreutils within the 25.10 cycle, with a possible rollback if something went wrong. A year later, in April 2026, the team said that promoting the package to Ubuntu Main required an in-depth security review, and that several sensitive commands were being held back until it passed.

Among those held back were cp and mv for copying and moving, as well as rm for deleting. They touch your files for real and any regression there hurts. Version 26.04 LTS arrived in April 2026 with uutils 0.8.0 as the default userland across some eighty utilities. The three conflicting ones stayed in C pending approval. With 26.10, that approval has arrived and the transition is complete.

The timeline, seen from the perspective of September 2026, shows a textbook migration. Proposed in spring 2025, partially deployed in the 2026 LTS and fully closed in the fall. Seventeen months of work to change tools that almost nobody looks at but everyone uses.

What are the uutils coreutils?

The GNU coreutils are the basic toolkit of any Linux system. Listing, copying, moving, sorting, counting and concatenating all go through them, and they have been written in C within the GNU project for decades. The uutils coreutils are their cross-platform, open source reimplementation in Rust, which pursues compatibility with the originals without inheriting their memory risks.

Rust provides what C cannot promise. Its ownership and borrowing system prevents entire families of errors at compile time, such as out-of-bounds accesses or data races, which in C only appear when the program runs, sometimes years later and in the hands of an attacker. It is not that Rust code is perfect. It is that it turns into compile errors what in C would be vulnerabilities.

Version 0.9.0 of uutils, from May 2026, arrived marked by an external security audit that hardened TOCTOU accesses. The acronym refers to a classic race between checking a file and using it, because an attacker can change it in the interval between both operations. That the project prioritizes precisely that flank says a lot about its maturity. It no longer argues about option compatibility, it argues about race security.

Three independent signals confirm that uutils is no longer an experiment and has become infrastructure that a serious distro can ship by default to millions of machines without apologizing afterward in the form of urgent patches.

  • External security audit with TOCTOU hardening in version 0.9.0.
  • Entry review into Ubuntu Main with its packaging and maintenance requirements.
  • Three releases chaining the migration without the plan being reverted in any of them.

Why does Canonical take on such a task?

The short answer is that unsafe memory is expensive. Microsoft estimates that around 70 percent of its annual CVEs stem from memory flaws in C and C++, and Google and Chromium publish twin figures in their own reports. For a distribution that aims to be on servers, clouds and desktops around the world, reducing that surface with a memory-safe language is a defensive investment. The AskUbuntu debate from March 2026 sums it up bluntly. The reason is security, the rest are side effects.

There is also a less visible strategic reason. Whoever controls the base of the system controls its pace of evolution, and depending eternally on GNU limits Canonical's moves in performance and portability. Rust also attracts a new generation of contributors who no longer learn C as their first language. Adopting uutils is also a bet on who will maintain Ubuntu ten years from now.

As LWN reported in March 2025, the plan was never a leap of faith. Every package Ubuntu ships by default must move to Main and pass an exhaustive security review, and the migration kept the door open to reverting. That explicit safety net is a rarity in migrations of this scale. When you touch the commands that delete, better to arrive late than to break early.

What changes for you in practice?

Day to day, almost nothing visible, and that is the best news. Options and output formats remain compatible, your scripts keep working and performance is equivalent or better in most utilities. If you administer servers or audit networks with Linux cybersecurity tools, your pipelines of sort, uniq, cut and wc behave the same.

Where you can notice something is in error messages and obscure edge cases. Some old script that depended on undefined behavior of the GNU version might complain, and certain exotic flags took time to reach uutils. The practical recommendation fits in three checks.

  • Run your critical scripts on 26.04 before jumping to 26.10 and compare outputs.
  • Review the error messages if you parse the output of cp or mv in automations.
  • Keep the GNU package at hand in case you need to revert a specific machine.

If something fails, the rollback exists and has been documented since the original proposal. You can reinstall the GNU coreutils and pin them so they do not update, at the cost of staying off Ubuntu's main path. For a production server with strict audits, that temporary caution makes sense. For everyone else, going with the flow is the reasonable choice.

The move also fits a trend that goes beyond Ubuntu. The Linux kernel, which turned 35 in 2026, accepts more and more Rust in its subsystems, CERN migrated thousands of machines to Debian seeking solid foundations and even kernel compilation is now accelerated with the help of AI. The base of the operating system is being rewritten in safe languages, piece by piece.

How do I check which coreutils I run?

There is no need to trust the release calendar. Each utility states its origin on the first line of its version, so two commands are enough to know whether your machine already speaks Rust or is still on the same old C.

ls --version | head -1 cp --version | head -1

If the answer mentions uutils, you run Rust. If it mentions GNU coreutils, you are still on C. On Ubuntu 26.04 you will see the former in almost everything except cp, mv and rm, which wait for 26.10 with the rest of the migration already closed. On the previous LTS you will see GNU everywhere, because the change began with this cycle.

To find out which package each binary comes from, ask the package manager with dpkg -S $(which ls), which answers rust-coreutils or coreutils depending on the case. In containers, WSL and VPS with minimal images, the answer may vary compared with the desktop, because each image freezes its own base. Check each environment separately before taking anything for granted and save the output in your administration notes, because in a year nobody will remember what each machine was running.

What if I use another distro or program in C?

If you use a distro other than Ubuntu, for now nothing changes, although the precedent carries weight. When the most popular distro proves that the migration is viable, the others study it with different eyes. The uutils maintainers work precisely so that any distribution can take the step, and the 2026 audit gave them arguments.

For those who program in C, the message is not abandon your language. It is that critical infrastructure migrates where it can to compile-time guarantees, and that new C coexists with increasingly strict review and sanitizers. Learning to read Rust, even if you do not write it, is starting to be as useful as reading an strace. The Jupyter notebooks with Python on Ubuntu and Fedora will keep working the same, because above the coreutils nothing moves.

The operating system is rewritten without you noticing

The best migration is the one you do not notice, and Ubuntu has carried it out with a surgeon's patience. Seventeen months, two releases and one audit later, the heart of your terminal beats in Rust. When in a few years someone asks when Linux became memory-safe, the answer will start here, in an autumn of 2026 in which ls stopped being C without anyone having to change a single script.

It remains to be seen whether Debian and Fedora follow the path, but the question is no longer whether Rust can handle the base of the system. It is who will be the next to admit it in their release notes.

José Maldonado

Author

José Maldonado

Activist and blogger on technology, free software and blockchain.

The latest
From Huang to Botín, from Zara to Byron: corporate responsibility in global capitalism

Keep reading