The History of Open Source

First version 21 October 2026, last changed 23 October 2026 · Andreas Stockter

Open source denotes software whose source code lies open and which anyone may use, read, change and pass on, because its author has permitted that in a licence. The name has been in use since 1998; the thing itself is older than the software industry. Today it is in almost everything that computes: 97 per cent of the commercial programs examined in an analysis in 2025 contain open components,¹ seven out of ten smartphones run Android, whose kernel is Linux,² all of the 500 fastest computers in the world run Linux,³ and the servers of the Internet do so in their great majority. Whoever says open source means two things at once: a legal form, the licence, and a way of working in which strangers work together on a program over the net. Free software is the older name for the same thing with a different emphasis: the freedom of the user as a principle, not usefulness as an argument. This text uses both words where the people involved used them.

Like the history of AI, the history of software development and the history of the Internet, this text follows a chain: each era resolves a bottleneck the previous one left open, and creates the next one in doing so. First the closed source code was the bottleneck, then the lost common system, then the missing kernel, then recognition by business, then the scale of collaboration, then maintenance, money and trust, and lastly the question of what “open” means when states and machines use the code. The history of software development touches on open source in its fifth section; here the story is told in full. Every technical term is set in bold at the point where it is explained, and is only used after that. A glossary lists all terms alphabetically.

Contents: 1 Prehistory · 2 Unix and the hackers · 3 GNU and free software · 4 Linux and the bazaar · 5 Open source and the companies · 6 Git, GitHub, infrastructure · 7 Cloud, licences, supply chain · 8 Sovereignty and AI · Chain · Timeline · Further reading · Sources

1. Prehistory: software comes with the machine (1950s–1970s)

Source code and program. A program exists in two forms. The source code is the version that people write and read, in a programming language such as Fortran, C or Python. A compiler translates it into machine code, the sequence of instructions that the processor executes (the history of software development tells how both came about). Machine code can be executed, but hardly read and only changed with great effort; the names, comments and structure that make the source code understandable are lost in translation. Whoever receives a program only as machine code can use it, but cannot follow what it does, cannot fix a bug and cannot adapt it to their own purposes. Whether a program is open or closed is therefore decided by one question: does the user get the source code, and what may they do with it?

Programs as an extra. In the 1950s software was neither sold nor hidden. Computers were rented, not bought, and the manufacturer delivered the programs it had along with the machine, included in the price; the rest the customers wrote themselves. Every installation was different, and what one computing centre had written for its machine the next one had to adapt. Out of this grew an exchange: in August 1955 users of the IBM 701 in Los Angeles founded the association SHARE, which collected its members’ programs and distributed them on magnetic tape, source code included, because without it a program was useless anywhere else.⁴ For DEC’s computers DECUS followed in 1961. At the universities the rule of science applied anyway: what you have found, you publish. The journal of the ACM printed algorithms as source code in Algol from 1960 on, so that others could check and use them. Software was a by-product of the hardware and an object of exchange, not a business.

Unbundling. That changed with a decision by IBM. On 23 June 1969 the company announced that from 1 January 1970 it would charge for software and services separately from the hardware, partly under the pressure of an antitrust case that the government had opened in January 1969. This unbundling made software a commodity with its own price.⁵ A software industry already existed in outline, firms such as Applied Data Research had sold finished programs since 1965, but now it became a branch of its own with thousands of companies.⁶ With the price came secrecy. Whoever sells a program does not want the customer to copy and pass it on, and whoever can copy it does not pay. The manufacturers therefore delivered only the machine code, kept the source code back as a trade secret and did not sell the program but granted a licence: a permission to use it under conditions that the manufacturer sets.

Copyright. That a licence is needed at all is due to copyright, the right of the creator of a work to permit or forbid its reproduction. Whether programs are works in this sense was long unclear; the American Copyright Office accepted them for registration from 1964 as a precaution. A government commission recommended protection in 1978, Congress wrote it into law in 1980, and in 1983 an appeals court decided in the dispute between Apple and the clone maker Franklin that the machine code is protected too, not only the source code.⁷ In Germany the copyright act named programs explicitly from 1985, and a European directive of 1991 harmonised the protection.⁸ These decisions created the foundation for both sides: because the author decides about copies, they can forbid them, and they can permit them under conditions. Everything that was later called open source is copyright used for permission instead of prohibition.

The letter to the hobbyists. What the new attitude looked like was shown by a letter of February 1976. Bill Gates, 20 years old, had written a BASIC interpreter for the home computer Altair together with Paul Allen, and the members of the Homebrew Computer Club in California, the seedbed of the home computer, copied the paper tape among themselves. In his “Open Letter to Hobbyists” Gates calculated that most users had stolen the program and asked who would still write good software under these circumstances.⁹ The letter marks the transition: for the generation that came with the home computer, software was a commodity from the start, shrink-wrapped and without source code.

The bottleneck. At the end of this era the user of a program held something in their hands that they could not read. If it had a bug, they had to wait for the manufacturer; if it did not suit them, they could not change it; if the manufacturer abandoned it, it died with them. The closed source code was the bottleneck, and the first answer came from a system that had been created in a side room of the telephone company.

Try it yourself. Every smartphone contains open source, and the licences require the authors to be named. On Android: Settings → About phone (or System) → Legal information → Open-source licences; on the iPhone: Settings → General → Legal & Regulatory. The list is hundreds of screens long. The browser shows it too: in Firefox the address about:license opens the licences of all included components, in Chrome chrome://credits.

2. Unix and the hackers (1969–1983)

Unix. In 1969 Ken Thompson and Dennis Ritchie at Bell Laboratories, the research arm of the telephone monopoly AT&T, began to write an operating system on a discarded PDP-7 minicomputer, which they called Unix. It was small, consisted of tools that could be connected through data streams, and was rewritten in 1973 in the language C, designed for the purpose, so that it could be carried over to other computers with reasonable effort. In 1974 the two described it in a journal.¹⁰ What makes Unix important for this story is less the technology than the contract under which it was distributed. An antitrust settlement of 1956 obliged AT&T to confine itself to the telephone business and to license its patents; selling software was barred to the company.¹¹ So Bell Labs gave Unix to universities for a small fee, without support, without warranty, but with the complete source code. That is precisely what forced the users to understand and improve the system themselves.

The book by Lions. In 1976 John Lions at the University of New South Wales in Sydney wrote a commentary on the sixth edition of Unix for his students: the entire source code of the kernel, around 9,000 lines, with explanations line by line. The book was passed around the world in photocopies because AT&T forbade reprinting after a change of licence, and for twenty years it remained the most copied document in computer science, until it was allowed to appear again in 1996.¹² A generation of programmers learned from this text how an operating system is built. That was the culture Unix produced: the source code was textbook, tool and topic of conversation at once.

Berkeley. At the University of California in Berkeley, where Thompson had returned for a year in 1975, students began to extend Unix. Bill Joy put together the first Berkeley Software Distribution (BSD) in 1977, a tape of additions to AT&T’s Unix, among them the editor vi and a Pascal environment. From 1980 the research agency DARPA funded the work because it needed a common operating system for the ARPANET, and 4.2BSD of 1983 contained the first widespread implementation of the Internet protocols TCP/IP, with the interface of the sockets that every program that talks over the net uses to this day (the history of the Internet tells how the protocols came about).¹³ BSD became the Unix of the universities and research networks. Whoever wanted to use it still needed a licence from AT&T, though, because it contained their code.

The hackers. In parallel a culture of its own had grown at MIT whose members called themselves hackers: programmers who want to understand a system down to its last corner and measure their art by circumventing limits. The word meant mastery, not break-in; the second meaning came only in the 1980s through press and courts. In the Artificial Intelligence Laboratory there were no passwords, everyone was allowed to read and change every program, and the journalist Steven Levy summarised the unwritten rules in 1984 as the “hacker ethic”, whose core was that information should flow freely.¹⁴ Richard Stallman, at the lab since 1971, experienced in 1980 an event that he later described as a turning point: for the lab’s new laser printer, a gift from Xerox, he did not get the source code of the control software, because its author had signed a non-disclosure agreement. He could not improve the printer the way he had done with the old one, and nobody was allowed to help him.¹⁵

The turn. At the beginning of the 1980s the world in which source code was taken for granted broke in two places at once. At MIT members of the lab founded the companies Symbolics and LMI in 1980 to sell Lisp machines, hired away the best hackers and put the machines’ software under lock; within two years the community of the lab was scattered.¹⁵ At AT&T the fetter of 1956 came loose in 1982: the company consented to its break-up, which took effect on 1 January 1984, and in return was allowed to enter the computer business.¹⁶ Unix became a product. System III (1982) and System V (1983) cost commercial customers tens of thousands of dollars, the licence for the universities became stricter, and the seventh edition of 1979 had already forbidden using the source code in teaching; Lions’ book could no longer be reprinted. Manufacturers such as Sun, HP and IBM built their own variants from System V and BSD, which were incompatible with one another and whose source code they withheld; the “Unix wars” of the following years were a dispute over standards between closed products.

The bottleneck. The community had had a common system that everyone could read, learn from and help build, and it lost it. Unix belonged to AT&T, BSD hung on AT&T’s licence, and the tools on which the network of the universities ran were suddenly trade secrets. Whoever wanted to keep the old way of working had to write a whole system anew, from the ground up, without a line of foreign code, and had to secure it legally so that nobody could take the source code away again.

Try it yourself. The tools of Unix are on almost every computer today. On a Mac, under Linux or in the Android app Termux, uname -a shows the kernel, and under Linux cat /proc/version also shows which compiler it was built with. ls | wc -l connects two tools through a data stream, exactly as in 1973: the first cannot count, the second cannot list, together they count the files in the directory.

3. GNU and free software (1983–1991)

The announcement. On 27 September 1983 a message with the subject “new UNIX implementation” appeared in the newsgroup net.unix-wizards. Richard Stallman announced that from the following Thanksgiving he would write a complete operating system compatible with Unix and give it to everyone who could use it. He called it GNU, short for “GNU’s Not Unix”, and asked for computers, money and collaboration.¹⁷ In January 1984 he resigned from his post at MIT so that the institute could make no claims on the system, and began, alone, with an editor.

The manifesto and the four freedoms. In March 1985 Stallman explained his goal and his reasoning in the “GNU Manifesto”: sharing software was the golden rule among programmers, and whoever prevented a user from passing on or changing a program broke the solidarity of the community.¹⁸ He called his cause free software and had to explain from the start that “free” does not mean “at no cost”: free as in freedom, not as in free beer. The Free Software Foundation (FSF), which he founded in October 1985, later summarised the definition in four freedoms: a program is free if everyone may run it for any purpose, study and change its source code, pass on copies and publish changed versions. Access to the source code is not a freedom in itself but the precondition of the second and the fourth.¹⁹ This definition does not distinguish by price, purpose or person. Software you get for nothing but may not change is not free; software you buy at a high price and then own with all freedoms is.

The tools. An operating system consists of hundreds of programs, and Stallman began with those that every programmer needs daily. GNU Emacs, the editor, appeared in 1985, the debugger GDB in 1986, and in March 1987 the first version of GCC, the GNU C Compiler, which soon optimised better than the manufacturers’ compilers and ran on more computers than any other.²⁰ To these came make, the shell Bash (1989), the C library and the dozens of small tools that make up Unix. The quality of these programs was the argument that convinced industry long before it shared the reasoning: whoever needed a compiler for a new processor took GCC. Also in the mid-1980s the X Window System was created at MIT, the foundation of graphical interfaces on Unix, and with it a licence that today, as the MIT licence, is the most used in the world: a few sentences that permit everything as long as the copyright notice is preserved.²¹

Copyleft. Giving freedom was easy; keeping it was hard. Whoever released a program into the public domain had to watch companies take it, improve it and sell it as a closed product; exactly that happened to X, which every manufacturer built into its own unfree version. Stallman’s answer was a legal device he called copyleft: he kept the copyright and, resting on it, permitted everyone to copy, change and pass on the program, under a single condition: whoever passes it on, changed or not, must pass it on under the same conditions, with source code, and may add no restriction. The freedom is inherited, and copyright, which otherwise forbids copies, here enforces that they stay free. At first this stood in the licence of Emacs (1985), from February 1989 in one licence for all GNU programs, the GNU General Public License (GPL); version 2 of June 1991 is to this day the licence of the Linux kernel.²² For libraries that were also to be linked into unfree programs, the FSF created a weakened form in 1991, the Library (later Lesser) GPL.

Permissive or copyleft. Two families of licences now faced each other, and the dispute between them continues. The permissive licences of Berkeley and MIT permit everything, including incorporation into closed products; the BSD licence of 1990 required, besides the copyright notice, a mention in advertising, a clause that Berkeley struck out in 1999.²³ So the TCP/IP code from Berkeley found its way into almost every operating system, Windows included, without the manufacturers having to give anything back. The GPL demands the return and thereby rules out free software becoming unfree; in exchange it is avoided by companies that want to keep their changes. One side says that freedom also means the freedom to lock software up; the other, that a freedom which ends at the first passing on is none. Both families count as free in the FSF’s sense, and both are ubiquitous in today’s software world.

BSD in court. In Berkeley, meanwhile, people tried to free their own Unix from AT&T. In 1989 the Networking Release 1 appeared, the network code without a line from AT&T, in 1991 Net/2, for which volunteers had rewritten almost the whole system; only six files were missing. A company called Berkeley Software Design (BSDi) supplied them and from 1992 sold a complete Unix for PCs for 995 dollars. AT&T’s subsidiary Unix System Laboratories sued BSDi and the university for infringement of its copyrights and trade secrets. The case ended in January 1994 with a settlement under which three files were removed and some changed, and in June 1994 4.4BSD-Lite appeared as a free foundation, from which FreeBSD, NetBSD and, in 1995, OpenBSD emerged.²⁴ What counts for history is the time in between: for two years, 1992 and 1993, it was unclear whether BSD could be used at all, and in exactly these two years another kernel grew up.

Minix. Andrew Tanenbaum, a professor in Amsterdam, had written a small Unix-like system for his textbook on operating systems in 1987, Minix, whose 12,000 lines of source code were printed in the book because AT&T had forbidden teaching with the real Unix.²⁵ Minix ran on a PC, and students all over the world read it. But its licence did not permit free distribution of changed versions, and Tanenbaum wanted to keep it small as a teaching aid rather than let it grow as a tool.

The missing kernel. By 1990 GNU had almost everything: compiler, editor, shell, library, tools. What was missing was the kernel, the part of the system that manages processor, memory and devices and allocates them to the programs. The FSF had decided on a microkernel based on Mach, the GNU Hurd, whose development began in 1990 and dragged on for years.²⁶ Free software was a collection of tools without a foundation; whoever wanted to use it needed an unfree Unix underneath. The bottleneck was the kernel.

Try it yourself. The GNU tools announce themselves: bash --version or gcc --version show in the second line “Copyright (C) … Free Software Foundation, Inc.” and the licence, usually “GPLv3+”. Whoever wants to know what copyleft requires exactly reads section 3 of the GPL version 2 (gnu.org/licenses/gpl-2.0.html): in a few paragraphs it regulates how the source code is to be supplied when a program is passed on.

4. Linux and the bazaar (1991–1997)

A hobby from Helsinki. On 25 August 1991 a 21-year-old student at the University of Helsinki wrote to the newsgroup comp.os.minix that he was working on a free operating system, “just a hobby, won’t be big and professional like gnu”, for PCs with the 386 processor, and asked for wishes. Linus Torvalds had used Minix on his new computer and been annoyed by its limits; out of a program for switching between two tasks a kernel had grown. On 17 September he placed version 0.01 on a server of the university, on 5 October version 0.02, which ran with GCC and Bash: the tools of GNU finally had a kernel, just not the one planned.²⁷ The program was called Linux, a name the administrator of the server had chosen because Torvalds considered his own suggestion “Freax” vain. Its first licence forbade commercial use; in January 1992, with version 0.12, Torvalds put the system under the GPL, because others were sending him extensions and he did not want to demand anything they could not also do with his code.²⁸ With this decision Linux was bound to the tools it used and to their licence; the FSF therefore calls the system GNU/Linux.

The debate with Tanenbaum. On 29 January 1992 Tanenbaum wrote to the same newsgroup under the heading “LINUX is obsolete”: a monolithic kernel like Linux was a step backwards compared with microkernels, and a system that ran only on the 386 had no future. Torvalds replied the same day, sharply and with arguments.²⁹ The dispute became an object lesson, not because of its outcome but because of its form: a student publicly contradicted a professor, the whole world read along, and the decision was made not by authority but by the code that worked. Exactly so would the community around Linux settle its questions from now on.

The model. Linux was the first large program that came about over the Internet from the start. Whoever had a change sent it as a patch, a list of the changed lines, by email; Torvalds read, checked, accepted or rejected, and published new versions as soon as they ran, sometimes daily. Version 1.0 of March 1994 had 176,000 lines, version 2.0 of June 1996 ran on several processors and on architectures other than the PC and had 780,000 lines.³⁰ With the participants the roles grew: maintainers took over subareas such as a file system or a driver, collected the patches for them and passed them on in bundles, and the mailing list linux-kernel became the place where everything was discussed, openly and archived. There was no company, no plan and no contract, only the licence and the rule that the code counts.

Distributions. A kernel alone is not an operating system. That Linux became usable it owes to the distributions: compilations of kernel, GNU tools, X, applications and an installation program that someone has tested and put on media. The first appeared in 1992, in 1993 Slackware by Patrick Volkerding and Debian, which Ian Murdock announced in August and which persists to this day as a community project without a company.³¹ In Nuremberg the company S.u.S.E. had been founded in 1992, whose distribution appeared in 1994 as the first German one; in North Carolina Red Hat followed in November 1994. With the distributions came package management: every program is distributed as a package with information about which other packages it needs, and a tool installs, updates and removes it together with its dependencies, dpkg at Debian, RPM at Red Hat. In 1997 Debian laid down in a “social contract” that the distribution would consist entirely of free software and hide nothing, and defined in ten points which licences count as free; these Debian Free Software Guidelines became a year later the template for the definition of open source.³²

The net as a workshop. Linux was not alone. The Internet, which became public in the same years (the history of the Internet tells of it), ran on free software before anyone called it that: the name system on BIND, mail on sendmail, the first web servers on the program of the NCSA. When its development stalled in 1994, eight operators of web servers gathered their patches for the program in February 1995 into a common server, which they called Apache; by April 1996 it was, by Netcraft’s counts, the most used web server in the world, and remained so for more than two decades.³³ The Apache Group decided by consensus, by vote on the mailing list, and in 1999 became the Apache Software Foundation, the forerunner of all later foundations. To these came languages and databases that everyone got for nothing: Perl (1987), Python (1991), PHP (1995), MySQL (1995), PostgreSQL (1996). In 1998 the magazine c’t coined the acronym LAMP for the combination of Linux, Apache, MySQL and PHP: the kit with which anyone could start a service on the web without a licence fee.³⁴

KDE and GNOME. That the community took its licences seriously was shown by a dispute over the desktop. Matthias Ettrich, a student in Tübingen, called on 14 October 1996 for the building of a graphical working environment for Linux that was to be as convenient as Windows: KDE. He built on the library Qt of the Norwegian company Trolltech, whose licence forbade changes. For Debian and the FSF, KDE was therefore not free, and in August 1997 Miguel de Icaza in Mexico began GNOME, a second project with the same goal and entirely free components. The pressure worked: Trolltech relaxed the licence in 1998 and put Qt under the GPL in 2000.³⁵ Since then there have been two large desktops, and the dispute over whether one may tolerate unfree parts to make faster progress returns in every generation.

The cathedral and the bazaar. Why did it work? Eric Raymond, programmer and chronicler of the hacker culture, presented an essay at the Linux-Kongress in Würzburg in May 1997 that tried to give the answer: “The Cathedral and the Bazaar”. The big programs, those of GNU included, were built like cathedrals, by a few masters, in quiet, with publication only after completion. Linux was a bazaar: everyone contributes, releases come early and often, and the users are treated as co-developers. From this he derived rules, one of which became known as Linus’s law: given enough eyeballs, all bugs are shallow, that is, with enough reviewers someone to whom a bug is obvious is quickly found for every bug. Raymond demonstrated the rules on his own program fetchmail, which he had developed on the model of Linux.³⁶ The essay was less a theory than a piece of advocacy, and as such it worked.

The bottleneck. By 1997 it had been shown that strangers can build an operating system over the net that keeps up with the products of industry. What was missing was industry itself. Companies shied away from the GPL because their lawyers did not know it, they shied away from the word “free”, which sounded like no cost and like politics, and they had nobody to call when something did not work. Linux stood on servers that administrators had set up without the knowledge of their superiors. For it to become official, the cause needed a name that a board member would be willing to say, and a proof that money could be made with it.

Try it yourself. Torvalds’ first message of 25 August 1991 is still in the archive of the newsgroups (search for “What would you like to see most in minix” in Google Groups). The kernel’s mailing list can be read at lore.kernel.org, with every message since the 1990s: whoever follows a day there sees the model in operation, patches, objections, acceptances. In Termux, cat /proc/version shows which kernel runs in your own phone and who compiled it when.

5. The name open source and the companies (1998–2004)

Netscape. The proof came from a company in distress. Netscape, whose browser had opened the web in 1995, was losing the browser war against Microsoft, which shipped Internet Explorer free with Windows (the history of the Internet tells of the war). On 22 January 1998 Netscape announced that it would release the source code of the next version of its browser, and on 31 March 1998 it was on the net under the name Mozilla.³⁷ Those responsible referred explicitly to Raymond’s essay: if their own company could no longer sustain the browser, the world should. It took years before a usable program emerged from the source code, Firefox 1.0 appeared in November 2004, but the decision of a well-known company to open its most important product was the signal the movement had been waiting for.

The name. Two weeks later, on 3 February 1998, some of those involved met in Palo Alto, among them Raymond and Larry Augustin, the founder of the company VA Research, to discuss how the opportunity could be used. Christine Peterson, who ran an institute for nanotechnology, proposed a new name that was to avoid the misunderstanding “at no cost” and the flavour of the moral: open source.³⁸ The name caught on within weeks, Torvalds adopted it, and at the end of February Bruce Perens and Raymond founded the Open Source Initiative (OSI), which was to look after it. From the Debian guidelines Perens wrote the Open Source Definition: a licence counts as open source if it permits free redistribution, makes the source code accessible, allows derived works, excludes no one and no field of use, not even the military or the competition, and is not tied to a particular product, ten criteria in all.³⁹ Since then the OSI has examined licences and keeps a list of the approved ones, today more than a hundred.

Two names, one thing. Stallman rejected the new name and does so to this day: it conceals what it is about, namely the freedom of the user, and turns an ethical question into a development method.⁴⁰ In practice both names mean almost the same set of programs and licences; the definitions of the FSF and the OSI lead to the same verdict in almost all cases. The difference lies in the reasoning, and it shapes two camps to this day: one side speaks of rights and duties, the other of quality and cost. Whoever does not want to choose says FOSS or FLOSS, free and open source software.

Halloween. That the cause was taken seriously was shown by the opponent. In October 1998 internal memoranda from Microsoft reached Raymond, who published them at Halloween. They said that open source was a direct threat to Microsoft’s revenue and platform, that the quality of Linux was equal to commercial products, and as a countermeasure they recommended adding proprietary extensions to open protocols so that the free programs would lose touch.⁴¹ The documents were worth more to the movement than any advertising: the largest software manufacturer in the world considered it dangerous.

The money. In 1998 Oracle and Informix announced their databases for Linux, IBM took Apache into its own web server, and in December 2000 IBM’s chief executive Louis Gerstner declared that the company would put a billion dollars into Linux the following year.⁴² The stock market followed: Red Hat went public on 11 August 1999, the price rose from 14 to 52 dollars on the first day, and on 9 December 1999 VA Linux set a record with a rise of 698 per cent on the first day of trading that stands to this day.⁴³ How to make money with free software was not yet answered by this, and the answers that were found determine the industry to this day. From 2002 Red Hat sold not the program but a subscription to tested versions, updates and help, the model of support. MySQL and Trolltech offered their programs under two licences, free of charge under the GPL for all who opened their own product too, and for money for everyone else, the model of dual licensing. Hardware manufacturers such as IBM, HP and Intel paid developers so that Linux ran on their machines, because they sold machines, not operating systems. And in 2000 Sun released its office suite as OpenOffice.org to give Microsoft Office a competition it would never have had with a closed product.

Ballmer and SCO. The resistance changed form. In June 2001 Microsoft’s chief executive Steve Ballmer called Linux a cancer that attaches itself in an intellectual-property sense to everything it touches; what was meant was the GPL, which puts every piece of code linked with it under its conditions.⁴⁴ In March 2003 the company SCO Group, which believed it had acquired the rights to Unix, sued IBM for a billion dollars because Linux allegedly contained code from Unix, and wrote to 1,500 companies that they had licence fees to pay for Linux. The case dragged on for years; in 2007 a court and in 2010 a jury decided that the copyrights to Unix did not lie with SCO at all but with Novell, and SCO went into insolvency.⁴⁵ Linux had survived the first major legal attack and had become more credible as a result. At the same time the case showed that a project without a company needs a legal home: in 2000 the manufacturers founded the Open Source Development Labs, which paid Torvalds from 2003 so that he could devote himself entirely to the kernel, and which merged in 2007 into the Linux Foundation, a foundation that protects the name, holds conferences and carries the work on the kernel with membership fees from industry.⁴⁶

In court in Germany. Whether the GPL would stand up in court at all had never been tested before 2004. Harald Welte, a developer of the Linux network code, founded the project gpl-violations.org that year and proceeded against manufacturers who sold Linux in routers without supplying the source code. On 19 May 2004 the Regional Court of Munich I prohibited the company Sitecom from distributing such a device: the first judgment worldwide to enforce the GPL, followed by others in Frankfurt and Berlin.⁴⁷ In the same month the Munich city council decided to move the city’s administration from Windows to Linux, a project called LiMux, which was completed in 2013 and reversed in 2017.⁴⁸ Germany was a centre of the movement in those years: SUSE in Nuremberg, KDE, the LinuxTag since 1996, the trade magazines, and a public service that asked earlier than others whether it should not rather own its software.

Patents and licences. Two questions remained open. The first was the software patent: while copyright protects a particular source code, a patent protects an idea, and whoever holds a patent can also sue someone who implemented the same idea independently. For open source, whose authors have neither patents nor lawyers, that was a threat. When the European Commission wanted to make patents on software easier, the movement mobilised, and the European Parliament rejected the directive on 6 July 2005 by 648 votes to 14.⁴⁹ The Apache Licence 2.0 of January 2004 was the first widespread licence to state explicitly that every contributor permits the use of their patents. The second question was the number of licences: every company that opened its product wrote its own, and by 2004 the OSI had approved around sixty, many of them incompatible with one another, so that code under one could not be combined with code under another.

Weak copyleft and incompatibility. Between the two camps a middle ground emerged. Since 1991 the LGPL has permitted linking a free library into an unfree program as long as the library itself stays free. In 1998 Netscape wrote a licence for Mozilla that became the Mozilla Public License: the copyleft applies only to the single file, so that free and unfree files can be mixed in one program; the Eclipse Public License (2004) and Sun’s CDDL (2005) followed the pattern. This weak copyleft is the compromise on which Firefox, LibreOffice and many tools of industry stand. With the variety came incompatibility: code under two licences can only be combined into one program if each licence allows the conditions of the other. In the FSF’s reading, GPL 2 is compatible neither with the Apache Licence 2.0 nor with the CDDL, which is why the file system ZFS, which Sun released in 2005, may not become part of the Linux kernel to this day; version 2.0 of the Mozilla licence (2012) was written specifically so that it goes together with the GPL.⁵⁰ At the other end of the spectrum stands the renunciation of every right: the database SQLite (2000) is in the public domain, its author has given up all claims, and in 2009 Creative Commons created with CC0 a declaration with which an author can do the same, as far as the law of their country allows.⁵¹

The bottleneck. By 2004 open source had arrived in business. But the tools of collaboration still came from the 1990s: email, mailing lists and version control with a central server to which only the initiated could write. For the Linux kernel, by now millions of lines and a thousand contributors, Torvalds had chosen a closed program out of necessity in 2002, BitKeeper, which its maker let him use free of charge, under protest from his own community. The scale of collaboration had outgrown the tool.

Try it yourself. Which licence a program has is usually stated in its package. pip show requests names the licence of Python packages in the line “License”, npm view express license for JavaScript packages, and on Debian and Ubuntu every package comes with the file /usr/share/doc/PACKAGE/copyright. The list of approved licences with their texts is kept by the OSI at opensource.org/licenses; whoever is looking for one for their own project finds a selection aid from GitHub at choosealicense.com.

6. Git, GitHub and the infrastructure of the world (2005–2014)

Git. In April 2005 the maker of BitKeeper withdrew the free licence from the kernel after a developer from its circle had examined the program’s protocol. Torvalds stood without a tool, looked at the free alternatives and found none that could cope with a thousand contributors and a patch a minute. He wrote his own. The first commit of Git dates from 7 April 2005, within a few days Git managed its own source code, and kernel version 2.6.12 of June 2005 was the first produced with it.⁵² Git is a distributed version control system: every participant has a complete copy of the whole history of the project, can work without a network and without permission, create branches and merge them again, and every state is named by a cryptographic checksum, so that nobody can change the history unnoticed (the history of software development describes how one works with it). There is no server that holds the truth; the truth is what the maintainer takes over. In July 2005 Torvalds handed the maintenance of Git to Junio Hamano, who holds it to this day. That Git became the tool of almost all programmers within ten years it owes to a second project.

GitHub. In 2008 three programmers in San Francisco founded a service that hosted Git projects on the net and gave them an interface: GitHub. Its invention was the pull request: whoever wants to contribute to someone else’s project creates their own copy with one click, a fork, changes in it what they want to change, and asks the maintainer to take the change over; the request becomes a discussion with comments line by line, and at the end stands acceptance or rejection, visible to all. That was nothing other than the patch by email, but without mailing list, without etiquette, without a barrier to entry, and with a profile on which every contribution was recorded. GitHub made open source something one could do on the side, and a calling card: employers looked at the profiles. The numbers show the effect: 100 million accounts in January 2023, more than 180 million in autumn 2025, 36 million of them added in the last year.⁵³ With the convenience came dependence: the largest part of the world’s open software has since lain with a single company, which since 2018 has belonged to Microsoft.

Android and the cloud. While the tools changed, open source became the foundation of the industry that had still fought it in the previous section. On 5 November 2007 an alliance around Google announced an operating system for phones, Android, with Linux as kernel and a user interface under the Apache licence; the first version appeared in September 2008.⁵⁴ Because every manufacturer could take and adapt Android without a fee, in 2024 it ran on a good seven out of ten smartphones in the world, the most widespread operating system there has ever been.² What is open about it is the core, not the whole: Google’s services, the app store, the maps, are closed and bound to contracts, and whoever ships Android without them, like Amazon or the Chinese manufacturers, gets a system without the parts users expect. Google’s browser Chrome (2008) builds on the open Chromium, whose rendering engine descends from Apple’s WebKit, and WebKit from KHTML, the browser engine that KDE developers had written in 1998: the code of a group of volunteers is today in every iPhone and in Microsoft’s Edge. The cloud, the renting out of computing power over the net, which Amazon began in 2006, ran on Linux from the start, and the tools with which it is operated were created in the open: Hadoop (2006) for computing on thousands of machines, after models from Google’s publications, Docker (2013) for containers, in which a program is packed with everything it needs and can be started anywhere, and Kubernetes (2014), which Google derived from its internal system and handed to a foundation in 2015, to manage containers at scale.⁵⁵ Since November 2017 all 500 computers on the list of the fastest machines have run Linux.³ The infrastructure of the world, phones, servers, clouds, supercomputers, was open, even if the services on it were not.

GPLv3 and the foundations. On 29 June 2007, after a year and a half of public consultation, the FSF published the third version of the GPL. It closed gaps that had opened in sixteen years: devices that contained free software but locked out changed versions by means of signatures, the FSF called this tivoisation after the video recorder TiVo, patent agreements with which a manufacturer protected its customers and nobody else, and the incompatibility with the Apache licence.⁵⁶ Torvalds rejected the new version for the kernel; he felt a licence should govern the code, not the hardware it runs on, and Linux stayed with GPL 2. The movement now had two copyleft licences and a rift. In the same period the weight shifted towards the permissive licences: on GitHub in 2015, 45 per cent of the projects with a licence stood under the MIT licence, 11 per cent under the Apache licence and 22 per cent under some version of the GPL.⁵⁷ The new generation wanted its code to be used and asked less to what end. What stepped up beside the licence as an ordering power was the foundation: the Apache Software Foundation (1999), Eclipse (2004), the Linux Foundation (2007), later OpenStack (2012) and the Cloud Native Computing Foundation (2015), neutral owners of name and trademark, with rules for a say and with contributions from the companies, which could thus work together without handing their code to one another.

Oracle and the forks. What happens when the owner of an open project loses trust was shown by the year 2010. In January Oracle took over Sun Microsystems and with it MySQL, OpenOffice.org, Java and Solaris. The communities’ answer was the fork: the splitting off of the source code into a new project under a new name, which every open-source licence permits. The inventor of MySQL had already begun MariaDB in 2009, the developers of OpenOffice.org founded the Document Foundation and LibreOffice in September 2010, OpenSolaris became illumos, the tool Hudson became Jenkins in 2011.⁵⁸ In all cases the contributors followed the fork, and the original branch lost significance. The fork is the community’s veto: nobody can lock up an open project, because everyone may take the code with them, and the mere possibility forces the owners to be considerate. At the same time Oracle sued Google because Android had reproduced the interfaces of Java; the dispute went up to the Supreme Court of the United States, which decided in 2021 that the taking over of the interfaces was permitted.⁵⁹ A different outcome would have called into question the reimplementation of compatible programs on which Unix, GNU and Linux rest.

Beyond software. The idea travelled. Wikipedia (2001) let everyone write and put the texts under a licence modelled on the GPL, Creative Commons created licences in 2002 for texts, images and music with the same freedoms and gradations, OpenStreetMap (2004) collected a map of the world from volunteers, the Budapest declaration of 2002 demanded free access to scientific papers, and from 2005 open hardware emerged with the Arduino, whose plans anyone may rebuild; the processor instruction set RISC-V (2010) is today the open alternative to the licences of ARM.⁶⁰ Openness, once formulated as a licence, proved to be a principle that can be applied to any work.

The sciences. Research, which had once set the example of sharing source code, became its largest user. The statistics language R, begun in New Zealand in 1993 and under the GPL since 1995, replaced the expensive packages in university departments; for Python came SciPy (2001) and NumPy (2006) for computing with arrays of data, and in 2014 Jupyter, the notebook in which code, result and explanation stand together and which became the form in which data analyses are published.⁶¹ The Human Genome Project had agreed in Bermuda in 1996 to release every decoded sequence within 24 hours, and made open data the norm of biology; bioinformatics, astronomy and climate research have built their tools as shared projects ever since.⁶² AI research ran on open libraries from the start: Google released TensorFlow in 2015, Facebook PyTorch in 2017, and almost every paper of the following years, the history of AI tells of it, appeared with code on GitHub.⁶³ At the same time the demand turned around: journals such as Science and Nature have required since 2011 and 2014 that the code belonging to a paper be accessible so that others can recompute the result, funders write it into their conditions, and since 2012 there has been the profession of the research software engineer, who builds research software so that it outlives the paper.⁶⁴ Open code became part of the scientific method, like publication itself.

Heartbleed. On 7 April 2014 a bug became known in OpenSSL, the library that handles the encryption of HTTPS on a large part of all servers. The bug, named Heartbleed, allowed anyone to read out parts of a server’s working memory, passwords and keys included, and it had stood unnoticed in the code for two years; by measurements, between a quarter and half of the most visited HTTPS servers were vulnerable at the start.⁶⁵ When the world looked, it found a project carried by a single full-time developer that received about 2,000 dollars in donations a year, while companies with billions in revenue used it free of charge.⁶⁶ Linus’s law had a gap: eyes look where it is interesting, not where it is important. Within three weeks the Linux Foundation founded the Core Infrastructure Initiative, in which Amazon, Google, Microsoft, Facebook and others gave money for the maintenance of such basic components, and the word that has shaped the debate since is sustainability: whether the work on which everyone lives is paid for, and whether those who carry it hold out.

The bottleneck. In 2014 the infrastructure of the world was open and at the same time in the hands of a few volunteers. The companies that had the most from it, above all the operators of the clouds, gave back the least, and the licences that enforced giving back on redistribution did not bite, because a service on the net redistributes nothing. Maintenance, money and trust were the bottlenecks of the next era.

Try it yourself. In every project managed with Git, git shortlog -sn | head shows the contributors with the number of their changes, and git log --oneline | wc -l the number of all changes. On GitHub the same stands under “Insights” → “Contributors”. Whoever wants to contribute looks in a project for tasks with the label “good first issue”, reads the file CONTRIBUTING.md and sends a first pull request; a typo in the documentation is the classic beginning.

7. Cloud, licences and the supply chain (since 2014)

Microsoft’s turn. On 20 October 2014 Microsoft’s new chief executive Satya Nadella said in San Francisco “Microsoft loves Linux” and showed that a fifth of the machines in Microsoft’s own cloud ran Linux. In November 2014 the company released the foundation of its programming platform .NET, in 2015 the editor Visual Studio Code, which within a few years became the most widely used editor in the world, in 2016 it joined the Linux Foundation and built a Linux kernel into Windows, and on 4 June 2018 it bought GitHub for 7.5 billion dollars.⁶⁷ The company whose chief had called Linux a cancer was the largest contributor on GitHub. The reason was not a change of heart but the cloud: Microsoft earned from renting out computers, and on rented computers the customers wanted Linux. In October 2018 IBM announced that it would take over Red Hat for 34 billion dollars, the largest acquisition of a software company up to then.⁶⁸ Open source had become a business on the scale of the corporations, and the corporations were the buyers.

The cloud and the licence wars. The cloud set off the dispute that the previous section had announced. Companies such as MongoDB, Elastic, Redis and HashiCorp had developed their programs in the open and lived from operating them as a service. Amazon Web Services took the programs, as the licence permitted, offered them as its own service and kept the revenue. The GPL did not bite, because the programs were permissively licensed, and even the GPL would have demanded nothing, for whoever operates a program as a service does not redistribute it. The makers answered with new licences: MongoDB in October 2018 with the Server Side Public License, which demands of everyone who offers the program as a service that they open the entire service, Elastic in January 2021 with the same, HashiCorp in August 2023 with the Business Source License, which prohibits competing with the maker, Redis in March 2024. This was possible because these companies had required an agreement from every contributor in advance, a Contributor License Agreement, which gives them the right to relicense the entire code. The Linux kernel knows nothing of the kind: every contributor keeps their copyright and, since 2004, confirms with the Developer Certificate of Origin only that they may contribute the code; nobody can change its licence, because thousands of authors would have to be asked, and that is why the kernel stays with GPL 2.⁶⁹ The OSI recognised none of them as open source because they exclude users and purposes; the makers called their model source available: the source code can be read, but is not free. The answer of the communities was the fork under the roof of a foundation: Amazon itself split OpenSearch off from Elasticsearch in 2021, Terraform became OpenTofu, Redis became Valkey, both under the Linux Foundation. Elastic in 2024 and Redis in 2025 returned to an open-source licence, the AGPL, a version of the GPL that extends copyleft to services on the net as well.⁷⁰ The pattern was the same every time: change of licence, fork, departure of the contributors, sometimes return. It confirmed what the fork had meant since 2010, and showed at the same time that the business model of the makers of open software is not settled.

In court, continued. Whether the licences hold continued to be tested. In 2008 the Federal Circuit court of appeals of the United States decided in Jacobsen v. Katzer that the conditions of an open-source licence, here the Artistic License for model railway software, are conditions under copyright whose violation can be pursued like an unauthorised copy, and not merely contract clauses; since then enforceability has been settled in the USA too.⁷¹ In Germany the other side showed itself. Christoph Hellwig, one of the kernel developers, sued VMware in Hamburg in 2015 because its operating system allegedly contained Linux code; the courts dismissed the suit in 2016 and 2019 because he could not show precisely enough which lines were his, and the case ended without an answer to the actual question.⁷² Patrick McHardy, once maintainer of the network code, pursued dozens of manufacturers from 2014 with injunctions and contractual penalties, not to obtain source code but money; the kernel developers excluded him and in 2017 committed themselves in a Kernel Enforcement Statement to pursue violations first with a period to cure, as GPL 3 provides, so that the licence remains a tool of the community and not one of the litigants.⁷³ And since 2021 the Software Freedom Conservancy has been suing the television maker Vizio in California, not as an author but as the buyer of a device, arguing that the GPL promises every customer the source code; the court let the suit go to trial at the end of 2023 and decided partial questions in 2024 and 2025; in autumn 2026 the trial was scheduled for the end of the year. A success would extend enforcement from the authors to the users.⁷⁴

The supply chain. A program of today is not written but assembled. A web application includes a few dozen libraries directly, each of them further ones, and in the end hundreds or thousands of packages hang in it, which a tool such as npm for JavaScript or pip for Python loads automatically from a public registry at build time. These dependencies are the supply chain of software, and it is as vulnerable as any supply chain. In March 2016 an annoyed author deleted his package left-pad from the npm registry, eleven lines that pad a string with spaces, and thousands of projects could no longer be built because somewhere deep in their chain this package stood.⁷⁵ In November 2018 the maintainer of a package with two million downloads a week handed its maintenance to a helpful stranger, who built in a malicious function for stealing cryptocurrency. On 10 December 2021 Log4Shell became known, a hole in Log4j, a library for writing log files that sits in almost every Java application in the world and allowed the execution of foreign code with a single line of text; the maintainers, volunteers, worked through the nights while authorities worldwide sounded the alarm.⁷⁶ And on 29 March 2024 Andres Freund, a developer at Microsoft who had wondered about half a second of delay when logging in, reported a backdoor in xz, a compression tool that sits in almost every Linux distribution: an unknown person under the name Jia Tan had over two years won the trust of the sole, overburdened maintainer through helpful contributions, taken over co-maintenance and built in an access that would have opened the login service SSH of every affected server. The backdoor was discovered a few weeks before delivery into the major distributions, by chance.⁷⁷ The case showed both: how thin the layer is, a single person between the world and its infrastructure, and that openness was what made the discovery possible at all.

Answers. The answers came from three directions. Technology: a software bill of materials (SBOM), a parts list of all components of a program, is to make visible what is in the chain, and names the licence of every component with an SPDX identifier, a short code maintained since 2010 such as “GPL-2.0-only” or “MIT”, which the Linux kernel too has carried in every file since 2017;⁷⁸ the American government demanded the bill of materials from its suppliers in 2021, the Open Source Security Foundation (2020) develops tools for checking and signing packages, and Debian has worked since 2013 on making every package rebuildable bit for bit from the source code, so that a manipulated package stands out.⁷⁹ Money: in 2019 GitHub created the possibility of paying developers directly, foundations and companies set up funds, and in Germany the Sovereign Tech Fund began in October 2022 to pay with federal money for the maintenance of basic components that everyone uses and nobody pays for, since 2024 put on a permanent footing as the Sovereign Tech Agency.⁸⁰ Law: in 2024 the European Union adopted the Cyber Resilience Act, which makes manufacturers of networked products liable for their security, with reporting obligations since September 2026 and full obligations from December 2027. A first draft would also have hit the volunteers who maintain a package; after protests from the foundations the law exempted non-commercial development and created the role of the open-source steward, an organisation that looks after projects and bears lighter duties for it.⁸¹ For the public service the Free Software Foundation Europe has demanded since 2017 “Public Money, Public Code”: what is paid for with public money should be public, and in 2024 Schleswig-Holstein was the first German state to decide to move its administration to free office and operating software.⁸² For public administrations the European Commission has had its own licence since 2007, the European Union Public Licence, with weak copyleft and equally binding in all official languages, so that an authority can pass on software under a law it knows.⁸³ Politics reached the kernel too: in October 2024 the maintainers of the Linux kernel struck eleven Russian developers from the list of those responsible, with reference to sanctions; for the first time a government had a say in who may work on the common system.⁸⁴

The bottleneck. The answers to money and trust have been found, if not completed: forks under a neutral roof, bills of materials, funds and laws. What has shifted is the question itself. Open code is no longer only the tool of programmers and companies, but the foundation of state infrastructure and the raw material of language models, and both, states and machines alike, claim the word “open” for themselves, without it being clear whether it still means the same thing.

Try it yourself. Your own supply chain can be counted: in a project with Node.js, npm ls --all | wc -l shows the number of all included packages, in a Python project pip install pipdeptree && pipdeptree the tree of dependencies. Google’s site deps.dev shows for every package from npm, PyPI, Maven or Cargo what it depends on, under which licence it stands and which known holes it has; the holes themselves are recorded at osv.dev and cve.org, Log4Shell under the number CVE-2021-44228, the backdoor in xz under CVE-2024-3094.

8. Sovereignty and AI (since 2022)

State, military and sovereignty. The state, which has appeared in this story as funder (ARPA), legislator and customer (Munich, Schleswig-Holstein), is also present as user and contributor, right into defence. In December 2000 the American NSA released SELinux under the GPL, a security model that leaves every process only the rights a rule assigns to it and reports nothing to the outside; it became part of the Linux kernel in 2003 and has protected servers and every Android phone since, and in 2019 Ghidra followed, the agency’s tool for taking foreign programs apart.⁸⁵ In 2009 the US Department of Defense put open software on a par with purchased software by directive and in 2022 encouraged its units to contribute their own work outwards; the Navy’s destroyer Zumwalt sails on Red Hat Linux.⁸⁶ From 2008 the French Gendarmerie moved its roughly 70,000 computers step by step to Ubuntu, the largest migration by a public authority.⁸⁷ Russia and China built their government and military systems on Linux distributions of their own, Astra Linux and Kylin, to be independent of American manufacturers; that open code serves everyone, the adversary included, was the background when the kernel developers struck the Russian maintainers in 2024.⁸⁸ In the war in Ukraine the cheap drones of both sides fly with open control software such as Betaflight and ArduPilot, which hobbyists had written for model flying; the drones with which Ukraine attacked Russian airfields in June 2025 were, by analysis of the published footage, steered by ArduPilot.⁸⁹ Whether open code can be controlled at all had been settled by the crypto wars of the 1990s: when the USA banned the export of strong encryption, the source code of PGP appeared in 1995 as a printed book, which could be exported freely as speech, and in 1999 an appeals court decided that source code stands under the protection of free speech; in January 2000 the government gave up control over published code.⁹⁰ The intelligence services themselves have spoken for decades of “open source intelligence” when they evaluate newspapers, radio and the net; the term is older than the software and has nothing to do with it.⁹¹ What all states have called digital sovereignty since the 2020s, the ability to understand, change and operate one’s own infrastructure without asking a manufacturer for permission, is Stallman’s freedom to study and change a program, carried over to the state.

AI and the question of what open means. Since 2021 language models have been writing code (the history of AI and the history of software development tell of it), and they learned it from the open source code that lies on GitHub. Whether the learning violates the licences that require the authors to be named has been the subject of a lawsuit against GitHub and Microsoft since November 2022, which has so far been largely dismissed.⁹² The maintainers feel the models from two sides: they receive contributions and bug reports that machines generate in bulk and that people have to check in bulk, the maintainer of curl complained in 2024 about a flood of worthless security reports written by AI, and at the same time the companies that earn with the models build on code whose maintenance they do not pay for. Conversely the word “open” became a matter of dispute as in 1998: Meta calls its Llama models open source although their licence excludes large competitors, and in October 2024 the OSI published a definition for open AI models that requires, besides the weights, the code and information about the training data; the Chinese DeepSeek released the weights of its model R1 under the MIT licence in January 2025.⁹³ The question that SHARE had answered in 1955 arises anew with the models: what must one receive in order to understand, change and pass on a work?

Where the chain stands. In 2026 open source is the rule, not the exception. On 12 April 2026 Torvalds released version 7.0 of the Linux kernel, 35 years after the first, with more than 40 million lines, to which by now around 2,000 developers contribute per version, most of them paid by companies.⁹⁴ Almost every commercial program consists predominantly of open components, and the largest software companies in the world are the largest contributors. What that is worth, economists estimated in 2024: writing the existing open code anew once would cost 4.15 billion dollars; replacing it in every company that uses it, 8.8 trillion, because companies without it would have to spend three and a half times as much on software. For the European Union a study for the Commission put the contribution to economic output at 65 to 95 billion euros a year, calculated for 2018.⁹⁵ The closed source code, the bottleneck of the first era, has been removed for the infrastructure; the services on it, the platforms and the models, are as closed as ever. What remains open is what has been open since Heartbleed: who pays for the work on which everyone lives, who trusts the people who do it, and what “open” means when the work is no longer source code.

Try it yourself. On Fedora or Red Hat Enterprise Linux the command getenforce shows whether SELinux, the permission model developed by the NSA and part of the kernel since 2003, only reports violations or prevents them; the answer there is “Enforcing”. It works solely on your own computer and sends nothing to the agency. On every Android phone it has run just as strictly since 2014, only the user can neither query it nor switch it off. The source code of ArduPilot lies at github.com/ArduPilot/ardupilot, with every change since 2009; whoever looks in finds the same control software that model flyers improve and armies deploy. What “open” means for models is shown by huggingface.co: the model card of DeepSeek-R1 names the licence MIT, that of Llama 3 a “Community License” with conditions; whoever reads both sees the difference that has been argued about since 2023.

The chain in brief

1. The computing centres of the 1950s and 1960s exchange source code because software is not yet a commodity; unbundling (1969) and copyright (1980) make it one, and the source code disappears.
2. Unix (1969–1983) gives the universities a common system with source code; the break-up of AT&T (1984) makes it a product, and the community loses its system.
3. GNU (1983–1991) rewrites the tools and secures them with copyleft; the kernel is missing.
4. Linux and the net (1991–1997) deliver the kernel and a way of working in which strangers collaborate over the net; business lacks a name and a proof.
5. Open source (1998–2004) gives both: name, definition, business models, lawsuits survived; the tools of collaboration are not equal to the scale.
6. Git and GitHub (2005–2014) make collaboration a mass practice, Android and the cloud make open source the infrastructure of the world; Heartbleed shows that it depends on a few unpaid people.
7. Cloud, licence wars and the supply chain (since 2014) answer the questions of money and trust with new licences, forks under a neutral roof, bills of materials, funds and laws; in the process open code becomes the foundation of states and the raw material of language models.
8. Sovereignty and AI (since 2022): states build their independence on open code, language models learn from it and are themselves called “open”; what one must receive in order to understand and change a work is once again the open question.

Timeline

Further reading

• Steven Levy: Hackers. Heroes of the Computer Revolution. Doubleday, Garden City 1984 (new edition O’Reilly 2010). The culture from which everything came, from the model railroaders at MIT to the home computers.
• Sam Williams, Richard Stallman: Free as in Freedom 2.0. Free Software Foundation, Boston 2010. The biography of Stallman, annotated by himself in the second version; free on the net.
• Eric S. Raymond: The Cathedral & the Bazaar. O’Reilly, Sebastopol 1999. The essays that gave the movement its self-image and its name; free on the net.
• Linus Torvalds, David Diamond: Just for Fun. The Story of an Accidental Revolutionary. HarperBusiness, New York 2001. The origin of Linux as seen by its author.
• Glyn Moody: Rebel Code. Linux and the Open Source Revolution. Perseus, Cambridge, MA 2001. The narrative of the years 1991 to 2000 after conversations with those involved.
• Steven Weber: The Success of Open Source. Harvard University Press, Cambridge, MA 2004. The political scientist’s explanation of why the collaboration of strangers works.
• Volker Grassmuck: Freie Software. Zwischen Privat- und Gemeineigentum. Bundeszentrale für politische Bildung, Bonn 2002 (2nd edition 2004). The German overview of copyright, licences and history; free on the net.
• Nadia Eghbal: Working in Public. The Making and Maintenance of Open Source Software. Stripe Press, San Francisco 2020. How open source works in the age of GitHub and what its maintainers suffer from.

Sources

The chronicle rests on the original papers, licence texts, court decisions and contemporary reports named in the footnotes.