Remix.run Logo
Remix clone Hacker News
new | show | ask | jobsGithub
▲ Ubuntu 26.10 completes transition to Rust-based coreutils(omgubuntu.co.uk)
125 points by theanonymousone 16 hours ago | 65 comments
▲collinfunk 15 hours ago | parent | next [-]

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
▲teekert 15 hours ago | parent | next [-]

Rush? This is an interim release (95% or so only tracks LTS's) that is not even out yet... Go file a bug reports if you have some time.

▲mixmastamyk 14 hours ago | parent | next [-]

I did, and the original dev of the component fixed it within a few days. It was straightforward, a backwards reading of a spec, reordered.

The fix is still sitting unmerged many months later.

This surprised me since I thought the project was in heavy bugfix/compat mode. I won’t touch it until I see some velocity on open bugs.

▲collinfunk 15 hours ago | parent | prev | next [-]

I have. It has been an open bug upstream for years as well.

▲teekert 15 hours ago | parent [-]

ok, that's concerning, if you post it here I'll vote for it (after confirming).

▲jeffbee 14 hours ago | parent | prev [-]

Reporting bugs before Ubuntu releases has never worked for me. They always land a bunch of major changes after the supposed "freeze" then they ignore all feedback because of the freeze. It's infuriating.

▲collinfunk 14 hours ago | parent [-]

Glad to hear that I am not alone. I feel like launchpad is totally ignored most of the time.

To get a response on a buggy GNU coreutils patch of theirs [1], I had to mention it in a rust-coreutils bug months later...

[1] https://bugs.launchpad.net/ubuntu/+source/coreutils/+bug/215...

▲lynx97 29 minutes ago | parent | prev | next [-]

Wow! Memory safety and such... Reminds me when a friend of mine wrote in IRC long time ago: "Hmm, tail just segfaulted." When I asked "Are you on Hurd?" he just replied "Yes."

▲amelius 15 hours ago | parent | prev | next [-]

Let them first fix Snap.

▲tjoff 34 minutes ago | parent | next [-]

There is no reason for anyone on any distro to use snap.

It will die so just leave it alone.

▲0x696C6961 6 hours ago | parent | prev [-]

They need to kill snap ...

▲cute_boi an hour ago | parent [-]

Yes, please. Linux distros is better with macos approach. And making appimage first class makes a lot of sense.

▲petre an hour ago | parent [-]

I'll avoid it at this point anyway. The Rust coreutils is another reason for that. Snap, monetizing updates, telemetry, enough is enough.

▲voakbasda 38 minutes ago | parent [-]

Yup. After almost 20 years, I have had enough of their crap. All of my new machines are getting Debian. Can’t wait until I am free of Ubuntu.

▲dark-star 15 hours ago | parent | prev | next [-]

yeah, this is a bug. And yes, it should be fixed. But I don't think it will affect many users, I mean who has a 32000 -evels deep directory on their system?

▲tosti 13 hours ago | parent | next [-]

What programmer or programming language can't iterate a loop more than 32000 times?!

▲Ygg2 13 hours ago | parent | next [-]

When triaging an issue you have to prioritise. Do you fix a problem that affects 2-3 people or one that may affect thousands?

▲IshKebab 13 hours ago | parent | prev | next [-]

It's a stack overflow which means it's using recursion and for historical reasons that don't make sense any more, stacks are teeny tiny on 64-bit Linux - apparently only 8 MB on Linux! I'm not sure why they don't raise it to something reasonable like 4 GB. I guess because they want consistency with 32-bit? Maybe we can finally change it if/when they phase out support for 32-bit Linux. Apparently it might not be that far away:

https://lwn.net/Articles/1035727/

▲ploxiln an hour ago | parent | next [-]

8MB is the default per-thread stack size from glibc, also seems to be the default "ulimit" from pam or the kernel, I'm not sure. So for the main/default thread (or if not using threads) the process can use setrlimit() and for threads it can use pthread_attr_setstacksize() to get bigger stacks if it knows it may need them.

8MB is pretty huge though; musl libc is famous for defaulting to much smaller per-thread stack size of 128KB (to avoid over-committing lots of memory when there are many threads - the main dev is really principled/opinionated on this topic, but again there are a few ways for applications to explicitly size their stacks as large as they need). Linux kernel threads get a bit less than 16KB!

▲tosti 13 hours ago | parent | prev [-]

OIC. Rust doesn't guarantee optimizing tail recursion. How unfortunate for a language that's getting widespread adoption.

▲gpm 12 hours ago | parent | next [-]

For what it's worth there's reasonably active [1] work on implementing opt-in guaranteed tail calls - but it's not particularly fast going. LLVM (the backend rust uses) needs better support for musttail (e.g. some architectures just don't support it [2]).

[1] https://github.com/rust-lang/rust/issues/112788

[2] https://github.com/rust-lang/rust/issues/153827

By-default guaranteed tail calls really isn't rust's style, because it means subtle changes (introducing a destructor, re-ordering code, etc) can change semantics without you realizing it. If you want to guarantee that a call can't allocate a new stack frame you should have to say it.

▲jmalicki 3 hours ago | parent | next [-]

> because it means subtle changes (introducing a destructor, re-ordering code, etc) can change semantics without you realizing it.

No, it won't change semantics - if you say @musttail or similar, it will simply fail to compile if you, say, introduce a destructor - the semantics will not subtly change.

▲afdbcreid an hour ago | parent | next [-]

Incorrect. `become` does change drop order - https://play.rust-lang.org/?version=nightly&mode=debug&editi....

▲jmalicki 44 minutes ago | parent [-]

That's not implementing tail calls breaks things, that's bad design of implementing tail calls breaking things.

The whole idea of "let's change semantics to make it easier" is dumb.

If you want guaranteed tail calls, change your code until it works.

▲gpm 3 hours ago | parent | prev [-]

Uh, yes, if you guarantee the semantics only when the code explicitly opts in and not by default then semantics will not subtly change, that is the point of my comment

▲jmalicki 2 hours ago | parent [-]

It's not a change in semantics of compiled code. It is only a change of whether or not the code will compile.

▲lioeters 12 hours ago | parent | prev [-]

Not so familiar with this area, but isn't the existing behavior of implicitly creating new stacks more of a problem than implicit tail-call elimination? Seems the latter is a kind of compiler-level optimization, of which there are already many (I think) that change the semantics internally but guarantee the outward behavior stays the same.

But I can understand the preference for an explicit opt-in, to make clear that it is enforced and not assumed.

▲gpm 11 hours ago | parent [-]

> implicitly creating new stacks

I'd argue that it's explicit - that's what a function call does and you don't have implicit function calls in rust.

> Seems the latter is a kind of compiler-level optimization, of which there are already many (I think) that change the semantics internally but guarantee the outward behavior stays the same.

What you're asking for here already exists. Tail calls might be optimized into not allocating extra stack frames, the rust compiler just doesn't guarantee that it will perform that optimization (and almost certainly won't when code is compiled without optimizations... for instance).

What people want is the semantic guarantee that the stack frame won't be allocated. Not just a compiler that often performs the optimization. Otherwise you can't be sure that your code will keep working with new compiler flags/versions/architectures/... You could say "whenever the code is the right shape we'll guarantee the optimization" (C++ famously did this for things like copy elision)... but now the shape of code comes with non-obvious semantic guarantees and that's not rust's style. Hence the proposal for a keyword instead.

▲lioeters 11 hours ago | parent [-]

I see it, certain algorithms need guaranteed tail-call elimination, otherwise they are too inefficient and must be manually unrolled or rewritten to avoid blowing the stack. So a compiler optimization that is "nice to have" is not good enough.

▲clhodapp 2 hours ago | parent [-]

No algorithm requires tail-call elimination in a general-purpose language with imperative mutability. It's just another way to express iteration.

▲IshKebab 9 hours ago | parent | prev [-]

Do any widely used languages guarantee tail call optimization? It's a pretty niche feature.

▲gpm 8 hours ago | parent [-]

Scala, ocaml, racket, clojure, zig.

For recursion only kotlin.

(For most of these only with syntax specifying it)

▲hulitu 23 minutes ago | parent | prev [-]

Rust ? Because of ... memory safety. /s

▲secondcoming 15 hours ago | parent | prev [-]

That way of thinking just means it'll never be fixed

▲abirch 15 hours ago | parent | next [-]

"The Linux philosophy is 'Laugh in the face of danger'. Oops. Wrong One. 'Do it yourself'. Yes, that's it." Linus Torvalds

▲dfox 14 hours ago | parent [-]

The problem there is that this is exactly the class of bug that does not exist in GNU coreutils because of philosophy of that project. Non-existence of such bugs proves that the impementation is not copied from AT&T code.

▲gpm 15 hours ago | parent | prev | next [-]

Nah, people should (and do) fix small issues as well as big issues. Lying about the scale of issues and calling them "big" when they aren't just leads to no ability to prioritize or evaluate.

Incidentally someone submitted a PR for this issue about 3 hours before the first comment about it in this thread - https://github.com/uutils/coreutils/pull/14554 (and 2 hours before this link was submitted to HN)

▲7bit 15 hours ago | parent | prev [-]

What approach would you suggest for priorisation of tickets?

▲mrkdkirlwkfkf 2 hours ago | parent | next [-]

Capitalism.

▲secondcoming 14 hours ago | parent | prev [-]

Ideally there should have been no tickets at all if all that's happening is a program being ported to another language.

▲gpm 14 hours ago | parent [-]

This isn't a port - it's a re-implementation without any use of the original source.

That's also not all that's happening. It's also making improvements like better internalization support, better error messages, and a small handful of other extensions.

▲collinfunk 14 hours ago | parent [-]

I have had to tell them repeatedly to stop copying tests verbatim, including the original comments from GNU coreutils. So I doubt this is true, which is frustrating.

▲IshKebab 13 hours ago | parent | prev [-]

I mean, that should work... but you can see why that would be considered low priority right?

▲Malakun 15 hours ago | parent | prev | next [-]

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...

▲egorfine 14 hours ago | parent | next [-]

For now you can list dependent packages manually in apt-get install: https://packages.ubuntu.com/resolute/build-essential

But it's clear that Ubuntu will remove coreutils, genuine sudo and other tools from the future versions. It's the direction, it's ideological and thus nor merit nor our feedback will change anything here.

▲lioeters 11 hours ago | parent [-]

> genuine sudo

That made me curious, it sounds related to this:

Ubuntu 26.04 Ends 46 Years of Silent sudo Passwords - 5 months ago (413 comments)

https://news.ycombinator.com/item?id=47464134

▲egorfine 11 hours ago | parent [-]

nah

i was referring to their counterfeit sudo emulator written in rust. It's called "sudo-rs" afair.

▲lioeters 10 hours ago | parent [-]

Ah I see, found it.

Security issues discovered in sudo-rs - https://lists.debian.org/debian-security-announce/2025/msg00...

Sudo-Rs Affected by Multiple Security Vulnerabilities - https://www.phoronix.com/news/sudo-rs-security-ubuntu-25.10

Sudo-rs enables password feedback by default - https://www.phoronix.com/news/sudo-rs-password-feedback

▲collinfunk 14 hours ago | parent | prev [-]

You can use equivs to create a dummy coreutils-from-uutils package, as mentioned in the responses to that report.

It is frustrating that Canonical has no interest in fixing it, though. It makes it hard to take their claims seriously that you can still use GNU coreutils if you want.

▲SubiculumCode 34 minutes ago | parent | prev | next [-]

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.

▲arjie 44 minutes ago | parent | prev | next [-]

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

▲Arcuru 14 hours ago | parent | prev | next [-]

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/

▲estebank 14 hours ago | parent | next [-]

> last I looked[1] (which was a few years ago)

You weren't kidding: it was exactly 4 years ago ("September 13, 2022").

▲egorfine 14 hours ago | parent | prev [-]

The reason for existence of uutils is ideological, not technical. Thus code quality is of no use for the objective.

▲stouset 13 hours ago | parent | next [-]

I’m a huge proponent of Rust and generally lean a lot closer to the RIIR mentality than most, but this effort seems to be such a waste of effort and resources.

There have been a dozen CVEs reported against all of coreutils in the past twenty years. The most recent audit of uutils-coreutils turned up forty-four CVEs.

By all appearances they’re replacing battle-tested and fundamental tooling which hasn’t been a problem with extremely amateurish Rust. The threading highlighted in the linked post above seems pretty egregious.

▲egorfine 13 hours ago | parent [-]

Same here. Love Rust. Hate rust rewrites.

▲tcfhgj 5 hours ago | parent | prev [-]

I bet you don't know the reason for existence

▲dsign 2 hours ago | parent | prev | next [-]

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.

▲someothherguyy an hour ago | parent [-]

then install the other tool. no one is holding a gun to your head. it isn't windows.

▲nairboon 11 minutes ago | parent [-]

Like how one can easily not use snap on Ubuntu? /s

▲hk1337 14 hours ago | parent | prev | next [-]

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

▲Flimm 30 minutes ago | parent | next [-]

Neither. They basically see Rust as the future. They want to be able to attract young contributors and to hire young employees who are excited about Rust and who want the safety features. Bear in mind, the average age of the Linux developer is increasing. They also see technical benefits in Rust. And they are increasing test coverage of both the Rust tools and the tools written in C, IIRC.

My source is this interview with the VP of Engineering at Canonical on this topic: https://corrode.dev/podcast/s05e05-canonical/

▲01HNNWZ0MV43FF 3 hours ago | parent | prev [-]

License. GNU is copyleft and the new thing is permissive.

We might see a fracture open slowly. For me, even AGPL is not enough

▲zahlman 2 hours ago | parent [-]

Once they have a more permissive license, cui bono?

▲asrk-qlwu 15 hours ago | parent | prev [-]

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.