I ask this because I think of the recent switch of Ubuntu to the Rust recode of the GNU core utils, which use an MIT license. There are many Rust recodes of GPL software that re-license it as a pushover MIT or Apache licenses. I worry these relicensing efforts this will significantly harm the FOSS ecosystem. Is this reason to start worrying or is it not that bad?
IMO, if the FOSS world makes something public, with extensive liberties, then the only thing that should be asked in return is that people preserve these liberties, like the GPL successfully enforces. These pushover licenses preserve nothing.
I’m going to continue releasing my software with a license that I deem appropriate.
For things I’m building only for myself or that I have no interest in building a community around, I couldn’t give a shit what people do with it or if they contribute back. My efforts have nothing to do with them. I’m releasing it for the remote chance someone finds it useful, either commercially or personally. Partially because I’ve benefited from others doing the same thing.
I’m not anti-copyleft, but the only time I actually care to use something like the GPL is for projects that would be obviously beneficial to have community contributions. Things that require more effort than I can put in, or that needs diverse points of views.
I use permissive licenses not because I’m a pushover, but because I really don’t care what you do with it.
The switch to permissive licensing is terrible for end-user software freedom given that corporations like Apple and Sony have leeched off of FreeBSD in the past to make their proprietary locked-down OSes that took over the market. Not sure what would happen if RedoxOS became usable in production, but if it turns out to function better than Linux enough to motivate corporations to shift their focus to it, open source versions for servers would probably still exist, but hardware compatibility on end-user devices would be at higher risk than before as vendors switch their support and stop open sourcing stuff. Or they keep focusing on Linux for server stuff due to the GPL license and the fact that their infrastructure is already on it.
To quote Brian Lunduke, because the GPL is viral and functioning systems licensed under the GPL have been published, if a future Rust-based MIT version of Linux ever comes out, we can just “Fork it, then we’ll have our own Linux.”
To paraphrase Brian Lunduke: This software has gone woke! That software has gone woke! Boo woke software!
like the GPL successfully enforces
I’m not aware of the GPL being legally tested to where you can claim that; there are a lot of open questions, and it has failed to protect works from AI companies, for example.
I’m not aware of the GPL being legally tested
https://fsfe.org/activities/avm-gpl-violation/avm-gpl-violation.en.html
How does permissive licensing lead to corporate takeover? Companies can do proprietary forks of permissively licensed foss projects, but they can’t automatically take over the upstream.
Permissive licensing can create what is effectively “software tivoization” (the restriction or dirty interpretation of distribution and modification rights of software by the inclusion of differently-licensed components).
The Bitwarden case is a good example of how much damage can be done to a brand with merely the perception of restrictive licensing. obviously, bitwarden has clarified the mess, but not before it was being called ‘proprietary’ by the whole oss community.
So I don’t think op is referring to direct corporate takeover, but damage caused by corporate abuse of a fork.
That’s good point.
Another thing that is dangerous are CLAs or “contributor license agreements”, like Google uses. Technically, it is GPL, but Google might demand to hold all the copyright, so as the copyright holder it can change the license at a whim.
GPL is the only thing standing between us and Embrace-Extend-Extinguish.
There’s a reason that “Stallman was right” is a meme in the FOSS world.
Do you think IBM wouldn’t make Red Hat completely proprietary if they had the chance? They already tried to use their customer licensing to restrict source access!
It only takes one successful proprietary product to gain mind-share and market-share and become a new de-facto standard, and then all of the original FOSS has to play catch-up and stay compatible to stay relevant.
See Jabber/XMPP for an example.
Do you think IBM wouldn’t make Red Hat completely proprietary if they had the chance?
Adding to this, Google would make Android fully proprietary in a heartbeat if they could, given they’re already closing down more and more portions of the AOSP and trying to lock down app development and distribution as well.
And conceivably all it would take to turn Android fully proprietary ala Windows, is to hard-fork AOSP to keep the Lineage/Graphene/etc. users happy, and then rewrite main Android as closed-source.
Although, it’s kinda ironic that Windows, a fully closed environment, is less restrictive in terms of app dev and distribution, than Android, a supposedly semi-open environment, is. Like, MS isn’t mandating signed exes or trying to fully lock Windows into the MS Store, yet, while Google is trying to mandate signed APKs and also trying to lock Android into the Play Store.
And before anyone says, ‘But SmartScreen,’ unless that option is specifically disabled, you can just run unsigned exes by clicking ‘Run anyway’ still, Android doesn’t have a ‘Run anyway’ equivalent option AFAIK.
See Google Chrome too.
See Jabber/XMPP for an example.
There was a (short) time when I could chat with my friends on google hangouts (or whatever that was called back then) and facebook messaging via my own xmpp server. It was pretty cool and somehow felt like that’s the way things should be. Like email today (even if every big player is trying to destroy that too).
Maybe in some version of the future we’ll get that back.
https://matrix.org/category/dma/
There is work in progress to address this compelled by EU legislation.
You’re on the fediverse where that is a possibility.
It’s not really a same thing. I can’t reach my mother or neighbor over fediverse since they don’t know nor care what that is. But they use whatsapp, facebook and other stuff which are in their own walled gardens and there’s no option to communicate to those gardens with anything I self host.
And trying to convince everyone to switch is not a battle I’m actively fighting for multiple reasons. Of course I mention signal, fediverse and everything to anyone who’s willing to listen, but those encounters are pretty rare.
The problem you are describing in this comment is a social problem, not a technological one. In the previous comment I answered, a technological problem was described, and I offered a technological solution.
I am on the fedi, I do not proselytize to anybody that’s not on the fedi, nor do I interact outside of it. I am not fighting a battle, nor do I need to change people. There’s tons of people on the fedi that I can interact with. If people like where they are, they can continue to enjoy that, and I don’t have to bother them. I call my parents using the phone.
It’s kinda-sorta social problem, but originally not the way you intend. It used to be possible to self host XMPP and chat with people regardless of the platform since both Google and Facebook (it wasn’t Meta at the time) adopted the protocol. But then they changed their policy and created the walled gardens they have now and thus it’s a social and/or political problem.
They fully followed the playbook of Embrace-Extend-Extinguish which [email protected] mentioned few messages up the thread and pretty much devastated XMPP out of existence. Sure, there’s still handful of users and project itself isn’t dead, but before their policy change I saw quite a lot of servers around which are now either dead or forgotten.
On a previous comment I didn’t mean to describe that as a technological problem but a problem related to big corporations embracing FOSS projects/protocols and killing them by introducing their own walled garden variant of it.
I like non-copyleft licenses for one reason. Imagine if ffmpeg devs were like:
so many security vulnerabilities, your free labor is bad
thanks for pointing that out, it’s not longer free
Most devs (including me) want to have some control over what they made. Permissive licenses allow rugpulling project if someone is using it while making YOU do stuff. ffmpeg is a great example. You may not like it but that’s how it is.
A little bit.
A lot of the Rust remakes are being made by morons who have no problem using weak licenses that favor corporations.
We should hold them accountable and avoid using/contributing to their projects until they switch to a free license.
You’re taking an incredibly slanted position. There is a whole world of vibrant, viable, meaningful FOSS outside copyleft licenses. Even when one philosophically and politically prefers copyleft licenses, sometimes there are cases where the humanitarian or practical argument favours permissive licensing. But there are many who simply don’t share your interpretation of the philosophy and politics.
Coreutils has little commercial value to take can create a proprietary fork of. There is little value that can be added to it to make it worthwhile. The same is for sudo - which has had a permissive licence from the start. In all that time no one has cared enough to fork it for profit.
Not saying that is true of every project. But at the same time even GPL software has issues with large companies profiting off it and not contributing back. Since unless you are distributing binaries the GPL does not force you to do anything really. See mongodb and their move to even more restrictive licences.
The GPL is not the only thing that stops companies from taking open software. Nor does it fully protect against that.
Not does everything need to be GPL. It makes sense for some projects and less sense for others. Especially libraries as that basically forces no company from using them for anything. Which is also not what you want from a library.
Yeah, Ubuntu actually isn’t the first distro without GNU coreutils. Beyond Android and Busybox, there’s also stuff like Talos, which is something like … Kubernetes/Linux.
IME something like Kubernetes/Linux running “distroless” containers have a huge potential to displace traditional GNU/Linux in the server market, and I wouldn’t be surprised if someone manages to build a desktop out of it, either.
Compare Ubuntu and MacOS. MacOS ships ancient version of Bash because its GPL2 which allows for coexistence with proprietary software on sold machines.
So if Ubuntu gets rid of GNU coreutils and sudo what else stays GPL3 on a barebones system? You can swap Bash with Zsh like Apple did. And just like that you got yourself a corpo friendly distro to ship proprietary software. Just like Android, and look where that got us.
sudo is not GPL3. It is not even GPL2. It is an old license that is just as permissive as the MIT license. It has never had any big problems with that being the case. I don’t think that coreutils being GPL has really done anything to force companies to contribute back to it. It is mostly fixed in its function and does not really have much room for companies taking and modifying it to a point where others will favor the closed version over the open on. And what it provides is fairly trivial functions overall that if someone did want to take part of it then it is not terribly hard to rewrite it from scratch.
GNU Coreutils is not the only implementation of those POSIX features - just the most popular one. FreeBSD has its own, there is busybox, the rust ports and loads of other rewrites of the same functionality to various degrees. None of that really matters though as they dont really add much if any value to what coreutils provides as there is just not that much more value to add to these utilities now.
And it is not like the GPL license of coreutils affects other binaries on the system. So if you dont need to modify it and it does not infect other things there is little point in trying to take it over or use an alternative.
MacOS does not use a later version because they cannot. But also they don’t care enough to even try to maintain their own.
GPL is important on other larger/more complex bits of software. But on coreutils/sudo IMO it does not matter nearly as much as people think it does.
Okay then; what licence can we use to force any entity using a library to make their project open-source?
EDIT: clarification
what licence can we use to force any entity using a library to make their project open-source
GPL requires this, since linking with a library is considered a derivative work even if the library is dynamically loaded.
This is why the LGPL exists, which makes the library copyleft but does not extend the derivative work classification to programs linking with the library.
The FSF says this is the case but the actual legal situation is less clear, especially in the EU. Linking does not necessarily constitute a derivative work. Even decompilation of a (proprietary) library in order to link to it might be acceptable depending on the circumstance.
This isn’t something that can be fixed with a license, it’s a direct result of EU copyright law. Historically companies have tended to err on the side of the FSF interpretation, but it is on somewhat shaky grounds.
That’s the orthodoxy but noone ever bothers to actually back it up. If I write an encyclopedia and refer extensively to external sources it’s not a derivative work, and that seems to be the closest obvious example.
None. The closest you can get is the AGPLv3.
If you go further, it will no longer be open source. This is the case for the Server Side Public License (SSPL) for example. It requires the entire system configuration to be released under the same license*. This sounds “open source friendly” but it’s actually just a proprietary license because it’s not realistically possible to legally comply with it. You cannot run standard hardware without proprietary firmware, which means you cannot run SSPLed software on it legally.
*This only applies if you host the software as a service but the result is the same. It basically violates the freedom to use the work for any purpose.
I don’t think there is a good license for that. The ones MongoDB used turned the open source community against them. But that is not really my point. I just mean that some projects using MIT won’t suddenly mean every company will start stealing and closing that software. Some things like coreutils and sudo just don’t have the commercial value to make that worth the effort. So there is no real need to worry about these two projects IMO. Other projects are a different story altogether though. Each project needs to make its own decision on what licence best suits it. The GPL is not the one and only license that is worth using.
I would say AGPL is the “safest” license still approved by the OSI. Could you share your opinion?
There is no one size fits all safest option. Details matter and each project needs to read the licenses and decide on which suits their needs best.
MIT is probably the safest option for a company creating a library wrapping their service where there is no real value in others taking that code. Or for simpler libraries that are fairly easy to reproduce so the need to steal the code is low. Or you just don’t care what others do with the code.
GPL is probably safest for some hobbies that does not care about companies and just wants everyone that is using their project to not bake it into a product they distribute. But also means companies likely wont want to use your project if it is a library.
LGPL might be a good option for library code if you want other companies to use and contribute back to some complex library you are using that is hard to reproduce in isolation.
Other licenses are needed if you want to prevent other hosted services from using your project without contributing back.
Different licenses exist for different reasons and it all depends on what you want for your project.
Yes.
Anyone who cares about user freedoms is not choosing a permissive licence.
The problem is developers only caring about themselves and other developers.
When I talk to devs I know who like FOSS, they are always focussed on their needs as a dev when it comes to licences. The real concern was, and always should be, for the software user’s freedoms.
God forbid developers earning something for their work
Developers should absolutely get paid for their work, but as @[email protected] said, that is is a different issue. There are plenty of companies that employ developers of FOSS code, both copyleft and permissive licence.
uutils developers aren’t earning any more than coreutils developers. This is an orthogonal discussion.
GOOD GOD, the number of people getting downvoted in this thread that know WTF they are talking about IS INSANE.
This question is a bad question by somebody who is new to this ecosystem, and clearly doesn’t understand how the community, development, or code works.
The people in here who are pointing this out are being brigaded by other commentors who have zero idea about how any of the licensing or code management works as well.
You can’t have a corporate “takeover” of something which is code-complete, and already out in the world. There is a fundamental misunderstanding over what licensing protections are designed to do as well.
Y’all need Jesus /s
Code complete is arguably a myth when talking about security. You need to update when vulnerabilities are found at minimum. Sometimes, the changing software environment changes and so the software has to start adding features again or get replaced. Rarely old features are the vulnerability, and have to be removed.
What does security have to do with open-source projects succumbing to “corporate takeover”, which isn’t even possible?
If the code is of such a restrictive license that you aren’t able to fork and re-release it with changes, then it isn’t open-source to begin with.
To your last point about removing “old features”, this is done all the time, and this is why things use semantic versioning. Nobody wants to be forced to maintain old code into perpetuity when they can just drop large portions of it, and then just release new versions with deprecated backends when needed
Sorry, I didn’t explain what I was talking about.
The problem is that in the modern software environment there’s a constant need for updating and patching, and if a proprietary fork provides those updates and a free original can’t keep up for whatever reason, the proprietary fork (that could have contributed otherwise) gains inertia until the free original dies. This is admittedly harder to pull off in a mature and well maintained free software ecosystem, but I think you’d be surprised how many important free software projects lack needed manpower. It doesn’t help that MIT practically encourages people not to publish code, compared to GPL.
People make out forking like it’s a big protection against proprietisation, and it is, but it’s not foolproof. Good forks are usually founded by community members that already understand and contribute to the code, most forks actually die quickly. The fewer contributors relative to the project’s size and complexity, the more realistic it is to either be overtaken by a more competitive proprietary fork, or for the maintainers to sell out and relicense without anybody to fork it.
Realistically, I don’t know how likely this would happen to anything decently important, but it has happened at least a few times. I remember using Paint .NET while it was still MIT licensed years back, but nobody forked it. Since we’re on Lemmy, Reddit used to use a Free software license.
There’s a few different things getting wrapped in here together, so let me break down my take:
-
Licensing - if you intend to only use FOSS software, it wouldn’t matter if a corporate/proprietary version of something exists or not. If you intend to release something and make it free, you would need to include only license-compatible libraries. I don’t see why Microsoft having a proprietary version of something that is better would be a problem, because that’s not the focus of your goal of releasing something for free. Similarly if you start a company and bootstrap a product off of open libraries, you will steer towards projects that are license-compatible. Whether there is a better version is irrelevant.
-
Scope of license - Your comments seem to focus on larger product-complete projects. You mentioned Paint.net as an example. So say Adobe forks GIMP, and drops a bunch of proprietary Photoshop libraries into it to make it beefier or whatever. Similar to the above, people who intend to only use FOSS software still wouldn’t adopt it.
-
Death by license - there have been some cases where FOSS project maintainers get picked up by corporate sponsors and sort of “acquired”. This is on the maintainers to make that choice of course, not the community, and contributing members of that community have every right to be pissed about that. Those contributing members also have the right to immediately fork that project, and release their own as a competitive product. Redis vs Valkey, and Terraform vs OpenTofu, are examples. Some people flock away, some people don’t, but in most cases ts a guaranteed way to turn the community against you, and towards a fork of said project. Happens a lot.
I think what you’re not seeing here is that these companies buying out projects really don’t intend to put a lot of money back into them after they get their bags of money. Whether or not people continue to use the originals is less important than the forks being available and supported. If companies believe in the project, they kick in PRs to keep things rolling along because they need that particular part of their stack. I myself am a maintainer in multiple public projects, and also work with companies that contributed to dozens of different public projects because the products they make revolve around them: everything from ffmpeg, to the torch ecosystem. You find a bug you can fix, you submit a PR. That’s what keeps this ecosystem going.
Smaller scale startups to mid-sized companies contribute all the time to public projects, though it may not be apparent. Larger corporations do as well, but it’s more of legal thing than an obligation to the community. Rewriting entire batches of libraries isn’t feasible for these larger companies unless there is a monetary reward on the backend, because paying dev teams millions of dollars to rewrite something like, I don’t know, memcache doesn’t make sense unless they can sell it, and keeping an internal fork of an open project downstream is a huge mess that no engineer wants to be saddled with.
Once a public project or library is adopted, it’s very unlikely to be taken over by corporate interests, and it’s been that way for almost fifty years now (if we’re going back to Bell and Xerox Labs). Don’t see that changing anytime soon based on the above, and being in the space and seeing it all work in action. Though there are scant cases, there’s no trend of this becoming more prevalent at the moment. The biggest threat I see to this model is the dumbing down of engineers by “AI” and loss of will and independent thought to keep producing new and novel code out in the world.
I suppose you’re right that copyleft is not the primary motivator for contributions.
I’m aware that forks happen often when a takeover is attempted. There are many big success stories in FOSS. However, my point was that most FOSS software isn’t that successful. There are plenty of projects out there with very few contributors, and it is those I’m saying are easy for taking over. Perhaps they get taken over because most of the community doesn’t care, but it still happens from time to time. I originally commented because you seemed to make out that proprietisation was impossible.
I get your point that it’s incredibly unlikely for anything that matters however.
Edit: I think I misremembered an example I gave of a successful fork after an attempted takeover, but it was something Oracle.
Just based on experience in the community and professional experience, I can solidly say that your take on FOSS not being successful is just wrong, and I don’t mean that like you’re stupid or I’m shooting you down, you just wouldn’t realize how huge contributions are unless you know where to look.
Here’s a big example: look how many companies hire for engineers writing Python, Ruby, Rust, Go, Node…whatever. ALL OPEN SOURCE LANGUAGES. You bootstrap a project in any of these, and you’re already looped into the FOSS community. 100% of the companies I have personally worked with and for write everything based on FOSS software, and I can tell you hands down as a fact: never met a single person writing in any closed source IDEs or languages, because very few exist.
If you want to see where all the community stuff happens, find any project on GitHub and look at the “Issues” section for closed tickets with PRs attached. You’ll see just how many people write quick little fixes to nags or bugs, not just on their own behalf, but on behalf of the companies paying them. That’s sort of the beauty of the FOSS community in general in that if you want to build on community projects, you’ll be giving back in one form another simply because, as my last comment said, NOBODY wants to maintain a private fork. Submodules exist for a reason, and even then people don’t want to mess with that, they’d rather just commit fixes and give back. Companies are paying engineers for their time, and engineers committing PR fixes is defacto those companies putting back into the community.
To your Oracle point, I think the biggest thing there you may have been Java. That one is tricky. Java existed long before it was ever open sources by Sun Microsystems, and was available for everyone sometime in the early '00s (not bothering to look that up). Even though it was created by an engineer at Sun, it was always out there and available for use, it just wasn’t “officially” licensed as Open Source for contributions until some time. Sun still technically owned the trademarks and all of that though, and Oracle acquired them at some point, bringing the trademarks under their ownership. There wete a number of immediate forks, but I think the OpenJDK crew was further out in front and sort of won that battle. To this day I don’t know a single Java project using Oracle’s official SDK and tools for that language aside from Oracle devs, which is a pretty small community in comparison, but you’re right in that was essentially a corporate takeover of a FOSS project. How successful it was in bringing people to bear that engagement I think is up for discussion, but I’m sure the community would rightly say “Fuck, Oracle” and not engage with their tooling.
-
I suppose it’s true that neither would have been called feature complete by its authors, proprietisation is much more likely when there is still a lot missing. But I would still caution against thinking that having all the features you need means you’re immune to it.
You’re the only user catching downvotes
Check the rest of the thread 🤣
People in here don’t work in the space, and are clearly not knowledgeable about the subject. They can downvote me all they want.
I did, twice
Also on that topic, very interesting read:
Interesting, but ultimately a roundabout justification for why the author chose a non-FOSS license for their startup Slack-clone built on ATProto.
They talk about “pro-labor licensing” but what they mean is pro- their -labor, not pro- anyone else’s -labor.
GPL is already the most pro-labor licensing since it respects the work of anyone who contributes in equal measure, and does not hold the “original” founding author in higher regard.
It’s really quite something to rail so unequivocally against the “fascistic mega-corps” and “autocratic corpostates” in your licensing justification blog post and then build your commercial product on top of Bluesky .
Why are they pushover licenses? Because they don’t force people to contribute back? Because a lot of companies aren’t doing that for GPL licensed software either.
Also not really sure how this would allow a takeover, because control of the project is not related to the license.
It’s not so much about forcing to contribute, but rather keeping companies from selling commercial forks/having checks against profiting from work that happens to be freely available.
You can profit from GPL software. The only restriction is if you distribute it you also need to distribute modifications under the GPL.
GPL also does nothing for software as a service since it is never distributed.
GPL even explicitly allows selling GPL software. This is effectively what redhat do. They just need to distribute the source to those that they sell it to.
Prograns like that are usually distributed under AGPL which protects server side software
And RHEL bit-for-bit compatible gratis alternatives exist, which is because of the GPL
The GPL doesn’t place any restrictions on selling or profiting from GPL licensed works. It only requires that anyone distributing the work provides the recipients with the same rights under the GPL, ie. the right to view, modify and redistribute the source code.
This means that a company cannot take a GPL licensed work and turn it into a proprietary product.
The GPL doesn’t force to contribute. But if you make changes to it, you need to have these changes reflect the liberties you yourself received. Megacorporations use the so-called “Explore, Expand, Exterminate” model, the GPL stops this from happening.
I’ve heard it mostly as Embrace, Extend, Extinguish
You can just wrap the software in a binary and interact with the binary and you will likely elude the GPL terms. This is kinda grey area but it would be hard to win against it in court. (I am not a lawyer)
I mean that broadly because nobody will make proprietary Coreutils or sudo as someone already pointed out.
You should look into the origins of OS X and CellOS.
Your pathetic rhetoric actively contributes to making people richer than you even richer.
Stop selling yourself out just because it’s easy.
Funny you say that because OS X shipped (and probably still ships) plenty of copyleft licensed software such as Bash. The Linux kernel is used in Android and ChromeOS.
If you want to stop corporations from profiting off your work, putting a GPL on it isn’t gonna do it. In fact no free software license will do it, because by definition they allow anyone to use and ship your software.
Tell me you don’t understand how GPL works without telling me how GPL works.
GPL has been battle tested in court and has the most precedence than any other license. Hell I’d even include proprietary licenses.
Core Android and ChromeOS are FOSS because they have to be. But because Linus Torvalds didn’t want to move Linux to GPL3, we have proprietary bootloaders with free software.
THAT’S how we have corporations profiting from GPL. Not because GPL allows anyone to use it.
Core Android and ChromOS don’t need to be FOSS because they use the GPL. You can use the Linux kernel without having to make everything that runs on it GPL as well. Things that run on the kernel are not derivative works of the kernel. These projects are FOSS because google at the time thought it would give them an advantage to make the FOSS.
If you add too many restrictions to a license it does not force companies to give their stuff away for free, it just means they wont use your project which can drastically stunt the growth of your project. If Linux had a more restrictive license to start with all that would of happened is no one would have heard of it today as companies would have created something else that they can use.
GPL has been battle tested in court
Well… parts of it have been. Others have not. Notably the FSFs view on whether or not linking to a GPL-licensed library constitutes a derivative work (and triggers the GPLs virality) is not universally shared by legal scholars. In the EU in particular linking does not necessarily create derivative works, despite what the FSF says. This has not been tested in court.
Some other parts like the v3 anti-tivoization hasn’t gone to court either, but that has lesser ramifications (assuming you’re not TiVo).
THAT’S how we have corporations profiting from GPL. Not because GPL allows anyone to use it.
What distinction are you trying to draw here exactly? They can do it precisely because the GPL (v2) allows it. The GPLv3 has some extra restrictions but doesn’t do anything about closed source drivers (beyond the linking thing) or the Google Play Services type of proprietary extensions.
You don’t understand.
It’s not a problem if corporations profit off of it. It’s a problem when they extend a program without giving the public access to those changes.
Sure it’s a problem when that happens. It’s not the only problem, and honestly in the case of coreutils it’s not really the most relevant one.
Do you think it’s likely that corporations will take over UNIX-likes with proprietary coreutils extensions forked from uutils? Because that’s the one thing that is legal to do with an MIT/BSD licensed coreutils but not with GPL licensed ones.
