Combining GPL and non-GPL code

Chris Travers chris at
Wed Aug 15 22:44:58 UTC 2007

Hi all;

IANAL, of course.  But this topic seems to me to be a huge mess.  My own 
advice would be, "don't do it unless you talk to a lawyer first." The 
rest of this discussion is about my thoughts why certain apparently 
questionable practices might in fact be permitted under the license.

Consider two obvious examples:  ndiswrapper and the closed source Linux 
drivers from nVidia.  I have not heard a clear argument that either one 
of these, as generally distributed separately from the Linux kernel, is 
a GPL violation.  In fact I think that neither one is.

In the case of ndiswrapper, you have a program which is clearly 
derivative of the Linux kernel which is licensed under terms compatible 
with the GPL.  This program, however, allows the kernel to dynamically 
link to a set of closed-source Windows drivers which otherwise would not 
work.  Before people say "linking is not permitted," I would  point out:

1)  the closed source drivers are *clearly* not derivatives of the Linux 
kernel since they were written and tested for the NT kernel.

2)  The closed source drivers, when downloaded from the hardware vendors 
site can hardly be considered to be part of the same "work as a whole" 
as the Linux kernel.

Since the closed source drivers are neither derivative nor part of the 
Linux kernel's copyrighted work as a whole, it is hard to see how they 
are covered under the GPL v2.

As for the nVidia drivers, you have a similar case.  The driver software 
was written for an environment other than Linux, there is a LGPL'd 
wrapper, and the driver is distributed as a separate work.  Derivative 
portions are licensed in terms compatible with the GPL.  I would point 
out that the FSF would be entirely within their means to help Linux 
kernel developers go after nVidia for this, but they have not done so to 
my knowledge, perhaps because nVidia has a very defensible position?

I suspect that the question of whether a GPL-incompatible portion of an 
application falls within the scope of the GPL would depend on whether it 
is really part of the covered work (not clearly defined in any version 
of the license) and whether it is derivative (also not clearly defined 
in the license).  If these are clearly not the cse, I would think that a 
developer would be safe but I would still recommend asking lawyers for 
additional inormation.

The big question that remains is this:  If nVidia is within their rights 
to offer a means to mix their closed-source drivers with the GPL'd Linux 
kernel, does that necessarily mean that distributors are free to 
distribute those drivers with the Linux kernel?  Or would this make them 
part of the covered work, thus opening up distributors who do offer both 
to copyright infringement lawsuits even where the original developer was 
not guilty of such infringement?

As to the contrived GPL/BSD questions:
 >Do you honestly think you would win this argument that you can strip 
off the GPL just

>because a BSD version exists somewhere? 

No I don't actually.  If you could show that you did have a copy of the 
BSD application somewhere but had not, say, even looked at it, it would 
be a harder case to make.  But I would question who is the bigger fool 
in such a hypothetical lawsuit:  you or the defendant.  In both cases, 
it seems to me that this is effectively a non-issue provided that both 
programs are publically available (one could argue that by making the 
original BSD code publically available, if this in fact was done, you 
had granted the public as a whole permission to use it as such).  At any 
rate such a lawsuit would probably cost both parties a lot of time and 
money and solve very little if the BSD code was publically available.

"Final Judgement:  The Defendant is hereby ordered to download the BSD 

However, if the BSD code was not your own, one might question your 
copyright ownership of the code fragments in question and that would be 
another issue.

Key lesson-- probably a good idea to ask a lawyer.

One more point from a while back:

"From a pragmatic point of view, although GPL requires you to mark source

code changes, in the real world this doesn't always happen.  The user
who has received a copy of a derivative should see the original
BSD copyrights intact in the sources, but he/she is probably ill-advised
to assume the original code is also intact."

My reading of the GPL does not require a GPL project maintainer to change files from
BSD-licensed to GPL-licensed.  If the file has a BSD copyright/License notice, I would 
argue that it is BSD-licensed *regardless of* its place in a larger GPL project.

Similarly nothing in the GPL prevents an author from releasing half of the code under
other licenses provided that these licenses are compatible with the GPL.

Hence it probably doesn't matter if the original code is intact if the original license
and copyright notice is.  By including that copyright notice  (even for a stated part
of the file), I would argue that the author has *granted you* all relevant rights under
the BSD license.

"If the code does contain any modifications, if those modifications are made to a 
GPL'd derivative they are automatically GPL." 

No.  If those modifications are derivative of code covered under the GPL to which the
author does not have rights to grant additional licenses, then they must be released 
under the same license.  This may be simple or complex to evaluate depending on the 
structure of the project.

I create a project consisting of 100 BSD libraries and 1 GPL'd library.  I choose to 
release the main logic of the program under the GPL in order to comply with the GPL'd
library's license.  In the process of the code, I make
changes to 3 of the BSD libraries in order to solve interop issues between them.  These
changes do *not* involve any intimate knowledge of the data structures of the GPL'd 
code.  Are the final BSD files as distributed as a part of a larger GPL'd work required
by the GPL to now be under the GPL just because I made changes which had *nothing* to
do with the GPL'd portions of the application?  If I keep the BSD license intact in the 
files, and someone does use them in proprietary software, can I sue them for failing to
apply a license *I* never applied to the code?

Granted this is a huge mess and can of worms.  Back to:  If you want to do this, hire a
lawyer for advice, ask a *lot* of questions, and then pay him a *large* retainer :-)

Best Wishes,
Chris Travers
-------------- next part --------------
A non-text attachment was scrubbed...
Name: chris.vcf
Type: text/x-vcard
Size: 171 bytes
Desc: not available
URL: <>

More information about the License-discuss mailing list