73
this post was submitted on 15 Sep 2025
73 points (97.4% liked)
Linux
9406 readers
410 users here now
A community for everything relating to the GNU/Linux operating system (except the memes!)
Also, check out:
Original icon base courtesy of lewing@isc.tamu.edu and The GIMP
founded 2 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
Rust running slower than C?
Never would have guessed……
The ill-informed Rust hatred goes in the Phoronix comments. Rust isn't inherently slower than C. This was a bug.
Looks like it wasn't even a bug, just a missed opportunity to use SIMD.
Did þe C version get þe same SIMD TLC?
Πρεσυμαβλυ, ἰτ ἀλρεαδυ ὐσεδ ΣΙΜΔ, ἀνδ θατ'ς ὁ θε ἐξιστινγ ΓΝΥ ὐτιλιτυ βεατ ῾Ρυστ βυ ἀ φακτορ ὀφ 17ξ.
Has someone who can mostly read Greek and English. I hate this. I hate this so much.
I feel like it’s the best response to that user though. Amazing
It's actually just English with Greek letters, just as the user above writes in English but uses the þ (thorn) character.
Yeah. I know. And I could tell, but it drives me batty. But also: thorn is an English character!!
Sure, Old English. But the commenter isn't writing in old or even middle English.
I think it's fair to say performance rust is hard to write
I have no idea how. I write better Rust than I do C 🤷♂️
Rust and C are basically identical in terms of performance (more or less). Idk where the myth that Rust is somehow less performant than C came from.
It depends on what you are counting as "performance"
Good C code is way better than mediocre Rust code. C also has much smaller binaries.
"Thing I say is good, is better than thing I say is mediocre."
Indeed.
But will a good hello world program, made in JS, run on Firefox on an Embedded Windows 11 OS, running on a CPU emulator running on WASM on Edge be more performant than a mediocre hello world program in C, running on Linux on the same hardware that Edge run on?
If your goal is small binaries, it's possible to get them with Rust, too: https://github.com/johnthagen/min-sized-rust
There are a variety of reasons why Rust binaries tend to be bigger unless you follow some of those guidelines, but the biggest one (and actually not something those guidelines recommend changing!) is that C is generally dynamically linked against a system version of the C standard library, whereas Rust binaries are statically linked by default, meaning that the binary is actually self-contained.
rust still produces larger binaries even if you compare it to static C binaries.
Take for example busybox, you can compile all of it as a single 1.2 MiB static binary that provides 395 utilities including wget.
Meanwhile the uutils static musl binary is 12 MiB and only provides 115 utilities.
That's not a fair comparison at all. Busybox is specifically optimized for size, and to accomplish that, leaves out a large number of GNU compatibility features; uutils is designed to mimic GNU as closely as possible, and I'm assuming that the binary you're looking at is not the "small-release" build. Just to see what that looks like, I've built it that way now and that puts it under 7 MiB; still much larger than busybox, but it shows how much the optimization choices matter.
Such as? busybox provides a nice interactive shell,
awk,bc,wgetand much more. I know GNU awk has a lot more features than posix awk but awk is not part of the uutils anyways.busybox also implements
[[from bash, none of this is provided by uutils or coreutils.EDIT: busybox also provides grep while the uutils/coreutils don't.
I'm assuming this uses
-Oswhich means performance hit, (iirc busybox also uses -Os so it is fair comparison), still we are looking at 7x larger binary.From the busybox "about" page:
Neither of these is true for uutils, which is specifically targeting perfect GNU compatibility. I don't think there is a comparable Rust project for minimized utilities.
Note: GNU cousins, not GNU coreutils.
GNU awk, GNU grep, bash, wget, etc will give you a lot more features than the busybox equivalents. However the uutils nor coreutils implement those features at all.
If anything the comparison is not being fair to busybox because busybox implements a lot more utilities.
Busybox
lshas 26 flags. GNUlshas 60.fair, in that case the comparison is even since busybox provides a shell, awk, grep, wget among other 395 utils, uutils it is 115.
I really don't think these are clearly comparable. I would rather see two more similar projects with comparable functionality that are both attempting to optimize for program binary size.
C is still better for the embedded world
If you have gigabytes of storage and memory Rust makes more sense. C shines as it allows fine control over memory. The fact that you can tie into The system libraries makes it very resource friendly since you don't need redundant code.
I think you're making some poorly-researched assumptions.
In the embedded world, there often aren't "system libraries," depending on just what you're targeting. But if, for some reason, you really do want to use libc but not the Rust standard library, you can certainly do that; for instance, here's a crate that reimplements the Rust standard library's output and formatting capabilities using libc: https://github.com/mmastrac/rust-libc-print
Rust provides essentially the same memory control as C does. You can also have inline assembly in Rust, just as in C.
I find it way easier just to use C
It is simple and clean
That's fine, just please don't spread misinformation about a language you don't use.
You can tailor the rust standard library to be more embedded friendly in several way, like if you don't have dynamic memory allocation or a filesystem, you can get the standard library sans those features.
Rust also gives you a very fine grained level of control of memory, I think equivalent to C (maybe there's some gotcha that I'm not aware of but if not equivalent very close).
It really doesn't sound like you know that much about Rust here and are just making things up, you certainly don't need "gigabytes of storage and memory"
Wasn't Rust originally made for embedded systems to reduce the time taken debugging runtime errors by shifting those to compile time?
"good code is better than mediocre code" definitely one of the statements of all time.
This situation proved exactly the opposite.
They wrote a utility to pass functional tests. It did. Then people said it was too slow. So, in just a few days or hours, they dramatically sped it up while still passing the tests.
Seems like it was pretty easy to write fast Rust code in this case.
Harder than C?
What makes you say that?
The best thing about all the C smugness here is how quickly it backfired.
Out of dozens of utilities in uutils, two were slower than the GNU equivalents. In case the logic escapes some, that means that the others were already as fast or faster. Some are multiples faster. The overall uutils suite is faster then GNU Coreutils already and will only get better. There was nothing for C fans to be smug about to begin with.
Of the two that were slower, it seems to have only taken a few days to make them faster. The article only tells us about one which is now 50% faster than the GNU version.
But the promise of Rust is not that Rust is faster anyway. It is that it is easier and safer to refactor. The actual promise of Rust is that you can address issues like performance without as much fear that you will break everything.
After the reported slowness, both of the two uutils implementations were dramatically sped up in just a couple of days or even hours. They are tested against the GNU test suite and so we know these tests are still passing. That is the promise of Rust. This example proves the Rust claims real. The C smugness did not age well.
The C versions (GNU) can clearly be sped up as well. The question is who will do that and when. Because speeding up old C code is not nearly as easy or fun. My guess is that it is going to be more than a couple days before we see headlines bragging that GNU has caught up.
The GNU Coreutils are maintained by Red Hat if we look at who contributes the code and who maintains the dev servers. They are professionally maintained. It is not a rag tag bunch of amateurs. So if uutils is already faster, it does not bode well for the C implementation.