Ubuntu 26.10 completes transition to Rust-based coreutils

Ubuntu 26.10 officially completes its bold transition to Rust-based core utilities, a move championed by Canonical for its security benefits derived from Rust's memory safety. This change, however, has ignited a fierce debate within the Hacker News community, with many questioning the maturity and stability of the new tooling compared to its battle-tested GNU predecessors. Critics point to new bugs, ideological motivations, and the perceived forced adoption, signaling deep-seated frustrations with Ubuntu's strategic direction.

124

Score

107

Comments

#19

Highest Rank

on Front Page

First Seen

Sep 14, 2:00 PM

Last Seen

Sep 15, 8:00 AM

Rank Over Time

The Lowdown

Ubuntu 26.10, codenamed 'Stonking Stingray,' marks the full migration of the distribution's core utilities to Rust-based uutils. This initiative, begun in 2025, aims to enhance system security by leveraging Rust's inherent memory safety features, which prevent common vulnerabilities found in C-based applications. Canonical has actively supported this transition through funding and audits.

Key tools like cp, mv, and rm, initially held back in 26.04 due to Time-of-Check to Time-of-Use (TOCTOU) issues in uutils, have now been migrated following resolution of these bugs upstream.
The uutils suite replaces GNU versions of essential command-line tools including ls, cat, chmod, and du.
Canonical views memory safety as a critical security advantage, as Rust catches potential memory bugs at compile time.
The project has not been without challenges, including prior hiccups and the need for a security audit by Zellic, which identified initial issues.
Canonical actively contributes €40,000 annually to the Trifecta Tech Foundation, which develops Rust software, including a Rust-based Network Time Protocol (NTP) client planned for Ubuntu 27.10.
The Rust uutils are designed for drop-in compatibility, ensuring no functional differences for end-users, with deviations considered bugs to be fixed.

This final step in the 'oxidization' of Ubuntu underscores Canonical's strategic commitment to modernizing its foundational software stack for improved security, despite ongoing community skepticism regarding the practical implications and trade-offs.

The Gossip

Technical Trepidation & Bug Blight

Many commenters express significant technical concerns about the maturity and quality of the Rust `uutils`. Examples include specific bug reports like `rm` causing segmentation faults with deeply nested directories, and general sentiments that the new tools lack the robustness of their GNU counterparts. Some argue that replacing decades-old, stable utilities with less mature Rust versions introduces unnecessary risks and subtle bugs for users.

Canonical's Controversial Choices

A dominant theme is the criticism of Canonical's decision-making, with users suggesting the move to Rust is more ideological than technical. Commenters liken it to past controversial decisions like forced Snap adoption or systemd. There's frustration over the inability to easily opt out of the Rust versions, especially when `build-essential` now depends on `coreutils-from-uutils`, making it difficult to install GNU alternatives without dependency conflicts.

Security Scrutiny & CVE Count Confusion

Despite Canonical's stated goal of improved security, the discussion scrutinizes the security track record of `uutils`. Several users highlight that a recent audit found 44 CVEs in `uutils`, compared to only 12 in GNU coreutils over two decades, questioning the actual security benefits. The debate extends to whether CVE counts are a reliable metric, with specific examples of `uutils` vulnerabilities like TOCTOU races and symbolic link issues being cited.

License & Fragmentation Fears

Some commenters raise concerns about the shift from GNU GPL licensed coreutils to the more permissively licensed `uutils` (often MIT). This change sparks fears of potential Linux fragmentation, where corporations might adopt and modify the permissive code without contributing changes back, similar to historical issues with proprietary Unix variants. This is seen by some as a move that undermines the FOSS ethos.

Recursion, Stacks, and Tail Calls

A specific technical deep dive emerges from a bug report involving a stack overflow in `rm` with deeply nested directories. This leads to a discussion on default stack sizes in Linux (often 8MB), the implications for recursive algorithms, and the debate around Rust's lack of guaranteed tail call optimization. Commenters explore whether this behavior is a fundamental language limitation or an optimization choice, contrasting it with languages that ensure tail recursion.