62
Rust Coreutils 0.1 Released With Big Performance Gains - Can Match Or Exceed GNU Speed
(www.phoronix.com)
Rust 👍
MIT instead of GPL 👎
this post was submitted on 25 May 2025
62 points (94.3% liked)
Rust
6951 readers
34 users here now
Welcome to the Rust community! This is a place to discuss about the Rust programming language.
Wormhole
Credits
- The icon is a modified version of the official rust logo (changing the colors to a gradient and black background)
founded 2 years ago
MODERATORS
Using MIT license means the developers cannot look at GNU source code when writing code for uutils. This feels like a unnecessary hurdle given that uutils wants to be 100% compatible with GNU tools.
That's not accurate. They can look at it, but they can't port it. But looking at how it works and then coming up with their own implementation is fine.
It’s a gray area, legally. What you say is theoretically correct, but there’s practical issues once you’ve looked at the code that will open you up to legal liability anyway.
For instance, what if you need a utility function during your reimplementation for which there is really only one obvious implementation? You can no longer claim to have come up with it by yourself.
I doubt the FSF would sue over it, but companies are known to avoid the risk.
If a piece of code is so trivial there is only one obvious solution then it does not fall under copyright. There is jurisprudence for this.
Maybe not the best example then, but not the only example. If you unintentionally create something that resembles the original too much you may still become liable. It’s hard to draw the line, which is why many in such a position would prefer to be safe rather than sorry.
How so? People come up with the same idea all the time independently of each other. When doing clean room implementation (the ideal best case), you are not liable if what you create at the end matches 1-1 with the original. You never know anything about the implementation detail of the original. Academia also acknowledged independent discovery and publication of many things. Why would clean room implementation be different?
Because coming up with the same implementation independently is legal, while copying someone else’s implementation isn’t. Which method you used to arrive at your implementation can be difficult to prove either way, which is why it’s important for implementors to be able to say they never looked at the original. It’s a legal defence, in case you ever need to stand in front of a judge or jury who will question how you arrived at yours.
That's... what I'm saying. Clean room implementation is legal. You accidentally arrive at the same conclusion independently. And yes, it is tedious to do it but it is legal.
@jenesaisquoi @Ordoviz It’s a gray area, legally. What you say is theoretically correct, but there’s practical issues once you’ve looked at the code that will open you up to legal liability anyway.
For instance, what if you need a utility function during your reimplementation for which there is really only one obvious implementation? You can no longer claim to have come up with it by yourself.
I doubt the FSF would sue over it, but companies are known to avoid the risk.
It's not quite that bad. They say
This means that we cannot accept any changes based on the GNU source code.
You are totally allowed to look at it. For example if there was some weird behaviour that you couldn't work out, you could look at the GNU code to understand it.
What you can't do is closely base your code on the GNU code. I.e. you can't just translate it from C into Rust.
On the other hand a new GPL licensed version of coreutils will run into the exact same adoption problems that brought us the current mess of "you can use this parameter on GNU but not on the BSD version",...
1000%
Precisely. The Rust community should stop using pushover licenses.
Eh, I don't see the issue here. The MIT license is fine for a few reasons:
- attractive to lots of FOSS projects, like BSDs, Redox, etc
- no incentive to embed into proprietary projects - ls, cp, etc aren't particularly interesting to embed, and functionality is usually better in the stdlib of whatever language you're using
- increases appeal generally for research purposes
I really don't see much benefit of GPL here. It makes sense for larger works with interesting snippets of code, but not for small, one-off tools like this.
If the other projects are licensed with a GPL, there is no issue doing any of these things (except using them for proprietary purposes later), which is the point. If you licensed your project incorrectly, that isn't the GPL-licensed project's fault.
If you licensed your project incorrectly
If you think other people disagreeing with you on how to license their own work is "incorrect" maybe you are the one not really in favor of freedom.
GPL is more freedom for users and developers. MIT is less freedom for users because it grants more "freedom" for some company to exploit the developer's labor by taking it to make something proprietary with it.
If you want to use GPL code, pushover licenses are incorrect because they protect the user and developer from this nonsense.
I always see people with the argument that the developer labour is somehow being exploited. But have you never thought that maybe, just maybe, the person in question does not care? He just wanted to publish his creation and be done with it. He does not care if people are using it. That's my case. I don't care if people want to use my piece of cryptographic library. Just be aware that I am just some random dude, providing no support nor warranty. I make the library for my use cases and it works fine.
GPL is just as bad as proprietary licenses in the sense that GPL makes the user worry about the licensing of some library they just want to use. MIT, BSD,... give the code user the freedom to avoid worrying about licensing bullshit. GPL meanwhile doesn't really solve any of the problems you claim it solves because all it does is duplicate effort and the non-GPL duplicate is used in a lot of places where a single copy of the code could be used if the GPL-using author hadn't stubbornly insisted on a disproven theory of how GPL will save us.
Debian should fork it and re-license it under the GPL.
What would be the point of doing that when they can just keep using GNU coreutils?
Well presumably there are at least some performance and safety benefits to using these new alternatives. Otherwise it's just a blatant license dodge.
In that case, nothing is stopping Debian from using uutils as it is; they can't really "re-license" it anyway since the original code will continue to be MIT-licensed.
The original CoreUtils have beenvetted through decades of use. They have been broken and fixed many times, and they have been hardened against so many edge cases, it's not funny anymore. That's where those 600 tests come from (mostly). Once they have brought the Rust tools to that level, how much performance advantage will there be left?
It's also a great learning opportunity to see how core tools like cat, ls, etc are written in rust. Relevant repo dir: https://github.com/uutils/coreutils/tree/main/src/uu