Author: Jake Bauer | Published: 2021-11-08 | Updated: 2026-08-21
Based on certain kinds of feedback I've received in
response to this post (which says a lot about the current state of Free
Software culture), I feel the need to say that if you disagree with what I have
written, I would appreciate it if you would voice those disagreements by
criticising the ideas that I've presented rather than assuming things about my
character or level of experience and insulting me. I have no problem with
people disagreeing with me; I appreciate having discussions in good faith, and
hope that you would give me the benefit of the doubt. You might even be
surprised at what I actually believe.
In this post, I use the term "Free Software" to
mean software licensed with Copyleft licenses, and to explicitly
differentiate it from permissively-licensed "Open Source" software
(which is what the Free Software Foundation and Co. also do).
I used to be a staunch software freedom evangelist. I used to license
all my works GPLv3-or-later and CC-BY-SA wherever I could, and I used to
believe strongly in the words of Richard Stallman. I have since started
to think more about the real effects of the Free Software movement and
have changed the way I write and license my software as a result.
Although I believe FOSS as a concept is still very important, I simply
no longer believe in the Free Software movement.
I’ve come to the conclusion that Free Software is an abject failure.
While Free Software may on its face sound like a good concept—especially
with the kind of language often used to describe the movement and its
opponents—when put under scrutiny, the institutions and practices that
make up the Free Software movement fundamentally fail at their stated
goals. The Free Software movement is doing more harm to FOSS than good.
Not only is it an ideological mess, it hampers collaboration, it is
legally ineffective, it makes the lives of developers harder while doing
nothing actually useful for users, and it fundamentally gets in the way
of a thriving, free, and open software ecosystem.
The Failure of the Free Software Ideology
Why Software Should Be Free by Richard Stallman
presents an argument against having owners of software and explains the harm
done by obstructing software development through proprietary licensing. He
posits that software with obstructions results in fewer users, the inability
for users to fix programs, and the inability of developers to build upon prior
knowledge or work. He also states that the justifications one uses for keeping
ownership of the software (which he equates with keeping the software
proprietary) are emotional (i.e. “This software is mine, and I wish to control
it”) and economical (i.e. “I wish to become wealthy by programming.”). He shuns
these excuses and spends the rest of the document refuting those excuses, and
explaining why the existence of proprietary software is bad and why the
alternative—software not having owners—is better. By and large, I agree with
this essay: I don’t think software should have owners. Instead, I believe
software should be released into the public domain as much as is possible.
However, in nearly every Free Software project which exists today, there is a
clear “owner” of the software—someone who is the copyright holder, benevolent
dictator for life, or simply de facto leader of the project and through whom
all contributions must flow. Whether we’re talking about large projects that
are too large to fork and maintain by anybody but large, well-funded groups
such as the Linux kernel (in which Linus still has complete veto power by the
way), Qt (in which the company controls the development of the software and
simply allows older versions to be used under a free license), Android
(where Google maintains pretty solid control), or smaller projects which have
simple leaders. As long as there is a copyright statement, there are one or
more owners to be aware of.
Additionally, the GNU Manifesto, aside from calling
the Open Source movement an “amoral approach”, goes on to say that GNU “is not
in the public domain” and will have restrictions placed on further
modifications in the form of disallowing proprietary modifications, with the
justification given by Stallman being: “I want to make sure that all versions
of GNU remain free.” With that, Stallman does exactly what he shunned in Why
Software Should Be Free. He uses his emotional attachment to the software,
something he said was an excuse people use to defend why software has an owner,
to justify his want to control how others can distribute and modify his code.
He is effectively saying “this is my creation, and I wish to control what
others can do with it” while also clearly assigning an owner to the software.
Update 2021-12-13: I was recently made aware of an article in which Richard
Stallman advocates against positive changes to copyright laws because of how
it would hurt Free Software. Instead of making software free of copyright
after 5 years, he advocates for maintaining copyright control because it would
hurt the control that Free Software licenses would have over the distribution
of software later on. It’s not enough that the software would still fulfill
the four pillars of free software after the 5 years is up, control must be
maintained over how other people can distribute and use the software in their
products in case they ever decide to fork it and make something proprietary
from it. Not only does he not trust that people would use only the Free
version (as if we need to be protected by Free Software licenses lest we fall
prey to encountering proprietary software), he is, in essence, advocating for
maintaining ownership over software even though the change to copyright
legislation would be positive for society overall. The article is called: How the Swedish Pirate
Party Platform Backfires on Free Software.
Even if you’re also staunchly against proprietary software, you should at least
recognize the hypocrisy in this stance.
If software is not in the public domain, then, by definition, it has to have at
least one owner. If Stallman can dictate how others can use his software—even
if it is more free than most proprietary software—then it clearly has an
owner.
Simply put, Stallman and others in the Free Software community use the exact
same excuses that he criticized in Why Software Should Be Free as
justification for their actions. GNU, the GPL, and seemingly the entirety of
Free Software as it stands today are all based on the same premises as
proprietary software. They use existing copyright systems in what they deem
the “right” way while simultaneously criticizing the way others use them as
wrong.
The Free Software movement comes off as both a “cult of
personality"—worshipping Richard Stallman and his
teachings while ignoring
the inconsistencies between his words and his actions—as well as a “cult
of ideology"—shunning those who disagree with the manifestos and the
“way of life” that the movement espouses to an extreme degree. As long as you,
as a developer, do everything within the framework of the GPL and the culture
of Free Software, you are considered ethical and good. As soon as you wish to
do something outside of this domain—even by using a more open, permissive
license—you are considered amoral.
In an article where Linus Torvalds criticizes the
GPLv3,
Torvalds even says:
The Failure of the GPL
One of the stated goals written in the GNU Manifesto is:
One look at the GPL or any other Free Software license will tell you that they
have utterly failed at this. For example, the GPL has become so complicated
that only a programmer with relatively advanced legal knowledge and ability to
read and properly understand “legalese” will be able to decipher it to know
what they are able and unable to do with it. There exist websites which explain
the license in plain English, but even those say their explanations are no
substitute for reading the license. There are very specific meanings that many
of the words in the license take on when put in the context of our modern legal
system so, while you may be able to read the GPL and think that you
understand it, unless you are well-educated in this legal domain, you probably
don’t fully understand the true meaning and effect that the words of the
license would actually have in court.
Especially because the ramifications of the GPL are still not even fully
understood by lawyers themselves. Many large companies will shy away from the
GPL simply because they don’t want to take the risk of using GPL-licensed code
improperly and being forced to reveal their proprietary code. While I don’t
agree with proprietary software as a concept, the fact that even lawyers—who
are supposed to be expertly trained in the kind of language used in the
license—are uneasy about its terms further reinforces just how unapproachable
it is to the everyday software developer. GNU and the GPL have done nothing to
remove the overhead of considering who owns software and how it can be used.
Update 2023-07-13: It has become especially clear how few people
actually
understand
what the GPL does and does not permit based on the responses to changes
that Red Hat made to how they offer their source code (more on this later).
Since the development of the GPL is reactionary—that is to say, its development
and growth over time was in response to discovered workarounds—there is now
even more overhead by way of the extra complication of the “-or-later/only”
clauses. So this is now a license that has multiple versions which are not
backwards compatible. A project licensed under the GPLv2-only cannot integrate
GPLv3-or-later code without being re-licensed as GPLv3. The Linux kernel is an
excellent example of this.
Linus Torvalds even came out strongly against the GPLv3
and the process by which the FSF created the license. Many others in the
industry also saw this as an extreme and unnecessary move by the FSF to wield
the ultimate power over the GPLv3; all because a manufacturer put Linux in
their products and blocked users from running their own modified software on
that hardware. The absurdity of this line of thinking is compounded by the fact
that this had absolutely nothing to do with the Linux kernel since it’s the
system’s firmware that would stop users from running different software. This
seems to many as just an excuse to expand the scope and powers of the GPL over
something completely out of the scope of the GPL-licensed software. The move by
the FSF, the actions of Stallman, and the “tivoization” rhetoric are even
heavily criticized by Software Freedom Conservancy member Bradley M. Kuhn.
Putting aside the political manoeuvrings of the FSF, the mere existence
of an “-or-later” clause is a ridiculous thing to attach to a license.
Anybody who licenses their project under a GPLv3-or-later license puts
a lot of trust in the stewards of the GPL that the next version of the
GPL will align with their values and goals; a GPLv3-or-later project
will be able to be licensed under a GPLv4 license, whatever the clauses
of that GPLv4 license. This is a lot of stock to put into a group of
people like the FSF who were so dogmatic and exclusionary in their
development of the GPLv3.
The reality of the GPL is that there is still a lot of overhead in
considering who owns the software and how it can be used. Not only in
whether or not a developer should choose version 2 or version 3 of the
license depending on their goals, but also for developers and users
alike who try to understand the language of the license to determine
what they can do with the software and, if they are integrating some
GPL-licensed code into their own product, who actually owns and has
copyright over that software.
Those who wish to integrate GPL-licensed code into their otherwise
non-GPL-licensed projects are faced with the decision to relicense their code
under the GPL, remake the functionality of the library under a more open
license, or otherwise abandon those efforts altogether. While the GPL
may “prevent” corporations or people from taking GPL-licensed code and
integrating it into a proprietary product, it also prevents many other
non-GPL-licensed projects from using GPL-licensed code, even other FOSS
projects.
GPL fans said the great problem we would face is that companies would
take our BSD code, modify it, and not give back. Nope – the great
problem we face is that people would wrap the GPL around our code, and
lock us out in the same way that these supposed companies would lock us
out. Just like the Linux community, we have many companies giving us
code back, all the time. But once the code is GPL’d, we cannot get it
back.
– Theo DeRaadt, Message to the Linux Kernel Mailing List
Even so, it’s not like the GPL actually prevents corporations from
stealing GPL-licensed code and integrating it into projects. While there
are plenty of corporations who freely comply with the GPL, there are
plenty more, such as VMWare, who don’t comply and yet don’t face
consequences.
Even if a lawsuit is successful, it is usually at the cost of members
of the FOSS community who burn out or are
left disenchanted by the whole process. Being GPL-licensed also doesn’t
prevent a project from being bought and therefore having all control
handed over to a corporation. This was most recently seen in the
acquisition of Audacity by Muse
Group
in which Muse Group bought the rights to the Audacity code and project.
Users have since forked the project1, but this doesn’t necessarily stop
something like this from happening in the future, and certainly doesn’t
stop it from happening to other projects. If software actually didn’t
have owners, this could not happen.
Update 2022-10-23: It just happened to
Gitea!
Update 2023-07-16: Being under the GPL also doesn’t even stop projects
from being closed-source except to paying customers. As just happened
with Red Hat Enterprise
Linux!
Red Hat is making Red Hat Enterprise Linux’s source code available only
to paying customers. Since there’s no other way to get a copy from Red
Hat (you can’t just download it like you can Ubuntu), this is entirely
within the letter of the GPLv2. They’ve also said they’ll terminate
support contracts and not give customers new versions of the code if
those customers exercise their rights under the GPL by distributing the
code they receive from Red Hat. This angered a huge portion of the FOSS
community who shouted from the rooftops about how this violates the
“spirit” of Free Software. However, this is nothing new, and a company
was doing the same thing in 2006 to
which the Free Software Foundation said “that’s ok!”. That “spirit”
clearly doesn’t matter when it comes to a company’s bottom line and
neither the GPL nor the FSF do anything to address this.
The GPL-family of licenses attempt to solve a societal problem by
restricting the distribution of software in a manner not unlike the
so-called Ethical
Software
movement. The GPL acts effectively as a proprietary license that allows
you to do the things it deems ethical, so long as you abide by the terms
of the license with regards to the distribution and re-licensing
restrictions. As long as you are in this “club”, everything is fine and
dandy and you can make your changes and push them to your favourite
projects. As soon as you leave this club and want to pull code from
a GPL-licensed project into your MIT-licensed project, well, sorry, too
bad for you.
Update 2026-08-21: Even more onerous is the AGPL, which stops even
GPL-licensed software from including code without infecting the whole project
with its terms. An instance of this being an issue for a popular GPL project
just happened with the code forge software Forgejo, where
they had to stop using an image library because it turned out to be
AGPL-licensed. This would have required Forgejo to be distributed under the
terms of the AGPL, rather than their preferred Free Software license, the GPL.
This is FOSS friendly-fire at its best. Congratulations, you played
yourselves.
While the GPL may not cause as much of an obstruction or be as unethical
as proprietary software, it is frankly not that much better. It causes
distress and conflict in the software community, is difficult for
non-lawyers to fully understand, and harms developers of
non-GPL-licensed FOSS software all while not even being effective at
what it was ostensibly designed to do. It is, for example, the reason
why the BSDs cannot take improvements made in the Linux kernel and
directly integrate them into their own kernels, and it is the reason why
ZFS cannot be integrated into the Linux
kernel,
but can be shipped with FreeBSD.
For all this talk of Free Software being the ethical option and the GPL
being the ultimate defender of user and developer rights, it completely
goes against the ethical principles laid out in Why Software Should Be
Free.
The Failure of the Free Software Culture
The GNU Manifesto speaks a lot about how:
But a cursory look at the current landscape of Free Software will tell
you that this is simply not the case at all.
Users are absolutely at the mercy of the maintainers of software projects to
integrate their changes in the current landscape of software development,
especially with software projects as complicated as many of the popular GUI
toolkits, kernels, or desktop environments. In fact, the reality is that Free
Software project issue boards and forums are not much better than corporate
support forums. Often when one opens an issue in a large software project it
can take months or even years for those issues to be worked out. It’s also not
uncommon for those issues to simply go unsolved for many years. A great example
of this is the ‘Add an “icon view with thumbnails” mode’ GNOME issue
which was opened in 2004 (it’s almost old enough to vote!) and is still
not actually fixed despite many users expressing how useful it would be to have
this featureapparently has been recently added nearly 20 years
later. Good job everyone!
Users simply cannot maintain such complex software on their own and, if they
have limited programming ability, cannot be expected to fork a project, make
their fix, test their fix, act on feedback from the maintainers (if they’re
lucky enough to get their patch or pull request noticed), and so on. The
current software development ecosystem makes this impossible, regardless of the
license of the project. Software is not simple enough for that and GNU and Free
Software did nothing to solve this. In fact, it can be argued that they made
this worse by contributing to the creation of a culture of “elitists” who
expect all the users of their software to have the ability to read code,
technical discussions, and documentation in order to understand and fix
problems.
If an experienced user does come along and is dis-satisfied with their
corporate support forum-like experience, they might be inclined to fork
the project. However another very common sight in the FOSS realm is to
see accusations towards groups or companies who fork projects of making
“hostile forks” or committing “theft” of Free Software. For example,
Members of the Free Software community shunned and criticized the group
of developers who forked Gogs to make
Gitea
when they forked a Free Software project to extend it for their own
needs because of an unresponsive maintainer. They even still kept the
project under the same license (an “unethical” Open Source license, no
less).
Update 2022-09-13: I recently learned of the XFree86 fiasco in which
another, similar incident occurred where one of the original developers
of the X window system felt that the current state of things was
untenable and that the project needed to be forked and replaced. He was
summarily shunned and kicked from the
project
for his actions. This is yet another example of how forking is viewed by
many who work in FOSS and who wish to maintain control over their
particular piece of software.
If software is not supposed to have an owner, as Why Software Should Be
Free advocates, what exactly is being stolen? Why do they, as the
creator of some piece of software, care if some company or even another
FOSS developer takes it and uses it in their product or makes
proprietary modifications with it?2 Why Software Should
Be Free specifically outs this need to control what happens with one’s
software as one of the main justifications for proprietary licensing and
something to be avoided, yet it is seen everywhere in the Free Software
culture. In fact, an article entitled Don’t fear the fork: How DVCS
aids open source
development
perfectly exemplifies how the Free Software culture views forks (of
course, it’s written from the perspective of the “amoral” Open Source
movement).
The goal of Free Software as laid out by Why Software Should Be Free
was to create a world in which there were no owners of software and in
which distribution was not restricted. Yet, despite this, the way the
GPL family of licenses puts restrictions on the distribution of
GPL-licensed software combined with the culture of Free Software
actively encourage both of those things and actively discourage
forking software and modifying it to suit your own needs. From the point
of view of Why Software Should Be Free, the GPL combined with this
culture is, in reality, not much better than the world of proprietary
software we had before as far as users (and developers to a lesser
extent) are concerned.
The degree of openness which exists in the current software landscape
can be, to a large degree, attributed instead to the Open Source
movement3. It happened in spite of the Free Software movement, not
because of it.
The Failure of Free Software to Remain Relevant
Free Software and the surrounding culture and institutions are often
viewed as a farce outside of the dedicated Free Software cult
community. The FSF has been slowly descending into irrelevancy for the
past two decades as they struggle to do anything meaningful with their
time and resources; instead opting to make a lot of unproductive noise.
Take, as recent examples, how they mailed a hard drive to Microsoft
telling them to put the Windows 7 source code on
it,
or how they accuse Apple of “censoring free
software”
—despite the fact that Apple isn’t actually censoring anything and
plenty of Free Software projects such as
are on the App
Store—and
also criticizing them for not supporting their specific chosen free
media codecs—once again, ignoring the plenty of other free media codecs
which are otherwise perfectly supported.
To expand on that last point about Free Software projects on the App
Store, the Apple App Store
EULA
contains restrictions that the GPL doesn’t allow (see section 10 of the
GPLv3 and section 6 of the GPLv2). It says:
Note that this only applies to the application you purchased in the App store,
as bundled by the App Store. It doesn’t prevent you from going to GitHub and
modifying the software there, it only prevents you from legally modifying the
software you got from the Apple App Store. Sure, this isn’t a good thing, yet
it is hardly “censoring free software” given that, as the owner of a Free
Software project, you can freely submit GPL-licensed software to the App Store
and Apple assumes you have the rights to provide them with a non-GPL-licensed
build.
If you don’t have that ability because you don’t own exclusive rights to the
software and it’s not feasible for you to get the permission of every
contributor with their name attached to the project, well, that’s not Apple’s
problem. The FSF words their article like Apple is attacking them when, in
reality, Apple doesn’t care what license you’ve chosen, only that you grant
them the ability to distribute your app under the terms of their EULA. The
wording in that blog post is yet another example of why the FSF are seen as a
farce. They should know better.
This reputation of preferring ideological book-thumping over meaningful action
is nothing new. Most who are familiar with Linux are likely familiar with
Richard Stallman’s “GNU+Linux” rant
in which he squabbles and nitpicks over the relevancy of GNU to the Linux name.
Ignoring that the only significant contributions to the Linux system GNU can
claim is the compiler, the coreutils, and the C library. Significant? Yes, but
this ignores that most Linux systems today run far more non-GNU software than
GNU software.
In fact, even those GNU components are quickly fading into irrelevancy as
projects like Clang/LLVM, rewrites of coreutils to be faster and cleaner
(e.g. Busybox or various Rust projects), and other libc’s such as muslc are
gaining more and more traction with each passing day. GNU is simply failing to
make any meaningful and actual progress, and is grasping at straws in an
attempt to remain relevant. Not only have other projects such as OpenBSD long
since abandoned things like modern GCC due to later versions becoming
unmaintainable, buggy behemoths, GNU themselves haven’t even released their
HURD kernel in any meaningful capacity despite promising to create such a thing
since before Linux existed.
Speaking of fading into irrelevancy, many of the Free Software institutions such
as the Software Freedom Conservancy and Free Software Foundation Europe have
either been reliant on GPL violation lawsuits as one of their primary means to
exist, or have been relatively ineffective at carrying out their mandates with
regards to litigation. It has gotten so bad that the SFC have tried to bring
lawsuits on behalf of the users of GPL software; something which has little basis in actual
copyright law, but is the only option they have left when companies either
skillfully hide their GPL violations or the owners of GPL software are
unwilling to enforce the license against large opponents. A cursory glance on
the SFC’s website reveals a lot of information about this Vizio lawsuit, but
not much information about previous lawsuits or successes. No wonder these
institutions also tend to only go after small opponents. Even very public
violations such as those committed by OnePlus
have still gone unanswered for. If such violations are clearly allowed to
continue with such ineffective enforcement, what even is the use of the GPL in
reality?
Regarding the quality of GNU software, outside of the Free Software
community, GNU code has a reputation for being resource-hungry, buggy,
bloated, or annoying and frustrating to work with, as many who have had
the pleasure of using alternative libc’s, compilers, utilities, or
programs will attest. GNU creations have a reputation for being
needlessly complex—solving problems which don’t really exist in the
first place if you write good software (or documentation)—and having
bafflingly complex source code. The GNU Info system and the code found
in many of the coreutils are good examples of this.
Finally, we can talk about how the conduct of Richard Stallman himself
reflects on the whole Free Software movement. The Free Software movement
went through its own little “constitutional crisis” over the question of
whether or not to keep him on as the face of Free Software after he made
some comments on an MIT mailing list about a sensitive topic. I won’t go
into specifics about that situation here, since it has been covered to
death in other media outlets and can be easily searched for (search
“stallman mit mailing list”), but, suffice to say, Stallman acted in
a completely improper and inept manner and, in fact, that is far from
the only example of him behaving in such a way.
In 2007, Stallman sent a message to the OpenBSD-misc mailing
list entitled
“Real men don’t attack straw men” in which he accuses the OpenBSD folk
of making straw-man arguments about himself, and then using those
arguments to attack his credibility. If you read through this mailing
list thread, you don’t have to go far to realize that Stallman has
absolutely no clue what he’s talking about. He bases his opinion of
OpenBSD on “what I have heard” and presumes that the OpenBSD folk care
whether or not he recommends their system. He proceeds to have
everything he said get taken apart by the replies which point out all
the inconsistencies in his own arguments and stances.
After seeing just how ineffective this culture is at advocating for and
enforcing its principles in a meaningful way, as well as seeing the conduct
of one of its top-most members (not to mention the conduct from its
supporters),
how could anyone view this as a movement to be appreciated, let alone joined
and celebrated?
Where Do We Go From Here?
I think, by now, it is accurate to say that Free Software is an abject
failure.
It has failed at its stated goals through both the licenses and the
culture it has created and has instead perpetuated the paradigm of
software ownership and the use of unethical and flawed copyright
legislation. It has done very little to prevent corporate takeover of
projects, improve the software development landscape, or make the lives
of developers or users easier. It has done nothing that more ethical,
permissive software licenses and the culture of collaboration born out
of projects such as BSD Unix didn’t already do, except to create a toxic
subculture of Free Software cult worshippers.
One cannot solve the copyright, ownership, or restricted distribution
problems of software through playing into the exact same flawed systems
that allow such problems to exist in the first place. These are problems
which must be solved on a societal level, not on the level of individual
software projects through obtuse licensing. Free Software, as it stands
today, has the very real effect of restricting innovation, sharing, and
collaboration between developers.
None of this is to say that proprietary licenses are okay or even that
the Open Source movement is the alternative. In fact, the Open Source
Initiative is not all that much better than the Free Software
Foundation, it just has a mostly different set of problems which are out
of scope for this essay.
For the most part, I agree with Why Software Should Be Free. Stallman
has perfectly valid and good ideas in that essay, yet he misses the mark
with their implementation. He’s right in that software should not have
owners and restricting software distribution is unethical; I ultimately
believe that nobody should get to control how their software is used,
studied, distributed, or hacked upon. Software should be as much in the
public domain as possible just like books, music, product schematics
and other such things should be.
The only licenses which truly meet all these criteria under that framework are
public domain-equivalent licenses. Licensing your code under the Unlicense, the 0BSD License, or the CC0 License means that you
do not place any restrictions on the software whatsoever. People don’t even
have to mention your name or your project when they use your code because you
disclaim any ownership of the software. The extremely popular SQLite uses this approach and has spread across
the entire industry as a result, to the benefit of everyone.
If you do at least wish to have your name attached to the code to claim credit,
commonly used permissive licenses are the best option. Licenses such as the
MIT License or the ISC License (preferred due to it being a
simplified MIT) impose no further restrictions other than maintaining a
copyright and permission notice for that code if it’s used in other projects.
Essentially, people are free to do whatever they want with your code, so long
as they keep your name on parts that you wrote.
Not only do these options provide far more real freedom4 to
developers5, they remove the overhead of having to think about
who owns the software. In the case of software in the public domain, you
don’t have to worry at all because there is no owner. In the case of
permissively-licensed software, it’s a simple matter of copy-pasting the
necessary notice(s) wherever that code is used. These licenses are also
relatively easy to understand (except perhaps the CC0), and the culture
surrounding them is generally such that you don’t have to worry about
a mob coming after you for forking a project and morphing it into
something that serves your needs, nor do you have to worry about being
sued for an accidental violation of a license that even people who are
well-versed in software licensing aren’t confident about getting right.
You’ll notice that those licenses, however, do not address the issue of
corporations controlling software development and distribution, people using
software in ways you may deem bad or harmful, or the existence of megasoftware.
This is because those are problems that cannot be solved or even effectively
addressed by software licensing. These are societal problems that must be
tackled on a societal level. Attempting to do otherwise harms and imposes more
restrictions on small teams, independent developers, and hobbyists who don’t
have the resources to ignore your restrictions or buy your development team.
In reality, by licensing your project under the GPL and participating in
Free Software culture, instead of limiting the harms that corporations
inflict, you end up limiting the good that the rest of us can do. Free
Software, as it stands today, has failed.