The History of Software Licensing

Software licensing is the legal framework that governs the use, modification, and distribution of computer programs.^[16] Because software exists simultaneously as a functional machine instruction and a written literary work, it occupies a unique position in intellectual property law. The mechanisms used to control software have evolved from physical hardware barriers in the mainframe era to complex legal contracts, copyright assertions, and patent claims in the modern digital economy.

The historical development of these licenses reflects a continuous negotiation between commercial entities seeking to protect research and development investments, and collaborative communities seeking to share foundational technologies. This tension has produced distinct licensing models, ranging from strictly proprietary end user license agreements to permissive open source licenses that require no financial compensation.

Understanding this history requires examining the technical constraints of early computing, the antitrust pressures applied to monopoly hardware manufacturers, the adaptation of copyright concepts to digital media, and the shift from local execution to cloud hosted distributed systems. Each era of software licensing was directly caused by a shift in how software was physically or electronically delivered to the end user. The legal fiction of the software license, where a user purchases a right to use rather than physical ownership of a copy, remains the foundational concept of the modern software industry.

The Era of Bundled Software and Informal Sharing (1950s to 1969)

In the 1950s and 1960s, the commercial software industry did not exist. Computers like the UNIVAC I or the IBM 704 were massive capital investments, often costing over two million dollars. The business model of the computing industry was entirely focused on selling or leasing hardware. Software, consisting of operating systems, input and output utilities, and compilers, was viewed as a necessary secondary component required to make the hardware function. Manufacturers bundled this software with the machine at no additional cost.

Because the hardware was the sole source of revenue, manufacturers had no incentive to restrict the distribution of software. Source code, the human readable instructions written in languages like FORTRAN or assembly, was routinely distributed to customers on punched cards or magnetic tape. Users were expected to modify the source code to fix bugs or adapt the programs to their specific scientific or business needs. Programmers working at universities, aerospace companies, and government laboratories frequently found themselves solving the same computational problems.

This environment fostered informal sharing networks. In 1955, users of the IBM 704 formed SHARE^[1], a cooperative group that maintained a library of software routines. Members freely exchanged code, establishing early conventions for collaborative development. The SHARE library included machine diagnostics, the SAP assembler, and various compilers. This collaboration eventually led to the creation of the SHARE Operating System for the IBM 7090. A Software Reference Manual for the IBM 704^[2] was published by SHARE in 1956; the Computer History Museum merely hosts it and provides exhibit text detailing how user groups traded software and documentation they wrote for their mainframe computers. Similarly, the Digital Equipment Computer Users Society was formed in 1961 to share software for DEC minicomputers.

During this period, software was not considered a trade secret or a copyrightable work. The barrier to entry was the cost of the computer itself, rendering the legal protection of the code unnecessary. If a rival company obtained a copy of an IBM sorting algorithm, the code was useless without the multimillion dollar IBM hardware required to execute it.

The Unbundling of Software and the Birth of the Commercial Market (1969 to 1979)

The informal sharing model collapsed at the end of the 1960s due to legal and commercial pressures on International Business Machines. By the late 1960s, IBM controlled roughly 70 percent of the computer market, primarily through the massive success of the System/360 mainframe architecture. Competitors and the United States Department of Justice scrutinized IBM for monopolistic practices, specifically arguing that bundling software and hardware prevented independent software developers from competing. The Association of Data Processing Service Organizations heavily lobbied for transparent pricing.

On January 17, 1969, the Department of Justice filed a massive antitrust lawsuit, United States v. IBM. In response to this legal threat, IBM announced on June 23, 1969, that it would unbundle its software and services from its hardware. Effective January 1970, IBM customers had to pay separate fees for systems engineering services, educational classes, and software programs.

This single corporate decision birthed the commercial software industry. Independent software vendors could now compete on a level playing field, as hardware buyers were no longer receiving operating utilities and applications for free from IBM. Companies like Informatics General, which produced the MARK IV data management system, saw massive growth. However, this new commercial market required a legal mechanism to prevent customers from simply copying the software they had purchased and giving it to others.

The legal status of software was highly ambiguous in the early 1970s. It was unclear whether software should be protected by patents, copyrights, or trade secrets. The United States Patent Office was reluctant to grant patents for software, viewing programs as unpatentable mathematical algorithms. Trade secret law required strict confidentiality agreements, which were impractical for mass market distribution. Copyright law, traditionally applied to books and music, seemed the most viable option, but it was uncertain if machine readable code on a magnetic tape qualified as a literary work.

To resolve this ambiguity, the United States Congress established the National Commission on New Technological Uses of Copyrighted Works in 1974. The commission was tasked with studying how copyright law should accommodate the creation of new works by automatic systems and machine reproduction. In its Final Report, issued in 1978, the commission recommended that computer programs be explicitly recognized as copyrightable subject matter. The commission argued that software, like a book, contained original expression and that protecting this expression would incentivize the creation of new software.

Congress adopted these recommendations in the Computer Software Copyright Amendments of 1980, which amended the Copyright Act of 1976^[3]. The 1980 amendments defined a computer program as a set of statements or instructions to be used directly or indirectly in a computer in order to bring about a certain result. This legislation firmly established that software was protected by copyright, giving developers the exclusive right to reproduce, distribute, and modify their code. It also included Section 117, which provided a limited exception allowing the owner of a copy of a computer program to make an archival or backup copy.

The Microcomputer Revolution and Proprietary EULAs (1970s to 1980s)

As mainframe computing gave way to the microcomputer revolution in the late 1970s and early 1980s, the software market expanded from large corporations to individual consumers. The introduction of machines like the Altair 8800, the Apple II, and the IBM Personal Computer created a massive demand for operating systems, word processors, and spreadsheet applications.

This era was marked by a significant cultural clash between the hobbyist community, which retained the sharing ethos of the mainframe era, and the emerging commercial software developers. This tension was famously articulated by Bill Gates in his Open Letter to Hobbyists^[4], published in February 1976. Gates, whose company Micro-Soft had developed a version of BASIC for the Altair 8800, expressed frustration that hobbyists were freely copying and distributing his software without paying for it. He argued that this unauthorized copying was essentially theft and that it removed the financial incentive for developers to write high quality software. Gates asked the community if quality software would ever be written for the hobby market if developers were not compensated.

To protect their intellectual property in the mass market, software companies fundamentally changed how they distributed their products. Instead of providing the human readable source code, companies began distributing only the machine readable object code. Object code is the compiled binary instructions that the computer processor executes. Distributing only the compiled binary made it exceedingly difficult for users to understand, modify, or copy the underlying logic of the program.

In addition, software companies adopted the End User License Agreement.^[17] Under the first sale doctrine^[5] of traditional copyright law, a person who buys a physical book owns that specific copy and can resell it or lend it to a friend. Software companies wanted to avoid this doctrine because a software copy can be duplicated perfectly with no degradation in quality. Rather than selling a copy of the software outright, companies structured the transaction as a license. The user was merely purchasing a license to use the software under specific conditions dictated by the developer.^[16]

These licenses were often presented as shrink wrap agreements. The terms and conditions were printed on the outside of the software box or included inside the manual, and the user was deemed to have accepted the terms by breaking the plastic shrink wrap seal or by installing the software. Shrink wrap licenses routinely prohibited reverse engineering, limited the software use to a single computer, and disclaimed all warranties.^[18]

The legal enforceability of shrink wrap licenses was initially contested. Critics argued that they were contracts of adhesion, forced upon consumers without an opportunity for negotiation. However, the landmark 1996 case ProCD, Inc. v. Zeidenberg^[6] validated the shrink wrap model. In this case, ProCD sold a database of telephone directories on CD-ROM, with a shrink wrap license restricting the database to non commercial use. Matthew Zeidenberg purchased the software and made the database available on the internet for a fee. The United States Court of Appeals for the Seventh Circuit ruled in favor of ProCD, holding that the vendor is the master of the offer and may invite acceptance by conduct, such as using the software after having an opportunity to review the license. This ruling cemented the license agreement as the standard legal mechanism for proprietary software distribution.

The Free Software Movement and Copyleft (1980s to 1990s)

The aggressive commercialization of software and the proliferation of restrictive license agreements provoked a strong ideological backlash. At the Massachusetts Institute of Technology Artificial Intelligence Laboratory, a programmer named Richard Stallman witnessed the transition from a collaborative academic environment to a closed, proprietary culture. When a new laser printer jammed and Stallman was unable to access the source code to fix the driver, he viewed the restriction as a fundamental injustice.

In 1983, Stallman announced the GNU Project, an ambitious effort to create a completely free, Unix like operating system. To support this work, he founded the Free Software Foundation in 1985. Stallman defined free software^[7] not in terms of price, but in terms of liberty. He articulated four essential freedoms. Freedom zero is the freedom to run the program for any purpose. Freedom one is the freedom to study how the program works and change it. Freedom two is the freedom to redistribute copies. Freedom three is the freedom to distribute copies of modified versions to others.

To legally guarantee these freedoms, Stallman pioneered a revolutionary licensing concept called copyleft. Traditional copyright uses the law to restrict the distribution and modification of a work. Copyleft uses the exact same copyright law to ensure that the work remains free.

In 1989, Stallman published the first version of the GNU General Public License^[8]. The license granted users the right to copy, modify, and distribute the software, but it included a crucial condition. Any modified versions or derivative works must also be distributed under the exact same license terms. This reciprocal clause ensured that the software, and any improvements made to it by others, would remain in the public commons in perpetuity. It prevented a corporation from taking free software, making proprietary modifications, and selling the result as a closed source product.^[19]

The GNU General Public License version 2^[9], released in 1991, became the most influential free software license in history. Its preamble explicitly stated its purpose, noting that the licenses for most software are designed to take away freedom to share and change it, whereas the General Public License is intended to guarantee freedom to share and change free software.

The success of this licensing model was cemented by the development of the Linux kernel. In 1991, a Finnish student named Linus Torvalds began writing a Unix like kernel and eventually released it under the second version of the General Public License. The combination of the Linux kernel and the GNU operating system components created a highly capable, free operating system that could compete with proprietary Unix systems and Microsoft Windows. The reciprocal nature of the license encouraged thousands of developers and corporations to contribute to Linux, knowing that their competitors could not appropriate their work without sharing their own improvements.

The Open Source Definition and Commercial Pragmatism (Late 1990s to 2000s)

While the Free Software Movement was highly successful in producing code, its moral and political rhetoric alienated many corporate executives. The term free software was often misunderstood as meaning zero cost, and the ideological insistence on software freedom made businesses hesitant to adopt copyleft licensed code.

In 1998, a pivotal event shifted the industry perspective. Netscape Communications, facing intense competition from Microsoft Internet Explorer, announced that it would release the source code for its Netscape Communicator web browser. This decision demonstrated that releasing source code could be a viable strategic business decision rather than purely a moral crusade.

Following the Netscape announcement, a group of technology leaders sought to rebrand the free software movement to make it more palatable to the corporate world. The term "open source" was coined by Christine Peterson at a February 1998 meeting in Mountain View, California, which Bruce Perens did not attend, to emphasize the practical, engineering benefits of collaborative development, such as faster bug fixing and higher code quality, rather than the ethical imperatives of software freedom.

To formalize this new approach, Raymond and Perens founded the Open Source Initiative^[10] in February 1998. The first major task for the organization was to establish a clear, objective standard for what constituted an open source license. Bruce Perens drafted the Open Source Definition^[11], which was heavily based on the Debian Free Software Guidelines he had previously written.

The Open Source Definition outlined ten criteria that a license must meet to be considered open source. These included free redistribution, access to source code, permission for derived works, and a strict prohibition against discriminating against any persons, groups, or fields of endeavor. Crucially, the definition accommodated a wider variety of licenses than the strict copyleft model championed by the Free Software Foundation.

The Open Source Initiative began reviewing and approving licenses that met these criteria. This created a taxonomy of open source licenses, broadly categorized into two camps.^[19] The first camp included copyleft licenses like the General Public License. The second camp included permissive licenses, such as the MIT License, the BSD License, and the Apache License. Permissive licenses allow users to modify and distribute the software, but they do not require derivative works to be released under the same license. A developer can take MIT licensed code, incorporate it into a proprietary application, and keep their modifications closed source.

This pragmatic approach led to the massive commercial adoption of open source software in the 2000s. Companies realized they could build their infrastructure on open source foundations, collaborating on non differentiating technologies like operating systems and web servers, while reserving their proprietary efforts for the application layer. It also gave rise to dual licensing business models. A company could offer its database under a copyleft license for open source projects, but sell a commercial license to corporations that wanted to embed the database in proprietary software without triggering reciprocal sharing requirements.

Software Patents and the Cloud Computing Loophole (2000s to 2020s)

As the software industry matured, licensing became increasingly entangled with patent law. While copyright protects the specific expression of a program, a patent protects the underlying idea, method, or algorithm. In the late 1990s, the United States Patent and Trademark Office began issuing thousands of software patents.

This created a minefield for software developers, particularly in the open source community. A developer could write original code from scratch, ensuring no copyright infringement, but still violate a broad software patent held by a large corporation. Patent trolls, which are non practicing entities that acquire patents solely to extract licensing fees, became a significant threat to collaborative software development.

The tension over software patents culminated in the 2014 Supreme Court case Alice Corp. v. CLS Bank International. The Court ruled that merely implementing an abstract idea on a generic computer does not transform that idea into a patent eligible invention. This decision invalidated many broad software patents and provided some relief to developers, but patents remain a complex factor in software licensing. Modern open source licenses, such as the Apache License 2.0 and the GNU General Public License version 3^[12], include explicit patent grant clauses. These clauses ensure that contributors grant a license to any of their patents that are implemented in the software, protecting users from patent litigation by the contributors.

Simultaneously, the rise of cloud computing and Software as a Service^[13] fundamentally disrupted the traditional licensing paradigm.^[20] Historically, software licensing, and the triggering of copyleft obligations, was tied to the physical or electronic distribution of a copy of the software. If a company modified copyleft licensed software and distributed the compiled binary to customers, they were required to release their modified source code.

However, in the cloud computing model, the software runs on a remote server. The user interacts with the software over a network, but no copy of the software is ever distributed to the user local machine. This created the software as a service loophole. A cloud provider could take copyleft licensed software, make proprietary modifications to optimize it for their cloud infrastructure, and offer it as a service without ever distributing the software. Because there was no distribution, the requirement to share the modified source code was never triggered.

To close this loophole, the Affero General Public License was released by Affero, Inc. in 2002; the Free Software Foundation released the GNU Affero General Public License version 3^[14] in 2007. The Affero license includes a specific provision stating that if the modified program is intended to interact with users through a computer network, the operator must make the source code available to those users.

Despite the creation of the Affero license, the tension between open source developers and major cloud providers escalated in the late 2010s. Companies that invested heavily in developing open source infrastructure software found that massive cloud providers were taking their open source code, hosting it as a managed service, and capturing the majority of the revenue without contributing back to the project.

In response, several of these companies began abandoning approved open source licenses in favor of new, highly restrictive licenses. In 2018, the database company MongoDB introduced the Server Side Public License. This license was based on the third version of the General Public License but included a sweeping clause stating that anyone offering the software as a service must release the source code not just for the software itself, but for the entire management, backup, and hosting infrastructure used to run the service.

MongoDB submitted the new license to the Open Source Initiative for approval, arguing that it was a necessary evolution of copyleft for the cloud era. However, the submission sparked intense backlash. Critics argued that the license was designed to be impossible for cloud providers to comply with, effectively acting as a proprietary license that forced providers to negotiate a commercial agreement with MongoDB. The Open Source Initiative indicated that the license violated the Open Source Definition by restricting specific fields of endeavor, specifically cloud hosting. Facing certain rejection, MongoDB withdrew the license from the review process. The Open Source Initiative later published a formal statement declaring that The SSPL is Not an Open Source License^[15].

The adoption of these source available licenses marked a significant fracture in the software licensing ecosystem. It highlighted the limitations of traditional open source models in an era where the primary value of software is derived from operational hosting rather than the physical distribution of code.

Conclusion

The history of software licensing demonstrates the constant adaptation of the technology industry to changing hardware constraints and legal frameworks. From the bundled mainframes of the 1950s, where code was freely shared among a small community of engineers, to the unbundling of the 1970s that birthed the commercial software market, the mechanisms of control have continually evolved.

The proprietary shrink wrap licenses of the microcomputer era established software as a highly lucrative, tightly controlled commodity. In direct opposition, the free software and open source movements leveraged copyright law to create a vast, collaborative commons that now forms the foundational infrastructure of the global internet. Today, as computing shifts from local execution to cloud based services, the industry is once again renegotiating the terms of software access and ownership. Whether through permissive open source models, strict copyleft requirements, or new service oriented proprietary licenses, the software license remains the fundamental legal instrument that dictates how technology is built, shared, and monetized.