Rust Coreutils 0.11 crosses 95% of the GNU test suite and upgrades its error messages
On August 31, 2026, uutils released Rust Coreutils 0.11, whose GNU test-suite compatibility passed 95% and which adopts compiler-style diagnostics for chmod, cut, sort, and tr. The Rust rewrite of the core utilities has left the experimental stage.
August 31, 2026. The uutils project released Rust Coreutils 0.11, the latest version of its Rust reimplementation of the GNU Coreutils. 95.33%. That is its GNU test-suite pass rate, clearing the 95% bar for the first time. Ariadne. That is the Rust library bringing compiler-style error messages to chmod, cut, sort, and tr. Why it matters: the Rust rewrite of Linux’s foundational utilities is no longer a prototype, and distributions are starting to adopt it.
A symbolic threshold crossed: 95% of the GNU test suite
The project’s benchmark of record is the GNU test suite — the same corpus the historical GNU Coreutils run against. Rust Coreutils 0.11 now passes 95.33% of those tests, a 0.89-point gain over the previous release carried by eight additional tests. The milestone is symbolic, but it says the compatibility gap is closing on real-world cases rather than toy examples.
The remaining 4.67% is anything but trivial. The GNU test suite is deliberately conservative: it covers edge cases, exotic locales, date formats, and option combinations that few users ever hit, but on which init scripts and packages depend and which tolerate no behavioral variation. Every point gained means utilities that behave, bit for bit, like their GNU counterparts across a widening corpus. That is exactly what distributions look at before substituting a utility — a single output difference can break a log pipeline or a deployment script. It is also worth noting that the pass rate is measured against the full GNU suite, so the number understates how close the day-to-day commands already are: the gaps concentrate in the long tail, not in the ls, cp, and mv paths everyone relies on.
uutils does not present itself as a GNU rival on security grounds first. Its own site notes that GNU Coreutils has had only 17 CVEs since 2003. The core argument is elsewhere: modernizing a C codebase so the next generation of contributors can maintain it, with Rust’s memory safety, portability across Linux, macOS, Windows, Android, FreeBSD, NetBSD, OpenBSD, Solaris, Fuchsia, and even WebAssembly, and modern tooling — Cargo, crates.io, differential fuzzing, and CI across many OS/architecture pairs.
Error messages that read like a compiler’s
The most visible change in this release is the arrival of the Ariadne library, described as a “fancy diagnostics and error reporting library” for Rust programs. In practice, chmod, cut, sort, and tr now produce far more informative messages on wrong arguments or syntax errors.
The analogy is deliberate: instead of a terse “invalid option,” the user gets a structured diagnostic that points at the exact location of the problem and suggests a fix. For anyone who does not know every option of every utility by heart, that is a real readability win. The change currently covers only four commands, but uutils says it will extend it to the rest over time.
The choice deserves attention because it shifts the project’s ambition: it is no longer only about matching GNU exactly, but about offering a better experience where the historical tools deliberately stayed terse. Compatibility remains the first constraint, but it no longer blocks improvement.
Performance baked in at build time
On the performance side, Rust Coreutils 0.11 enables Profile Guided Optimizations (PGO) release builds for Linux, macOS, and Windows. PGO compiles once, runs representative workloads to collect hot paths, then recompiles using those measurements. The gains land on the most heavily used utilities, where the difference between a Rust and a C implementation comes down to constant factors.
It sits alongside the ongoing optimization work uutils does in parallel with its compatibility hunt. The project’s “on par with or better than C” performance claim is long-standing, and enabling PGO by default in release builds makes it more verifiable for anyone who compiles from source.
# Try uutils coreutils 0.11 without replacing GNU
cargo install coreutils --locked
~/.cargo/bin/coreutils chmod 755 fileWhere real adoption stands
Adoption is no longer theoretical. uutils states that Ubuntu is carefully but purposefully adopting its coreutils, that Debian may follow the same path, and that Microsoft offers it as well — a notable signal, since Windows never had a native GNU equivalent and uutils fills that gap with a single multicall binary.
The road to a full replacement is still long. Replacing GNU Coreutils on a distribution means touching the substrate that init scripts, packages, and decades of habits rely on. Distributions are rational to be cautious: they proceed utility by utility, confirming each edge case of the GNU test suite is covered before switching. Clearing 95% is one more argument in that process, not an endpoint.
Why memory safety is becoming an infrastructure argument
The uutils project is careful not to make the Rust rewrite a pure security pitch: it notes that GNU Coreutils has recorded only 17 CVEs since 2003, a low count for software that old and that exposed. The argument is therefore not “C is dangerous” but “memory safety removes an entire class of bugs without a measurable performance cost,” and above all “the substrate must be maintainable by the next generation.”
That reasoning has already won battles elsewhere. The Linux kernel itself has been integrating Rust for several cycles, and even the most skeptical maintainers have conceded that unsafe memory is a recurring source of exploitable flaws. For core utilities that parse untrusted input, file paths, binary data, and regular expressions, the stakes are the same at a smaller scale: every parser rewritten in Rust is a parser that can no longer be exploited through a buffer overflow.
The multicall binary adds an operational argument. A single binary that groups every command simplifies distribution, shrinks the executable surface, and eases deployment onto immutable images. That explains the interest from Microsoft, which never had a native GNU equivalent on Windows, and from distributions that see in uutils a common cross-platform substrate rather than a mere copy of GNU.
None of this changes the fact that, for a production server, the prudent default is still to wait before switching. But the direction is now measurable: a 95% pass rate, PGO builds by default, and diagnostics that rival a compiler mean the distance between “interesting experiment” and “viable default” has narrowed to a small tail of edge cases. The remaining work is mostly verification against real workloads, not invention — which is exactly the phase where a project stops being a curiosity and starts being a candidate.
Verdict
If you run production Linux servers, stay on GNU Coreutils: nothing justifies a switch today, and the risk of regression on existing scripts outweighs the immediate benefit. But follow the project — Ubuntu’s adoption and the prospect of Debian will flip this question within the next two years.
If you build minimal, embedded, or immutable images, test uutils now. A single multicall binary, Rust memory safety, and portability reaching as far as WebAssembly make it a serious candidate wherever every byte and every attack surface counts.
If you are a developer or contributor, the Ariadne feature is a good reason to install 0.11 and watch what a generation of utilities whose errors read like a compiler’s would look like. It is the clearest signal yet that the Rust rewrite no longer just imitates GNU — it is starting to improve on it.