2

I'm working on a proprietary application and am considering using QtCharts, a GPL licensed low-level plotting library. The plotting aspect is not the IP we are trying to protect so I'm trying to think if there is a fair way to have my cake and eat it too.

I'm considering the following

  • Keep all our IP in proprietary libraries
  • Change the main application to a GPL compatible license
  • Have the main application load both our IP libraries and QtCharts

I know this isn't as open as FSF would like, but it is more than just a GPL condom. Someone could take the main application's source code and reasonably insert their own libraries to do something useful and more than just directly using QtCharts themselves.

Is this legal? As authors of both the main application and the IP libraries I'm hoping we can grant ourselves the necessary exceptions (link). Does the answer change if the IP libraries depend on other libraries not written by us but with permissive licenses?

Is this fair?

** UPDATE **

I think I understand Phillip Kendall's point better now. Even if the main application is changed to a GPL license, use of QtCharts would prevent us from issuing the exception to use the proprietary library.

So the next logical step, for me it,

  • Move IP to separate application (no GPL dependencies)
  • Create an IPC library to talk to the proprietary application. This would be released under GPL with some sort of exception to use in the proprietary application.
  • Change the GPL main application, using QtCharts, to use this IPC library.

This feels more like it is violating the intent of the GPL but legally is it on stronger footing?

Improve this question
4
  • Basically, in your revised scenario, you are authoring a piece of GPL software, which has facilities for supporting plugins via interprocess communication, and then you plan to release a closed-source plugin compatible with this framework. Is my understanding correct?
    – apsillers ♦
    Feb 20 at 0:40
  • 4
    It's very bad styles to change the scope of the question so dramatically after there is an answer to the original. Chameleon questions which change based on answers are unwanted. Use new follow-up questions for new scenarios. Edits to clarify is good, when there are questions or need for clarity, edit to change the question when answers show you want to ask something different, not so
    – planetmaker
    Feb 20 at 5:14
  • @apsillers, maybe? To me a plugin is a library file that gets loaded at runtime by another application. This situation would be two separate applications that use a common library to exchange messages.
    – ryan0270
    Feb 20 at 19:06
  • I'm doubtful you can do this based on "issuing exceptions to yourself". If you're not breaking license obligations you owe to somebody else, then there is no need for any exception. And if you are breaking those obligations, you need an exception granted from them, not from yourself. (It does not matter if you release some code you entirely own under a GPL license and then do things with that code that others would not be permitted by the GPL; the GPL license you grant over your own code imposes restrictions on other people, but it does not restrict what you can do with your own code).
    – Ben
    Feb 21 at 4:01

2 Answers 2

Reset to default
4

You can't do this.

The GPL FAQ question you link to is for a free application using non-free libraries, but your situation is the reverse: you want a non-free application using a free library. As you are creating a derivative work of the GPL library, you must obey the GPL for all code making up the combined work; you cannot grant an exemption to this because you are not the copyright owner for Qt Charts.

If you want to use Qt Charts in non-free software, you will need to pay for a Qt commercial license.

Improve this answer
1
  • see updated scenario.
    – ryan0270
    Feb 20 at 0:23
6
  • Create an IPC library to talk to the proprietary application. This would be released under GPL with some sort of exception to use in the proprietary application.
  • Change the GPL main application, using QtCharts, to use this IPC library.

The FSF takes the position that, if your proprietary application integrates with the "GPL main application" through a complex and intimate IPC interaction, then your proprietary application becomes a derivative work of the GPL application, and therefore of QtCharts. No amount of indirection through secondary libraries will fix that problem, according to the FSF. It also does not matter what license the IPC library is under, or what exceptions you may apply to it, because the problem is not with the IPC library itself, it's with the GPL application. While there is room for interpretation over whether the FSF is correct in this judgment, ultimately what matters is whether your application forms a derivative work of the GPL'd application. If your application would be incomplete without the GPL'd application, it may be difficult to argue that it is not a derivative work.

The typical recommendation is to segregate the GPL'd component into a separate application altogether, and avoid intimate or complex IPC interactions. To do this, you should either use something like gnuplot, which is a complete command-line application rather than a library, or you should repackage QtCharts into a similar command-line application, and then have your proprietary application invoke the plotting application as a separate process. There is no meaningful IPC in this arrangement, just a few command-line arguments and possibly input files consisting of simple data (e.g. x, y coordinates) to be plotted.

The FSF says that such an arrangement would "normally" constitute two separate programs rather than one program, although it should be stressed that this is ultimately just their interpretation of the license. If you get sued, a court would have to evaluate whether your proprietary application forms a derivative work of the plotting application, and nobody is going to give you an absolute guarantee about how a court would rule in that case.

Improve this answer
5
  • I don't understand why QtCharts would require an exception in this case. QtCharts would only be used by the GPL main application, which doesn't require any exceptions ... I think. Maybe I'm just misunderstanding who's granting what exception. I was thinking the IPC library, released under GPL or similar, would grant an exception for the proprietary IP library to use it. QtCharts isn't involved in the IPC library so wouldn't be affected by the exception.
    – ryan0270
    Feb 20 at 18:59
  • @ryan0270: If I am interpreting your question correctly, the IPC library is part of the GPL application, and the GPL application is a derivative work of QtCharts. But there's a more basic problem here, so I'll reword the answer to focus on that instead.
    – Kevin
    Feb 20 at 21:53
  • I supposed "complex and intimate IPC interaction" is a phrase left for lawyers to argue over? The IPC library is linked into the main application but has use elswhere as well. The situation I had in mind was the IPC library was basically a set of agreed upon TCP message formats and is generic enough that it absolutely could, and likely would, be used by other applications to query outputs of the IP application. Sorry for all the back and forth. I'm trying to properly understand what exactly the GPL implies.
    – ryan0270
    Feb 21 at 1:07
  • @ryan0270: I have added more to this, but frankly, I'm not your lawyer, and you are reaching the limits of what is reasonable to ask of strangers on the internet. If you want specific advice for your individual situation, you should retain legal counsel, and follow their advice rather than ours.
    – Kevin
    Feb 21 at 2:00
  • @ryan0270 The typical recommendation is to avoid anything that would create the impression that the two applications were interdependent. Consider using bog-standard transport protocols like HTTP, gRPC, DBus, or simply a pipe between two processes. Consider exchanging data between the two processes using an existing widely supported format, for example JSON. The Language Server Protocol is an example of a JSON-over-pipe protocol. Consider writing protocol bindings as an MIT-licensed library that you can include in both programs.
    – amon
    Feb 21 at 18:08

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.