25

I understand the rules of the GPL stating that if I distribute any software using GPL code, then that code must be licensed under the GPL.

However, I'm wondering what the rules are in this case: I am creating a service where I will be selling and distributing client side software.

The client side software has absolutely no GPL code in it. It is 100% my own code.

However, the client software will be connecting to my server, which internally uses GPL code.

I am not distributing my server side software; the server side software will live on a dedicated server that I alone control, but the client side software will not work without connecting to said server.

Does this count as one software? If I were to do this, would I be required to license my client side source code as GPL? Or, can I sell the client side software without releasing its source code?

Community
  • 1
Steven Jeffries
  • 353
  • 1
  • 3
  • 6

3 Answers3

17

This is not a clear-cut issue. Consider two extreme ends of the spectrum:

  1. Your proprietary client software is an HTTP client and it renders HTML responses. It can work with any HTTP server. The HTTP server that you use for your service happens to use GPL components.

  2. You have a program that uses GPL-licensed components. You pick an arbitrary point in that program's operation and break the program into two programs. The two programs communicate over a totally superfluous network hop. You put all the GPL-licensed components in the first program and license under the GPL, and you license the other program under a GPL-incompatible license.

The first case is clearly okay. The second case is clearly not okay. You haven't given much information about your particular case, and even if you did, only a court ruling could decide definitively whether you're in the right.

The GPL FAQ has this to say on interoperable, separately-licensed programs:

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.

You must decide whether you think your client are server meet the standard of "two parts of the same program" (and therefore must each be licensed under the GPL) or not. The GPL FAQ gives some further explanation on this topic on another question:

Where's the line between two separate programs, and one program with two parts? This is a legal question, which ultimately judges will decide. We believe that a proper criterion depends both on the mechanism of communication (exec, pipes, rpc, function calls within a shared address space, etc.) and the semantics of the communication (what kinds of information are interchanged).

...

By contrast, pipes, sockets and command-line arguments are communication mechanisms normally used between two separate programs. So when they are used for communication, the modules normally are separate programs. But if the semantics of the communication are intimate enough, exchanging complex internal data structures, that too could be a basis to consider the two parts as combined into a larger program.

So, network communication certainly passes the "mechanism of communication" test but it is unclear where your client/server pair falls on the "semantics of communication" test.

Community
  • 1
apsillers
  • 5,083
  • 25
  • 33
  • Would it be reasonable to base the distinction on the extent to which the interfacing between the programs was public? If e.g. I implement a chess-playing system which uses a GPL user interface program that communicates with a proprietary chess engine, and I document how anyone else wishing to write their own chess engine could make it use that same UI front-end, I would think that should satisfy the spirit (and hopefully the letter) of GPL even though, unless someone happened to write an alternative engine, the UI front end would have no purpose other than to talk to the proprietary program. – supercat May 08 '15 at 16:03
  • 1
    Hmm. I asked this question so vaguely because I was just curious about the GPL in general. However, I think I understand the difference now. If my server has user account information that my client software needs to run, then that clearly violates the GPL. If my server is something like a packet relay server that just allows two versions of my client software to communicate with each other, then that would be okay. Am I correct in these assumptions? – Steven Jeffries May 08 '15 at 17:39
5

Two processes communicating over a network does not entail the creation of a derived work the way linkage of an executable with a library does. So the GPL code on the server does not apply to the client code.

Under the GPL, you are required to distribute the modified source code when you distribute binaries. Since you're not distributing the server binaries, you're not required to distribute the server source code.

The GNU Affero GPL is a license similar to the GPL with additional verbage designed to close this very loop hole you wish to take advantage of (see: http://www.gnu.org/licenses/why-affero-gpl.html and http://en.wikipedia.org/wiki/Affero_General_Public_License#Examples_of_web_applications_under_GNU_AGPL).

Disclaimer: I'm a developer, not a lawyer.

J. Lenthe
  • 365
  • 1
  • 5
  • 4
    Just a note of warning: If the client is designed to specifically communicate with *this* server software, then it is entirely possible that the FSF *does* consider server and client software as *one* product. See also [here in the GPL FAQ](https://www.gnu.org/licenses/gpl-faq.html#GPLInProprietarySystem) – Bart van Ingen Schenau May 08 '15 at 06:29
  • On the other hand, if a third party writes client software to communicate with your server, without ever having seen the server software or a license, that argument looks ridiculous. And it would mean Microsoft could sue anyone writing software connecting to Outlook servers, for example. – gnasher729 May 08 '15 at 15:22
  • But Microsoft Outlook is not GPL licensed. – Ragaroni Aug 27 '23 at 18:48
2

Does the client software depend on the server software for its proper functioning? In other words, will the client software work without being connected to the server?

If the answer to that is "yes," and the server merely provides an additional feature, and not core support, to your client software, then you're probably in the clear. If the server software is an integral part of the client software and provides core functionality to the client software (i.e. the client software will not work without the server), then the combination is a derived work, covered under the GPL.

Robert Harvey
  • 198,589
  • 55
  • 464
  • 673
  • I shall err on the side of caution and *not* use GPL code in my server then. – Steven Jeffries May 08 '15 at 03:51
  • 4
    @StevenJeffries This answer runs against both current practice and the requirements of the GPL. As long as I do not distribute a software or a derived work, I am free to use GPL'ed software on a server, e.g. Linux or GCC or WordPress. Merely using a software does not create a derived work. In the case of the GPL, its considered to be okay when at least process-level separation is involved (no shared memory, no shared data structures). See J. Lenthe's answer for a correct solution and for references. – amon May 08 '15 at 04:55
  • @amon: If you're not even sharing data structures between the server and the client, then you're right. I doubt that's the case, though. The distinction I'm drawing (is the client software dependent on the server software for its proper execution) is not arbitrary; it's one of the two essential requirements for what the FSF considers not a "derived work;" the other is "arms length communication." Don't take my word for it; read it for yourself on the FSF website. – Robert Harvey May 08 '15 at 05:13
  • @amon: You can read more about that [here](https://www.gnu.org/licenses/old-licenses/gpl-2.0-faq.html#GPLInProprietarySystem). – Robert Harvey May 08 '15 at 05:18
  • @amon Another very relevant GPL FAQ item (good as a follow-up after reading Robert's link) is this one, particularly the last three paragraphs: https://www.gnu.org/licenses/gpl-faq.html#MereAggregation – apsillers May 08 '15 at 14:17