Ubuntu 26.10 completes transition to Rust-based coreutils

I really don't understand why Canonical rushes this. If 'rm' can't remove all possible directory entries, that is a big issue:

  $ podman run --rm -it ubuntu:26.10
  $ apt update -y; apt upgrade -y
  $ rm --version
  rm (uutils coreutils) 0.10.0
  $ gnumkdir -p $(yes a/ | head -n $((32 * 1024)) | tr -d '\n')
  $ rm -rf a
  Segmentation fault (core dumped) rm -rf a
  $ ls a
  a
  $ gnurm -rf a
  $ ls a
  ls: cannot access 'a': No such file or directory

Whether you like Rust or not, it's questionable as to why Canonical would push this so much and do it in such a cavalier way.

Will this really make coreutils more secure? I doubt it, if anything there will be a river of new bugs.

So, again, why are they pushing Rust so much? Having Microsoft make Rust a 'Tier-1' language also doesn't bode well.

You can use coreutils-from-gnu instead uutils. However since 26.04 build-essential depends on coreutils-from-uutils, it cannot be upgraded while coreutils-from-gnu is installed.

https://bugs.launchpad.net/ubuntu/+source/build-essential/+b...

Has the code quality in that repo gotten to a good point then? I haven't followed it much, but last I looked[1] (which was a few years ago) almost every tool I looked at in detail had pretty bad performance or correctness issues.

[1] https://jackson.dev/post/rust-coreutils-dd/

I was bummed when I came across this: https://github.com/trifectatechfoundation/sudo-rs/issues/129...

People still use ubuntu when Debian and Mint exist?

So what is the way forward for Linux to have sandboxi g as strong as Android? Appimage everything? I know it's possible now hacking together things, but I mean by default and integrated.

Other distros are based of ununtu. Will the all ship with crippled coreutils from now on?

Hmm, this doesn’t make sense. You simply don’t replace utilities with many decades of maturity and that “just work” with something that is not as mature. It will open all users of the distro to all sorts of subtle and not so subtle bugs. I for one don’t want to find myself staring at a mysterious segfault when I want to build the latest version of nodejs or flash a microcontroller. It’s such a pity; I have used Ubuntu for close to 23 years.

Was there something wrong with how they are currently written or do they just want the badge that says they converted to Rust?

Ubuntu continues on it's quixotic mission to kill Linux...

If you ask their motivation? "We want to make them safer"

They worked pretty fine for decades, now, who needs these rewrites? Not saying it's useless, but in practice, what benefits did this bring?

Can’t wait for the whole Rust rewrite of Linux!

I would be very curious about a bit more concrete and substential criticism what is bad (or good) about how the both versions, that goes beyond general arguments like:

  Just because it is Rust, it is not safe!  
  
  It worked before, don't replace it!  
  
  etc.  
  

I had to reimplement and reverse engineer old tech myself as part of my dayjob and had those engineers seen my results it probably would have improved their work as well, since I usually found oddities that they probably did not intend to be that way. This means my work on their work could be seen as another pair of eyeballs, bullet-proofing their original work, instead of seeing me as a threat. That additional pair of eyeballs is crucial to open source software.

This is why it is sad that too much about this whole discussion feels like yet another culture war, heated on the stove of social media figures looking to convert heat into ad revenue.

Which is why I would love to have more concrete points of technical criticism of specific bits maybe even to specific lines in the code or specific reproducable behavior.

If we go the culture-war route nobody wins, if we discuss both solutions on their merits, we all can win.

Everything online reminds of when Ubuntu switched to dash for init scripts or something. Good times.

[flagged]

[flagged]

[flagged]

[flagged]

[flagged]

Better security, what's not to like. It's ridiculous to be against this in these times when we need all security we can get. So what if there is a minor incompatibility, can be fixe in no time. If we do a snapshot in time and count vounerabillities in the C codebase vs Rust im pretty sure who will have more in 5 years. It's just the nature of C codebases. C is a nice language but it was never designed with memory safety in mind. It was designed to be flexible and portable. It's a great language. Rust was designed to be fast and memory safe because it had 20+ years of C++ and C experience to learn from.

[flagged]

Fil-C[0] can compile GNU coreutils, it has stronger* memory safety guarantees than rust, none of the compatibility issues that a wholesale rewrite has, and performance that seems to be within about a factor of two[1] compared to the normally compiled code..

[0]: https://fil-c.org/.

[1]: https://bannalia.blogspot.com/2025/11/comparing-run-time-per...

* Guaranteed to crash rather than potentially grant arbitrary code execution.