Ubuntu 25.10's Rust Coreutils Transition Has Uncovered Performance Shortcomings


Ubuntu 25.10's transition to using Rust Coreutils in place of GNU Coreutils has uncovered a few performance issues so far with the Rust version being slower than the C-based GNU Coreutils. Fortunately there still are a few weeks to go until Ubuntu 25.10 releases as stable and upstream developers are working to address these performance gaps.
in reply to Strit

Rust is fundamentally more limiting than C, even with unsafe. It is often faster if you write naive code (because the Rust compiler can optimize more aggressively due to those same limitations), but an experienced developer with a lot of time for optimization will probably be able to squeeze more performance out of C than they would out of Rust - as you can see in this example. Rust is still better because those limitations all but guarantee that the resulting code will be safer, and the performance differences would be negligible all things considered.
in reply to Strit

Language isn't everything. While Rust provides some features and safety that C doesn't while being roughly equivalent in performance, the algorithms that developers choose will dominate the performance impact on the program.

GNU core utils has decades of accumulated knowledge and optimisation that results in the speed it has. The Rust core utils should in theory be able to achieve equivalent performance, but differences in the implementation choices between one and another, or even something as simple as the developers not having prioritised speed yet and still focusing on correctness could explain the differences that are being reported.

This entry was edited (7 months ago)
in reply to Froggie 🐸

Well the entire point of the project is that they used algorithms/features of Rust that make it easier to write fast code. This article basically reports on a "bug". Uutils are in many ways already faster than Coreutils.

Correctness is really more of a byproduct of using Rust. Coreutils have had only a few CVEs in their lifetime so it would be sort of redundant to rewrite them in Rust for "correctness".

in reply to رضا

This should be avoided like the plague because of the choice to use MIT over GPL.

Any work dedicated to this can and will be stolen by corporations without giving back if they find it useful. This is what happened with Sony and Apple and their respective operating systems. They chose to base them on BSD so they could steal work and not give back to the public.

Do not be fooled.

in reply to atzanteol

But that is what he was actually saying. His comment was he would rather see it as gpl because mit effectively allows the hard work to be stolen like what we saw with apple and bsd. Hes not blaming apple he is just saying he would not have issue if it was gpl instead of mit. Again its like you have to look at the whole message and context for meaning rather than the strict definition of the one line.
in reply to atzanteol

It's not like improper use of "steal" is unheard of, I see all the time people use "I'm gonna steal that" and similar even when it applies to things openly given for free. And considering that it's quite clear that the MIT allows others to take without sharing back (it's the main difference with GPL) I'm quite sure the commenter was aware that it wasn't really theft, yet chose that word probably with the intention to insult the practice, rather than as a fair descriptor.

So yes, you're right, it isn't theft... but I don't think that was the point of the comment.

This entry was edited (7 months ago)
in reply to digger

The reason Ubuntu switched was Rust's "safety". Which is sort of a dumb reason because Coreutils have had very few CVEs in the past. A less dumb reason is performance. Uutils are faster than Coreutils, this was an edge-case.

MIT license is the schizo reason. Making a closed source version of Unix utilities would not be beneficial for Canonical in any way, but that does not stop the schizos from schizoing.

in reply to CarrotsHaveEars

You can fork it and GPL it just fine, the MIT licence allows for that, however anyone who wants to make the codebase proprietary can just fork the original upstream project. Not much point GPLing a project if you make zero changes to it. If you make changes then in practice just your changes are GPLed because anyone wanting to use code from upstream can just use it directly from upstream under MIT.
in reply to communism

They articulated the reason and gave examples of precedence.

And you're dismissing their voice as irrelevant, but as the consumer of the product, their voice is most critical, and more people should be aware of how corporations use their massive wealth to choke and starve open source competition out of existence despite building their products on open source work in the first place.

in reply to 3abas

in reply to communism

in reply to 3abas

You're arguing with a strawman you created, no one made any statements about the author.


The original comment called it stealing. There's nothing morally wrong with stealing, but regardless it's not even stealing. It's a stupid argument.

Solid justification for using it for coreutils you got there...


I'm obviously talking about not giving a shit about how people use it. Which makes sense for coreutils. Loads of people use it for loads of different purposes. The author shouldn't care how people use it.

in reply to communism

We're obviously talking about corporations intentionally using open source software with the intention of eliminating it as competition, we aren't talking about the literal definition of the word "stealing", which you seem smart enough to be able to recognize, but you're insisting on being pedantic.

You twisted that into an argument about what the author of the code has the right to do... No one gives a shit, and we aren't obligated to support it.

in reply to 3abas

in reply to flux

A major version of 0 isn't necessarily any statement regarding the projects maturity, it can also be a hack with semantic versioning. Normally, any change that is not fully backwards compatible requires you to increment the major version, but if the major version is 0, you may only increase the minor version. Because of this, many projects stay at the 0.x.y versions, so they don't need to release version 2.0.0, 3.0.0, 4.0.0 and so on just because of minor but breaking changes as many users might expect significant new features from that version steps.
in reply to excral

They don't need to use semantic versioning. I doubt coreutils itself uses it, though I admit I haven't checked. Actually I think semantic versioning is less popular in practice than it looks like.

For a set of tools to that completely replaces another one, announcing a 1.0 version would be a message that the developers think the project has actually reached its initial goals. "0.2" does not.