path: root/docs/thegnuproject.md

---
Generator: 'texi2html 1.82'
description: Untitled Document
distribution: global
keywords: Untitled Document
resource-type: document
title: Untitled Document
...

1. The GNU Project {#the-gnu-project .chapter}
==================

### The First Software-Sharing Community {#the-first-software-sharing-community .subheading}

When I started working at the MIT Artificial Intelligence Lab in 1971, I
became part of a software-sharing community that had existed for many
years. Sharing of software was not limited to our particular community;
it is as old as computers, just as sharing of recipes is as old as
cooking. But we did it more than most.

The AI Lab used a timesharing operating system called ITS (the
Incompatible Timesharing System) that the lab’s staff
hackers[(1)](#FOOT1) had designed and written in assembler language for
the Digital PDP-10, one of the large computers of the era. As a member
of this community, an AI Lab staff system hacker, my job was to improve
this system.

We did not call our software “free software,” because that term did not
yet exist; but that is what it was. Whenever people from another
university or a company wanted to port and use a program, we gladly let
them. If you saw someone using an unfamiliar and interesting program,
you could always ask to see the source code, so that you could read it,
change it, or cannibalize parts of it to make a new program.

### The Collapse of the Community {#the-collapse-of-the-community .subheading}

The situation changed drastically in the early 1980s when Digital
discontinued the PDP-10 series. Its architecture, elegant and powerful
in the 60s, could not extend naturally to the larger address spaces that
were becoming feasible in the 80s. This meant that nearly all of the
programs composing ITS were obsolete.

@firstcopyingnotice{{@footnoterule @smallskip Copyright © 1998, 2001,
2002, 2005–2008, 2010 Richard Stallman\
 {The original version of this essay was published in Open Sources:
Voices from the Open Source Revolution, by Chris DiBona and others
(Sebastopol: O’Reilly Media, 1999), under the title “The GNU Operating
System and the Free Software Movement.” Though I was never a supporter
of “open source,” I contributed this article anyway, so that the ideas
of the free software movement would not be entirely absent from that
book. This version is part of @fsfsthreecite}

The AI Lab hacker community had already collapsed, not long before. In
1981, the spin-off company Symbolics had hired away nearly all of the
hackers from the AI Lab, and the depopulated community was unable to
maintain itself. (The book Hackers, by Steve Levy, describes these
events, as well as giving a clear picture of this community in its
prime.) When the AI Lab bought a new PDP-10 in 1982, its administrators
decided to use Digital’s nonfree timesharing system instead of ITS.

The modern computers of the era, such as the VAX or the 68020, had their
own operating systems, but none of them were free software: you had to
sign a nondisclosure agreement even to get an executable copy.

This meant that the first step in using a computer was to promise not to
help your neighbor. A cooperating community was forbidden. The rule made
by the owners of proprietary software was, “If you share with your
neighbor, you are a pirate. If you want any changes, beg us to make
them.”

The idea that the proprietary software social system—the system that
says you are not allowed to share or change software—is antisocial, that
it is unethical, that it is simply wrong, may come as a surprise to some
readers. But what else could we say about a system based on dividing the
public and keeping users helpless? Readers who find the idea surprising
may have taken the proprietary software social system as a given, or
judged it on the terms suggested by proprietary software businesses.
Software publishers have worked long and hard to convince people that
there is only one way to look at the issue.

When software publishers talk about “enforcing” their “rights” or
“stopping piracy,”[(2)](#FOOT2) what they actually *say* is secondary.
The real message of these statements is in the unstated assumptions they
take for granted, which the public is asked to accept without
examination. Let’s therefore examine them.

One assumption is that software companies have an unquestionable natural
right to own software and thus have power over all its users. (If this
were a natural right, then no matter how much harm it does to the
public, we could not object.) Interestingly, the US Constitution and
legal tradition reject this view; copyright is not a natural right, but
an artificial government-imposed monopoly that limits the users’ natural
right to copy.

Another unstated assumption is that the only important thing about
software is what jobs it allows you to do—that we computer users should
not care what kind of society we are allowed to have.

A third assumption is that we would have no usable software (or would
never have a program to do this or that particular job) if we did not
offer a company power over the users of the program. This assumption may
have seemed plausible, before the free software movement demonstrated
that we can make plenty of useful software without putting chains on it.

If we decline to accept these assumptions, and judge these issues based
on ordinary commonsense morality while placing the users first, we
arrive at very different conclusions. Computer users should be free to
modify programs to fit their needs, and free to share software, because
helping other people is the basis of society.

There is no room here for an extensive statement of the reasoning behind
this conclusion, so I refer the reader to the articles “Why Software
Should Not Have Owners,” at <http://gnu.org/philosophy/why-free.html>,
and “Free Software Is Even More Important Now” (@pageref{More Important
Now}).

### A Stark Moral Choice {#a-stark-moral-choice .subheading}

With my community gone, to continue as before was impossible. Instead, I
faced a stark moral choice.

The easy choice was to join the proprietary software world, signing
nondisclosure agreements and promising not to help my fellow hacker.
Most likely I would also be developing software that was released under
nondisclosure agreements, thus adding to the pressure on other people to
betray their fellows too. I could have made money this way, and perhaps
amused myself writing code. But I knew that at the end of my career, I
would look back on years of building walls to divide people, and feel I
had spent my life making the world a worse place.

I had already experienced being on the receiving end of a nondisclosure
agreement, when someone refused to give me and the MIT AI Lab the source
code for the control program for our printer. (The lack of certain
features in this program made use of the printer extremely frustrating.)
So I could not tell myself that nondisclosure agreements were innocent.
I was very angry when he refused to share with us; I could not turn
around and do the same thing to everyone else.

Another choice, straightforward but unpleasant, was to leave the
computer field. That way my skills would not be misused, but they would
still be wasted. I would not be culpable for dividing and restricting
computer users, but it would happen nonetheless.

So I looked for a way that a programmer could do something for the good.
I asked myself, was there a program or programs that I could write, so
as to make a community possible once again?

The answer was clear: what was needed first was an operating system.
That is the crucial software for starting to use a computer. With an
operating system, you can do many things; without one, you cannot run
the computer at all. With a free operating system, we could again have a
community of cooperating hackers—and invite anyone to join. And anyone
would be able to use a computer without starting out by conspiring to
deprive his or her friends.

As an operating system developer, I had the right skills for this job.
So even though I could not take success for granted, I realized that I
was elected to do the job. I chose to make the system compatible with
Unix so that it would be portable, and so that Unix users could easily
switch to it. The name GNU was chosen, following a hacker tradition, as
a recursive acronym for “GNU’s Not Unix.”

An operating system does not mean just a kernel, barely enough to run
other programs. In the 1970s, every operating system worthy of the name
included command processors, assemblers, compilers, interpreters,
debuggers, text editors, mailers, and much more. ITS had them, Multics
had them, VMS had them, and Unix had them. The GNU operating system
would include them too.

Later I heard these words, attributed to Hillel:[(3)](#FOOT3) @medskip

> If I am not for myself, who will be for me?\
>  If I am only for myself, what am I?\
>  If not now, when?\

@smallskip The decision to start the GNU Project was based on a similar
spirit.

### Free as in Freedom {#free-as-in-freedom .subheading}

The term “free software” is sometimes misunderstood—it has nothing to do
with price. It is about freedom. Here, therefore, is the definition of
free software.

A program is free software, for you, a particular user, if:

-   You have the freedom to run the program as you wish, for
    any purpose.
-   You have the freedom to modify the program to suit your needs. (To
    make this freedom effective in practice, you must have access to the
    source code, since making changes in a program without having the
    source code is exceedingly difficult.)
-   You have the freedom to redistribute copies, either gratis or for
    a fee.
-   You have the freedom to distribute modified versions of the program,
    so that the community can benefit from your improvements.

Since “free” refers to freedom, not to price, there is no contradiction
between selling copies and free software. In fact, the freedom to sell
copies is crucial: collections of free software sold on CD-ROMs are
important for the community, and selling them is an important way to
raise funds for free software development. Therefore, a program which
people are not free to include on these collections is not free
software.

Because of the ambiguity of “free,” people have long looked for
alternatives, but no one has found a better term. The English language
has more words and nuances than any other, but it lacks a simple,
unambiguous, word that means “free,” as in freedom—“unfettered” being
the word that comes closest in meaning. Such alternatives as
“liberated,” “freedom,” and “open” have either the wrong meaning or some
other disadvantage.

### GNU Software and the GNU System {#gnu-software-and-the-gnu-system .subheading}

Developing a whole system is a very large project. To bring it into
reach, I decided to adapt and use existing pieces of free software
wherever that was possible. For example, I decided at the very beginning
to use TeX as the principal text formatter; a few years later, I decided
to use the X Window System rather than writing another window system for
GNU.

Because of these decisions, and others like them, the GNU system is not
the same as the collection of all GNU software. The GNU system includes
programs that are not GNU software, programs that were developed by
other people and projects for their own purposes, but which we can use
because they are free software.

### Commencing the Project {#commencing-the-project .subheading}

In January 1984 I quit my job at MIT and began writing GNU software.
Leaving MIT was necessary so that MIT would not be able to interfere
with distributing GNU as free software. If I had remained on the staff,
MIT could have claimed to own the work, and could have imposed their own
distribution terms, or even turned the work into a proprietary software
package. I had no intention of doing a large amount of work only to see
it become useless for its intended purpose: creating a new
software-sharing community.

However, Professor Winston, then the head of the MIT AI Lab, kindly
invited me to keep using the lab’s facilities.

### The First Steps {#the-first-steps .subheading}

Shortly before beginning the GNU Project, I heard about the Free
University Compiler Kit, also known as VUCK. (The Dutch word for “free”
is written with a *v.*) This was a compiler designed to handle multiple
languages, including C and Pascal, and to support multiple target
machines. I wrote to its author asking if GNU could use it.

He responded derisively, stating that the university was free but the
compiler was not. I therefore decided that my first program for the GNU
Project would be a multilanguage, multiplatform compiler.

Hoping to avoid the need to write the whole compiler myself, I obtained
the source code for the Pastel compiler, which was a multiplatform
compiler developed at Lawrence Livermore Lab. It supported, and was
written in, an extended version of Pascal, designed to be a
system-programming language. I added a C front end, and began porting it
to the Motorola 68000 computer. But I had to give that up when I
discovered that the compiler needed many megabytes of stack space, and
the available 68000 Unix system would only allow 64k.

I then realized that the Pastel compiler functioned by parsing the
entire input file into a syntax tree, converting the whole syntax tree
into a chain of “instructions,” and then generating the whole output
file, without ever freeing any storage. At this point, I concluded I
would have to write a new compiler from scratch. That new compiler is
now known as GCC; none of the Pastel compiler is used in it, but I
managed to adapt and use the C front end that I had written. But that
was some years later; first, I worked on GNU Emacs.

### GNU Emacs {#gnu-emacs .subheading}

I began work on GNU Emacs in September 1984, and in early 1985 it was
beginning to be usable. This enabled me to begin using Unix systems to
do editing; having no interest in learning to use vi or ed, I had done
my editing on other kinds of machines until then.

At this point, people began wanting to use GNU Emacs, which raised the
question of how to distribute it. Of course, I put it on the anonymous
ftp server on the MIT computer that I used. (This computer,
`prep.ai.mit.edu`, thus became the principal GNU ftp distribution site;
when it was decommissioned a few years later, we transferred the name to
our new ftp server.) But at that time, many of the interested people
were not on the internet and could not get a copy by ftp. So the
question was, what would I say to them?

I could have said, “Find a friend who is on the net and who will make a
copy for you.” Or I could have done what I did with the original PDP-10
Emacs: tell them, “Mail me a tape and a SASE (self-addressed stamped
envelope), and I will mail it back with Emacs on it.” But I had no job,
and I was looking for ways to make money from free software. So I
announced that I would mail a tape to whoever wanted one, for a fee of
\$150. In this way, I started a free software distribution business, the
precursor of the companies that today distribute entire GNU/Linux system
distributions.

### Is a Program Free for Every User? {#is-a-program-free-for-every-user .subheading}

If a program is free software when it leaves the hands of its author,
this does not necessarily mean it will be free software for everyone who
has a copy of it. For example, public domain software[(4)](#FOOT4)
(software that is not copyrighted) is free software; but anyone can make
a proprietary modified version of it. Likewise, many free programs are
copyrighted but distributed under simple permissive licenses which allow
proprietary modified versions.

The paradigmatic example of this problem is the X Window System.
Developed at MIT, and released as free software with a permissive
license, it was soon adopted by various computer companies. They added X
to their proprietary Unix systems, in binary form only, and covered by
the same nondisclosure agreement. These copies of X were no more free
software than Unix was.

The developers of the X Window System did not consider this a
problem—they expected and intended this to happen. Their goal was not
freedom, just “success,” defined as “having many users.” They did not
care whether these users had freedom, only that they should be numerous.

This led to a paradoxical situation where two different ways of counting
the amount of freedom gave different answers to the question, “Is this
program free?” If you judged based on the freedom provided by the
distribution terms of the MIT release, you would say that X was free
software. But if you measured the freedom of the average user of X, you
would have to say it was proprietary software. Most X users were running
the proprietary versions that came with Unix systems, not the free
version.

### Copyleft and the GNU GPL {#copyleft-and-the-gnu-gpl .subheading}

The goal of GNU was to give users freedom, not just to be popular. So we
needed to use distribution terms that would prevent GNU software from
being turned into proprietary software. The method we use is called
“copyleft.”[(5)](#FOOT5)

Copyleft uses copyright law, but flips it over to serve the opposite of
its usual purpose: instead of a means for restricting a program, it
becomes a means for keeping the program free.

The central idea of copyleft is that we give everyone permission to run
the program, copy the program, modify the program, and distribute
modified versions—but not permission to add restrictions of their own.
Thus, the crucial freedoms that define “free software” are guaranteed to
everyone who has a copy; they become inalienable rights.

For an effective copyleft, modified versions must also be free. This
ensures that work based on ours becomes available to our community if it
is published. When programmers who have jobs as programmers volunteer to
improve GNU software, it is copyleft that prevents their employers from
saying, “You can’t share those changes, because we are going to use them
to make our proprietary version of the program.”

The requirement that changes must be free is essential if we want to
ensure freedom for every user of the program. The companies that
privatized the X Window System usually made some changes to port it to
their systems and hardware. These changes were small compared with the
great extent of X, but they were not trivial. If making changes were an
excuse to deny the users freedom, it would be easy for anyone to take
advantage of the excuse.

A related issue concerns combining a free program with nonfree code.
Such a combination would inevitably be nonfree; whichever freedoms are
lacking for the nonfree part would be lacking for the whole as well. To
permit such combinations would open a hole big enough to sink a ship.
Therefore, a crucial requirement for copyleft is to plug this hole:
anything added to or combined with a copylefted program must be such
that the larger combined version is also free and copylefted.

The specific implementation of copyleft that we use for most GNU
software is the GNU General Public License, or GNU GPL for short. We
have other kinds of copyleft that are used in specific circumstances.
GNU manuals are copylefted also, but use a much simpler kind of
copyleft, because the complexity of the GNU GPL is not necessary for
manuals.[(6)](#FOOT6)

### The Free Software Foundation {#the-free-software-foundation .subheading}

As interest in using Emacs was growing, other people became involved in
the GNU project, and we decided that it was time to seek funding once
again. So in 1985 we created the Free Software Foundation (FSF), a
tax-exempt charity for free software development. The FSF also took over
the Emacs tape distribution business; later it extended this by adding
other free software (both GNU and non-GNU) to the tape, and by selling
free manuals as well.

Most of the FSF’s income used to come from sales of copies of free
software and of other related services (CD-ROMs of source code, CD-ROMs
with binaries, nicely printed manuals, all with the freedom to
redistribute and modify), and Deluxe Distributions (distributions for
which we built the whole collection of software for the customer’s
choice of platform). Today the FSF still sells manuals and other
gear,[(7)](#FOOT7) but it gets the bulk of its funding from members’
dues. You can join the FSF at <http://fsf.org/join>.

Free Software Foundation employees have written and maintained a number
of GNU software packages. Two notable ones are the C library and the
shell. The GNU C Library is what every program running on a GNU/Linux
system uses to communicate with Linux. It was developed by a member of
the Free Software Foundation staff, Roland McGrath. The shell used on
most GNU/Linux systems is BASH, the Bourne Again Shell,[(8)](#FOOT8)
which was developed by FSF employee Brian Fox.

We funded development of these programs because the GNU Project was not
just about tools or a development environment. Our goal was a complete
operating system, and these programs were needed for that goal.

### Free Software Support {#free-software-support .subheading}

The free software philosophy rejects a specific widespread business
practice, but it is not against business. When businesses respect the
users’ freedom, we wish them success.

Selling copies of Emacs demonstrates one kind of free software business.
When the FSF took over that business, I needed another way to make a
living. I found it in selling services relating to the free software I
had developed. This included teaching, for subjects such as how to
program GNU Emacs and how to customize GCC, and software development,
mostly porting GCC to new platforms.

Today each of these kinds of free software business is practiced by a
number of corporations. Some distribute free software collections on
CD-ROM; others sell support at levels ranging from answering user
questions, to fixing bugs, to adding major new features. We are even
beginning to see free software companies based on launching new free
software products.

Watch out, though—a number of companies that associate themselves with
the term “open source” actually base their business on nonfree software
that works with free software. These are not free software companies,
they are proprietary software companies whose products tempt users away
from freedom. They call these programs “value-added packages,” which
shows the values they would like us to adopt: convenience above freedom.
If we value freedom more, we should call them “freedom-subtracted”
packages.

### Technical Goals {#technical-goals .subheading}

The principal goal of GNU is to be free software. Even if GNU had no
technical advantage over Unix, it would have a social advantage,
allowing users to cooperate, and an ethical advantage, respecting the
user’s freedom.

But it was natural to apply the known standards of good practice to the
work—for example, dynamically allocating data structures to avoid
arbitrary fixed size limits, and handling all the possible 8-bit codes
wherever that made sense.

In addition, we rejected the Unix focus on small memory size, by
deciding not to support 16-bit machines (it was clear that 32-bit
machines would be the norm by the time the GNU system was finished), and
to make no effort to reduce memory usage unless it exceeded a megabyte.
In programs for which handling very large files was not crucial, we
encouraged programmers to read an entire input file into core, then scan
its contents without having to worry about I/O.

These decisions enabled many GNU programs to surpass their Unix
counterparts in reliability and speed.

### Donated Computers {#donated-computers .subheading}

As the GNU Project’s reputation grew, people began offering to donate
machines running Unix to the project. These were very useful, because
the easiest way to develop components of GNU was to do it on a Unix
system, and replace the components of that system one by one. But they
raised an ethical issue: whether it was right for us to have a copy of
Unix at all.

Unix was (and is) proprietary software, and the GNU Project’s philosophy
said that we should not use proprietary software. But, applying the same
reasoning that leads to the conclusion that violence in self defense is
justified, I concluded that it was legitimate to use a proprietary
package when that was crucial for developing a free replacement that
would help others stop using the proprietary package.

But, even if this was a justifiable evil, it was still an evil. Today we
no longer have any copies of Unix, because we have replaced them with
free operating systems. If we could not replace a machine’s operating
system with a free one, we replaced the machine instead.

### The GNU Task List {#the-gnu-task-list .subheading}

As the GNU Project proceeded, and increasing numbers of system
components were found or developed, eventually it became useful to make
a list of the remaining gaps. We used it to recruit developers to write
the missing pieces. This list became known as the GNU Task List. In
addition to missing Unix components, we listed various other useful
software and documentation projects that, we thought, a truly complete
system ought to have.

Today, [(9)](#FOOT9) hardly any Unix components are left in the GNU Task
List—those jobs had been done, aside from a few inessential ones. But
the list is full of projects that some might call “applications.” Any
program that appeals to more than a narrow class of users would be a
useful thing to add to an operating system.

Even games are included in the task list—and have been since the
beginning. Unix included games, so naturally GNU should too. But
compatibility was not an issue for games, so we did not follow the list
of games that Unix had. Instead, we listed a spectrum of different kinds
of games that users might like.

### The GNU Library GPL {#the-gnu-library-gpl .subheading}

The GNU C Library uses a special kind of copyleft called the GNU Library
General Public License,[(10)](#FOOT10) which gives permission to link
proprietary software with the library. Why make this exception?

It is not a matter of principle; there is no principle that says
proprietary software products are entitled to include our code. (Why
contribute to a project predicated on refusing to share with us?) Using
the LGPL for the C library, or for any library, is a matter of strategy.

The C library does a generic job; every proprietary system or compiler
comes with a C library. Therefore, to make our C library available only
to free software would not have given free software any advantage—it
would only have discouraged use of our library.

One system is an exception to this: on the GNU system (and this includes
GNU/Linux), the GNU C Library is the only C library. So the distribution
terms of the GNU C Library determine whether it is possible to compile a
proprietary program for the GNU system. There is no ethical reason to
allow proprietary applications on the GNU system, but strategically it
seems that disallowing them would do more to discourage use of the GNU
system than to encourage development of free applications. That is why
using the Library GPL is a good strategy for the C library.

For other libraries, the strategic decision needs to be considered on a
case-by-case basis. When a library does a special job that can help
write certain kinds of programs, then releasing it under the GPL,
limiting it to free programs only, is a way of helping other free
software developers, giving them an advantage against proprietary
software.

Consider GNU Readline, a library that was developed to provide
command-line editing for BASH. Readline is released under the ordinary
GNU GPL, not the Library GPL. This probably does reduce the amount
Readline is used, but that is no loss for us. Meanwhile, at least one
useful application has been made free software specifically so it could
use Readline, and that is a real gain for the community.

Proprietary software developers have the advantages money provides; free
software developers need to make advantages for each other. I hope some
day we will have a large collection of GPL-covered libraries that have
no parallel available to proprietary software, providing useful modules
to serve as building blocks in new free software, and adding up to a
major advantage for further free software development.

### Scratching an Itch? {#scratching-an-itch .subheading}

Eric Raymond[(11)](#FOOT11) says that “Every good work of software
starts by scratching a developer’s personal itch.”[(12)](#FOOT12) Maybe
that happens sometimes, but many essential pieces of GNU software were
developed in order to have a complete free operating system. They come
from a vision and a plan, not from impulse.

For example, we developed the GNU C Library because a Unix-like system
needs a C library, BASH because a Unix-like system needs a shell, and
GNU tar because a Unix-like system needs a tar program. The same is true
for my own programs—the GNU C compiler, GNU Emacs, GDB and GNU Make.

Some GNU programs were developed to cope with specific threats to our
freedom. Thus, we developed gzip to replace the Compress program, which
had been lost to the community because of the LZW patents. We found
people to develop LessTif, and more recently started GNOME and Harmony,
to address the problems caused by certain proprietary libraries (see
below). We are developing the GNU Privacy Guard to replace popular
nonfree encryption software, because users should not have to choose
between privacy and freedom.

Of course, the people writing these programs became interested in the
work, and many features were added to them by various people for the
sake of their own needs and interests. But that is not why the programs
exist.

### Unexpected Developments {#unexpected-developments .subheading}

At the beginning of the GNU Project, I imagined that we would develop
the whole GNU system, then release it as a whole. That is not how it
happened.

Since each component of the GNU system was implemented on a Unix system,
each component could run on Unix systems long before a complete GNU
system existed. Some of these programs became popular, and users began
extending them and porting them—to the various incompatible versions of
Unix, and sometimes to other systems as well.

The process made these programs much more powerful, and attracted both
funds and contributors to the GNU Project. But it probably also delayed
completion of a minimal working system by several years, as GNU
developers’ time was put into maintaining these ports and adding
features to the existing components, rather than moving on to write one
missing component after another.

### The GNU Hurd {#the-gnu-hurd .subheading}

By 1990, the GNU system was almost complete; the only major missing
component was the kernel. We had decided to implement our kernel as a
collection of server processes running on top of Mach. Mach is a
microkernel developed at Carnegie Mellon University and then at the
University of Utah; the GNU Hurd is a collection of servers (i.e., a
herd of GNUs) that run on top of Mach, and do the various jobs of the
Unix kernel. The start of development was delayed as we waited for Mach
to be released as free software, as had been promised.

One reason for choosing this design was to avoid what seemed to be the
hardest part of the job: debugging a kernel program without a
source-level debugger to do it with. This part of the job had been done
already, in Mach, and we expected to debug the Hurd servers as user
programs, with GDB. But it took a long time to make that possible, and
the multithreaded servers that send messages to each other have turned
out to be very hard to debug. Making the Hurd work solidly has stretched
on for many years.

### Alix {#alix .subheading}

The GNU kernel was not originally supposed to be called the Hurd. Its
original name was Alix—named after the woman who was my sweetheart at
the time. She, a Unix system administrator, had pointed out how her name
would fit a common naming pattern for Unix system versions; as a joke,
she told her friends, “Someone should name a kernel after me.” I said
nothing, but decided to surprise her with a kernel named Alix.

It did not stay that way. Michael (now Thomas) Bushnell, the main
developer of the kernel, preferred the name Hurd, and redefined Alix to
refer to a certain part of the kernel—the part that would trap system
calls and handle them by sending messages to Hurd servers.

Later, Alix and I broke up, and she changed her name; independently, the
Hurd design was changed so that the C library would send messages
directly to servers, and this made the Alix component disappear from the
design.

But before these things happened, a friend of hers came across the name
Alix in the Hurd source code, and mentioned it to her. So she did have
the chance to find a kernel named after her.

### Linux and GNU/Linux {#linux-and-gnulinux .subheading}

The GNU Hurd is not suitable for production use, and we don’t know if it
ever will be. The capability-based design has problems that result
directly from the flexibility of the design, and it is not clear whether
solutions exist.

Fortunately, another kernel is available. In 1991, Linus Torvalds
developed a Unix-compatible kernel and called it Linux. It was
proprietary at first, but in 1992, he made it free software; combining
Linux with the not-quite-complete GNU system resulted in a complete free
operating system. (Combining them was a substantial job in itself, of
course.) It is due to Linux that we can actually run a version of the
GNU system today.

We call this system version GNU/Linux, to express its composition as a
combination of the GNU system with Linux as the kernel. Please don’t
fall into the practice of calling the whole system “Linux,” since that
means attributing our work to someone else. Please give us equal
mention.[(13)](#FOOT13)

### Challenges in Our Future {#challenges-in-our-future .subheading}

We have proved our ability to develop a broad spectrum of free software.
This does not mean we are invincible and unstoppable. Several challenges
make the future of free software uncertain; meeting them will require
steadfast effort and endurance, sometimes lasting for years. It will
require the kind of determination that people display when they value
their freedom and will not let anyone take it away.

The following four sections discuss these challenges.

#### Secret Hardware {#secret-hardware .subsubheading}

Hardware manufacturers increasingly tend to keep hardware specifications
secret. This makes it difficult to write free drivers so that Linux and
XFree86 can support new hardware. We have complete free systems today,
but we will not have them tomorrow if we cannot support tomorrow’s
computers.

There are two ways to cope with this problem. Programmers can do reverse
engineering to figure out how to support the hardware. The rest of us
can choose the hardware that is supported by free software; as our
numbers increase, secrecy of specifications will become a self-defeating
policy.

Reverse engineering is a big job; will we have programmers with
sufficient determination to undertake it? Yes—if we have built up a
strong feeling that free software is a matter of principle, and nonfree
drivers are intolerable. And will large numbers of us spend extra money,
or even a little extra time, so we can use free drivers? Yes, if the
determination to have freedom is widespread.

\[2008 note: this issue extends to the BIOS as well. There is a free
BIOS, LibreBoot[(14)](#FOOT14) (a distribution of coreboot); the problem
is getting specs for machines so that LibreBoot can support them without
nonfree “blobs.”\]

#### Nonfree Libraries {#nonfree-libraries .subsubheading}

A nonfree library that runs on free operating systems acts as a trap for
free software developers. The library’s attractive features are the
bait; if you use the library, you fall into the trap, because your
program cannot usefully be part of a free operating system. (Strictly
speaking, we could include your program, but it won’t *run* with the
library missing.) Even worse, if a program that uses the proprietary
library becomes popular, it can lure other unsuspecting programmers into
the trap.

The first instance of this problem was the Motif toolkit, back in the
80s. Although there were as yet no free operating systems, it was clear
what problem Motif would cause for them later on. The GNU Project
responded in two ways: by asking individual free software projects to
support the free X Toolkit widgets as well as Motif, and by asking for
someone to write a free replacement for Motif. The job took many years;
LessTif, developed by the Hungry Programmers, became powerful enough to
support most Motif applications only in 1997.

Between 1996 and 1998, another nonfree GUI toolkit library, called Qt,
was used in a substantial collection of free software, the desktop KDE.

Free GNU/Linux systems were unable to use KDE, because we could not use
the library. However, some commercial distributors of GNU/Linux systems
who were not strict about sticking with free software added KDE to their
systems—producing a system with more capabilities, but less freedom. The
KDE group was actively encouraging more programmers to use Qt, and
millions of new “Linux users” had never been exposed to the idea that
there was a problem in this. The situation appeared grim.

The free software community responded to the problem in two ways: GNOME
and Harmony.

GNOME, the GNU Network Object Model Environment, is GNU’s desktop
project. Started in 1997 by Miguel de Icaza, and developed with the
support of Red Hat Software, GNOME set out to provide similar desktop
facilities, but using free software exclusively. It has technical
advantages as well, such as supporting a variety of languages, not just
C++. But its main purpose was freedom: not to require the use of any
nonfree software.

Harmony is a compatible replacement library, designed to make it
possible to run KDE software without using Qt.

In November 1998, the developers of Qt announced a change of license
which, when carried out, should make Qt free software. There is no way
to be sure, but I think that this was partly due to the community’s firm
response to the problem that Qt posed when it was nonfree. (The new
license is inconvenient and inequitable, so it remains desirable to
avoid using Qt.)

\[Subsequent note: in September 2000, Qt was rereleased under the GNU
GPL, which essentially solved this problem.\]

How will we respond to the next tempting nonfree library? Will the whole
community understand the need to stay out of the trap? Or will many of
us give up freedom for convenience, and produce a major problem? Our
future depends on our philosophy.

#### Software Patents {#software-patents .subsubheading}

The worst threat we face comes from software patents, which can put
algorithms and features off limits to free software for up to twenty
years. The LZW compression algorithm patents were applied for in 1983,
and we still cannot release free software to produce proper compressed
GIFs. \[As of 2009 they have expired.\] In 1998, a free program to
produce MP3 compressed audio was removed from distribution under threat
of a patent suit.

There are ways to cope with patents: we can search for evidence that a
patent is invalid, and we can look for alternative ways to do a job. But
each of these methods works only sometimes; when both fail, a patent may
force all free software to lack some feature that users want. What will
we do when this happens?

Those of us who value free software for freedom’s sake will stay with
free software anyway. We will manage to get work done without the
patented features. But those who value free software because they expect
it to be technically superior are likely to call it a failure when a
patent holds it back. Thus, while it is useful to talk about the
practical effectiveness of the “bazaar” model of development, and the
reliability and power of some free software, we must not stop there. We
must talk about freedom and principle.

#### Free Documentation {#free-documentation .subsubheading}

The biggest deficiency in our free operating systems is not in the
software—it is the lack of good free manuals that we can include in our
systems. Documentation is an essential part of any software package;
when an important free software package does not come with a good free
manual, that is a major gap. We have many such gaps today.

Free documentation, like free software, is a matter of freedom, not
price. The criterion for a free manual is pretty much the same as for
free software: it is a matter of giving all users certain freedoms.
Redistribution (including commercial sale) must be permitted, online and
on paper, so that the manual can accompany every copy of the program.

Permission for modification is crucial too. As a general rule, I don’t
believe that it is essential for people to have permission to modify all
sorts of articles and books. For example, I don’t think you or I are
obliged to give permission to modify articles like this one, which
describe our actions and our views.

But there is a particular reason why the freedom to modify is crucial
for documentation for free software. When people exercise their right to
modify the software, and add or change its features, if they are
conscientious they will change the manual, too—so they can provide
accurate and usable documentation with the modified program. A nonfree
manual, which does not allow programmers to be conscientious and finish
the job, does not fill our community’s needs.

Some kinds of limits on how modifications are done pose no problem. For
example, requirements to preserve the original author’s copyright
notice, the distribution terms, or the list of authors, are OK. It is
also no problem to require modified versions to include notice that they
were modified, even to have entire sections that may not be deleted or
changed, as long as these sections deal with nontechnical topics. These
kinds of restrictions are not a problem because they don’t stop the
conscientious programmer from adapting the manual to fit the modified
program. In other words, they don’t block the free software community
from making full use of the manual.

However, it must be possible to modify all the *technical* content of
the manual, and then distribute the result in all the usual media,
through all the usual channels; otherwise, the restrictions do obstruct
the community, the manual is not free, and we need another manual.

Will free software developers have the awareness and determination to
produce a full spectrum of free manuals? Once again, our future depends
on philosophy.

### We Must Talk about Freedom {#we-must-talk-about-freedom .subheading}

Estimates today are that there are ten million users of GNU/Linux
systems such as Debian GNU/Linux and Red Hat “Linux.” Free software has
developed such practical advantages that users are flocking to it for
purely practical reasons.

The good consequences of this are evident: more interest in developing
free software, more customers for free software businesses, and more
ability to encourage companies to develop commercial free software
instead of proprietary software products.

But interest in the software is growing faster than awareness of the
philosophy it is based on, and this leads to trouble. Our ability to
meet the challenges and threats described above depends on the will to
stand firm for freedom. To make sure our community has this will, we
need to spread the idea to the new users as they come into the
community.

But we are failing to do so: the efforts to attract new users into our
community are far outstripping the efforts to teach them the civics of
our community. We need to do both, and we need to keep the two efforts
in balance.

### “Open Source” {#open-source .subheading}

Teaching new users about freedom became more difficult in 1998, when a
part of the community decided to stop using the term “free software” and
say “open source software” instead.

Some who favored this term aimed to avoid the confusion of “free” with
“gratis”—a valid goal. Others, however, aimed to set aside the spirit of
principle that had motivated the free software movement and the GNU
Project, and to appeal instead to executives and business users, many of
whom hold an ideology that places profit above freedom, above community,
above principle. Thus, the rhetoric of “open source” focuses on the
potential to make high-quality, powerful software, but shuns the ideas
of freedom, community, and principle.

The “Linux” magazines are a clear example of this—they are filled with
advertisements for proprietary software that works with GNU/Linux. When
the next Motif or Qt appears, will these magazines warn programmers to
stay away from it, or will they run ads for it?

The support of business can contribute to the community in many ways;
all else being equal, it is useful. But winning their support by
speaking even less about freedom and principle can be disastrous; it
makes the previous imbalance between outreach and civics education even
worse.

“Free software” and “open source” describe the same category of
software, more or less, but say different things about the software, and
about values. The GNU Project continues to use the term “free software,”
to express the idea that freedom, not just technology, is important.

### Try! {#try .subheading}

Yoda’s aphorism (“There is no ‘try’”) sounds neat, but it doesn’t work
for me. I have done most of my work while anxious about whether I could
do the job, and unsure that it would be enough to achieve the goal if I
did. But I tried anyway, because there was no one but me between the
enemy and my city. Surprising myself, I have sometimes succeeded.

Sometimes I failed; some of my cities have fallen. Then I found another
threatened city, and got ready for another battle. Over time, I’ve
learned to look for threats and put myself between them and my city,
calling on other hackers to come and join me.

Nowadays, often I’m not the only one. It is a relief and a joy when I
see a regiment of hackers digging in to hold the line, and I realize,
this city may survive—for now. But the dangers are greater each year,
and now Microsoft has explicitly targeted our community. We can’t take
the future of freedom for granted. Don’t take it for granted! If you
want to keep your freedom, you must be prepared to defend it.

<div class="footnote">

------------------------------------------------------------------------

### Footnotes

### [(1)](#DOCF1)

@raggedright The use of “hacker” to mean “security breaker” is a
confusion on the part of the mass media. We hackers refuse to recognize
that meaning, and continue using the word to mean someone who loves to
program, someone who enjoys playful cleverness, or the combination of
the two. See my article “On Hacking,” at
<http://stallman.org/articles/on-hacking.html>. @end raggedright

### [(2)](#DOCF2)

@raggedright See @pageref{Piracy} for more on the erroneous use of the
term “piracy.” @end raggedright

### [(3)](#DOCF3)

@raggedright As an Atheist, I don’t follow any religious leaders, but I
sometimes find I admire something one of them has said. @end raggedright

### [(4)](#DOCF4)

@raggedright See @pageref{Category Public Domain Software} for more on
public domain software. @end raggedright

### [(5)](#DOCF5)

@raggedright In 1984 or 1985, Don Hopkins (a very imaginative fellow)
mailed me a letter. On the envelope he had written several amusing
sayings, including this one: “Copyleft—all rights reversed.” I used the
word “copyleft” to name the distribution concept I was developing at the
time. @end raggedright

### [(6)](#DOCF6)

@raggedright We now use the GNU Free Documentation License
(@pageref{FDL}) for documentation. @end raggedright

### [(7)](#DOCF7)

@raggedright See our online shop, at <http://shop.fsf.org>. @end
raggedright

### [(8)](#DOCF8)

@raggedright “Bourne Again Shell” is a play on the name “Bourne Shell,”
which was the usual shell on Unix. @end raggedright

### [(9)](#DOCF9)

@raggedright That was written in 1998. In 2009 we no longer maintain a
long task list. The community develops free software so fast that we
can’t even keep track of it all. Instead, we have a list of High
Priority Projects, a much shorter list of projects we really want to
encourage people to write. @end raggedright

### [(10)](#DOCF10)

@raggedright This license is now called the GNU Lesser General Public
License, to avoid giving the idea that all libraries ought to use it.
See “Why You Shouldn’t Use the Lesser GPL for Your Next Library,” at
<http://www.gnu.org/philosophy/why-not-lgpl.html>, for more information.
@end raggedright

### [(11)](#DOCF11)

@raggedright Eric Raymond is a prominent open source advocate; see “Why
Open Source Misses the Point of Free Software” (@pageref{OS Misses
Point}). @end raggedright

### [(12)](#DOCF12)

@raggedright Eric S. Raymond, The Cathedral and the Bazaar: Musings on
Linux and Open Source by an Accidental Revolutionary, rev. ed.
(Sebastopol, Calif.: O’Reilly, 2001), p. 23. @end raggedright

### [(13)](#DOCF13)

@raggedright See the “GNU/Linux FAQ,” at
<http://gnu.org/gnu/gnu-linux-faq.html>, and “Linux and the GNU System”
(@pageref{Linux and GNU}) for more on this issue. @end raggedright

### [(14)](#DOCF14)

@raggedright See <http://libreboot.org>. @end raggedright

</div>

------------------------------------------------------------------------

This document was generated by *tonghuix* on *March 25, 2016* using
[*texi2html 1.82*](http://www.nongnu.org/texi2html/).\