Making the program a GNU software package means explicitly contributing to the GNU Project. That happens only if the developers and the GNU Project agree to do it. If you are interested in contributing a program to the GNU Project, please write to gnu@gnu.org .

Some have proposed alternatives to the GPL that require modified versions to go through the original author. As long as the original author keeps up with the need for maintenance, this may work well in practice, but if the author stops (more or less) to do something else or does not attend to all the users' needs, this scheme falls down. Aside from the practical problems, this scheme does not allow users to help each other.

Sometimes control over modified versions is proposed as a means of preventing confusion between various versions made by users. In our experience, this confusion is not a major problem. Many versions of Emacs have been made outside the GNU Project, but users can tell them apart. The GPL requires the maker of a version to place his or her name on it, to distinguish it from other versions and to protect the reputations of other maintainers.

But if you release the modified version to the public in some way, the GPL requires you to make the modified source code available to the users, under the GPL.

Thus, the GPL gives permission to release the modified program in certain ways, and not in other ways; but the decision of whether to release it is up to you.

If you commercially distribute binaries not accompanied with source code, the GPL says you must provide a written offer to distribute the source code later. When users noncommercially redistribute the binaries they received from you, they must pass along a copy of this written offer. This means that people who did not get the binaries directly from you can still receive copies of the binaries, along with the written offer.

The reason we require the offer to be valid for any third party is so that people who receive the binaries indirectly in that way can order the source code from you.

The GPL is a free software license, and therefore it permits people to use and even redistribute the software without being required to pay anyone a fee for doing so.

It might be tempting to include a URL that refers to the license, instead of the license itself. But you cannot be sure that the URL will still be valid, five years or ten years from now. Twenty years from now, URLs as we know them today may no longer exist.

The only way to make sure that people who have copies of the program will continue to be able to see the license, despite all the changes that will happen in the network, is to include a copy the license in the program.

For some licenses, the way in which the combination is made may affect whether they are compatible--for instance, they may allow linking two modules together, but not allow merging their code into one module.

The GPL permits such a combination provided it is released under the GNU GPL. The other license is compatible with the GPL if it permits this too.

     However, as a special exception, the source code distributed need not
     include anything that is normally distributed (in either source or
     binary form) with the major components (compiler, kernel, and so on) of
     the operating system on which the executable runs, unless that
     component itself accompanies the executable.

then you don't have to do anything special to use them. In other words, if the libraries you need come with major parts of a proprietary operating system, the GPL says people can link your program with them.

If you want your progam to link against a library not covered by that exception, you need to add your own exception, wholly outside of the GPL. This copyright notice and license notice give permission to link with the program FOO:

   Copyright (C) yyyy  <name of copyright holder>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    As a special exception, <name of copyright holder> gives permission
    to link this program with FOO, and distribute the resulting
    executable, without including the source code for the FOO in the
    source distribution.

Only the copyright holders for the program can legally authorize this exception. If you wrote the whole program yourself, then assuming your employer or school does not claim the copyright, you are the copyright holder--so you can authorize the exception. But if you want to use parts of other GPL-covered programs by other authors in your code, you cannot authorize the exception for them. You have to get the approval of the copyright holders of those programs.

When other people modify the program, they do not have to make the same exception for their code--it is their choice whether to do so.

Adding this exception eliminates the legal issue, but does nothing about the more serious problem of using a non-free library: your program won't be fully usable in a free environment. If your program depends on a non-free library to do a certain job, it cannot do that job in the Free World. If it depends on a non-free library to run at all, it cannot be part of a free operating system such as GNU; it is entirely off limits to the Free World.

So please consider: can you find a way to get the job done without using this library? Can you write a free replacement for that library?

If the program is already written using the non-free library, perhaps it is too late to change the decision. You may as well release the program as it stands, rather than not release it. But please mention in the README that the need for the non-free library is a drawback, and suggest the task of changing the program so that it does the same job without the non-free library.

Also please tell us (gnu@gnu.org) us about the non-free library and what job it does. We could encourage people to develop a free library to do the same job.

However, registering the copyright in the US is a very good idea. It will give you more clout in dealing with an infringer in the US.

The case when someone else might possibly claim the copyright is if you are an employee or student; then the employer or the school might claim you did the job for them and that the copyright belongs to them. Whether they would have a valid claim would depend on circumstances such as the laws of the place where you live, and on your employment contract and what sort of work you do. It is best to consult a lawyer if there is any possible doubt.

If you think that the employer or school might have a claim, you can resolve the problem clearly by getting a copyright disclaimer signed by a suitably authorized officer of the company or school. (Your immediate boss or a professor is usually NOT authorized to sign such a disclaimer.)

If you see any chance that your school might refuse to allow your program to be released as free software, it is best to raise the issue at the earliest possible stage. The closer the program is to working usefully, the more temptation the administration might feel to take it from you and finish it without you. At an earlier stage, you have more leverage.

So we recommend that you approach them when the program is only half-done, saying, "If you will agree to releasing this as free software, I will finish it." Don't think of this as a bluff. To prevail, you must have the courage to say, "My program will have liberty, or never be born."

The license that comes in your copy, assuming it was put in by the copyright holder and that you got the copy legitimately, is the license that applies to your copy.

However, if the developer does something that would violate the GPL if done by someone else, the developer will surely lose moral standing in the community.

Some programs copy parts of themselves into the output for technical reasons--for example, Bison copies a standard parser program into its output file. In such cases, the copied text in the output is covered by the same license that covers it in the source code. Meanwhile, the part of the output which is derived from the program's input inherits the copyright status of the input.

As it happens, Bison can also be used to develop non-free programs. This is because we decided to explicitly permit the use of the Bison standard parser program in Bison output files without restriction. We made the decision because there were other tools comparable to Bison which already permitted use for non-free programs.

So the only way you have a say in the use of the output is if substantial parts of the output are copied (more or less) from text in your program. For instance, part of the output of Bison (see above) would be covered by the GNU GPL, if we had not made an exception in this specific case.

You could artificially make a program copy certain text into its output even if there is no technical reason to do so. But if that copied text serves no practical purpose, the user could simply delete that text from the output and use only the rest. Then he would not have to obey the conditions on redistribution of the copied text.

But you can give additional permission for the use of your code. You can, if you wish, release your program under a license which is more lax than the GPL but compatible with the GPL. The license list page gives a partial list of GPL-compatible licenses.

    You may not impose any further restrictions on the recipients' exercise
    of the rights granted herein.

The advertising clause provides just such a further restriction, and thus is GPL-incompatible.

The revised BSD license does not have the advertising clause, which eliminates the problem.

If the program dynamically links plug-ins, and they make function calls to each other and share data structures, we believe they form a single program, so plug-ins must be treated as extensions to the main program. This means they must be released under the GPL or a GPL-compatible free software license.

If the program dynamically links plug-ins, but the communication between them is limited to invoking the `main' function of the plug-in with some options and waiting for it to return, that is a borderline case.

If the program dynamically links plug-ins, and they make function calls to each other and share data structures, we believe they form a single program, so plug-ins must be treated as extensions to the main program. This means that linking the GPL-covered plug-in with the main program would violate the GPL. However, you can resolve that legal problem by adding an exception to your program's license which gives permission to link it with the non-free main program.

For more details, see the question above that starts with, "I am writing free software that uses a non-free library."

You always have the legal alternative of not using our code.

• To make my software work, it must be linked it to the FOO library, which is available under the Lesser GPL.
• My software makes a system call (with a command line that I built) to the BAR program, which is licensed under "the GPL, with a special exception allowing for linking with BAZ".

Combining two modules means connecting them together so that they form a single larger program. If either part is covered by the GPL, the whole combination must also be released under the GPL--if you can't, or won't, do that, you may not combine them.

What constitutes combining two parts into one program? This is a legal question, which ultimately judges will decide. We believe that a proper criterion depends both on the mechanism of communication (exec, pipes, rpc, function calls within a shared address space, etc.) and the semantics of the communication (what kinds of information are interchanged).

If the modules are included in the same executable file, they are definitely combined in one program. If modules are designed to run linked together in a shared address space, that almost surely means combining them into one program.

By contrast, pipes, sockets and command-line arguments are communication mechanisms normally used between two separate programs. So when they are used for communication, the modules normally are separate programs. But if the semantics of the communication are intimate enough, exchanging complex internal data structures, that too could be a basis to consider the two parts as combined into a larger program.

We also ask individual contributors to get copyright disclaimers from their employers (if any) so that we can be sure those employers won't claim to own the contributions.

If you want to make an effort to enforce the GPL on your program, it is probably a good idea for you to follow a similar policy. Please contact licensing@gnu.org if you want more information.

These requirements are the condition for including the GPL-covered code you received in a program of your own.

However, for manuals and textbooks, or more generally any sort of work that is meant to teach a subject, we recommend using the GFDL rather than the GPL.

A system incorporating a GPL-covered program is an extended version of that program. The GPL says that any extended version of the program must be released under the GPL if it is released at all. This is for two reasons: to make sure that users who get the software get the freedom they should have, and to encourage people to give back improvements that they make.

However, in many cases you can distribute the GPL-covered software alongside your proprietary system. To do this validly, you must make sure that the free and non-free programs communicate at arms length, that that they are not combined in a way that would make them effectively a single program.

The difference between this and "incorporating" the GPL-covered software is partly a matter of substance and partly form. The substantive part is this: if the two programs are combined so that they become effectively two parts of one program, then you can't treat them as two separate programs. So the GPL has to cover the whole thing.

If the two programs remain well separated, like the compiler and the kernel, or like an editor and a shell, then you can treat them as two separate programs--but you have to do it properly. The issue is simply one of form: how you describe what you are doing. Why do we care about this? Because we want to make sure the users clearly understand the free status of the GPL-covered software in the collection.

If people were to distribute GPL-covered software calling it "part of" a system that users know is partly proprietary, users might be uncertain of their rights regarding the GNU software. But if they know that what they have received is a free program plus another program, side by side, their rights will be clear.

First, a general one. If we permitted company A to make a propriatary file, and company B to distribute GPL-covered software linked with that file, the effect would be to make a hole in the GPL big enough to drive a truck through. This would be carte blanche for withholding the source code for all sorts of modifications and extensions to GPL-covered software.

Giving all users access to the source code is one of our main goals, so this consequence is definitely something we want to avoid.

More directly, the versions of the programs linked with the Money Guzzler libraries would not really be free software as we understand the term--they would not come with full source code that enables users to change and recompile the program.

When a user says he wants the source, you have to make sure to get the source to that user. If a particular user can conveniently get the source from you by anonymous FTP, fine--that does the job. But not every user is on a network. The rest of the users are just as entitled to get the source code from you. So you have to be ready to send it to them, on a disk or tape by snail mail.

Of course, it's easiest to just send the source with the binary in the first place.

Note, however, that it is not enough to find some site that happens to have the appropriate source code today, and tell people to look there. Tomorrow that site may have deleted that source code, or simply replaced it with a newer version of the same program. Then you would no longer be complying with the GPL requirements. To make a reasonable effort to comply, you need to make a positive arrangement with the other site, and thus ensure that the source will be available there for as long as you keep the binaries available.

Part of the idea of free software is that users should have access to the source code for *the programs they use*. Those using your version should have access to the source code for your version.

A major goal of the GPL is to build up the Free World by making sure that improvement to a free program are themselves free. If you release an improved version of a GPL-covered program, you must release the improved source code under the GPL.

A user that wants the source a year from now may be unable to get the proper version from the FSF at that time. We might have a newer version, but the same diffs probably won't work with that version.

So you need to provide complete sources, not just diffs, with the binaries.

So if you want to distribute binaries by anonymous FTP, you have to distribute sources along with them. This should not be hard. If you can find a site to distribute your program, you can surely find one that has room for the sources.

The sources you provide must correspond exactly to the binaries. In particular, you must make sure they are for the same version of the program--not an older version and not a newer version.

You can make the sources and binaries available on different machines, provided they are equally easy to get to, and provided that you have information next to the binaries saying where to find the sources.

Our requirements for redistributors are intended to make sure the users can get the source code, not to force users to download the source code even if they don't want it.

Sometimes a localized retreat is a good strategy. Sometimes, using the LGPL for a library might lead to wider use of that library, and thus to more improvement for it, wider support for free software, and so on. This could be good for free software if it happens to a large extent. But how much will this happen? We can only speculate.

It would be nice to try out the LGPL on each library for a while, see whether it helps, and change back to the GPL if the LGPL didn't help. But this is not feasible. Once we use the LGPL for a particular library, changing back would be difficult.

So we decide which license to use for each library on a case-by-case basis. There is a long explanation of how we judge the question.

Maximizing the number of users is not our aim. Rather, we are trying to give the crucial freedoms to as many users as possible. In general, proprietary software projects hinder rather than help the cause of freedom.

We do occasionally make license exceptions to assist a project which is producing free software under a license other than the GPL. However, we have to see a good reason why this will advance the cause of free software.

We also do sometimes change the distribution terms of a package, when that seems clearly the right way to serve the cause of free software, but we are very cautious about this, and you will have to show us very convincing reasons.

If each program lacked the indirect pointer, we would be forced to discuss the change at length with numerous copyright holders, which would be a virtual impossibility. In practice, the chance of having uniform distribution terms for GNU software would be nil.

Suppose a program says "Version 2 of the GPL or any later version" and a new version of the GPL is released. If the new GPL version gives additional permission, that permission will be available immediately to all the users of the program. But if the new GPL version has a tighter requirement, it will not restrict use of the current version of the program, because it can still be used under GPL version 2. When a program says "Version 2 of the GPL or any later version", users will always be permitted to use it, and even change it, according to the terms of GPL version 2--even after later versions of the GPL are available.

If a tighter requirement in a new version of the GPL need not be obeyed for existing software, how is it useful? Once GPL version 3 is available, the developers of most GPL-covered programs will release subsequent versions of their programs specifying "Version 3 of the GPL or any later version". Then users will have to follow the tighter requirements in GPL version 3, for subsequent versions of the program.

However, developers are not obligated to do this; developers can continue allowing use of the previous version of the GPL, if that is their preference.

The GPL was designed for programs; it contains lots of complex clauses that are important for programs, but that are dead weight for a book or manual. Conversely, the GFDL has clauses that help publishers of free manuals make a profit from them.

We permit changes in the text that covers technical topics, but we do not permit changes in sections that state our legal or political or ethical position. We do this by explicitly listing the sections that may not be changed. The GFDL makes provisions for these "invariant sections"--the GPL would not allow them.

It is important to permit changes in technical parts, because people who change a program ought to change the documentation to correspond. We can't require them to do this job, but if we hope they will, we had better not stand in their way.

A legal document is in some ways like a program. Translating it is like translating a program from one language and operating system to another. Only a lawyer skilled in both languages can do it--and even then, there is a risk of introducing a bug.

If we were to approve, officially, a translation of the GPL, we would be giving everyone permission to do whatever the translation says they can do. If it is a completely accurate translation, that is fine. But if there is an error in the translation, the results could be a disaster which we could not fix.

If a program has a bug, we can release a new version, and eventually the old version will more or less disappear. But once we have given everyone permission to act according to a particular translation, we have no way of taking back that permission if we find, later on, that it had a bug.

Helpful people sometimes offer to do the work of translation for us. If the problem were a matter of finding someone to do the work, this would solve it. But the actual problem is the risk of error, and offering to do the work does not avoid the risk. We could not possibly authorize a translation written by a non-lawyer.

Therefore, for the time being, we are not not approving translations of the GPL as globally valid and binding. Instead, we are doing two things:

• Referring people to unofficial translations.

  This means that we permit people to write translations of the GPL, but we don't approve them as legally valid and binding.

  An unapproved translation has no legal force, and it should say so explicitly. It should be marked as follows:

      This translation of the GPL is informal, and not officially approved
      by the Free Software Foundation as valid.  To be completely sure of
      what is permitted, refer the original GPL (in English).
  

  But the unapproved translation can serve as a hint for how to understand the English GPL. For many users, that is sufficient.

  However, businesses using GNU software in commercial activity, and people doing public ftp distribution, should need to check the real English GPL to make sure of what it permits.

• Publishing translations valid for a single country only.

  We are considering the idea of publishing translations which are officially valid only for one country. This way, if there is a mistake, it will be limited to that country, and the damage will not be too great.

  It will still take considerable expertise and effort from a sympathetic and capable lawyer to make a translation, so we cannot promise any such translations soon.

Return to GNU's home page.

Please send FSF & GNU inquiries & questions to gnu@gnu.org. There are also other ways to contact the FSF.

Please send comments on these web pages to webmasters@gnu.org, send other questions to gnu@gnu.org.

Copyright (C) 2001 Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA

Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.

Updated: $Date: 2001/05/24 05:11:47 $ $Author: paulv $