I've read some of the GPL questions on here that seem relevant, but I haven't found an understandable answer for my particular case. I'll note them here for reference.
- When does a dependency imply a derivative work?
- Software: If I bundle built (compiled) GPL 2 licensed software with commercial software package how does it affect my software license?
- How should I mark a source file with GPLv2 as a derivative work?
- Can license-incompatible program communicate with GPLv2 program via websocket?
I've also read this, which seems relevant.
Hopefully this is not a duplicate.
I have a project that's mostly written in C with many dependencies. Many are MIT, some ISC, some custom, and some GPL with special exceptions.
I want the project to have a permissive license. I'd like to be able to allow people to use parts of my project for proprietary applications without being affected by things like GPL. To do that, my thought was to decouple invasive dependencies such as GPL from select parts of my work.
The project is comprised of multiple components.
MyLib (author: me)
- A custom library that can be shared OR static depending on platform.
- It only depends on projects with permissive licenses.
- It implements a REST API that takes in (and returns) data types of its own definitions which don't depend on any restrictive licenses.
MyServer (author: me, but depends on a GPLv2 project)
- A server application that depends on a GPLv2 networking stack.
- I have not made modifications to the networking stack source code.
- The network stack source is compiled directly into the server program.
- The server also uses MyLib as a dependency, but this dependency does not utilize any of the facilities from the network stack. The reverse is also true. Instead, it is the server application's responsibility to transform data from the networking stack into primitive data types that can be consumed by MyLib without exposing any implementation details of the GPLv2 project, and vice-versa.
MyClient (author: me)
- A web client with no dependencies which talks to MyServer and utilizes the REST API as defined by MyLib.
- As mentioned before, the logic and data structures for the REST API is defined in MyLib which is agnostic to the server implementation.
The idea is that the server implementation could use ANY framework and the client/library on each end wouldn't care. The middleman is completely opaque to them.
- Can I have a separate, more permissive license for MyLib and MyClient?
- Does static linkage between MyLib and MyServer change how the GPLv2 license applies to distributed binaries?
- What happens if I or some user of this project does modify the GPLv2 network stack?
- Would the following project structure comply with the GPLv2 license?
my_project_repo/ server/ LICENSE.txt - GPLv2 server.c - MyServer which includes network.c and abitrarily links to MyLib client/ LICENSE.txt - Whatever index.html lib/ LICENSE.txt - Whatever mylib.c - MyLib extern/ network_project/ LICENSE.txt - GPLv2 network.c - Networking stack
My intuition says that this situation is making myself the user of a dependency I made. This means the same rules apply to my other permissive dependencies. That is, it doesn't make sense to say a project with the zlib license becomes GPL just because someone out there compiled it into a project that also includes a GPL project.
I believe this means that MyServer becomes treated as the "default" server implementation. The restriction on users who wish to use a server component for proprietary purposes would be that they need to reimplement the server using MyLib and a different networking framework to evade the GPL license.
Is that a correct assumption?