Chapter 2 The Manifesto and the License (circa 1985) (c. 1985)

The text appeared without fanfare in the March 1985 issue of Dr. Dobb’s Journal of Software Tools, nestled among advertisements for compilers and listings of Pascal code. It was typeset in the publication’s standard font, a block of dense prose under a simple, declarative title: “The GNU Manifesto.” Its opening sentence was not an appeal but a statement of fact, a declaration of war issued from a quiet corner of the technical press. “GNU, which stands for Gnu’s Not Unix, is the name for the complete Unix-compatible software system which I am writing so that I can give it away free to everyone who can use it.” The pressure that had built in an empty lab, born from a printer that could not speak, had found its form. Here was its declaration of intent. The author was identified as Richard Stallman, an American free software movement activist and programmer who campaigned for software to be distributed so users had the freedom to use, study, distribute, and modify it. The prose was direct, unadorned, and relentless. It laid out a plan to build an entire operating system, piece by piece, and then it explained why such a monumental task was not just practical but morally necessary.

The manifesto was not a dream; it was a blueprint. It was the codification of a grievance into a crusade, and its publication marked the moment the idea left one man’s mind and entered the circulatory system of the nascent digital world. The document performed several crucial operations at once. First, it named the enemy: proprietary software. It framed the issue not as one of convenience or cost but of freedom. “The fundamental act of friendship among programmers is the sharing of programs,” it stated, arguing that the existing market mechanisms had “destroyed” this community. Software hoarding, it claimed, “cuts at the heart of programming.” This was the philosophical core, transforming a technical frustration into a social and ethical breach. Second, it addressed the obvious, pragmatic objections head-on. Would programmers not starve if they gave their work away? The manifesto offered a detailed economic rebuttal, suggesting that programming would become a service rather than a product-based profession.

It clarified a critical point of semantics that would echo for decades: free software meant “free as in freedom, not free as in free beer.” This distinction, which Stallman would later expand into the four essential freedoms, was essential; it separated the movement from mere hobbyism or cheap distribution and anchored it in a principle of liberty. Third, it issued a call to arms. It asked for contributions of time, money, machines, and programs. It was a recruiting poster for an army of engineers to build a commonwealth of code. The manifesto’s power lay in its synthesis of utopian vision and practical detail. It spoke of a world where cooperation replaced competition, where users controlled their tools, where the “fundamental act of friendship” was restored. Yet it also contained a FAQ section, tackling questions about Unix compatibility, GNU’s relationship to the public domain, and how to contribute. It was both a sermon and a manual. Its publication created a pole. One could now be for or against the principles of the GNU Project. A line had been drawn in the sand of source code. The response was not universal acclaim.

To many in the burgeoning commercial software industry, it seemed quixotic, even naive. To others in academia and corporate research labs, it resonated with a fading ethos of open exchange. But its existence as a published document meant the idea was now loose, subject to interpretation, adoption, and contradiction. It had become a public fact. Yet a manifesto, however eloquent, is only words. It could inspire, persuade, and define, but it could not protect. It could not prevent a piece of software released in the spirit of freedom from being taken, modified, made proprietary, and locked away again. The idealism of the manifesto required a legal engine to make it self-sustaining. The vision of a free operating system needed a mechanism to ensure that every component, and every component built upon those components, remained free. Without this, the entire project would be fragile, vulnerable to appropriation by the very forces it opposed. The philosophical imperative demanded a legal innovation. Thus, parallel to the drafting and dissemination of the manifesto, another document was being crafted: the GNU General Public License.

If the manifesto was the movement’s declaration of independence, the GPL would be its constitution, its binding legal covenant. The creation of this license was an act of profound legal craftsmanship. Its challenge was unique: to use the existing framework of copyright law—a law designed to restrict copying and create monopolies—to achieve the opposite effect. The goal was to guarantee perpetual freedom to use, study, share, and modify. The solution was a conceptual inversion so elegant it would later be termed “copyleft.” The license did not relinquish copyright; instead, it asserted copyright very specifically to attach conditions to the work’s distribution. Anyone was free to redistribute the software, with or without changes, provided that any distributed version carried the same license terms. The freedom granted was infectious. It could not be stripped away downstream. If you used GPL-licensed code in your own work, your combined work had to be licensed under the GPL. The license acted as a conceptual virus, propagating its own terms through any software ecosystem it touched.

This was not an accident but the core of its design. The first version of the GNU General Public License, finalized in 1989, was the legal embodiment of the manifesto’s morality. Its preamble explicitly linked law to philosophy: “The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software—to make sure the software is free for all its users.” It then laid out the precise terms. It granted the four essential freedoms: the freedom to run the program for any purpose; to study how the program works and adapt it, which requires access to source code; to redistribute copies; and to improve the program and release improvements to the public. The critical, revolutionary clause was Section 2(b), which stated that modified versions, if released, must be “licensed as a whole at no charge to all third parties under the terms of this License.” This was the copyleft heart.

It ensured that freedom was not a one-time gift but a persistent condition, binding the chain of derivatives back to the original grant. This legal machinery transformed reactive protest into a proactive, replicable model for collective action. Stallman and early collaborators had engineered a tool that turned the power of the state—the enforcement of copyright—to a novel end. They created a self-replicating legal construct. A company could take GPL code, incorporate it, and sell it, but it could not then close the source. The code and the freedom traveled together. The license made the manifesto’s community enforceable. It provided a standardized, portable legal framework that could outlive its founders and operate autonomously. Anyone, anywhere, could now take this license and apply it to their own work, injecting the same principles into it and binding all future users. The movement now had its foundational tool. The isolated incident of the locked printer driver had generated a systemic response.

The feeling of betrayal had been distilled into a principle, and that principle had been encoded into a license that could be attached to any piece of intellectual work. The synthesis of manifesto and license marked the critical transition from personal grievance to codified ideological and legal framework. The manifesto provided the “why,” the GPL provided the “how.” One was public rhetoric, aimed at hearts and minds; the other was private law, aimed at governing actions and preserving a state of liberty. Together, they formed the basic infrastructure for a new kind of software production. They established the rules of engagement for a territory that did not yet fully exist: the territory of free software. This was not the inevitable result of external conditions like cheaper computers or growing networks. It was a deliberate human choice to respond to those conditions with a specific, engineered ideology and a novel legal instrument. The movement chose to build its own institutions rather than accept the emerging proprietary norms.

The construction of these documents was a portrait of their principal architect in a specific moment. Richard Stallman began work on GNU Emacs in 1984 to produce a free software alternative to the proprietary Gosling Emacs. This practical work proceeded alongside the theoretical and legal drafting. The Emacs project was an early testbed for the principles being formulated. It required not just coding but the creation of a community that could share and modify the work. The lessons from this effort fed back into the refining of the license’s terms. The activism was not separate from the engineering; each informed the other. Stallman argued that software users should have the freedom to share with their neighbors and be able to study and make changes to the software that they use. He maintained that attempts by proprietary software vendors to prohibit these acts were antisocial and unethical. The manifesto and the GPL were the twin outlets for this argument, one for the court of public opinion, the other for the court of law.

The manifesto’s rhetorical architecture was as carefully engineered as the software it championed. Its structure mimicked that of a technical FAQ or a software manual, a familiar format to its intended audience of programmers and engineers. This deliberate choice lent an air of pragmatic authority to its moral claims; it presented freedom not as a vague abstraction but as a series of operational requirements. By preemptively answering objections about programmer livelihoods, Unix compatibility, and copyright status, it disarmed practical skepticism and forced debate onto the philosophical ground it had staked out. The document functioned as a recursive argument: it defined the problem as broken social relations, proposed a solution in technical construction, and then justified that construction by appealing to the very social relations it aimed to restore. This circular logic was not a flaw but a strength, creating a self-reinforcing ideological system. The manifesto did not merely describe a community; it performed an act of community-building through its mode of address. It spoke to “you,” the programmer, as a potential participant in a collective endeavor, appealing simultaneously to professional pride, ethical conviction, and the sheer pleasure of solving interesting problems without obstruction.

The dissemination strategy was as significant as the text itself. Publishing in Dr. Dobb’s Journal placed the manifesto within the established circuit of software tools and hobbyist exchange, but its simultaneous posting across Usenet newsgroups injected it directly into the emerging networked public sphere. On Usenet, it was not a static article but a living document subject to immediate comment, critique, and discussion. This dual-channel release reflected a keen understanding of the media ecology of the mid-1980s: one foot in the legitimizing world of print trade publications, another in the anarchic, conversational space where technical culture was being forged in real time. The ensuing discussions on nets like net. unix-wizards or net. usoft became an extension of the manifesto itself, a public workshop where its ideas were stress-tested. Stallman engaged in these debates tirelessly, refining his arguments in response to challenges about feasibility, economics, and license design. This process transformed the manifesto from a monologue into a dialogue, embedding its principles within a growing discourse.

While the manifesto articulated the “why,” its power would remain discursive without a mechanism to govern the “what”—the actual code. The development of the GNU General Public License was therefore an exercise in applied philosophy, a translation of ethical axioms into legally binding sentences. This translation was not accomplished by Stallman alone. Early collaborators, including legal scholars like Professor Eben Moglen (who would later become chief counsel for the Free Software Foundation) and fellow programmers familiar with copyright nuances, provided critical feedback on draft language. Their discussions grappled with a central tension: how to make freedom legally contagious without making the license so restrictive it would deter adoption or be unenforceable in court. The goal was to create a license that was both ideologically pure and pragmatically robust—a tool that could survive encounters with proprietary legal departments.

The crafting of Section 2(b), the copyleft clause, represented this synthesis. Its logic was deceptively simple: if you distribute modified versions, you must distribute them under the same terms. But this simple rule created a complex legal inheritance. It meant freedom could not be unilaterally revoked by any downstream user; each recipient inherited both the rights and the obligations. This turned copyright from a shield for exclusivity into a conduit for reciprocity. The legal innovation lay in using the state’s enforcement power—the threat of copyright infringement lawsuits—not to prevent sharing, but to mandate it under specific conditions. It was a judo move against proprietary software, using its own weight against it. Drafting language precise enough to achieve this in varying jurisdictions, while withstanding accusations of being “anti-commercial,” required meticulous iteration. Each word—“distribute,” “modified,” “whole”—carried significant legal weight and was debated for its implications.

The license’s preamble served as its philosophical anchor, explicitly linking its dry clauses back to the manifesto’s moral vision. This was strategic legal craftsmanship. In potential legal disputes, courts often look to statements of intent to interpret specific terms. By embedding the “four freedoms” and the critique of restrictive licenses directly into the license text, Stallman and his collaborators ensured that judges could not interpret the GPL as merely another proprietary software agreement; its purpose as a freedom-preserving instrument was integral to its identity. This made the GPL not just a set of rules but a purpose-driven legal institution.

The release of GNU Emacs under this nascent license in 1985-1986 provided the first real-world test bed. Version 13, the first public release, was made on March 20, 1985. The Emacs distribution did not merely include source code; it came bundled with the license text itself, making acceptance of its terms a prerequisite for use and modification. This practice established a critical norm: the license traveled with the code inseparably. Users encountering GNU Emacs were thus introduced to copyleft logic through direct experience before they might ever read the manifesto. They learned that they could freely modify this powerful tool, but if they chose to redistribute their versions, they were bound to pass along those same freedoms. This created a practical education in principled cooperation.

Reactions from the broader software industry and legal community were initially muted but held undertones of skepticism or dismissal. To corporate attorneys accustomed to end-user license agreements (EULAs) designed solely to limit liability and restrict use, the GPL appeared alien—a document that granted rights rather than withholding them seemed perverse. Some open-source pioneers of later years would criticize copyleft as overly restrictive or “viral,” but in 1985-1989, that very quality was its defining revolutionary feature. It was not designed for mere permissive openness; it was engineered for sustainable ideological defense.

The creation of these two documents—the manifesto and the license—established a replicable model for institutionalizing dissent. They demonstrated that a movement could build its own governance tools from within an oppressive legal framework. This was not protest through negation but through constructive substitution: offering a working alternative with its own rules. The model proved portable beyond software; later movements for open hardware, open access publishing, and creative commons licensing would directly emulate this dual approach of visionary declaration coupled with enforceable legal innovation.

Stallman’s role evolved from coder to movement-builder during this period precisely through this document-centric labor. Writing compilers like GCC demanded one kind of technical brilliance; drafting licenses demanded another—a brilliance of conceptualization and persuasive definition. The pressure he faced was immense: to articulate a compelling future without sounding utopian, and to devise ironclad legal protections without sounding draconian. His almost monastic dedication to textual precision in both domains reveals a figure who believed that words—whether in source code comments or license clauses—were the primary substance from which reality could be reshaped.

Thus, by 1989, while GNU still lacked its kernel (the core piece needed for an operating system), it possessed something arguably more foundational: a complete social technology stack comprised of declarative philosophy and recursive law. This stack could operate independently of any single piece of software or any single leader; it provided an operating system for collective action itself.
The pressure thus shifted from doctrine to construction

For all its conceptual brilliance, the GPL in early 1989 was an untested instrument. It was a released construct, a new piece of legal technology sitting on the bench. It had not yet been challenged in court. Its terms had not yet been dissected by corporate lawyers seeking loopholes. Its viral nature had not yet propagated through a major commercial product. It existed in a state of potential energy. It governed early GNU utilities like GCC and GNU Emacs, but these were tools for programmers, not end-users. The grand goal—a complete free operating system—remained distant, a kernel short of fulfillment. The license was the lock, but the house was only partly built. The movement had its bible and its law code. It had a growing collection of tools. But it lacked its central unifying platform. The consequence of this duality—a powerful legal mechanism in search of a kingdom—was a period of suspended animation. The pressure thus shifted from doctrine to construction. The manifesto had issued a call; the GPL had provided the rules of the workspace.

Now the work itself had to accelerate, or the entire edifice risked becoming a beautiful theory, admired by a few but irrelevant to the world. The license’s viability depended on something to govern, something valuable enough that people would both use it and test its boundaries. It awaited its proving ground, a project large enough, desirable enough, to make the copyleft condition matter on a scale its authors envisioned. The blueprint was finished. The foundation was laid. The legal virus was written, but it needed a host body of significant size to begin its replication in earnest. The next pressure was the pressure of the unbuilt city, waiting for its cathedral, waiting for a kernel around which an entire world could coalesce under the terms of this new and untested constitution.