The rise of open source, from outsider to default

Field note. Most of the stack you operate is open source: the OS, the JVM, your panel, the server software, the modloader. Why that happened and what it cost is worth understanding.

In 1995, "open source" wasn't a phrase. The closest equivalent was "free software," and most corporate developers regarded it as a hobbyist activity. Mainstream software was proprietary, closed-source, commercial.

In 2026, almost every major piece of infrastructure software is open source. Almost every major company is a significant open-source contributor. Almost every new project that wants adoption uses an open-source license.

This transformation took 30 years. It wasn't predetermined. It happened through a sequence of specific events. This article tells the story.

The 1990s: outsider status

Open-source (or its predecessor, free software) in 1995 was real but small:

• GNU and Linux existed but weren't mainstream.
• BSD UNIX was used in some research and Internet infrastructure.
• Apache (1995) was emerging as a major web server.
• Perl (1987) was widely used for scripting.

Mainstream software was Microsoft, Oracle, SAP, Adobe, IBM. Closed-source, commercial, profitable.

The corporate position was clear: open-source was for projects with no commercial value. Real software was proprietary.

This view had champions. Bill Gates wrote an "Open Letter to Hobbyists" in 1976 arguing that sharing software was theft. Microsoft executives in the 1990s and 2000s called Linux "cancer" (Steve Ballmer, 2001) and a "communistic" model.

The Halloween Documents (1998)

In October 1998, internal Microsoft memos leaked. Known as the Halloween Documents, they showed Microsoft analyzing Linux as a credible threat.

The documents acknowledged:

• Linux's quality was high.
• Open-source development worked.
• Linux was growing rapidly in server markets.
• Microsoft needed strategies to compete.

This was significant because it showed that even Microsoft, the company most invested in proprietary software, took open-source seriously enough to study and strategize against it.

The leak energized the open-source community. It confirmed they were a real competitor.

"Open source" as a term (1998)

Earlier in 1998, a group including Eric Raymond, Bruce Perens, and others coined the term "open source" as an alternative to "free software." They felt "free" was confusing (free of charge?) and ideologically loaded.

"Open source" emphasized practical benefits:

• Better code through peer review.
• Faster development through collaboration.
• Lower cost.
• No vendor lock-in.

The argument was pragmatic, not ethical. This made it more palatable to business decision-makers.

The Open Source Initiative was founded to formalize the term. The OSI's definition closely tracks the Free Software Foundation's, but the framing differs.

The two terms coexist in 2026 with mostly the same code and slightly different communities.

Mozilla open-sources Netscape (1998)

Also in 1998, Netscape released the source code for Netscape Communicator (their browser) under a free license. This became the Mozilla project, eventually leading to Firefox.

Netscape's reasoning:

• Losing the browser war to Microsoft.
• Hoping the open-source community could help develop the browser.
• Reducing the strategic value of Microsoft's bundled IE.

The move was watched closely. A major proprietary commercial product being released as open-source was unprecedented.

It worked, eventually. Mozilla's reborn product, Firefox (2004), would take significant market share from Internet Explorer.

The lesson: big companies can open-source their products and get value from doing so. This lesson was learned slowly by others.

The 2000s: pragmatic adoption

Through the 2000s, open-source moved from outsider to "second option":

Linux on the server. Real adoption. Big banks, big websites, big enterprises ran Linux for cost and quality reasons.

LAMP stack. Linux + Apache + MySQL + PHP/Perl/Python became the default for new web applications.

Eclipse, Mozilla, OpenOffice. Major open-source desktop applications.

MySQL acquisition by Sun (2008), then Oracle (2010). A flagship open-source product owned by big corporations.

JBoss, MongoDB, others. Open-source companies built around supporting open-source software.

Corporate attitudes shifted. By 2010, most CTOs accepted that open-source was sometimes the right choice.

Microsoft's transformation

The most dramatic shift: Microsoft. From "Linux is cancer" to "We love Linux" in 15 years.

The transition:

• 2014: Satya Nadella becomes CEO. Open-source friendlier than predecessors.
• 2015: .NET goes open-source. Microsoft's flagship development platform.
• 2016: PowerShell goes open-source. Bash on Windows announced.
• 2018: Microsoft acquires GitHub for $7.5 billion.
• 2019-2020: Major contributions to Linux, Kubernetes, many other projects.
• 2023-2026: Microsoft is one of the largest open-source contributors in the world.

Microsoft's transformation is genuinely remarkable. The company most aligned against open-source in 2001 is now one of its largest patrons.

The reasoning is clear: cloud (Azure) sells Microsoft services regardless of OS choice. Owning the OS is less important than owning the cloud. So why not embrace Linux, where the developers are?

This pragmatic logic spread.

Google's open-source

Google has been a major open-source contributor since early. Examples:

• Android (open-source kernel and userland; the apps are partly closed).
• Chromium (Chrome's open-source base).
• TensorFlow (machine learning framework).
• Kubernetes (originally Google internal; open-sourced 2014).
• Go programming language.
• Numerous infrastructure tools.

Google's pattern: build internal infrastructure, open-source the parts that don't directly threaten Google's competitive position, attract developer mindshare.

Whether Google's motives are pure or strategic is beside the point. The result is significant open-source contributions.

Facebook / Meta's open-source

Facebook (now Meta) followed a similar pattern:

• React (front-end framework).
• PyTorch (machine learning framework).
• GraphQL (API query language).
• MyRocks (database engine).
• Cassandra (NoSQL database, originally Facebook, now Apache).

Meta has invested heavily in open-source AI tools, partly to compete with closed-source AI from OpenAI and others.

The startup playbook

By the 2010s, many startups were essentially "build a product around open-source, sell support / hosted versions / enterprise features":

• Elastic (Elasticsearch).
• MongoDB.
• GitLab.
• HashiCorp (Terraform, Vault, etc.).
• Confluent (Apache Kafka).
• Snowflake (using lots of open-source under the hood).
• Databricks.

The business model: give away the core software, sell value-adds (support, hosting, enterprise features, integrations).

This model works for some products. The economics depend on enough customers paying for non-core features to fund continued development.

License drama

As open-source became commercially valuable, license disputes grew:

The "cloud competition" problem. AWS, Azure, GCP have offered managed versions of popular open-source software (MongoDB, Elasticsearch, Redis). The original developers worry their revenue is being siphoned off without compensation.

Some companies have responded by changing licenses:

• MongoDB (2018): switched to SSPL (Server Side Public License), incompatible with most "open source" definitions.
• Elastic (2021): switched to similar non-permissive license.
• Redis (2024): switched to dual licensing with restrictions.
• HashiCorp (2023): switched Terraform to BUSL, prompting an OpenTofu fork.

These changes are controversial. Some see them as betrayals of open-source principles. Others see them as necessary business adaptations. The community usually forks the last permissive version.

The pattern: established open-source projects with commercial backing often face license-vs-revenue tensions. Resolutions are case-by-case.

What open source enabled

Beyond specific products, open-source enabled:

The cloud era. Almost every cloud infrastructure component is open-source (Linux, Kubernetes, etcd, Prometheus, Grafana, Terraform, many more).

Modern development tooling. Git (covered in a later article), Docker, modern CI/CD, all open-source.

Modern programming language ecosystems. Most modern languages are open-source. Their package ecosystems (npm, PyPI, crates.io, etc.) are open-source.

Internet infrastructure. BIND (DNS), Apache and nginx (web), Let's Encrypt (certificates), etc. All open-source.

AI and machine learning. Most major ML frameworks (PyTorch, TensorFlow, JAX, Hugging Face Transformers) are open-source.

If you build software in 2026, you build on open-source. The proprietary alternative is rare.

The unsung maintainer problem

A persistent issue: many critical open-source libraries are maintained by one or two people, often unpaid. Burnout is real. Security incidents from underfunded libraries (Heartbleed in OpenSSL, log4shell in log4j, xz utils in 2024) have repeatedly shown the fragility.

Various efforts to address this:

• The Open Source Security Foundation (OpenSSF). Industry-funded effort to improve open-source security.
• Better corporate sponsorship. Some projects have funded paid maintainers.
• Foundations. Apache, Linux, CNCF, etc. provide neutral homes for projects with funding from corporate members.
• GitHub Sponsors, etc. Individual sponsorship models.

The problem isn't solved. The pattern of "the world depends on this library, the library depends on one person" persists across many critical pieces of infrastructure.

What "open source" means in 2026

A few different things:

The license. Software released under an OSI-approved license. Clear and important.

The development model. Public repositories, open contribution, public discussions. Many companies "open source" their code without operating in this open way; the result is partially open.

The community. Active contributors, users, governance. Some open-source projects have thriving communities; some are essentially single-vendor.

The ethics. Commitment to user freedom. Aligned with the FSF view. Less universal in the broader open-source community.

These can come together or not. A project can have an open-source license but no community, or an active community on a non-open license. Each project has its own combination.

Conclusion

Open source went from outsider to default in three decades. The shift wasn't planned by anyone; it emerged from many decisions by many actors. By 2026:

• The dominant operating system (Linux) is open-source.
• The dominant database stack (PostgreSQL, MySQL/MariaDB, SQLite, MongoDB) is mostly open-source.
• The dominant web server (nginx) is open-source.
• The dominant container platform (Kubernetes + Docker) is open-source.
• The dominant programming languages (Python, JavaScript, Java, C, C++) have open-source primary implementations.
• The dominant AI tools (PyTorch, TensorFlow) are open-source.

The proprietary software industry still exists, but most of it now builds on top of open-source infrastructure.

Whether this is good or bad depends on your perspective. The economic effect is enormous: hundreds of billions of dollars of software value provided at zero or low cost. The cultural effect: a generation of developers who expect to read code and contribute fixes.

For anyone working in software in 2026, open-source is the substrate. Understanding its history is understanding the foundation you build on.

Coming up

Next: containers and Docker. The 2013 transformation of how software gets packaged and deployed.