I would understand if Canonical want a new cow to milk, but why are developers even agreeing to this? Are they out of their minds?? Do they actually want companies to steal their code? Or is this some reverse-uno move I don’t see yet? I cannot fathom any FOSS project not using the AGPL anymore. It’s like they’re painting their faces with “here, take my stuff and don’t contribute anything back, that’s totally fine”
Here’s a fun idea, let’s fork these MIT-based projects and licence them under the AGPL :-)
You could do that. MIT is a very free license.
Of course, that would only be a useful thing to do if you were also going to contribute to the code.
True, but the mere existence of an AGPL project that follows the MIT one might be enough to convince would-be contributors to choose our version instead.
It may also be more likely to be adopted by non-corporate Linux distros that favour the AGPL over MIT (Debian for example) which in turn could help make the AGPL version the dominant one.
Note that AGPL can take changes from MIT but MIT can’t take changes that are purely AGPL without following the AGPL.
So, as far as I can understand, any improvements done to the AGPL version cannot be carried over to the MIT version (without very painful and careful re-implementation / re-engineering). That alone would be a big advantage to the hypothetical AGPL fork.
It would be a bit of a legal nightmare, since it’s theoretically possible that, even without really knowing it, the same feature might be implemented the same way in both forks separately, and the MIT devs might have no sure way to prove they did not copy it. So this would be like walking on eggshells for them.
Thats the point of GPl licenses. You cant close source it.
MIT is a free and also heavy closed source friendly. GPL fixes the greed
Yes. Did I deny that?
Can anyone confirm or deny if what I said is wrong?
I get downvoted for stating one advantage an AGPL fork would have, and yet nobody seems to be disagreeing with what I said… *shrugs* 🤷
A glitch in the matrix.
Ok idk. Your message felt like it wants to explain why we shouldnt use GPL/lgpl
If I could code at the level that these people do, I definitely would. If I ever publish anything that I’ve written for myself it will never be MIT/BSD licensed
If you’re developing software for a platform that doesn’t allow users to replace dynamic libraries (game consoles, iOS, many embedded/commercial systems), you won’t be able to legally use any GPL or AGPL libraries.
While I strongly agree with the motives behind copyleft licenses, I personally never use them because I’ve had many occasions where I was unable to use any available library for a specific task because they all had incompatible licenses.
I release code for the sole purpose of allowing others to use it. I don’t want to impose any restrictions on my fellow developers, because I understand the struggle it can bring.
Even for desktop programs, I prefer MIT or BSD because it allows others to take snippets of code without needing to re-license anything.
Yes I understand that means anyone can make a closed-source fork, but that doesn’t bother me.
If I wanted to sell it I might care, but I would have used a different license for a commercial project anyway.If the only problem is that you can’t use dynamic linking (or otherwise make relinking possible), you still can legally use LGPL libraries. As long as you license the project using that library as GPL or LGPL as well.
However, those platforms tend to be a problem for GPL in other ways. GPL has long been known to conflict with Apple’s App Store and similar services, for example, because the GPL forbids imposing extra limits that restrict user freedom and those stores have a terms of service that does exactly that.
I guess I forgot to mention that those platforms usually require you to sign NDA’s that prevent you from releasing any code that references their SDK.
This makes it impossible to license your entire project as GPL/AGPL, as you would be breaking the NDA.
Sorry, I’m not much of a software dev so bear with me:
If the libraries are GPL licensed, is there a problem? Unless you’re editing the libraries themselves.
Now if the application is GPL licensed and you’re adding functionality to use other libraries, please push upstream. It helps the community and the author will more likely than not be happy to receive it
Any linking against GPL software requires you to also release your source code under GPL.
ALGPL allows you to link to it dynamically without relicensing, but as explained, there are platforms where dynamic linking isn’t an option, which means these libraries can’t be used if one doesn’t want to provideALGPL licensed source code of their own product.You mean LGPL when you say AGPL, right?
Yes, sorry
Using a GPL library will require you to re-license your entire project as GPL, regardless of whether you made a change or not.
LGPL is a bit better, because it allows you to dynamically link the library. But you’re required to provide a copy of source for the library, and any users must be able to swap the built library with their own copy.
Eg; you can use an AGPL-licensed .dll in your closed-source windows program, because users can swap that .dll easily.
You can’t do the same for a ps5 game because users aren’t able to replace any files that the game uses.
I assume this is in reference to the rust coreutils being MIT-licensed. How would using GPL benefit them?
Improvements would be upstreamed. Not with MIT
GPL would not require that. It would only require publication of the source. There is no requirement to give back or even make your changes compatible with upstream.
Yes, publication of the source is enough. However, you are correct and I should have worded it better. In practice, publishing the source allows the developers of the software to make improvements unhindered by licensing and other IP-based hindrances which are otherwise present in closed-source software
True.
Though, you are probably going to have a much easier time implementing a change to your code that is present in a company’s published code, than you would trying to reverse-engineer a binary.
Sharing of the code I would consider “giving back” in it of itself.
I worked on an oss library with an MIT license and my colleagues told me they with that instead of GPL was with GPL it basically forces anyone who uses the library to make everything in their project available.
Only if they make changes/improvements to the code. If it’s a library that is used then no, AFAIK you don’t need to. If everyone using GPL code had to make their entire project FOSS then TPLink and DLink wouldn’t have any market share. The only reason OpenWRT exists is because Linksys was forced to open up their code because they had illegally refrained from opensourcing their code, which was a great positive for the community
If you are using a GPL library that is statically linked to code with a different license the result is one binary that has inside both GPL and other license code, which would not be allowed under the GPL terms, because it requires that the binaries that use the source code must have their source code available in full (including other source and modifications that are part of the same binary).
The only case in which you don’t need to provide the source for GPL software is if you don’t actually distribute the binary to customers… private binaries do not have to be published with their source, as long as you never made the binaries public and never gave it to anyone else. Only when you give it to someone you need to provide the code.
This allows for a loophole in which if you are providing a service, then you can run the software privately in your private server without sharing the source code to the clients using the service, since they do not really run the server program although they indirectly benefit from its results. This is why the AGPL was created, since it has a clause to force also those offering services to make the source of the server available to the users of the service.
I don’t mind if people use LGPL or some derivative of GPL. All I want is improvements to the source be published, and MIT simply doesn’t enforce that. I have no intention to force companies to publish their code that they have worked on for a long time - doing that never really helps. But I do want them to publish changes they make to already FOSS products so the author and the community can benefit.
Yes, but the loophole I was mentioning allows companies to not release the code even when it’s GPL, that’s why I was mentioning the AGPL (which is different from the LGPL).
I think it’s more complicated than use, like something about being allowed to dynamically link to it but not statically, or something like that.
If you link to GPL library, your software has to be GPL. You are confusing it with LGPL. Though you can bypass this by making the library its own standalone app. Like let’s say FFmpeg which is just a frontend for libAV libraries. (ignore that these libraries are actually LGPL, so you can link to them.)
it’s been a trend for a while unfortunately. getting rid of the gpl is the motivation behind e.g. companies sponsoring clang/llvm so hard right now. there are also the developers that think permissive licenses are “freer” bc freedom is doing whatever you want /s. they’re ideologically motivated to ditch the gpl so they’ll support the change even if there’s no benefit for them, financial or otherwise.
Some people might say that so many companies contributing free and open code to clang/llvm instead of GCC is real world evidence against the idea that companies only contribute to free software because the GPL makes them. Or even that permissive licenses can lead to greater corporate sharing than the GPL does. Why does Apple openly contribute to LLVM but refuse to ship GPL3 anything?
According to the web, Red Hat is the most evil company in Open Source. They are also the biggest contributor to Xorg and Wayland. Those are MIT licensed. Why don’t they just keep all their code to themselves? The license would allow it after all. Why did they license systemd as GPL? They did not have to.
The memory allocator used in my distro was written by Microsoft. I have not paid them a dime and I enjoy “the 4 freedoms” with the code they gave me because it is completely free software. Guess what license it uses?
you (and everyone else who thinks the gpl is just about contributing back) are missing the point. the main goal of the gpl licenses (including the lgpl) is user freedom. they ensure that you can modify any piece of gpl software anywhere it’s used. if you use a propietary system that includes gpl/lgpl software, you should be able to modify the gpl parts to do whatever you want. say for some reason you’re using a system that includes ai slop in its shell, but the shell is a gpl application. you could just grab a fork of the shell stripped of ai functionality and replace the system’s shell with it
that’s impossible with permissive licenses. with permissive licenses, you could be using a system with 80% open source software and be completely unaware of it, unable to change it as you see fit. from the pov of the user, “permissive” licenses are restrictive; copyleft licenses are freer bc its restrictions are there to forbid the developer from locking down free software for the users
of course companies are going to prefer permissive licenses. they want to take advantage of using free labor enable by open source while keeping the freedom to lock down said open source software in their systems. so, when given the option, they will always prefer to contribute back to software with permissive licenses
and that’s the whole problem here: you giving them the option by creating a copyfree alternative to an important piece of copyleft software. do you think companies would ever comtribute to linux if any bsd was a viable alternative to linux? but the kernel community at large decided to stick to the gpl, so the companies have no choice
it’s true that copyfree software isn’t any less free than copyleft software, and i’m not even completely against using permissive licenses. my issue is creating an mit alternative to gpl software
They are maliciously harming the community. They need to be named and shamed. I still seethe at OpenBSD using it. Why is it so hard for them to understand? Why do they want to give away their work for the taking to corporations who just want to make money off of their backs?
they have a different view on what freedom means
Then it’s not one that is actively helping the FOSS community
How is actually writing and contributing free software not “actively helping the FOSS community”?
Not using GPL or derivatives doesn’t force companies to publish changes (which are usually improvements) which harms the community
getting rid of the gpl is the motivation behind e.g. companies sponsoring clang/llvm so hard right now
And there it is. Follow the money.
sure, but it didn’t get much attention until gcc switched to gpl v3 from gpl v2 and apple decided to jump ship to it
my point is that competitors to gpl software are always advertised through their technical merits (valid or not), but the point behind their development is getting rid of gpl-licensed software
Speaking for myself, it’s because future monetization can be easier under mit when using a foss utility and private code.
My project would not exist at all unless there were ways to make money off it.
True, others can also use that same code too, in the exact same way, but that requires quite the investment, and those of us that are doing this are banking on not getting the interest of a monopoly in that way. We are competing against other small businesses who have limited resources.
At the same time the free part can get a boost by the community.
I comment a lot in politics here, and am sometimes an ass, so cannot name this project
not sure how it would be more difficult to make money using gpl tools
For our use case, this makes the most sense.
I’m not at all sure about the larger trend you noticed, but I know a non trivial number are doing it for the same reasons
Could you elaborate on those reasons, please? I’m not sure what you mean.
The mit license allows a mix of public and commercial code run by the same company, with minimal legal issues. One can use other tactics I am sure, but this one seems good when the commercial code absolutely needs the public code .
I think some confusion here can be resolved by stating this is anti foss, taking advantage of foss, it is capitalism taking advantage of having a good code base while making sure any contribution from outside the company is minimized. At the same time it gives my company absolute control over the private part.
Usually get into arguments here! I’m not defending it, but am saying open source would be less without.
I understand this may not be exactly how you meant your comment, but I think it’s important to clarify that free/libre software can also be commercial software, and in fact must allow commercial use in order to fit the Free Software Definition. It is probably easier to make lots of money with non-freely licensed software but I think contrasting “public” code with “commercial” code muddies the terminological waters a bit.
MIT/GPL is fine for smaller tools.
Yeah, specifically for something like coreutils I can’t see the malicious endgame that is suggested by others here. Is the fear that a proprietary version of
catorpwdorprintftakes over the ecosystem and then traps users into a nonfree agreement? Or a proprietary coreutils superset that offers some new tool and does the same thing? Or a proprietary coreutils that generates profit for businesses without attribution to the developers? What would stop anyone from just writing their own proprietary set of tools to do the same thing now, even if uutils didn’t exist? Clearly not much, since uutils did exactly that (minus the proprietary bit).I personally don’t see a compelling reason to change to MIT, but I also don’t see the problem.
What’s stopping people from doing that today is network effects. There are enough differences today between bsd coreutils and gnu coreutils that substituting one for the other doesn’t work out of the box.
The chain of events that would cause a problem are: due to Ubuntu popularity rust MIT core utils overtakes gnu coreutils and people drop support for gnu coreutils, then a large and we’ll funded corporate entity could privately fork rust coreutils and lock people in.
To me, the problem is not really so much about “locking people in” (it’s also unclear what you mean by that, if they were already using that ecosystem before using uutils aren’t they already locked in?)
To me, the problem is how the MIT removes legal protections when it comes to ensuring accountability to changes in the source… how can I be sure that the version of uutils shipped with “X Corp OS” has not had some special sauce added-in for increased tracking, AI magic, backdoor or “security” reasons? They are perfectly free to make changes without any public audit or having to tell their users what their own machine is doing anymore.
For small programs the FSF/GNU even suggests considering not using the GPL https://www.gnu.org/licenses/license-recommendations.html
Yes, and a cp or ls clone isn’t that meaningful to stick GPL to.
Its simple: its to exploit it in a corporate setting. I license under MIT because a lot of my things are of small convenience, but never without debating the ethics of why I am licensing it.
GNU is the enemy to capitalism and if you need more proof, look at what Apple has done with LLVM/Clang and CUPS. We need GNU more than ever.
The author explicitly states that this is not the reason.
https://github.com/uutils/coreutils/discussions/4358#discussioncomment-8027681
I understand that if your boss tells you to write MIT/Proprietary code, you do so. I just wish that the ones who had a choice would use GPL
Does anyone use MPL anymore? Is it a decent middle ground or the worst of both worlds?
For what use case?
For me, my personal projects are generally MIT licensed. I generally don’t like “restrictions” on licenses, even if those “restrictions” are requiring others to provide their source and I want as many people to use my projects as possible, I don’t like to restrict who uses it, even if it’s just small/home businesses who don’t want to publish the updated source code. Although, I admit, I’m not a huge fan of large corporations potentially using my code to generate a profit and do evil things with it, but I also think that’s not going to be very common versus the amount of use others could get from it by having it using MIT who might not be able to use it otherwise with AGPL.
With that said, though, I have been starting to come around more to AGPL these days.
I wohld agree, because you really downplay the scenario.
As soon as you accidentallt create something, which everyone starts to use or has an use case, then some Cooperation will copy that thing, make it better and make your community dissappear because there is the newer tool which you cant change the code of anymore and need to use a monthly subscription or something to even use.
So, it somehow seems like you’re gaslighting yourself by downplaying the use case.
Mostly it will be small buisnesses and hobbyists, which I would like to code for them too. Especially when they are nice and friendly. But as soon as Microsoft, Google, Meta, Amazon gets hands on it and sees a potential to squeeze money through it by destroying it, then they will surely do it.
This can happen.
The flip side is noone uses it. I’ve never worked at any company that allowed even lgpl code to be used. If it has a commercial license we’ll buy it, if not…find another tool.
Lawyers are terrified of gpl and will do anything to avoid going to court over it, including forcing you to rip code out and do a clean room rewrite.
In my Company, we do use such code. But its mainly because we distribute our own Propriatary Linux OS.
We sometimes need to change such code, so we just put it on Github as a fork.
I edited my comment to better and more fully reflect my thoughts. It’s hard to properly express myself when I’ve been as sick as I have been with bronchitis and possible pneumonia for the past 4 weeks.
Hopefully my comment now better reflects my thoughts.
I still feel like, the point where you say more people can use it and will use it, can create a dark pattern.
Imagine you create something and make people depending on it. Another cooperation copies it and advances it with a lot of money. Somehow, the ecosystem is so changed, that when you depend on that project, you need to use the newer version of the cooperation and soon they will paywall it heavily.
Then, your wish for people using the code as much as possible got nuked.
I assume that many scenarios will allow the usage of your old MIT project without relying on the new version of someone. But rare cases exist, where this happens. Its like predicting the 30th step in chess or smth. (Idk chess that well)
Its… unlikely that it will happen, but yeah. I can understand your perspective, but slowly going to AGPL sounds right.
Had bronchitis as a child nearly every few weeks for years. All gone but sucks to have it.
Get well soon.
Or on the flip side, they want usage to be pervasive so they win. I mean come on man it’s like “move this file” and “make this directory” these applications aren’t rocket science and providing them under a license that people will use outside of the hardcore Linux space is just good marketing.
Honestly it’s probably just because so many devs are involved more in their code and don’t want to worry about the nuances and headaches involved in licensing. MIT is still open source.
I guess I can’t really fault that. Developers not interested in the license they use to publish code baffles me
Canonical still licenses most of their stuff under GPL3, including new stuff. The license (other than it being open) was probably not even a consideration in deciding to experiment with uutils.
fyi: GNU coreutils are licensed GPL, not AGPL.
there is so much other confusion in this thread, i can’t even 🤦
My rule-of-thumb is: is the licence going to make things better for users? In other words, I try to predict whether a company would just not use my AGPL-licensed code, or would potentially contribute back. If they wouldn’t, I don’t really care and rather my code at least gets used to build something presumably useful.
The point is that even if companies have the personnel to contribute back, most of them don’t. It simply isn’t in their interest. If a project is good enough, AGPL will mean that no monopoly will form around that project and open standards will be maintained. AGPL is simply a bastion against closed-source software working against the best interests of consumers
Yeah I get that point, and so my point is that if the use case is important enough that they’d be able to justify allocating that personnel, I use the AGPL to give them that nudge. When it’s just some non-critical component, then I’ll just slap an MIT on it and be done with it.
The only problem is companies will always try to use MIT and using it for small projects will set a precedent. And we don’t have a governing body strong enough to enforce the GPL (nobody listens to the FSF)
Ha, well, if my single-digit-downloads (all by me) NPM module is influential enough to set precedent, then I’d consider that a success.
