Copylefting is an ingenious scheme promulgated by the GNU Project under the
aegis of the Free Software Foundation which uses the Copyright law to ensure
that copylefted code remains freely available. The concept seeks to utilize the
licensing mechanism to ensure that all subsequent users of a copylefted program
will have access to the source code of the software, and that any improvements
or modifications that they may make to the software will likewise be made
available to all subsequent users.
"Free software'' refers to the users' freedom to run, copy, distribute, study,
change and improve the software. More precisely, it refers to three levels of
The freedom to study how the program works and adapt it to your needs.
The freedom to redistribute copies so you can share with your neighbor.
The freedom to improve the program, and release your improvements to the
public, so that the whole community benefits.
The analogy that I like to use for copylefted software is that of a Rocky
Mountain stream. Code bubbles up from a clear creative and pristine spring (or
caffeine addled hacker) and flows down through the rocky banks of the software
development community. The author of the software is free to copyright the
software and license it under any terms he wants.
In the case of traditional commercial software, the software company puts up a
fence around the spring and sells bottles of the water to customers. If the
author gave his code to the public domain, there would nothing to prevent an
interloper from coming in and putting up his own fence around the spring. You
can take public domain code, add proprietary changes, and then protect the
entire program. Although the simplest way to make a program free is to put
it in the public domain, uncopyrighted, it is a plunderable
resource. Public domain allows people to share the program and their
improvements, if they are so minded. But it also allows uncooperative people to
convert the program into proprietary software. They can make changes, many or
few, and distribute the result as a proprietary product. People who receive the
program in that modified form do not have the freedom that the original author
gave them; the middleman has stripped it away.
The Free Software Foundation claims that by using the same distribution terms
(the "GPL" and "LGPL") for many different programs, it is easy to copy code
between various different programs. This ensures compatibility of terms.
Ratting out GNU
Given the high moral road taken by the GNU License, one of the most popular
questions is: "How do I get around it?" The reasons for wanting to
do so may range from outright avarice to mere convenience
. There are many different types of software licensed under
GNU. Some are standalone applications, some are libraries, and many are
in between. To see an example of what issues can arise, lets
take the example of some code that performs a traditional library function
that is licensed under the GNU General Public License. This code is
used to perform a relatively minor task in an otherwise Proprietary
program. Once done, the inevitable question is whether or not use of such
a utility imbues the benefits of GNU to the entire application;
or put another way, can this use of the GNU code that is
relatively minor to the application as whole serve to virally infect the
entire application and require that the entire application be distributed under
the GNU License?
The GNU General Public License is necessarily ambiguous considering its scope.
As a general license, it is not designed for any specific type of software, for
any particular platform, or for any particular use or circumstances. Therefore,
by necessity, application of the GNU General Public License requires a fair
amount of interpretation.
The ability to replace GNU code with non-GNU code without modification to the
other code is the traditional acid test for compliance with the GNU License.
Regarding the impact of using the GNU code in a Proprietary
application, the operative paragraph in the GNU General Public License is this
portion of Paragraph 2(c):
"These requirements apply to the modified work as a whole. If identifiable
sections of that work are not derived from the Program, and can reasonably be
considered independent and separate works in themselves, then this License, and
its terms, do not apply to those sections when you distribute them as separate
works. But when you distribute the same sections as part of a whole which is a
work based on the Program, the distribution of the whole must be on the terms
of this License, whose permissions for other licensees extend to the entire
whole, and thus to each and every part regardless of who wrote it."
Generally, the Proprietary application will be an
executable file that contains compiled object code. The object code will
be compiled from the original GNU source code, along with the addition of
any modifications. The modifications made to the GNU source code
clearly constitute a derivative work under copyright law. These changes and
modifications are covered by the GNU License and must be located in the same
directory as the GNU copyright/disclaimer file.
Consequently, you could comply with the terms of the
license by compiling the object code into a separate file
and directory, along with the GNU copyright/disclaimer file. In
this case, the functionality of the GNU code is clearly separated out
and the code provides incidental functionality to the overall program. The
source code of the GNU code and any modifications thereto can be made
available without exposing any other Proprietary code. The GNU code is not
compiled into Proprietary code, thus is not considered "incorporated" into a
Proprietary program. The file containing the GNU code is readily identifiable
and separate. The Proprietary code is clearly identifiable as a separate
section of the program that is not derived from the GNU code.
However, it should be noted here that there may be a
difference between how the GNU code is accessed on different
platforms. For example, there was a time when the Sun platform supported
dynamic linking of libraries, but the HP platform did not. Consequently, the
Sun code would accesses the GNU code dynamically at run-time, whereas the
HP code would have to link (not compile) the GNU code
statically. While it is clear that mechanically the Sun code is in compliance
with the License, the HP code does functionally what the Sun code does.
However, the static linking could arguably create an ambiguity.
The fact that the GNU code is compiled separately, located
in library directory, and used as a functional utility, indicate that
the GNU code is being used in the manner one would use any third-party
utility. This functionality can be replaced by other programs, the
functionality is incidental to the overall program, and the overall design of
the Proprietary program is not predicated on the GNU code.
However, the license itself does not explicitly define
"incorporation" or "works". This raises a possible ambiguity. To resolve
this possibility, you have to resort to traditional contract
interpretation methods and look to the intention of the drafters of the License
for resolution. The stated purpose of the License is to ensure that anyone who
redistributes the software, with or without changes, passes along the freedom
to further copy and change it. Further on in paragraph 2(c), the license
"Thus, it is not the intent of this section to claim rights or
contest your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or collective
works based on the Program."
The GNU License grants to the user a free license to copy,
distribute and/or modify the GNU code. The intent of the license is to protect
free flow of this software. Compiling the GNU code into Proprietary software
and refusing subsequent users access violates the intent of the License. This
would be the case if you compiled the GNU code into
the Proprietary code, and did not make that combined code available to
downstream users. However, if you have kept the GNU code freely
available, as well as added incremental improvements, and made such
improvements freely available to whomever receives the code downstream, then
you have adhered to the intent, and arguably to the letter, of the license .
Consequently, on the issue of ratting out the GNU License, there is
an argument that you may use the GNU freely without concern of
copyright violation, of breach of the GNU General Public License, or of
exposing proprietary code to the terms of the GNU License, as long as the
following is true:
- The library directory contains the copyright/disclaimer file;
- The GNU code is not compiled (as opposed to linked) into Proprietary
- The library directory contains the GNU source code.