Getting Around the GPL

[mmurfin87]

I would like to keep this to a purely "is it possible" discussion and save ALL commentary on the morality of it for a different thread.

I was just sitting around thinking about this earlier and came up with a concept that I though might work. Then a bing search brought this link (http://windyroad.org/2006/04/20/using-gpl-code-within-proprietory-code/) up and it is basically what my idea is about.

Assume that I write a program with well defined links where GPL code would fit. Assume that I write library modules that define those links and link to GPL code through those modules.

Assume that before distribution I replace those modules with ones that don't use any GPL code, but just use dummy code/data, or even completely different libraries licensed appropriately for my use. Then I release my program under whatever proprietary license I want.

So far, since I'm not distributing any GPL code, this is all perfectly valid and legal.

Now that my program is released under its proprietary license, I offer, as part of its own package completely separate from the original program, updated modules for that program that do in fact use the GPL and comply with the GPL in every way.

The original program can be as proprietary as it wants to as long as it doesn't distribute any GPL code, even if GPL modules are available for separate add on.

[mmurfin87]

My feeling is that this is completely legal and would stand up in court as long as the original modules weren't just stub programs and actually did allow something productive to be done. In other words, as long as this wasn't a completely blatant attempt then there is nothing illegal about it.

It could even be obvious and be legal as long as there was some original functionality.

[wmarone]

You can't have a discussion about "Getting around the GPL" without bringing the morality into it as the GPL is making a moral statement.

You can't link proprietary software to GPL libraries unless those libraries are licensed under the LGPL. Not even through a weasly shim layer you play license games with. The only exception to this rule is with the Linux kernel, where GPL stubs are used to adapt a proprietary driver blob.

My feeling is that this is completely legal and would stand up in court as long as the original modules weren't just stub programs and actually did allow something productive to be done. In other words, as long as this wasn't a completely blatant attempt then there is nothing illegal about it.

It could even be obvious and be legal as long as there was some original functionality.

Then why bother going through the effort of adapting to the GPL modules, unless you're just looking to freeload? On top of that, I believe there are bits in the GPL3 that were made to counter such attempts at legal dodges.

[slaapliedje]

It sounds to me like what you want is something that is LGPL'd. I believe that linking to GPL'd code isn't allowed, but then I also think that any of the libraries are already LGPL

http://www.gnu.org/licenses/lgpl.html

Then again, there are things like the nVidia binary blob that in essence has a GPL'd... crap, I can't recall what they called it, but it sounded like shank! Anyhow, it has a sort of wrapper than then talks to the binary blob for the driver. Similar to what you're talking about.

Now if you're talking about having GPL'd extensions as a separate add on to a proprietary application.. I'm not sure. I wouldn't think there would be a problem there.

Edit: the post above was made at the same time as mine and the word I was looking for was SHIM.

[lcuk]

ok

so lets put this in perspective.

you have gpl app/widget/library/tool called appG
it performs a certain function.

you aim to completely rewrite appG with a proprietary version which replicates the functionality of appG and is fuzzy compatible with its parameters and api

just so you can switch it out sometimes?

answer me this, if you went to the trouble of rewriting appG yourself and it works - why the hell would you bother saying you have a dubious method of circumventing the gpl?

its not like its a selling point, people won't buy your app just because of it?

[thp]

If you need legal advice, please consult a laywer, not this forum.

Nevertheless, this link might be of interest to you (GPL and linking on Wikipedia):

http://en.wikipedia.org/wiki/GNU_General_Public_License#Linking_and_derived_wor ks

[aspidites]

From what understand from reading the linked post and the linked abstract from the GPLv2, I think he is saying something more like:

AppG has been written which does FunctionA. He happens upon a GPL'd library that provides FunctionB. Rather than reinvent the wheel, he wants to add FunctionB to AppG without having to release AppG under the GPL itself. As such, he writes place-holder code, that is, StubB which he incorporates and distributes with AppG. Once AppG is installed, the option to download FunctionB is included.

While I'm not a lawyer, what I can gather from the relevant links is that doing the above is only legal if AppG doesn't rely on FunctionB to function properly -- that is, there is already some functioning code, and FunctionB is simply an alternative, not a requisite.

Actually, now that we're talking about it, this kind of reminds me of the CyanogenMod (android) fiasco with google. The key difference there is that the CyanogenMod doesn't require google apps to work, but is compatible with them.

[danramos]

Better still, why not ask lawyers who work with the GPL. Actual lawyers--not just a wiki. :)

http://www.softwarefreedom.org/

Introduction:
We provide legal representation and other law-related services to protect and advance Free, Libre and Open Source Software (FLOSS). Founded in 2005, the Center now represents many of the most important and well-established free software and open source projects.

[mmurfin87]

From what understand from reading the linked post and the linked abstract from the GPLv2, I think he is saying something more like:

AppG has been written which does FunctionA. He happens upon a GPL'd library that provides FunctionB. Rather than reinvent the wheel, he wants to add FunctionB to AppG without having to release AppG under the GPL itself. As such, he writes place-holder code, that is, StubB which he incorporates and distributes with AppG. Once AppG is installed, the option to download FunctionB is included.

While I'm not a lawyer, what I can gather from the relevant links is that doing the above is only legal if AppG doesn't rely on FunctionB to function properly -- that is, there is already some functioning code, and FunctionB is simply an alternative, not a requisite.

That is exactly what I'm talking about. Apparently I didn't explain myself clearly enough.

Another example is this: Microsoft uses DLLs extensively to modularize functionality in Windows. If tomorrow they released, as an optional download and not to be bundled with any distritbution of Windows, a DLL that replaces one that already exists, but is released under the GPL, they are not automatically obligated to put Windows under the GPL despite Windows then linking to that GPL library.

[wmarone]

That is exactly what I'm talking about. Apparently I didn't explain myself clearly enough.

Another example is this: Microsoft uses DLLs extensively to modularize functionality in Windows. If tomorrow they released, as an optional download and not to be bundled with any distritbution of Windows, a DLL that replaces one that already exists, but is released under the GPL, they are not automatically obligated to put Windows under the GPL despite Windows then linking to that GPL library.

While you could try that, it would be utterly ridiculous. Replacing a non-functional or minimally-functional stub and expecting users to swap in a GPL'd library to give your application functionality pushes off any potential GPL violation to them.

Or it might inspire someone to replace your program with a GPL'd equivalent. Witness how fast Git was built up to replace BitKeeper (despite use of GPL'd code not being the actual issue there.)

[lma]

First of all, which GPL? You cannot have a meaningful conversation about licence terms without clarifying the licence.

[mmurfin87]

While you could try that, it would be utterly ridiculous.

Ridiculous or not, it seems quite legal, and that was the point of this thread.

Replacing a non-functional or minimally-functional stub and expecting users to swap in a GPL'd library to give your application functionality pushes off any potential GPL violation to them.

I will need to reread the GPL to think about this. I don't think end users would even be capable of violating the agreement in any way.

First of all, which GPL? You cannot have a meaningful conversation about licence terms without clarifying the licence.

GPL v2?

[Rob1n]

That is exactly what I'm talking about. Apparently I didn't explain myself clearly enough.

Another example is this: Microsoft uses DLLs extensively to modularize functionality in Windows. If tomorrow they released, as an optional download and not to be bundled with any distritbution of Windows, a DLL that replaces one that already exists, but is released under the GPL, they are not automatically obligated to put Windows under the GPL despite Windows then linking to that GPL library.

This example is pretty clear - they've provided an interface which works with multiple equivalent libraries, so there should be no GPL issue at all.

In the case you originally discussed, you've provided an interface which works only with a GPL library (the fact that you've provided a useless stub library will probably be irrelevant) so is on very questionable ground. If you wrote a library to perform the same functionality, but suggested that the GPL library could be plugged in to improve performance, you'd probably be okay though.

As has been said earlier though - if you want a legal opinion, ask a lawyer. Otherwise all you're doing is canvassing opinions.

[lma]

GPL v2?

http://www.gnu.org/licenses/old-licenses/gpl-2.0-faq.html#GPLInProprietarySystem

[mmurfin87]

As has been said earlier though - if you want a legal opinion, ask a lawyer. Otherwise all you're doing is canvassing opinions.

I'm only interested in canvassing opinions about this legal issue. I'm not after professional legal advice.

[Texrat]

I'm only interested in canvassing opinions about this legal issue. I'm not after professional legal advice.

I think the point was that while people here are certainly qualified to offer any number of opinions, none of the ones provided will have legal standing.

[R-R]

While I'm no lawyer, I'm pretty sure this has been thought through correctly and the GPL must be forbidding the linking with proprietary code through any type of API!
If you call system() or exec() though, it's probably alright as it's defined as a different application entirely...

Of course this is all gray zone but for any practical purpose I'm sure they've based their text on many operating systems in use today.

I wish more software was licensed under (A)GPLv3

[CrashandDie]

Funny, seems the FAQ answers all questions.

Can I apply the GPL when writing a plug-in for a non-free program? (http://www.gnu.org/licenses/gpl-faq.html#GPLPluginsInNF)

If the program uses fork and exec to invoke plug-ins, then the plug-ins are separate programs, so the license for the main program makes no requirements for them. So you can use the GPL for a plug-in, and there are no special requirements.

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, which must be treated as an extension of both the main program and the plug-ins. This means that combination of the GPL-covered plug-in with the non-free main program would violate the GPL. However, you can resolve that legal problem by adding an exception to your plug-in's license, giving permission to link it with the non-free main program.

See also the question I am writing free software that uses a non-free library (http://www.gnu.org/licenses/gpl-faq.html#FSWithNFLibs).

What legal issues come up if I use GPL-incompatible libraries with GPL software? (http://www.gnu.org/licenses/gpl-faq.html#GPLIncompatibleLibs)

Both versions of the GPL have an exception to their copyleft, commonly called the system library exception. If the GPL-incompatible libraries you want to use meet the criteria for a system library, then you don't have to do anything special to use them; the requirement to distribute source code for the whole program does not include those libraries, even if you distribute a linked executable containing them.

The criteria for what counts as a "system library" vary between different versions of the GPL. GPLv3 explicitly defines "System Libraries" in section 1, to exclude it from the definition of "Corresponding Source." GPLv2 says the following, near the end of section 3:

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.

...

I'd like to incorporate GPL-covered software in my proprietary system. Can I do this? (http://www.gnu.org/licenses/gpl-faq.html#GPLInProprietarySystem)

You cannot incorporate GPL-covered software in a proprietary system. The goal of the GPL is to grant everyone the freedom to copy, redistribute, understand, and modify a program. If you could incorporate GPL-covered software into a non-free system, it would have the effect of making the GPL-covered software non-free too.

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 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.

[Texrat]

Nicely done, CrashandDie.

[mmurfin87]

Funny, seems the FAQ answers all questions.

Can I apply the GPL when writing a plug-in for a non-free program?

If the program uses fork and exec to invoke plug-ins, then the plug-ins are separate programs, so the license for the main program makes no requirements for them. So you can use the GPL for a plug-in, and there are no special requirements.

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, which must be treated as an extension of both the main program and the plug-ins. This means that combination of the GPL-covered plug-in with the non-free main program would violate the GPL. However, you can resolve that legal problem by adding an exception to your plug-in's license, giving permission to link it with the non-free main program.

See also the question I am writing free software that uses a non-free library.

I hadn't seen that one. Thank you for providing it. The other two I have seen but they don't really talk about exactly what I'm proposing, but that one hits the nail on the head.

Here is another one that is useful to my question that you didn't post:

If a program released under the GPL uses plug-ins, what are the requirements for the licenses of a plug-in?
It depends on how the program invokes its plug-ins. If the program uses fork and exec to invoke plug-ins, then the plug-ins are separate programs, so the license for the main program makes no requirements for them.

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, which must be treated as an extension of both the main program and the plug-ins. This means the plug-ins must be released under the GPL or a GPL-compatible free software license, and that the terms of the GPL must be followed when those plug-ins are distributed.

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.

Back to that first one, though. In the GPLv3 license itself (mixing version I know) it states

You are not required to accept this License in order to receive or run a copy of the Program.

So an end user is not bound by the license in so much as they merely run the Program and do not specifically affirm that they agree to the license in front of some reliable witness.

In this case, their statement that the "combination of the GPL-covered plug-in with the non-free main program would violate the GPL" is false if the GPL plugin is not distributed with the program, and could in fact be distributed with the Program as long as it is considered independent. In other words if the end user does download the GPL plugin separately from the program and install it himself. Then there is no GPL violation, yet GPL and proprietary code are in fact running together.

Maybe this example would be better. I write a program that plays back videos and write it so that I a data structure of my own design to store the video data. I include a basic video decoder that lets the video player decode video that was encoded in some public domain form. I then also allow the program to add other user designed decoding libraries that take some specific encoding and transform it into that custom data structure my program uses.

If I release my program with just the one non-GPL decoder library, it can be as proprietary as my heart desires.

I can then write a program that takes a GPL'd decoder library and turns it into that custom data structure form and release that under the GPL as a plugin for my original program. End users can download it and enhance their already functional video player program. There is no violation.

[uTMY]

Instead of thinking up schemes to try to circumvent the gpl, a policy which I am sure will cause you grief in the end, why not just learn how to properly create proprietary licensed code to run on a gpl based platform.

This link provides some useful discussion/info.

http://www.groklaw.net/staticpages/index.php?page=20050131065655645

As one poster suggested though, go consult a lawyer.

Also remember not all countries treat IP (copyright, patents, trademarks etc) the same.

rgds

[javispedro]

This is not ridiculous nor pointless: it is what the nvidia propietary driver kernel module is doing.

[volt]

While I am not a lawyer and certainly no licence expert, I still find anything that borders to principles of law kinda interesting, and some of the arguments in this thread fail when judged against these principles:

The law most certainly does not care to differentiate between "non-functional or minimally-functional stub" and "fully functional stubs". The law might differentiate on intent though, but probably not any much when it comes to licences and copyright law. Either it's legal for all and every stubs that use a technique not clearly mentioned in the licence, or it is illegal for all and every stub that use that same technique.

The law will not go into evaluations like "the original library is useless". It's all about principles and technicalities, not quality and featurerichness.

[Rob1n]

The law will not go into evaluations like "the original library is useless". It's all about principles and technicalities, not quality and featurerichness.

Indeed, but if the original library is useless then the intent is obviously to make use of the GPL library. If the original library is functional (but suboptimal) then the intent is far more difficult to prove.

[valdyn]

So an end user is not bound by the license in so much as they merely run the Program and do not specifically affirm that they agree to the license in front of some reliable witness.
.

Agreeing to anything here is totally irrelvant as the GPL only restricts *distribution* of software in certain ways, not running it.

[volt]

If the original library is functional (but suboptimal) then the intent is far more difficult to prove.

Should it come to that, this thread goes a far bit in proving the intent... Again, I am not sure intent is relevant for the specific licencing/contract laws that would apply here.

[Lord Raiden]

Wow, I was gonna add to this, but after reading mmurfin87 and wmarone's comments, there's really nothing more I can add except to say that they're spot on. You can't add GPL stuff without at least a LGPL license. The only exception I know is if the modules are plugins, meaning they're optional components that just "snap in" and not physically required for the application's core functions to work. You could also get around it by having a "shim", IE, some kind of software API that was LGPL and acted as a go between for the GPL'ed code and the proprietary code. It's how Microsoft figured out how to run their apps on Linux without having to open source them, or release them under an open source license.