The History of the Open Source Movement: From Libre Software to Linux

Today, millions of developers worldwide collaborate on software that anyone can freely use, inspect, and improve. But this culture of openness didn’t emerge overnight. It is the product of decades of philosophical battles, legal innovation, and a few pivotal individuals who refused to accept that software had to be locked away. The story of the open source movement is, at its core, a story about who gets to control technology – and who gets to be free.

The era of shared mainframes: computing’s collaborative origins 🔗

To understand open source, you have to go back to the 1950s and 1960s, when computers were enormous, expensive machines housed in dedicated rooms and owned primarily by universities, government agencies, and large corporations. In those early years, software was not considered a product in its own right. It was treated as a functional accessory to the hardware – something you needed to make the machine work, not something you paid for separately.

IBM, the dominant force in the mainframe market, exemplified this model. Customers who purchased an IBM computer automatically received a software suite with no separate licensing cost charged. Companies purchasing systems like the IBM System/360 in the 1960s received operating systems and productivity tools as part of the deal. Crucially, this software came with its source code – the human-readable instructions that make a program function – which meant users could read it, modify it, and share improvements.

Universities were among the earliest and most enthusiastic adopters of this model. Many of the modifications they developed were openly shared, in line with the academic tradition of knowledge exchange. User groups like SHARE, founded in 1955, formed around IBM’s systems so that members could trade software and documentation they had written. IBM amassed a vast, free software library through this community of willing sharers. It was an informal but vibrant ecosystem of collaborative development – a direct ancestor of what we now call open source.

The rise of proprietary software: when code became property 🔗

This culture of sharing began to erode in the late 1960s, driven not by ideology but by economics and antitrust law. Independent software companies complained that IBM’s practice of bundling free software with hardware made it impossible for them to compete. The U.S. Department of Justice agreed, and in response, IBM unbundled many programs from its hardware in 1969, transforming software overnight from a giveaway into a competitive commercial product.

This was a watershed moment. During the 1950s and early 1960s, source code had circulated relatively freely among university computing centers, research laboratories, and technically sophisticated corporate users, who customized and shared programs as a matter of normal professional practice. Once IBM unbundled software from hardware, that arrangement began to collapse. Companies realized that source code was a competitive asset to be protected, not shared. By the mid-1970s, software with restricted access to its underlying code – proprietary software – had become the industry standard. The open culture of early computing was being rapidly replaced by legal walls and license agreements.

Richard Stallman and the GNU Project: a philosophical counterattack 🔗

The shift toward proprietary software frustrated many in the technical community, but one person in particular made it his life’s mission to reverse it. In the late 1970s, Richard Stallman was working at MIT’s AI Lab when the lab received a new printer with proprietary firmware. Stallman was frustrated that he could not get a copy of the software to fix a straightforward problem – and he recognised this as a social issue, not merely a technical inconvenience.

That frustration crystallised into action. On September 27, 1983, Stallman announced his plan to develop a free, Unix-like operating system called GNU – a recursive acronym for “GNU’s Not Unix”. The goal was to build a complete operating system that users could run, study, modify, and share without restriction. The Free Software Foundation (FSF) was established in 1985 as a nonprofit to support the GNU Project and promote open-source software, giving the movement an institutional home and a formal philosophical framework.

Stallman was careful to distinguish “free” as in freedom, not as in price. Free software means users have the freedom to run, copy, distribute, study, change, and improve the software – it is a matter of liberty, not cost. This distinction – “free as in free speech, not free beer” – became a defining slogan of the movement. By 1992, the GNU Project had completed all major operating system utilities, though its own proposed kernel, GNU Hurd, remained unfinished. The stage was set for someone else to fill that final gap.

The General Public License: enforcing freedom through law 🔗

One of Stallman’s most enduring contributions was not a piece of software but a legal instrument. To ensure that free software stayed free – that no one could take open code, modify it, and lock it back up in a proprietary product – Stallman created the GNU General Public License (GPL), which allowed software and all future generations of code derived from it to remain free for public use.

The GPL introduced the concept of copyleft – a clever inversion of copyright. Where standard copyright restricts copying and modification, copyleft uses copyright law to guarantee that these freedoms are preserved. GNU pioneered this approach, requiring that the same rights be preserved in any derivative works – a principle best exemplified by the GPL. In practical terms, this meant that anyone who improved GPL-licensed code had to make those improvements available under the same terms. The license became the legal backbone of the free software movement, and later the open source movement, ensuring that shared code remained a commons rather than raw material for private enclosure.

Linus Torvalds and the Linux kernel: the missing piece 🔗

The GNU Project had built a rich collection of tools and utilities, but without a functioning kernel – the core component that manages hardware resources – it could not yet deliver a complete operating system. That missing piece arrived in 1991 from an unexpected source.

From April through August 1991, Linus Torvalds, a 21-year-old student at the University of Helsinki in Finland, wrote the Linux kernel. He was not trying to change the world. He was frustrated that MINIX, a teaching-oriented Unix clone, was too restricted for practical use, and he wanted an operating system that could take advantage of his new Intel 386 PC. On August 25, 1991, Torvalds posted a message to the Usenet newsgroup comp.os.minix describing a free operating system he was building as a hobby project for 386 and 486 clones.

The post was modest to the point of being self-deprecating, but it was an invitation to collaborate. Developers across the network responded – filing bug reports, contributing device drivers, and testing the code. Version 0.01 of the Linux kernel was released publicly on September 17, 1991, and in 1992 it was relicensed under the GNU GPL. That licensing decision was pivotal. Together with the utilities from the GNU Project, a new operating system was born – known as GNU/Linux. For the first time, it was possible to run a personal computer entirely on free software.

By 1993, over 100 developers were working on the Linux kernel, adapting it to the GNU environment and expanding its application types. Within three years of a student’s hobby post on a public newsgroup, a global community had assembled a production-grade operating system from scratch.

The internet and the power of community collaboration 🔗

The Linux story would not have been possible without the infrastructure that enabled it. Throughout the 1980s and into the 1990s, platforms like USENET and the early internet gave technically-minded people across the world a way to coordinate on shared projects without ever meeting in person.

Usenet, created in 1979, served as a precursor to modern social networks and forums – a place for text-based discussion, file sharing, and collaborative work, particularly among scientists, scholars, and tech enthusiasts. It was on Usenet that Torvalds first announced Linux, solicited feedback, and built an initial community of contributors. As one of the first operating systems that relied on the online community to support it, Linux was improved upon by the USENET community, a practice that continues alongside other online communities today.

The role of these platforms cannot be overstated. Before GitHub, before Slack, before any of the modern tools developers take for granted, USENET newsgroups were where ideas were debated, patches were shared, and software projects were steered by collective input. The internet didn’t just accelerate open source development – it made a globally distributed, community-driven development model structurally possible for the first time.

It is also worth noting that the term “open source” itself did not yet exist during most of this history. The term was coined in 1998 when figures like Eric S. Raymond, Linus Torvalds, and others sought to rebrand the free software movement in a way that was more appealing to commercial partners, separating the practical benefits of shared code from the more political connotations of Stallman’s “free software” framing. But the foundations of the movement – the collaborative ethic, the copyleft licensing, the Linux kernel – had all been laid in the decades before the name existed.

A legacy that runs the modern world 🔗

From the shared mainframes of the 1960s to Stallman’s principled stand in 1983 to Torvalds’ Usenet post in 1991, the open source movement is the product of a consistent, recurring idea: that software is most powerful when it is held in common. Today, Linux powers the vast majority of web servers, smartphones (through Android), and cloud infrastructure. The GNU tools that Stallman built are embedded in every corner of modern computing. The GPL license he wrote has shaped the legal landscape of the entire software industry.

The history of open source is not just a technical history. It is a history of values – a sustained argument that access to the tools of knowledge creation should not be gated behind proprietary walls. That argument, first made by programmers sharing code on mainframe terminals in the 1960s and sharpened by Stallman’s philosophy and Torvalds’ kernel, continues to shape how the digital world is built.

What do you think? If proprietary software had continued to dominate without the GNU Project or Linux, how different might today’s internet look? And as artificial intelligence systems are increasingly built on open-source foundations, do you think the values of the open source movement are strong enough to shape how AI develops?

References

1. https://www.computerhistory.org/revolution/mainframe-computers/7/172
2. https://ibmlicensingexperts.com/history-of-ibm-licensing/
3. https://en.wikipedia.org/wiki/History_of_free_and_open-source_software
4. https://en.wikipedia.org/wiki/GNU_Project
5. https://www.fsf.org/news/forty-years-of-gnu-and-the-free-software-movement
6. https://www.britannica.com/topic/Free-Software-Foundation
7. https://www.gnu.org/home.en.html
8. https://historyofinformation.com/detail.php?entryid=2000
9. https://www.learnlinux.ie/content/linus-torvalds-original-announcement-usenet
10. https://en.wikipedia.org/wiki/History_of_Linux
11. https://www.newsdemon.com/linus-usenet-birth
12. https://www.newsdemon.com/blog/linux-celebrates-usenet-announcement
13. https://www.btw.so/blog/history-of-open-source-software/