Quick Answer
The software that runs the modern world is mostly open source, created by individuals or small teams solving their own problems. Linux started as a hobby project by a Finnish student. Git was built in two weeks out of frustration. Python emerged from a Christmas break coding project. These projects succeeded because they solved real problems, attracted contributors, and built communities that outlasted any individual.

Operating systems

Linux (1991)

Created by: Linus Torvalds, a 21-year-old Finnish student

The story: Torvalds couldn’t afford a Unix workstation and was frustrated with Minix (an educational OS). He posted to a newsgroup: “I’m doing a (free) operating system (just a hobby, won’t be big and professional like gnu).” That “hobby” now runs most of the world’s servers, all Android phones, and much of the internet’s infrastructure.

Famous message (August 25, 1991):

Hello everybody out there using minix - I’m doing a (free) operating system (just a hobby, won’t be big and professional like gnu) for 386(486) AT clones.

Why it succeeded:

  • GPL license meant improvements had to be shared back
  • Internet enabled global collaboration (early example)
  • Good enough at the right time (PC hardware was taking off)
  • Torvalds’ pragmatic leadership and technical taste

Impact today: Linux runs 96%+ of top web servers, all top 500 supercomputers, Android (3+ billion devices), most cloud infrastructure, embedded systems everywhere.

Governance: Linus Torvalds remains “benevolent dictator” for kernel development. The Linux Foundation provides organizational support. Thousands of contributors, many employed by companies like Google, Microsoft, Red Hat, and Intel.

BSD and FreeBSD (1977/1993)

Created by: University of California, Berkeley researchers

The story: Berkeley Software Distribution started as extensions to AT&T Unix. Legal disputes with AT&T in the early 90s hampered adoption (Linux benefited from this timing). FreeBSD, NetBSD, and OpenBSD emerged from this lineage.

Impact today: FreeBSD forms the base of PlayStation OS, Netflix’s streaming infrastructure (partially), and macOS/iOS (Darwin kernel derived from BSD). WhatsApp famously ran on FreeBSD before the Meta acquisition.

Developer tools

Git (2005)

Created by: Linus Torvalds

The story: Linux kernel developers had been using BitKeeper, a proprietary version control system that was free for open-source use. When that arrangement ended in 2005, Torvalds wrote Git in about two weeks. His design goals: speed, distributed development, safeguards against corruption, and handling large projects.

Why it succeeded:

  • Distributed model fit open-source collaboration perfectly
  • Fast (Torvalds optimized aggressively)
  • Data integrity guarantees (cryptographic hashing)
  • GitHub (2008) made it accessible to everyone

Impact today: Git is the dominant version control system worldwide. GitHub has 100+ million developers. Nearly all software development uses Git.

Governance: Git development continues with multiple maintainers. Junio Hamano has been lead maintainer since 2005.

GCC (1987)

Created by: Richard Stallman and the GNU Project

The story: The GNU Compiler Collection was created as a free replacement for proprietary compilers. It was crucial to making Linux viable—you need a compiler to compile an operating system.

Impact today: GCC compiles code for most platforms. LLVM/Clang has emerged as a competitor, but GCC remains essential infrastructure.

LLVM/Clang (2003)

Created by: Chris Lattner at the University of Illinois

The story: LLVM started as a research project on compiler infrastructure. Apple hired Lattner and invested heavily. Clang (the C/C++/Objective-C compiler) emerged from this work.

Why it succeeded: Modular design, better error messages than GCC, Apple’s investment, permissive license (vs. GCC’s GPL).

Impact today: Powers Apple’s development tools, Rust compiler backend, and many other compilers.

Programming languages

Python (1991)

Created by: Guido van Rossum, a Dutch programmer

The story: Van Rossum started Python during Christmas break 1989, looking for a “hobby” programming project. He wanted a language that was readable, practical, and enjoyable to use. Named it after Monty Python’s Flying Circus.

Why it succeeded:

  • Readable, clean syntax (“executable pseudocode”)
  • “Batteries included” standard library
  • Easy to learn, powerful enough for professionals
  • Right place at right time for data science and AI boom

Impact today: Second most popular language on GitHub. Dominant in data science, machine learning, and AI. Used by Google, Instagram, Dropbox, NASA, and countless others.

Governance: Van Rossum was “Benevolent Dictator for Life” until 2018, when he stepped down. Python is now governed by a steering council elected by core developers. Python Software Foundation handles organizational matters.

JavaScript (1995)

Created by: Brendan Eich at Netscape, in 10 days

The story: Netscape needed a scripting language for web browsers, quickly. Eich created JavaScript in 10 days in May 1995. Despite the rushed timeline and some notorious quirks, it became the only language browsers understand natively.

Why it succeeded:

  • Only language that runs in browsers (no choice)
  • Node.js (2009) brought it to servers
  • NPM ecosystem grew explosively

Impact today: Most widely used programming language. Runs on every web browser, many servers, and increasingly on edge computing and IoT.

Governance: ECMAScript standards are managed by Ecma International (TC39 committee). Multiple implementations (browser engines) compete.

Rust (2010)

Created by: Graydon Hoare at Mozilla

The story: Hoare started Rust as a personal project in 2006. Mozilla sponsored development from 2009. Designed to be as fast as C/C++ while preventing memory safety bugs (buffer overflows, use-after-free, etc.).

Why it matters:

  • Memory safety without garbage collection
  • Catches bugs at compile time that crash C programs
  • Growing adoption in security-sensitive code (Android, Windows, Linux kernel modules)

Impact today: Used in Firefox, Discord, Cloudflare, Dropbox, and increasingly in Linux kernel development. Most loved language in Stack Overflow surveys for years running.

Governance: Rust Foundation (formed 2021) with corporate sponsors. Community-driven decision-making through RFCs.

Ruby (1995)

Created by: Yukihiro “Matz” Matsumoto in Japan

The story: Matz wanted a language that was more powerful than Perl and more object-oriented than Python. Ruby prioritizes developer happiness and elegant, natural-feeling syntax.

Why it succeeded: Ruby on Rails (2004) by David Heinemeier Hansson made web development dramatically faster. Twitter, GitHub, Shopify, and Airbnb started on Rails.

Impact today: Less dominant than its peak, but still powers major applications. Rails remains productive for web development.

Web and applications

React (2013)

Created by: Jordan Walke at Facebook (Meta)

The story: Facebook needed a way to build complex UIs that stayed consistent as data changed. Walke created React, introducing the virtual DOM and component-based architecture. Initially controversial (“why mix HTML and JavaScript?”), it became dominant.

Why it succeeded:

  • Solved real problems with complex UIs
  • Component model made code reusable
  • Facebook’s investment and adoption
  • Strong ecosystem (Redux, React Native, Next.js)

Impact today: Most popular frontend library. Powers Facebook, Instagram, Netflix, Airbnb, and countless other applications.

Governance: Meta controls React development but accepts community contributions.

Node.js (2009)

Created by: Ryan Dahl

The story: Dahl was frustrated with how web servers handled many simultaneous connections. He created Node.js using Chrome’s V8 JavaScript engine, enabling JavaScript on the server with an event-driven, non-blocking model.

Why it succeeded:

  • JavaScript everywhere (same language frontend and backend)
  • npm became the world’s largest package registry
  • Good for I/O-heavy, concurrent applications

Impact today: Powers many web services. npm has millions of packages. Changed how JavaScript developers think about full-stack development.

Governance: OpenJS Foundation (merged from Node.js Foundation and JS Foundation).

WordPress (2003)

Created by: Matt Mullenweg and Mike Little

The story: Started as a fork of b2/cafelog, a blogging tool. Mullenweg wanted to continue development after the original author went silent. WordPress grew from blogging software to a general-purpose CMS.

Impact today: Powers 40%+ of all websites. From personal blogs to major news sites. The most successful open-source CMS.

Governance: Automattic (Mullenweg’s company) heavily influences development while maintaining open-source nature. WordPress Foundation holds trademarks.

Infrastructure

Kubernetes (2014)

Created by: Joe Beda, Brendan Burns, and Craig McLuckie at Google

The story: Google had run containers internally using a system called Borg for a decade. Kubernetes was created as an open-source version of those ideas, designed to orchestrate containers across many machines.

Why it succeeded:

  • Google’s credibility in distributed systems
  • Donated to CNCF (neutral governance)
  • Solved real problems as containers took off
  • Strong ecosystem grew around it

Impact today: Standard for container orchestration. Most cloud providers offer managed Kubernetes. Critical infrastructure for modern applications.

Governance: Cloud Native Computing Foundation (CNCF), part of Linux Foundation. Large community with corporate contributors from Google, Red Hat, Microsoft, and others.

Docker (2013)

Created by: Solomon Hykes at dotCloud

The story: dotCloud was a PaaS company. They open-sourced their container technology, which made Linux containers accessible to developers. Docker didn’t invent containers, but it made them usable.

Why it succeeded:

  • Made containers easy (previously required deep Linux knowledge)
  • “Build once, run anywhere” actually worked
  • Docker Hub made sharing images simple
  • Right time: cloud and microservices were taking off

Impact today: Containers are standard. “Dockerfile” is a common noun. Docker Compose handles local development. Kubernetes handles production orchestration.

Governance: Docker Inc. controls Docker products. OCI (Open Container Initiative) standardizes container formats.

PostgreSQL (1996)

Created by: UC Berkeley research project (POSTGRES), then open-sourced community

The story: POSTGRES was an academic database research project in the 1980s. It was open-sourced in 1996 and renamed PostgreSQL. Decades of development have made it the most advanced open-source relational database.

Why it succeeded:

  • Technically excellent (features MySQL lacked for years)
  • Extensible (add custom types, functions, languages)
  • No corporate control (truly community-governed)
  • Standards compliant (SQL spec adherence)

Impact today: Default choice for many new applications. Powers Instagram, Spotify, Reddit, and many others. Supabase and Neon offer managed PostgreSQL.

Governance: PostgreSQL Global Development Group. No single company controls development.

Apache HTTP Server (1995)

Created by: Apache Group (community of developers)

The story: NCSA HTTPd was an early web server. When its primary developer left NCSA, a group continued maintaining it with patches—“a patchy server” became Apache (possibly apocryphal etymology). It became the dominant web server for years.

Impact today: Still widely used, though nginx has grown. Apache Software Foundation now hosts hundreds of projects beyond the web server.

nginx (2004)

Created by: Igor Sysoev

The story: Sysoev created nginx (pronounced “engine-x”) to solve the C10K problem—handling 10,000+ concurrent connections. Its event-driven architecture handled high concurrency better than Apache’s process-per-connection model.

Impact today: Powers many of the web’s busiest sites. Often used as a reverse proxy in front of application servers.

Governance: F5 Networks acquired Nginx Inc. in 2019. Still open source, but corporate-controlled.

Data and AI

TensorFlow (2015)

Created by: Google Brain team

The story: Google open-sourced their internal machine learning framework. It became the dominant deep learning framework until PyTorch caught up.

Impact today: Still widely used, especially in production. TensorFlow.js, TensorFlow Lite extend to browsers and mobile.

Governance: Google controls development.

PyTorch (2016)

Created by: Meta AI (Facebook)

The story: PyTorch emerged from Torch (Lua-based) and brought “define-by-run” dynamic computation graphs. Researchers preferred its Python-native feel over TensorFlow’s original graph-building approach.

Impact today: Dominant in AI research. Increasingly used in production. Powers much of the current AI boom.

Governance: PyTorch Foundation (under Linux Foundation) formed in 2022, with Meta, AMD, AWS, Google, Microsoft, and Nvidia as members.

Hugging Face Transformers (2018)

Created by: Hugging Face (startup)

The story: Started as a library to use transformer models easily. Grew into the central hub for AI models, datasets, and tools.

Impact today: Default place to find and share AI models. Hosts LLaMA, Stable Diffusion, and thousands of other models.

Common patterns in origin stories

Frustration drives creation

  • Linux: couldn’t afford Unix
  • Git: existing tools didn’t work for kernel development
  • nginx: Apache couldn’t handle the load
  • Docker: containers were too hard to use

Personal projects become infrastructure

  • Python: Christmas holiday project
  • Linux: “just a hobby”
  • Ruby: personal language experiment

Corporate backing helps scale

  • Kubernetes: Google’s experience and donation
  • React: Facebook’s investment
  • TensorFlow/PyTorch: Google and Meta resources

Timing matters

  • Linux benefited from BSD legal troubles
  • Docker arrived as cloud and microservices grew
  • Node.js hit when JavaScript developers wanted server-side options

Community determines longevity

  • Projects that built strong communities survived creator departure
  • Projects dependent on single companies face acquisition risk
  • Neutral foundations help projects outlast any single stakeholder

Further reading