Rust Coreutils 0.10 Reaches Production-Grade GNU Compatibility With Native Memory Hardening

August 5, 2026 — The uutils project shipped Rust Coreutils 0.10, a complete rewrite of GNU Coreutils in Rust that now clears the bar for production use. Memory hardening is compiler-enforced. GNU compatibility is near-complete. The argument for staying on the 40-year-old C codebase just got thinner.

This release is not another incremental milestone. Coverage of the GNU test suite hit a threshold where multiple distributions and infrastructure maintainers are actively discussing the switch. Rust Coreutils is no longer a proof of concept — it is a concrete drop-in for ls, cp, mv, cat, and the 90 other binaries every Linux admin runs a hundred times a day.

Why replace GNU Coreutils after four decades

GNU Coreutils is written in C. Memory corruption bugs — buffer overflows, use-after-free, double-free — remain the number one vector for critical vulnerabilities in mature C codebases. In 2025, the CVE program logged over 200 vulnerabilities in mature C projects under 100,000 lines. GNU Coreutils, at ~80,000 lines of C, is not immune: every cp or dd handling a malformed file is a potential attack surface.

Rust eliminates this entire bug class at the compiler level. No superfluous unsafe, no data races, no dangling pointers. The result is tangible: Rust Coreutils 0.10 adds per-process sandboxing and compiler-level hardening (PIE, RELRO, stack protector) without manual effort — the compiler bakes them in by default.

What 0.10 delivers

• 98% GNU test suite compatibility. Version 0.10 passes nearly all available GNU tests for cp, mv, dd, ls, sort, uniq, and wc. Remaining gaps involve obscure flags (dd conv=sparse with rare flag combinations) that most shell scripts never touch.
• Native memory safety. Every binary ships with stack-protector-strong, -fPIE, -Wl,-z,relro, -Wl,-z,now, and Rust’s ownership model structurally prevents use-after-free.
• Fuzzing integrated into CI. cargo-fuzz now runs on every PR for cp, dd, sort, and split.
• Performance at parity or better. Copy and sort operations match GNU, and large-volume sorting is sometimes faster thanks to Rayon-based parallelism.

Version 0.10 also introduces an experimental --sandbox mode for cp and dd, using seccomp to isolate syscalls — a first for a coreutils replacement.

What still blocks mainstream adoption

Two obstacles remain before Rust Coreutils ships as the default on a major distribution:

1. Shell scripts hardcode /bin/cp. On most systems, /bin/cp is a symlink to coreutils. Replacing that symlink requires a coordinated transition only distributions can orchestrate. Arch Linux and Fedora have active discussions, but neither has made the move in 2026.
2. dd block-device compatibility. Rust Coreutils’ dd does not yet handle all device-specific ioctls (direct, sync on block devices), blocking raw disk copy use cases.

For container or CI workloads, neither limitation matters. AWS already ships Rust Coreutils in Bottlerocket minimal images; Google includes them in select Distroless images.

Verdict

Rust Coreutils 0.10 is production-ready — just not for every production.

• If you ship minimal containers or run CI pipelines, switch now. You gain ~70% reduction in memory-related attack surface without changing a single line of script — alias cp='coreutils cp' is enough.
• If you manage bare-metal servers with legacy shell scripts, stay on GNU for the next 6 to 12 months, but begin testing your scripts against the Rust alternative. The switch will be trivial once distributions formalize it.
• If you write new code that calls coreutils, target Rust Coreutils first. Compatibility is sufficient and the security gain is immediate.

The replacement of GNU Coreutils is no longer a matter of “if” but “when.” Version 0.10 turns a promise into a product.

References

• Phoronix — Rust Coreutils 0.10 Released, August 5, 2026
• uutils/coreutils on GitHub — Release v0.10.0, August 5, 2026
• uutils/coreutils — GNU test suite compatibility, accessed August 6, 2026