GNU and Stallman, the free software movement

Field note. Minecraft runs on Java. Java runs on Linux. Linux exists in this shape because of the GPL. Free software ideology is in the foundation, whether you think about it or not.

In 1983, a programmer at the MIT AI Lab named Richard Stallman started a project to write a free version of UNIX. The technical goal was significant. The philosophical goal was larger: to establish that software should be free in a specific ethical sense.

The result was the GNU Project, the Free Software Foundation, the General Public License, and an ideology that has shaped how billions of programmers think about software. This article tells the story.

What "free" meant

The free software movement uses "free" in a specific sense, distinct from "free of charge."

The four freedoms (as Stallman articulated them):

1. The freedom to run the program as you wish.
2. The freedom to study how the program works, and change it.
3. The freedom to redistribute copies.
4. The freedom to distribute modified versions.

This requires access to source code. Software you can use but not see is not free.

"Free" is about freedom, not price. As Stallman often says: "free as in freedom, not free as in beer."

This distinction is the source of much confusion. The term "open source" was coined in 1998 partly to avoid the ambiguity. Both terms refer to similar code; the philosophies behind them differ.

Stallman's frustration

In the late 1970s and early 1980s, Stallman watched commercial pressures change the computing culture he'd grown up in.

At MIT's AI Lab in the 1970s, source code was shared. Programmers improved each other's tools. If a printer was misbehaving, you read its software, found the bug, fixed it. Collaboration was the default.

By the early 1980s, this was changing. Companies were closing source. Hardware came with closed-source firmware. New software had non-disclosure agreements. Stallman couldn't fix things he could see were broken because the source was secret.

He saw this as a moral problem, not just an inconvenience. Software that you couldn't read or modify was, he argued, treating users as captive consumers rather than as collaborators in their own computing.

In 1983, he announced the GNU Project: build a complete free UNIX clone. The name "GNU" stands for "GNU's Not Unix," a recursive acronym typical of programmer humor.

The early GNU work

Stallman left MIT in 1984 to work on GNU full-time. Initial milestones:

• GNU Emacs (already in development; mature by mid-1980s). The text editor.
• GCC (GNU Compiler Collection, 1987). A free C compiler. Essential for the rest of GNU.
• GDB (GNU Debugger).
• Bash (GNU shell, 1989).
• GNU Coreutils: ls, cat, cp, mv, etc.

By the late 1980s, GNU had most of the userland tools for a UNIX system. What was missing: the kernel.

The GNU kernel project, called the Hurd, was technically ambitious (microkernel design) and slow. By 1991, it wasn't usable.

When Linus Torvalds released Linux that year, it filled the gap. Linux + GNU tools = a working free UNIX. The full system is properly called GNU/Linux (though most people just say "Linux").

The Free Software Foundation

In 1985, Stallman founded the Free Software Foundation (FSF) to coordinate GNU work, hold copyrights, and advocate for free software.

The FSF:

• Owns the copyrights to many GNU programs (contributors assigned them).
• Publishes the GNU General Public License (GPL).
• Funds development of GNU components.
• Advocates politically for free software issues.

The FSF has always been small (a few staff). Its influence has been disproportionate to its size, mostly through Stallman's advocacy and the GPL.

The GPL

Stallman's biggest legal innovation: the GNU General Public License, published 1989 (first as GPL v1), revised 1991 (v2), and 2007 (v3).

The GPL is a software license with a specific, careful design:

• You may use, modify, and distribute GPL-licensed software freely.
• If you distribute a modified version, you must also distribute its source code under the GPL.
• You cannot add additional restrictions.

The clever bit: the license uses copyright to require sharing. If you accept the license (which you must to legally use or modify the code), you accept the requirement to share derivatives.

The GPL is sometimes called "copyleft" (a wordplay on copyright). It's the strongest free-software license: anything derived from GPL code stays free.

Companies that wanted to use GPL'd code had to comply. They could keep their own (non-derivative) code closed, but any improvements to GPL'd software had to be released. Over decades, this produced an enormous amount of free code.

The GPL is also controversial. Some companies avoid GPL'd code entirely because they can't (or don't want to) release their own derivatives. Alternative permissive licenses (BSD, MIT, Apache) allow closed derivatives, which some prefer.

Linux adopts GPL

In early 1992, Linus Torvalds released Linux under the GPL. This was a critical decision.

Effects:

• Linux automatically inherited a large community of GPL-friendly developers.
• Companies using Linux had to release their kernel modifications. This produced enormous improvements over time.
• The "Linux on the server" boom of the late 1990s was partly enabled by the GPL: companies trusted that no one could take Linux closed.
• Microsoft's lawyers spent years strategizing about how to compete with GPL'd software.

Without the GPL, Linux's success might have looked different.

Open source emerges (1998)

In 1998, a group of software developers (Eric Raymond, Bruce Perens, others) coined the term "open source" as a re-brand of free software. The motivation: "free" confused people (free of charge?), and the ethical framing alienated some businesses.

"Open source" emphasizes the practical benefits (better code through collaboration, faster development, etc.) rather than ethical freedom.

The two terms refer to mostly the same code. The Open Source Initiative's definition is similar to the FSF's. But the ideologies differ:

• Free software is an ethical movement. The point is user freedom.
• Open source is a development methodology. The point is better software.

Stallman has always insisted on "free software." Many practitioners use "open source." The two communities mostly coexist, occasionally disagreeing.

What GNU produced

Beyond the named tools, the GNU Project produced:

Cultural change. A generation of programmers who expect to read source code and contribute fixes. The internet's culture of permissionless collaboration is partly a GNU legacy.

Licensing infrastructure. The GPL and its variants. The Lesser GPL (LGPL) for libraries. The AGPL for network-distributed software.

Compiler infrastructure. GCC made it possible to develop free software on essentially any platform. The Free Pascal Compiler, the GHC Haskell compiler, many others built on GCC's model.

Reference implementations. GNU tools became the standard against which others compared. "GNU-style" command-line tools, "GNU-style" build systems.

Political advocacy. The FSF has been an active voice in copyright, patent, and DRM debates for 40 years.

Stallman the person

Richard Stallman is a complicated figure. His contributions to free software are enormous. He's also been controversial:

Personally awkward. Famous for unkempt appearance, unusual interpersonal habits.

Ideologically rigid. Refuses to use proprietary software entirely. Won't browse the modern web normally. This is consistent with his principles but extreme.

Politically outspoken. Holds firm positions on many issues, freely expressed. Some of his positions have been widely criticized.

Departures from the FSF. In 2019, Stallman resigned from MIT and the FSF after controversy over his comments about an associate of Jeffrey Epstein. He returned to the FSF board in 2021, which generated further controversy.

The Stallman question (how to relate to him, given his contributions and controversies) is recurring in free-software communities. Most contemporary writing acknowledges both his role in creating the movement and his complicated personal record.

For an understanding of free software's history, both sides matter.

The free-software movement today

In 2026, the free-software / open-source landscape is enormous:

• Most servers run Linux.
• Most websites run open-source web servers (Apache, nginx).
• Most programming languages have open-source implementations.
• Major databases (PostgreSQL, MySQL, SQLite) are open-source.
• Most cloud infrastructure stacks include extensive open-source.
• Most major companies contribute to open-source (Microsoft, Google, Apple, Amazon, etc.).

The "free vs. proprietary" battle, which seemed sharp in the 1990s, has resolved into a hybrid: open-source for infrastructure, proprietary for many applications, with corporate support for both.

Stallman's vision of "all software should be free" hasn't been fully realized. His pragmatic effect (most infrastructure software is now free) is enormous.

The questions still being debated

A few ongoing tensions:

License compatibility. GPL, MIT, Apache, AGPL: different licenses combine in different ways. License lawyers exist.

The corporate open-source model. Companies pay engineers to work on open-source. Is this still the same movement? Mostly yes, but the dynamics differ from independent contributor models.

Sustainability. Major libraries used by everyone often have one or two unpaid maintainers. Burnout and security issues result.

License changes mid-project. Companies sometimes change licenses on projects they own (Elasticsearch, MongoDB, others). Communities object. Forks happen.

The role of the AGPL. Software running on servers can be modified without distributing the modifications. The AGPL closes this loophole. Adoption is gradual.

The movement continues. Stallman's foundational decisions still shape it.

What Stallman got right

Several things:

Source access matters. The ability to read, modify, and share source code is genuinely valuable.

Licenses can encode ethics. The GPL's design is a marvel of legal creativity.

Pragmatism matters. GNU tools were useful even before the GNU OS was complete. Useful tools drive adoption.

Community can outproduce corporations. GNU, Linux, and the broader ecosystem demonstrated this convincingly.

What he got wrong (or not quite right)

A few things, in fairness:

The Hurd. The microkernel design was technically interesting but operationally slow. Linux's pragmatism beat it.

Marketing. "Free software" remains confusing to most people. "Open source" was a better label for popular adoption.

Reading the room. His ideological purity, while consistent, has alienated potential allies.

The all-or-nothing stance. Real-world computing involves trade-offs. Insisting on complete software freedom is a stance few people can maintain practically.

These don't diminish his contributions. They explain why the movement evolved beyond his strict ideology.

Conclusion

Richard Stallman started a project in 1983 to ensure that software could remain free. He built tools, wrote licenses, founded an organization, and articulated an ideology.

Four decades later, the world looks different. Most infrastructure software is free. Most major companies participate in open-source development. The internet's core systems are GPL-licensed in many cases.

The man himself is complicated. The movement he started is one of the most successful ethical-and-technical projects in computing history. Both are true.

If you've ever used Linux, edited a file in vim or Emacs, compiled C with GCC, or run almost any web server: thank GNU. The reason these tools exist for you to use freely is the work Stallman started forty-three years ago.

Coming up

Next: the rise of open source, the broader phenomenon of which GNU is one part. How software development culture shifted toward open by default in two decades.