What's with the move to MIT over AGPL for utilities?

fyi: GNU coreutils are licensed GPL, not AGPL.
there is so much other confusion in this thread, i can't even 🤦

The unfortunate reality is that a significant proportion of software engineers (and other IT folks) are either laissez-faire "libertarians" who are ideologically opposed to the restrictions in the GPL, or "apolitical" tech-bros who are mostly just interested in their six figure paychecks and fancy toys.
To these folks, the MIT/BSD licenses have fewer restrictions, and are therefore more free, and are therefore more better.
- it's interesting how the move away from the gpl is never explicitly justified as a license issue: instead, people always have some plausible technical motivation. with clang/llvm it was the lower compile times and better error messages; with these coreutils it's "rust therefore safer". the license change was never even addressed
  i believe they have to do this exactly bc permissive licenses appeal to libertarian/apolitical types who see themselves as purely rational and changing a piece of software bc of the license would sound too... ideological...
  so the people in charge of these changes always have a plausible technical explanation at hand to mask away the political aspect of the change
  
  The rust coreutils project choosing the MIT license is just another gambit to allow something like android or chromeos happen to gnu+linux, where all of the userland gets replaced by proprietary junk.
  And yet that's a popularly welcomed approach, for some reason. Just look at the number of thumbs down this has. https://github.com/uutils/coreutils/issues/1781
  
  I use LLVM because it's good, but I would like it even more if it was GPL and I agree with OP's comment as well.
  However, you're literally the guy that replies "oh, so you hate oranges" to people that say "I like apples" or however that meme goes. How about you don't completely twist people's justifications into something they never said.
  edit: It comes down to that I have no say in whether other people want to allow their code to be exploited by corporations nor does it make a practical difference to me in what I can do with it, all I can do is say "you're an idiot" to them.
- Add to this, the constant badmouthing of GNU and FSF from the crony bootlickers and sadly this is what we get
  The tech crowd is also more of a consumer kind these days than the hacky kind, so it's much easier to push corporate shite with a little bit of polish on top
- Yeah, that's all there's to it, along with pure ignorance. In a past not so ideologically developed life, I've written code under Apache 2 because it was "more free." Understanding licenses, their implications, the ideologies behind them and their socioeconomic effects isn't trivial. People certainly aren't born educated in those, and often they reach for the code editor before that.
- Freedom for the rich and powerful to fuck over society and everyone else!
- "apolitical" tech-bros who are mostly just interested in their six figure paychecks and fancy toys.
  This, I understand.
  laissez-faire "libertarians" who are ideologically opposed to the restrictions in the GPL
  This, I do not. Apologies for my tone in the next paragraph but I'm really pissed off (not directed at you):
  WHAT RESTRICTIONS???? IF YOU LOT HAD EVEN A SHRED OF SYMPATHY FOR THE COMMUNITY YOU WOULD HAVE BOYCOTTED THE MIT AND APACHE LICENSE BY NOW. THIS IS EQUIVALENT TO HANDING CORPORATIONS YOUR WORK AND BEGGING THEM TO SCREW OVER YOUR WORK AND THE FOSS COMMUNITY.
  I feel a bit better but not by much. This makes me vomit.
  
  Since you seem so reasonable…
  The restriction that some people object to is that the GPL restricts the freedom of the software developers (the people actually writing and contributing the code).
  Most people would agree at first glance that developers should be able to license code that they write under whatever license they like. MIT is one option. Some prefer the GPL. Most see the right to choose a proprietary license for your own work as ok but some people describe this as unethical. I personally see all three as valid. I certainly think the GPL should be one of the options.
  That said, if we are talking about code that already exists, the GPL restricts freedom without adding any that MIT does not also provide.
  MIT licensed software is “free software” by definition. Once something has been MIT licensed, it is Open Source and cannot be taken away.
  The MIT license provides all of the Free Software Foundations “4 freedoms”. It also provides freedoms that the GPL does not.
  What the MIT license does not provide is guaranteed access to “future” code that has not yet been written. That is, in an MIT licensed code base, you can add new code that is not free. In a GPL code base, this is not possible.
  So, the GPL removes rights from the developers in that it removes the right to license future code contributions as you want. Under the GPL, the right of users to get future code for free is greater than the right of the developer to license their future contributions. Some people do not see that as a freedom. Some even see it as quite the opposite (forced servitude). This “freedom” is not one of the “4 freedoms” touted by the FSF but it is the main feature of the GPL.
  
  I write code for a living. I cannot, by any means, utilize a GPL library to support the needs of our customers and will either have to write my own replacement or dig to find something with less restrictions like MIT.
  On many occasions, we will find bugs or usage gaps or slowdowns that can get pushed back to the MIT licensed open source cause we were able to use it in the first place. If your goal is to make sure your library gets used and gets external contributors, I don't see how GPL helps the situation as it limits what developers can even choose your library in the first place. If your goal is spreading the ideology that all software should be free, go keep banging your drum for GPL.

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.

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.
  
  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.

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.

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.
- 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.
- 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
- 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
- getting rid of the gpl is the motivation behind e.g. companies sponsoring clang/llvm so hard right now.
  Is it? As I understand it, LLVM is much easier to work with than GCC, especially given their LLVM IR and passes frameworks.
  
  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

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.
- 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
- The author explicitly states that this is not the reason.
  https://github.com/uutils/coreutils/discussions/4358#discussioncomment-8027681

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.
- 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 provide ALGPL licensed source code of their own product.
  
  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.
- 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.

Bruh instead of all this speculation, you guys could have just looked it up.
https://github.com/uutils/coreutils/discussions/4358#discussioncomment-8027681
- There is a big difference between what someone says they are doing vs why they are actually doing it

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.
- 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

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

here, take my stuff and don’t contribute anything back, that’s totally fine
I mean, yeah? They are probably fine with that and think that software should be distributed without restrictions. You may not agree with it, but it's their choice. Not really stealing if they give it away willingly.
I cannot fathom any FOSS project not using the AGPL anymore.
I mean, most of them that want to use a GPL-like license use the GPL or LGPL rather than the AGPL. :P
why are developers even agreeing to this?
Are they? Last I checked this wasn't as much of a plan as much of it was just a developer thinking out loud. And even if it was a real plan, developers should continue doing what they should be doing anyway: Write their scripts without any GNU/uutils/whatever-microsoft-calls-their-evil-uutils-fork extensions. Then their scripts could run across all platforms, including GNU, uutils, FreeBSD and BusyBox.
At any rate, if Microsoft really wanted to make their own coreutils fork (if they haven't already), they're not really that complicated tools. They could devote like maybe a year of engineering time and get it pretty much compatible.
- Write their scripts without any GNU/uutils/whatever-microsoft-calls-their-evil-uutils-fork extensions. Then their scripts could run across all platforms, including GNU, uutils, FreeBSD and BusyBox
  Sorry but that's besides the point. If improvements to coreutils are not published and upstreamed then the community loses out on potential improvements that trained personnel at a successful company make. Not being dependent on such utils is a different discussion and doesn't solve the core issue.
  Yeah I'd like for them to use AGPL but even GPLv3 or it's derivatives are fine as long as they emphasise FOSS
  
  What improvements are you thinking of? I can see that reasoning with something like the Linux kernel where there's a lot of complex and integrated code, but ultimately individual coreutils commands are really simple. There's very little you can do to extend something like ls... And if you do, you can just make your own superls command and not have to deal with any licensing restrictions.
  With regards to AGPL vs GPL, none of the coreutils programs have network connectivity, so I'm not sure what the network requirement actually adds?

Apple makes the source code to all their core utilities available? Nobody cares but they do.
Why do they?
They are BSD licensed (very similar to MIT). According to the crowd here, Apple would never Open Source their changes. Yet, in the real world, they do.
Every Linux distro uses CUPS for printing. Apple wrote that and gave it away as free software.
How do we explain that?
There are many companies that use BSD as a base. None of them have take the BSD utils “commercial”.
Why not?
Most of the forks have been other BSD distros. Or Chimera Linux.
How about OpenSSH?
It is MiT licensed. Shouldn’t somebody have embraced, extended, and extinguished it by now?
Why haven’t they?
- Apple makes the source code to all their core utilities available
  Apple makes the source code for many open source things they distribute available, but often only long after they have shipped binaries. And many parts of their OS which they developed in-house which could also be called "core utilities" are not open source at all.
  Every Linux distro uses CUPS for printing. Apple wrote that and gave it away as free software.
  
  I loved this comment as much as a person is allowed to love it
- "Commercial" is not the opposite of free/libre. In fact, GPL licensed software can be "taken commercial" with a guarantee that it will remain libre, whereas BSD-licensed software doesn't have those guarantees.

MIT/GPL is fine for smaller tools.
- 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.
- 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 cat or pwd or printf takes 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.

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 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.)
  
  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 think it's more complicated than use, like something about being allowed to dynamically link to it but not statically, or something like that.

Maybe there could be another reason why people choose MIT to begin with:
When you start a new repo on github it makes suggestions which license to use, and I bet many people can't be arsed to think about it and just accept what they're offered. [My memory is a little patchy since I very rarely use github anymore, but I definitely remember something like this.] And maybe github tends to suggest MIT.
That said, please undestand that many, many git platforms exist and there is no reason at all to choose one of the two that actually have the word git in them.
- I can't believe professional developers choose MIT because they can't be arsed to look at the license choices
  
  I can’t believe professional developers choose MIT because they can’t be arsed to look at the license choices
  Have you worked with many professional developers?
  
  Well professional developers are often employed by companies that want make use of open source code to sell their proprietary code. It seems more likely to me that those companies will instruct their developers not to work on any GPL code rather than some big ideological shift in the individual developers.
  
  Ah, OK. No, of course not. I was thinking more about hobby developers.
  But somebody else already pointed it out: MIT makes a project more attractive for investors. Follow the $£€

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.

Does anyone use MPL anymore? Is it a decent middle ground or the worst of both worlds?
- For what use case?

I like BSDs more than GPL just personal choice
- Squeek, squack. Your opinion is whack
  
  lol grow up

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.

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