The Evolutionary Tale of Open Source: A Historical Perspective

Every time you use Android, browse a website powered by Linux servers, or work with tools like Python or WordPress, you are benefiting from a tradition that goes back decades – one where programmers freely shared code, improved each other’s work, and built technology as a community. This tradition did not begin with a hashtag or a Silicon Valley startup. It grew quietly from the earliest days of computing, and its most decisive turning point came in 1983, when a programmer at MIT decided that software freedom was worth fighting for.

When software came free with the hardware 🔗

To understand the history of open source, you have to go back to an era when the very concept of “buying software” did not exist. In the 1950s and 1960s, software and compilers were delivered as part of hardware purchases without separate fees. When a university or government agency bought a computer, everything it needed – including source code – came bundled with the machine. The first example of what we would now call free and open source software is believed to have been the A-2 system, developed at the UNIVAC division of Remington Rand in 1953, where customers were invited to send source code improvements back to the vendor. Later, almost all IBM mainframe software was distributed with source code as a matter of course.

This era had a deeply communal character. Programmers at universities and research labs shared code freely, fixed each other’s bugs, and published their modifications without any legal friction. Software had no licenses attached and was shared as public domain software, typically with source code, largely because software was not even considered copyrightable until the 1974 US Commission on New Technological Uses of Copyrighted Works (CONTU) issued its landmark determination. In this environment, the focus of innovation was hardware – the machines themselves. Software was simply an afterthought, an operational tool that made hardware run.

The communal spirit of early computing 🔗

Nowhere was this collaborative culture more visible than at institutions like MIT and Bell Labs. When Ken Thompson and Dennis Ritchie began developing Unix at Bell Labs in 1969, their goal was explicitly social as much as technical. As Ritchie later described it, what they wanted to preserve was not just a good environment for programming, but a system around which a fellowship could form. Unix was designed to encourage close communication and sharing among its users – a philosophy baked into the architecture of the system itself.

This spirit extended to how Unix was distributed. In the early 1970s, AT&T distributed early versions of Unix at no cost to government and academic researchers. Universities across the United States and later the world received Unix source code, studied it, modified it, and shared their changes with others. The University of California, Berkeley, for example, developed its own widely used variant known as BSD (Berkeley Software Distribution). These early research communities operated with an implicit understanding that knowledge – including software – should circulate freely.

The shift: software becomes a product 🔗

This open culture began to fracture in the late 1960s and through the 1970s as the commercial potential of software became clear. The most symbolic moment came in 1969, when IBM separated software from hardware – a decision known as “unbundling” – meaning software now had to be purchased separately. That decision marked the birth of the proprietary software industry. By the mid-1970s, software licensing became the norm. In 1976, Bill Gates wrote his now-famous open letter criticising hobbyists for sharing Microsoft’s Altair BASIC without payment, signalling the direction the industry was heading.

At the same time, AT&T tightened its grip on Unix. After the system became more widespread in academic circles, AT&T stopped its free distribution and charged for system patches. The source code that had flowed freely through university corridors was now locked behind commercial licenses. A general industry trend took hold: companies stopped distributing source code and only released compiled, machine-readable executables. For the first time, programmers found themselves working with software they could not read, study, or fix.

The GNU Project: a direct response to lost freedom 🔗

For Richard Stallman, a programmer at MIT’s Artificial Intelligence Lab, this shift was not merely inconvenient – it was ethically unacceptable. His frustration crystallised around a specific incident. In 1980, the MIT AI Lab received a donation of a brand-new laser printer. When Stallman asked for the source code for the printer driver – so he could implement a feature that would notify users when the printer jammed, as they had done with an older machine – he was told that this was proprietary information. The printer jammed regularly. Users had no way to know, and Stallman had no way to fix it. He was blocked from solving a simple problem because a corporation had locked away the code.

This experience, combined with broader changes at MIT and in the industry, convinced Stallman that non-free software was not just a practical problem but a social one. On September 27, 1983, he announced the GNU Project on several ARPANET mailing lists and Usenet groups. The goal was to build a complete, Unix-compatible operating system made entirely of free software – software that users could run, study, modify, and redistribute without restriction. He named it GNU, a recursive acronym standing for “GNU’s Not Unix,” chosen in the tradition of hacker wordplay.

What “free” actually meant 🔗

Stallman was careful to distinguish between two meanings of the word “free.” He was not talking about price – he was talking about freedom. The free software movement he launched emphasised four essential freedoms: to run the program for any purpose, to study and modify it, to redistribute copies, and to distribute modified versions. These four freedoms became the philosophical backbone of the entire open source movement that followed. Without access to source code, none of these freedoms were possible – which is why source code availability became a non-negotiable requirement.

In January 1984, Stallman quit his job at MIT to work on the GNU Project full time. Early in 1985, he published the GNU Manifesto, a call to arms for programmers to join the effort, and launched the Free Software Foundation (FSF) to support the work financially and organisationally. To legally protect the freedoms he was championing, he invented a concept called copyleft – a clever inversion of copyright. The first version of the GNU General Public License (GPL) was released in 1989, and it required that anyone who modified and distributed GPL-covered software must make the modified source code available under the same terms. This “share alike” condition was designed to prevent free software from being absorbed into proprietary products.

The missing kernel and Linux 🔗

By the late 1980s, the GNU Project had produced a remarkable collection of tools – a compiler (GCC), a text editor (GNU Emacs), a debugger, and numerous Unix utilities. But one critical component was missing: the kernel, the core of an operating system that manages hardware and software resources. The GNU kernel project, called GNU Hurd, faced repeated delays. In 1991, a Finnish student named Linus Torvalds used the GNU development tools to produce a free monolithic Linux kernel. Combined with the existing GNU components, this created the complete, free operating system that Stallman had envisioned – known today as GNU/Linux. The arrival of Linux, and the internet that was rapidly expanding around it, gave the free software movement its most powerful platform yet.

From “free software” to “open source”: a strategic rebrand 🔗

By the late 1990s, a new tension had emerged. The ideological language of the free software movement – with its emphasis on ethics, freedom, and opposition to proprietary software – was difficult to sell to corporate boardrooms. When Netscape announced in January 1998 that it would release the source code for its Navigator browser, a group of developers and advocates gathered in Palo Alto to strategise about how to make free software more palatable to business. The term “open source software” was coined by Christine Peterson at that meeting as a way to focus on the practical reality – access to source code – rather than the politically charged word “free.”

The term gained momentum quickly. In February 1998, Bruce Perens and Eric S. Raymond founded the Open Source Initiative (OSI) to formally promote and define open source software. The OSI created the Open Source Definition, a set of criteria that a software license must meet to qualify as open source, covering requirements like free redistribution, availability of source code, and permission to create derived works. At an April 1998 summit organised by Tim O’Reilly – originally called the “Freeware Summit” and later renamed the “Open Source Summit” – the new label was formally endorsed by leading developers including Linus Torvalds. Open source was now a movement with a name, a definition, and institutional backing.

The significance for intellectual property law 🔗

This history is not merely a story about software development methods – it is fundamentally a story about intellectual property. Copyleft, the licensing innovation at the heart of the GNU GPL, inverted the traditional logic of copyright: instead of using copyright to restrict use, it used copyright to mandate openness. The GPL, BSD licenses, and later the Creative Commons framework all emerged from the tension between proprietary control and community-based sharing that Stallman identified in 1983. For students of IP law, the open source movement represents one of the most consequential experiments in how legal instruments can be engineered to produce social outcomes – preserving access and freedom rather than restricting them.

India, home to one of the world’s largest developer communities, has a direct stake in this history. The government’s own Policy on Adoption of Open Source Software encourages the use of open source in public institutions, recognising the same values of accessibility and freedom that Stallman articulated four decades ago. Understanding where open source came from – the communal computing labs of the 1950s, the Unix culture of Bell Labs, the defiant GNU announcement of 1983 – is essential for understanding both the technology and the law that governs it today.

What do you think? If the early computing community had continued sharing software freely without any legal or commercial pressure, would the open source movement as we know it – with its formal licenses and institutions – have ever needed to exist? And given that open source licenses like the GPL themselves rely on copyright law to function, does this mean that intellectual property restrictions and software freedom are fundamentally opposed, or can they coexist?

References

1. https://www.crystallabs.io/unix-history/
2. https://en.wikipedia.org/wiki/History_of_free_and_open-source_software
3. https://computerhistory.org/blog/the-earliest-unix-code-an-anniversary-source-code-release/
4. https://medium.com/@itstatyana/the-history-of-open-source-a88c67b64d99
5. https://opensource.com/article/18/2/pivotal-moments-history-open-source
6. https://en.wikipedia.org/wiki/GNU_Project
7. https://www.fsf.org/about/what-is-free-software
8. https://en.wikipedia.org/wiki/Richard_Stallman
9. https://opensource.com/article/18/2/coining-term-open-source-software
10. https://en.wikipedia.org/wiki/Open-source_software_movement
11. https://www.meity.gov.in/content/policy-adoption-open-source-software-government-india