The computing landscape of the 1990s set up one of the more interesting fights in tech history: a dominant proprietary software model against a scrappy alternative built by volunteers giving their code away for free. That fight is where Linux and the open-source movement come from, and it’s worth understanding both how they won and what it actually cost to get there.
History#
Phase 1: The rise of Microsoft and proprietary software#
In the early 1990s, Microsoft was already a dominant force in computing. MS-DOS had been the de facto PC standard for years, and the 1990 release of Windows 3.0 cemented Microsoft’s position as the leading provider of PC operating systems.
Microsoft’s proprietary model, keeping source code secret and tightly controlling development and distribution, was central to that success. It cut both ways: Microsoft could hold products to a consistent quality bar, but users had no real control over their own computing environment and depended entirely on Microsoft for updates and fixes. Third-party developers building on top of Microsoft’s products had to work from documentation and published APIs rather than the actual source, which produced its own steady stream of compatibility problems.
None of that slowed Microsoft down through the early 1990s. Office, bundling Word, Excel, and PowerPoint, became the standard productivity suite for businesses and consumers alike, and Windows was the default choice for PC buyers.
But even as Microsoft’s dominance looked unshakeable, the pieces of an alternative were already coming together. The internet was making it dramatically easier for developers to find each other and collaborate regardless of location, and the cost and complexity of proprietary software was becoming a real barrier for individual developers and small companies trying to compete with Microsoft at all. Open-source software offered a different path: build collaboratively, give the result away, and let quality come from many eyes on the code instead of one company’s QA process.
That shift would eventually put Linux and open-source software at the center of the industry. Getting there took the rest of the decade.
Phase 2: The birth of Linux and the GNU Project#
Linux’s roots go back further than Linux itself. The GNU Project, started by Richard Stallman in the mid-1980s, was built on the idea that software should be free and accessible, a direct reaction to a computing world Stallman saw as increasingly closed off from its own users.
GNU produced the foundational pieces of the open-source ecosystem, including the GNU Compiler Collection (GCC) and the GNU General Public License (GPL), both of which Linux would later depend on directly. GNU was also trying to build its own complete, free operating system: GNU Hurd, intended as a free replacement for proprietary Unix, built around a microkernel architecture where OS components stayed more loosely coupled than in a traditional design. That flexibility came at a cost. Hurd’s development dragged for years, and the project struggled to bring its finished pieces together into something that actually worked as a whole.
Linus Torvalds started Linux separately, initially just as a kernel, committed to the same open-source principles as GNU but without GNU’s ambition of building every layer of the OS himself. It was left to other developers to build the libraries, utilities, and applications around it, and GNU’s own tooling turned out to be exactly what filled that gap: GNU userland plus the Linux kernel became, in practice, the working free operating system Hurd had been trying and struggling to build.
Both projects drew directly on Unix, developed at Bell Labs in the 1970s and widely adopted at universities and research institutions despite being proprietary and expensive. By building a free alternative, Linux and GNU opened Unix-like computing to anyone with a machine and an internet connection, not just institutions that could afford a Unix license.
Torvalds also had a more specific inspiration close at hand: Minix, a small Unix-like operating system Andrew S. Tanenbaum built for teaching purposes, which Torvalds used as his development environment before Linux existed and which shaped his early thinking about kernel design. His initial choice of name for the project was “Freax” (free plus freak plus Unix), and he stored it under that name on the FTP server he used to share it. Ari Lemmke, the server’s administrator, didn’t like “Freax” and unilaterally renamed the upload directory to “Linux” without checking with Torvalds first. Torvalds, who’d considered “Linux” a bit self-aggrandizing to pick for himself, went along with it once it was already done.
Eric S. Raymond’s 1997 essay “The Cathedral and the Bazaar” gave the movement its defining metaphor: open, decentralized, “bazaar”-style development against tightly controlled, “cathedral”-style corporate development, with Raymond arguing the bazaar model produced faster iteration and better software by putting more eyes on the same code.
Licensing mattered as much as philosophy here. The GPL was the most influential open-source license, but not the only one; the BSD and MIT licenses took a more permissive approach, allowing proprietary software to be built on top of open-source code, a real point of tension within the community at the time. Whatever the license, the practical effect was the same: developers could share code freely while keeping enough structure around its use and distribution to sustain a project.
By the end of the 1990s, Linux’s flexibility, freely available and modifiable source, had made it viable everywhere from web servers to supercomputers, and it hasn’t stopped since.
Phase 3: The emergence of open-source software#
By the mid-1990s, Linux and GNU had company. The free BSDs, built on Unix code the University of California, Berkeley had released into the public domain, offered a similar open-source approach with a longer pedigree and a different development model. Alongside Linux and the BSDs, projects like Apache, Perl, and Python rounded out a broader open-source ecosystem built on the same commitment to collaboration and community development.
The LAMP stack, Linux, Apache, MySQL, and PHP, became the era’s defining proof of concept: a genuinely powerful, flexible platform for web development built entirely from open-source components. It did more than any single argument to establish Linux and its peers as serious contenders rather than a hobbyist curiosity.
Apache’s own origin is a good example of what “open source” actually looked like in practice. It wasn’t built to replace a closed-source competitor; NCSA’s HTTPd web server, which Apache grew out of, had its source publicly available. NCSA’s development just stalled after lead developer Rob McCool left the project in 1994. Brian Behlendorf and others started collecting the backlog of unofficial patches users had been applying to keep NCSA HTTPd working, and organized development around that patchwork (hence “a patchy server”) starting in 1995. Apache wasn’t a rebellion against a closed system; it was a community picking up a project a company had simply stopped maintaining.
Not everyone was convinced open source could compete. Skeptics called it chaotic and unreliable next to commercially developed software, and Microsoft, unsurprisingly, treated it as an existential threat. Microsoft CEO Steve Ballmer’s line that Linux was “a cancer that attaches itself in an intellectual property sense to everything it touches,” given in a June 2001 Chicago Sun-Times interview, is still the quote everyone remembers from that period.
Netscape’s 1998 decision to release Navigator’s source code was a genuine turning point: it demonstrated that even an established commercial company could benefit from opening its code to outside contributors, and it directly gave rise to the Mozilla project. Microsoft eventually started experimenting with open licensing and community collaboration of its own, though much of the open-source community treated those early efforts skeptically, reading them as an attempt to defuse a competitive threat rather than a genuine change of philosophy.
Early distributors like Slackware and Walnut Creek did the unglamorous but essential work of packaging Linux and its surrounding software into something a non-expert could actually install and use, which did as much to grow the user and developer base as any of the underlying technology.
Phase 4: The mainstreaming of open-source software#
As the decade closed, open-source had gone from credible alternative to genuine industry force. A new ecosystem of Linux-centric businesses emerged, Red Hat chief among them, built on providing the enterprise-grade support that let companies actually trust Linux with production infrastructure. IBM and HP followed, offering Linux-based solutions alongside their traditional Unix lines once the enterprise appetite was clearly there.
That embrace wasn’t without friction. In 2003, the SCO Group sued IBM, claiming IBM had illegally folded SCO’s proprietary Unix code into Linux. The suit dragged on for years and effectively stalled once SCO filed for Chapter 11 bankruptcy in September 2007; the case was later converted to Chapter 7 liquidation in 2012. SCO never proved its core claims, but the lawsuit spent years functioning as a real legal cloud over enterprise Linux adoption regardless of its eventual outcome.
Microsoft’s public stance kept shifting through the 2000s, from open hostility toward outright collaboration and open-licensed code releases, as Linux started making real inroads on the desktop, an arena Windows had owned outright. Projects like GNOME and KDE gave Linux desktop environments that didn’t require a command line to use, and hardware vendors including Dell and HP started shipping Linux-preloaded machines, which mattered as much as the software itself for mainstream adoption.
Development tooling kept pace with the ecosystem’s growth. Subversion (2000) and Git (2005) transformed how open-source projects tracked and merged changes; GitHub, launched in 2008, then built a social and collaborative layer on top of that, turning version control into something closer to a public commons where anyone could fork, contribute, and be credited. The Apache Software Foundation, formalized in 1999, extended well past the original web server to steward projects like Hadoop, Cassandra, and Tomcat, becoming one of the open-source world’s most important institutional homes.
Cloud computing gave open source its next major expansion. Virtualization, containerization, and software-defined networking, the technologies actually running the cloud, are built on open-source foundations, and once providers like AWS and Microsoft Azure started offering open-source-based services directly, the question of whether open source belonged in serious enterprise infrastructure was settled.
More recently, open source has become foundational to AI development: TensorFlow, PyTorch, and Keras are now standard tools across both industry and academic research. And the development model itself has kept evolving, shifting from single maintainers toward large, distributed contributor communities that make projects more resilient and more responsive to their actual users, alongside a growing, explicit focus on diversity and inclusion within many major projects.
Cybersecurity#
Open-source software’s impact on security cuts in a few directions at once.
Because the code is public, security researchers can actually audit it, which tends to surface and fix vulnerabilities faster than a closed-source equivalent where outside scrutiny simply isn’t possible. Because most open-source projects are maintained by a community rather than a single company with a reputation to protect, there’s less institutional incentive to quietly sit on a known flaw; disclosure tends to happen faster and more transparently. And because the code is modifiable, organizations can adapt a project’s security posture to their own specific compliance requirements instead of waiting for a vendor to add a feature.
None of that makes open-source software immune to vulnerabilities; it’s still software, and software has bugs. What the open, collaborative model actually buys you is a better chance of catching and fixing those bugs quickly, not a guarantee against having them in the first place. Heartbleed, the 2014 OpenSSL vulnerability that quietly undermined TLS across a huge share of the internet, is the case that made this concrete for the whole industry: even foundational, universally relied-upon open-source infrastructure can carry serious flaws for years if it isn’t getting the maintenance attention its importance would suggest. Heartbleed specifically pointed at a structural problem, a small number of volunteer maintainers responsible for security-critical code the entire internet depended on, that the industry is still working through today via efforts like the Open Source Security Foundation and corporate-funded maintainer programs.
Trivia#
Ten facts about the rise of Linux and open-source software:
- Linux almost wasn’t called Linux. Torvalds’s own working name was “Freax” (free plus freak plus Unix); Ari Lemmke, who ran the FTP server Torvalds used to share the code, disliked that name and unilaterally renamed the upload directory to “Linux” without asking first. Torvalds, who’d thought “Linux” too self-aggrandizing to pick himself, simply went along with it.
- Linux 0.01 (1991) was 10,239 lines of code. By 2023 the kernel had grown well past 30 million lines, and it crossed 40 million by early 2025.
- Apache didn’t set out to replace a closed-source competitor. NCSA’s HTTPd web server had public source; development just stalled after its lead developer left NCSA in 1994. Apache started as a community effort collecting the backlog of unofficial patches keeping NCSA HTTPd alive, hence the “patchy server” origin of the name.
- In 1998, Netscape released the source code for Netscape Navigator, one of the first major commercial software products to go open-source, and directly gave rise to the Mozilla project.
- Slackware (1993), the oldest Linux distribution still actively maintained today, wasn’t actually the first. It started as Patrick Volkerding’s cleaned-up fork of the earlier Softlanding Linux System (SLS), itself released in 1992.
- Red Hat, founded in 1993, became one of the first companies to build a real business around commercial support for Linux, a model that helped make Linux a credible option for enterprise IT.
- IBM announced a $1 billion investment in Linux development in December 2000, a serious signal that mainstream enterprise IT was betting on open source for the long term.
- The Free Software Foundation, founded by Richard Stallman in 1985, remains an active force in the open-source and free software world today.
- In 2003, the city of Munich, Germany announced it would migrate roughly 14,000 government desktop computers from Windows to Linux, the LiMux project, one of the most prominent public-sector open-source migrations of its era.
- Today, Linux runs everything from web servers and supercomputers to smartphones and smart appliances, a reach that would have been hard to imagine from its ten-thousand-line 1991 starting point.
Conclusion#
The emergence of Linux and the broader open-source movement changed the basic economics of who gets to build software and how. From GNU’s founding philosophy through Linux’s kernel-first pragmatism to the LAMP stack proving open source could run real infrastructure, the throughline is the same: collaboration and transparency, at scale, turned out to compete directly with proprietary control, and often won.
That fight isn’t finished. Cloud computing, AI development, and security all now run substantially on open-source foundations, which is exactly why Heartbleed-style maintenance gaps matter as much as they do. The tools that carry that load, GCC, the Linux kernel, OpenSSL, and thousands of smaller projects most people have never heard of, are still built and maintained largely by volunteers, and keeping that sustainable is as much a part of open source’s future as any new project someone starts tomorrow.
