Ubuntu 26.10 completes transition to Rust-based coreutils (omgubuntu.co.uk)

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/

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

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.

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

Ubuntu continues on it's quixotic mission to kill 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.  
  

Not that these are not valid points of criticism, but in my opinion if we have two core utils we can (and should) pick the better one after careful continous evaluation. And if the old one is the better one on the day of the release, so be it. Having two competing solutions can have benefits for everybody looking for the best core utils they can get in the long run.

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.

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

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.

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!

From the company that distributed Amazon spyware (https://www.fsf.org/blogs/rms/ubuntu-spyware-what-to-do) and now turns Debian into Slopian. No thanks.

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.