But Is It Open?The online edition
Type & theme

Make yourself comfortable

Page color
Text size
20 px
Reading width
Ask about this chapter ↗

Your settings and place stay in this browser.

Chapter 2 · Timothy O’Brien

A Short History of Open-Source Licensing

8 minute read23 source notesFree online edition

In the early 1990s, the web server most sites ran was NCSA httpd, written by Rob McCool at the National Center for Supercomputing Applications at the University of Illinois.1 Then McCool left NCSA and development stalled. The web was growing fast, and nobody was maintaining the server most of it ran on.2

Webmasters kept going anyway. They fixed bugs and added features in their own copies, and those fixes sat in patch files scattered across the internet. In early 1995, Brian Behlendorf, who ran the web server for HotWired, and Cliff Skolnick set up a mailing list and a shared repository to collect the patches in one place.2 A group of about eight developers, later known as the Apache Group, started reviewing and applying them. Their first public release, Apache 0.6.2, came out in April 1995.13

The name has two origin stories, and each has support. One is a pun. The server was a stack of patches on top of NCSA’s code, so it was “a patchy server.” The project’s own early FAQ said so directly: “A cute name which stuck. Apache is ‘A PAtCHy server’.”1 The other is a tribute. The Apache Software Foundation’s official position today is that Behlendorf chose the name out of respect for the Apache nations, and its history page describes the patchy-server version as a rumor that “became lore.”4 Behlendorf has said both: in a 2000 interview he gave the tribute explanation, and in 2007 he said the pun came first.3 I don’t think the record settles it, and I’m happy to leave it unsettled.

The group ran informally for about four years. By 1999 Apache was the dominant web server. A mailing list can’t defend a trademark or sign a contract, and it lasts only as long as people stay interested.2 That year the Apache Group incorporated as the Apache Software Foundation, a U.S. 501(c)(3) nonprofit.4 The license grew up alongside the institution. The first releases were built on NCSA’s public-domain code.2 Apache License 1.0 was a short BSD-style license with an advertising clause (ads that mentioned the software had to credit its authors), and Apache License 1.1, approved in 2000, dropped that clause.5 Apache License 2.0, approved in January 2004, was written so projects outside Apache could use it without editing it. It also added an express patent grant from contributors, a patent retaliation clause, and explicit rules about notices and trademarks.67 When people say “the Apache license” today, they mean 2.0.

I start with Apache because its story runs in the usual order. People shared fixes first. The license came later, and the foundation later still, once the sharing had grown big enough to need protecting.

Apache wasn’t the beginning, though. People in universities, research labs, and hacker communities shared software long before anyone wrote a standard license for it, and they mostly relied on custom rather than paperwork.8 There’s no clean answer to “what was the first open-source license,” and nobody adopted the term “open source” until 1998.9

Two schools of thought

By the mid-1980s, sharing had settled into two broad traditions, and most licenses in use today descend from one or the other.

The first is copyleft. Richard Stallman launched the GNU project in 1983 and founded the Free Software Foundation in 1985.108 His idea was to turn copyright into the protection: a license that gives everyone the right to copy, modify, and distribute the software, on the condition that anyone who passes it on passes on the same rights.8 The GNU General Public License, first released in 1989, is the standard example.11 When a covered version is distributed, recipients must receive the source and rights the license requires. Private modifications need not be published.

The second school is permissive licensing. The MIT and BSD families take nearly the opposite approach. They allow broad reuse with few conditions, mostly a requirement to keep the copyright and license notice intact.12 These licenses came out of how places like Berkeley and MIT already did things, not out of a movement.12 At MIT, a research group decided in early 1984 to give its networking code away with a short copyright and permission notice. License fees looked unlikely to bring in much, and negotiating contracts would have meant a lot of time with attorneys. Jerome Saltzer, who helped draft the notice, calls it probably the first version that deserves the name “MIT License.”13 Nobody wrote a manifesto. Someone judged that sharing code widely served the institution and wrote a license short enough to read in a couple of minutes.

Those two instincts mark the ends of the argument: protect the freedoms with conditions, or hand over the code and let people get on with it. The two camps want different things and put obligations in different places, and each has serious people defending it.

Different obligations

Reciprocity and patent rights are separate questions. Licenses can grant similar reuse rights while differing substantially on those details.

Apache 2.0 is permissive, but it also addresses patents. Contributors grant rights to patent claims necessarily infringed by their contributions alone or with the work they contributed to. That is a scoped grant, not blanket protection from patent suits. Bringing litigation alleging that the work or an incorporated contribution infringes a patent terminates the patent licenses granted for that work.7 The GNU Library GPL of 1991, renamed the Lesser GPL in 1999, applies a different form of reciprocity. It covered libraries and let them be linked into proprietary programs under specified conditions.14 The Mozilla Public License, which followed Netscape’s 1998 release of its browser source, applied copyleft one file at a time.15 Distribute a modified MPL-covered file and its source must remain available under the MPL; combine it with proprietary files and those can stay closed.16

Later licenses kept adjusting as new problems came up. GPLv3, released in 2007, added explicit terms for patents and for hardware that blocks users from running modified software.17 The Affero GPL filled a gap the original GPL didn’t anticipate. Merely letting users interact with server-side software does not convey a copy of that software, so a company could modify a GPL program and run it as a web service without sharing the changes. AGPLv3 requires a modified version to offer its corresponding source to users interacting with it remotely over a network. A service that sends client code to users may distribute that code too.18

These licenses place obligations on different acts and different portions of the code. That is why identifying a license family is only the start of reading its terms.

A word about Creative Commons

Creative Commons released its first licenses in 2002. It took the idea of a standard license and applied it to creative and knowledge work: writing, images, music, course materials, datasets, documentation.19

Creative Commons generally recommends software-specific licenses for code: its licenses contain no specific terms about distributing source code. CC0, its public-domain dedication with a fallback license, is a separate case that can be used for software.20 They matter here for two reasons. Much of the documentation and data around open source is released under them. And as AI models strain the old categories, people often reach for Creative Commons when they want to signal that materials other than code are open. Later chapters ask whether that fits.

Free software and open source

The field also argues over its own name: free software or open source. The free-software tradition talks about freedoms (to run, study, modify, and share) and treats them as an ethical matter.21 The “open source” label, adopted in 1998 when the Open Source Initiative formed, pitched the same practices to businesses in less confrontational terms.9 The two camps accept nearly the same licenses but disagree about why the freedoms matter. I use “open source” here while keeping that difference in view.

The cloud problem and the open-core answer

The sharpest licensing argument of the 2010s cut across the copyleft and permissive camps. It was about what happens when a license works exactly as designed and someone still feels cheated.

A cloud provider can take permissively licensed software, a database for instance, turn it into a hosted product, and collect the revenue while returning little to the people who built it. The license allows it. Copyleft advocates say this is why conditions exist, and the AGPL is their answer. Many companies won’t touch the AGPL, and their reasons are practical ones: obligations triggered by network use, uncertainty about what counts as a covered service, compliance costs, compatibility questions, and a worry that it will scare off commercial users and investors.

One business strategy for funding development is open core. A company releases the core under an open-source license and keeps enterprise features, hosted services, or operational tooling proprietary. The business depends on where it draws that line. Critics say it lets companies take community labor while fencing off the value. Defenders say software that has to keep running needs steady funding more than purity, and some startups can’t pay for development any other way. Its consequences depend on who controls the boundary and whether contributors understand the bargain.

Still being written

“History” is a slightly misleading word for all this. The field is established, but it’s still moving. Licenses are still being revised, courts are still deciding what they mean (a later chapter covers the case law), and every shift in computing reopens questions that seemed closed. The idea has spread past software, to open instruction-set standards such as RISC-V, which can be implemented in open or proprietary chips. Chapter 7 takes up standards.22 Other licenses add restrictions that can put them outside the open-source definition. We will need that distinction when we reach model licenses.

This unsettled history matters for a book about AI, because almost every argument about AI models has a precedent in it. Releasing weights while withholding training data is a question about which parts carry obligations, much like MPL’s file-level line. A ban on what a model may be used for is different from GPL or AGPL reciprocity. Copyleft preserves freedoms under specified sharing or network-interaction conditions; it does not forbid a field of use. A model released under a custom corporate license that offers access without the freedoms has the same shape as the source-available licenses that appeared in the 2010s.23 Words like “open weights,” “open model,” and plain “open” are being stretched to cover artifacts the existing licenses were never written to describe, often by people who aren’t sure of the answers themselves.

Licenses are only part of the story. A foundation gave the Apache Group a durable legal and administrative home. Many projects operate without one, but the work of stewardship remains. The next chapter looks at the institutions that steward these licenses and what each of them means by “open source.”

Notes

  1. “Apache HTTP Server,” Wikipedia, https://en.wikipedia.org/wiki/Apache_HTTP_Server (secondary source). The project’s own account is at https://httpd.apache.org/ABOUT_APACHE.html. The FAQ wording is from “Apache Server Frequently Asked Questions,” apache.org, as archived January 6, 1997, https://web.archive.org/web/19970106233141/http://www.apache.org/docs/misc/FAQ.html; the earliest version of the FAQ is not archived. ↩1 ↩2 ↩3

  2. The Apache HTTP Server Project, “About the Apache HTTP Server Project,” https://httpd.apache.org/ABOUT_APACHE.html. The project’s own history: NCSA httpd was public domain, development stalled after McCool left NCSA in mid-1994, Behlendorf and Cliff Skolnick set up the mailing list with bandwidth donated by HotWired, 0.6.2 shipped in April 1995, and Apache passed NCSA httpd as the most-used server on the Netcraft survey in 1996. ↩1 ↩2 ↩3 ↩4

  3. “Apache HTTP Server,” History of Information, https://historyofinformation.com/detail.php?id=2501, source for the founding details and for Behlendorf’s 2000 and 2007 interview remarks on the name. ↩1 ↩2

  4. The Apache Software Foundation, “History,” https://www.apache.org/history. ↩1 ↩2

  5. The Apache Software Foundation, “Licenses,” https://www.apache.org/licenses/; Apache License 1.0, https://www.apache.org/licenses/LICENSE-1.0; Apache License 1.1, https://www.apache.org/licenses/LICENSE-1.1, which states that 1.1 was approved by the ASF in 2000 and that its main change was removing the 1.0 advertising clause. See also “Apache License,” Wikipedia, https://en.wikipedia.org/wiki/Apache_License (secondary), which describes the 1995 license as essentially the four-clause BSD license. The ASF gives no date for 1.0 and describes it as the license of “very old versions of Apache packages (such as version 1.2 of the Web server).” ↩

  6. The Apache Software Foundation, “Apache-2.0 License History,” https://www.apache.org/licenses/license-history.html. Apache 2.0 was approved for Apache projects as of January 21, 2004; reuse by non-ASF projects without alteration was one of its stated goals, since each project had been altering the 1.1 template. ↩

  7. Apache License, Version 2.0, https://www.apache.org/licenses/LICENSE-2.0. ↩1 ↩2

  8. Richard Stallman, “The GNU Project,” GNU Project, https://www.gnu.org/gnu/thegnuproject.html. Covers the software-sharing community at the MIT AI Lab before free-software terminology existed, Stallman’s founding of the FSF in 1985, and copyleft as a use of copyright that grants the freedoms on condition that they are passed on. ↩1 ↩2 ↩3

  9. Open Source Initiative, “History of the Open Source Initiative,” https://opensource.org/about/history-of-the-open-source-initiative. The “open source” label was chosen at a strategy session on February 3, 1998, as a business-case label distinct from the “philosophically- and politically-focused” term “free software”; OSI was founded in late February 1998. ↩1 ↩2

  10. Richard Stallman, “Initial Announcement,” GNU Project, posted September 27, 1983, https://www.gnu.org/gnu/initial-announcement.html (the page notes that work actually began in January 1984); Free Software Foundation, “FSF History,” https://www.fsf.org/history. ↩

  11. Free Software Foundation, “GNU General Public License, Version 1,” February 1989, https://www.gnu.org/licenses/old-licenses/gpl-1.0.html. ↩

  12. License texts from the SPDX License List: MIT License, https://spdx.org/licenses/MIT.html; BSD 3-Clause License, https://spdx.org/licenses/BSD-3-Clause.html; BSD-4-Clause (University of California-Specific), https://spdx.org/licenses/BSD-4-Clause-UC.html, which carries the copyright notice of the Regents of the University of California; X11 License, https://spdx.org/licenses/X11.html. SPDX documents the texts, not their institutional history. ↩1 ↩2

  13. Jerome H. Saltzer, “The Origin of the ‘MIT License’,” IEEE Annals of the History of Computing 42, no. 4 (October-December 2020): 94-98, https://doi.org/10.1109/MAHC.2020.3020234 (open access at https://ieeexplore.ieee.org/document/9263265). Saltzer, of MIT’s Laboratory for Computer Science, describes drafting the notice with Larry Allen and the lab’s attorneys in January 1984, its first use in the February 1, 1984 distribution of the PC/IP networking software, and a reworded second version first applied to the X Window System (X10R3) in February 1986. He notes that the account rests largely on his own recollections, supported by documents from his files. The OSI-approved MIT License text differs from these early X notices; see Gordon Haff, “The Mysterious History of the MIT License,” Opensource.com, April 2019, https://opensource.com/article/19/4/history-mit-license. ↩

  14. Free Software Foundation, “GNU Library General Public License, Version 2,” June 1991, https://www.gnu.org/licenses/old-licenses/lgpl-2.0.html (the first released library GPL); “GNU Lesser General Public License, Version 2.1,” February 1999, https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html (the first version under the “Lesser” name). ↩

  15. Mitchell Baker, “January 22, 1998: The Beginning of Mozilla,” January 22, 2008, https://blog.lizardwrangler.com/2008/01/22/january-22-1998-the-beginning-of-mozilla/, reproducing Netscape’s January 22, 1998 announcement that it would release the Communicator source code; Mozilla, “Historical Licensing Documents,” https://www.mozilla.org/en-US/MPL/historical/, which identifies the Netscape Public License 1.0 as the license of the initial Mozilla source release and MPL 1.0 as the original MPL. ↩

  16. Mozilla Public License, Version 1.0, https://www.mozilla.org/MPL/1.0/ (sections 1.7 and 1.9 define “Larger Work” and file-based “Modifications”); the current version is listed at https://www.mozilla.org/en-US/MPL/. ↩

  17. Free Software Foundation, “GNU General Public License, Version 3,” 29 June 2007, https://www.gnu.org/licenses/gpl-3.0.html; Brett Smith, “A Quick Guide to GPLv3,” GNU Project, https://www.gnu.org/licenses/quick-guide-gplv3.html, which describes the patent provisions and the anti-tivoization requirement. ↩

  18. Free Software Foundation, “GNU Affero General Public License, Version 3,” 19 November 2007, https://www.gnu.org/licenses/agpl-3.0.html (section 13 covers remote network interaction); Free Software Foundation, “Why the Affero GPL,” https://www.gnu.org/licenses/why-affero-gpl.html. ↩

  19. Creative Commons, “History,” https://creativecommons.org/about/history/, which dates the first Creative Commons licenses to 2002. ↩

  20. Creative Commons, “Frequently Asked Questions,” https://creativecommons.org/faq/. CC recommends software-specific licenses for code because CC licenses lack source-distribution provisions. The FAQ separately identifies CC0 as GPL-compatible and acceptable for software. CC0 is a public-domain dedication with a fallback license, not an OSI-approved software license. ↩

  21. Free Software Foundation, “What is Free Software?,” GNU Project, https://www.gnu.org/philosophy/free-sw.html. ↩

  22. RISC-V International, “About RISC-V International,” https://riscv.org/about/, which describes RISC-V as an open, royalty-free instruction set architecture standard. ↩

  23. Michael “Monty” Widenius, “Applying the Business Source Licensing (BSL),” Monty says, August 16, 2016, http://monty-says.blogspot.com/2016/08/applying-business-source-licensing-bsl.html; MongoDB, Inc., “MongoDB Issues New Server Side Public License for MongoDB Community Server,” press release, October 16, 2018, https://www.mongodb.com/company/newsroom/press-releases/mongodb-issues-new-server-side-public-license-for-mongodb-community-server. ↩

From But Is It Open? by Timothy O’Brien (Discursive, 2026). © 2026 Timothy O’Brien. All rights reserved.

Chapter 28 min leftNext →

The book, chapter by chapter.

Source note

Go to the notes & sources ↓

The vocabulary.

A short guide to the book’s recurring terms. Follow each chapter for the argument and its sources.

Open weights
A release makes a trained model’s learned parameters available. The accompanying terms decide what you can do with them. Access to weights alone does not provide the training data, code or recipe. Read the chapter →
Copyleft
A way of using license conditions to preserve recipients’ freedoms when covered software is passed on. The obligations depend on the license and on what you distribute or make available. Read the chapter →
Permissive licenses
Licenses such as MIT and Apache 2.0 grant broad reuse rights with comparatively few conditions. Notice obligations still apply, and a software license does not automatically cover a release’s data or other components. Read the chapter →
Reproducibility
The ability to reconstruct and examine how an artifact was produced using the resources that are published. Running an existing checkpoint is a different achievement from rebuilding its training. Read the chapter →
Governance
Who can participate, who makes decisions, and how authority over a project or release is shared. A right to use the code does not by itself create a voice in upstream decisions. Read the chapter →
Training data
The examples used to train a model. Publishing the data, documenting its provenance and describing how it was filtered are distinct kinds of disclosure; privacy and other rights may limit what can be shared. Read the chapter →

A passage worth sharing.

Select a passage in the chapter, or share the one you’re reading.