Please consider the following situation:
You write a closed-source application, let's call it A. A depends on a system API (i.e. provided by the OS), that is in turn configurable to use different backends. Each backend is identified by a simple string value and also selected via this identifier. The API itself is not bound by any GPL-like requirements.
Now, a specific backend (B) would be preferred but is GPL-licensed. The application would run without it, and there are other backends available, just with worse performance or other downsides.
Is any of the following permitted?
- Hard-coding the identifier to B
- Automatically selecting any available backend, but preferring B if available
- Letting the user select a backend (and strongly suggesting B)
Would it also depend on whether I ship A and B together, or just A and suggest the user that installing B would improve the application performance?
I would generally think that all three options are o.k. since passing a specific string to a system API would hardly qualify for a derived work (IMHO), but the FAQ of B basically state that it does not matter how you call a function of B, any usage makes your program a derived work. Are they right even in the three cases outlined above?
P.S.: It is not my decision to make A closed-source, so GPL'ing it is not an option.
P.S. 2: I omitted the names of the system API and B to keep the question more generic, but I can add them if it makes any difference.
edit: From another point of view: When does the user (as opposed to the programmer) create a derived work? In the third case, it should be clear that the user creates the derived work since he installed A and B and actively selected B. This would be in line with MSalters' arguments in his comment. The second case at least makes it clear that the work does not depend on B, so this could be o.k., too.
Probably it would be most in the spirit of the GPL to just contact the authors; however, I'm not sure if their FAQ entry is in line with the actual text of the GPL.
Best Answer
TL;DR: The FSF doesn't make a distinction between process and program, suggesting restrictions on your program which only apply to the resulting process.
The GPL works fundamentally via copyright. In particular, it's a distribution license (doesn't cover use) and is limited to works that are placed under the GPL.
Now one of the problems is when a work starts falling under the GPL, and what happens to it. I believe that the FSF is right, and your process falls under the GPL once it loads plugin B.
Your process. Not your program. Only the process in memory which combines the two, that is the derived work. Before the combination was made, no derived work exists in a legal sense. Therefore the GPL cannot dictate terms on your program. It simply has no legal basis.
Of course, you may use the derived work created by combining your program and plugin B in a single process. The GPL explicitly allows use. Now, if you ran this process in a VM, and cloned the VM, you wold be banned from distributing this VM image. Those rare things are covered. But usually, processes aren't copied so their legal protection under copyright is rather pointless.