How should a project be structured to be able to use an AGPL license, but allow non-free extensions to it?

Question

My current situation is as follows:

I am building a card game and would like to make sure users can use it to make with it whatever they want without 'giving away' the game content. For this there are two logical parts: The game 'engine' and 'card packs'. I want the engine to be FLOSS, but the card packs independent of it (they can be foss, but should not be forced to.)

My current idea is to have the following structure:

• An 'API' library that is GPL3, which contains all definitions as well the behaviours of the game that is exposed.
• An 'engine' library that is AGPL, which links to the API (and thus makes the whole package AGPL, and they are compatible)
• Multiple card packs that link to the API, which due to the copyleft of GPL are now also under GPL

The idea being that only the server that includes the 'engine' would have to open-source any changes they made to it, as it will be directly interacted with by users. (Users would not actually directly send API requests to it, but that is AFAIK not relevant, as intermediaries do not have to AGPL'd in this situation.)

And, users would not have an automatic right to the card packs themselves. If they do purchase them independently, they get the right to the source code etc... but not by merely interacting with the server.

Communication would thus be as follows:

[Player User] -> [Some Server, not AGPL] -> [Engine, AGPL] -> [Card Pack, not AGPL]

The engine itself could be considered like a virtual machine, which is agnostic about the 'code executed' on it.

---

Now, the problem I have is how to interpret the information by GNU on this in their FAQ: https://www.gnu.org/licenses/gpl-faq.en.html#MereAggregation

If the modules are included in the same executable file, they are definitely combined in one program. If modules are designed to run linked together in a shared address space, that almost surely means combining them into one program.

In the above situation, the Card Packs are not linked, nor are they designated at build/compile time to be. However, at runtime they will be loaded and treated as executable code and 'exchange' information, using the definition in the API library.

So my question is, are there any obvious oversights/precedents that I have not been able to find?

I will discuss this with a copyright lawyer before officially releasing the code/game, I only wish to understand/do some groundwork.

Answer 1

I wouldn't do this by messing about with aggregation vs. combination, or GPL bits vs. AGPL bits, or any other "it doesn't really cover the card decks" hack. Instead, I'd put the whole thing under AGPLv3, keeping life simple, but add an exception in the API library that says something like:

[Name of project] is distributed under the terms of the GNU Affero General Public License (AGPL) with the following clarification and special exception.

Card decks loaded at runtime by [name of API library] are complex data structures read by the library and the larger game engine, and thus form part of a combined work based on this library and engine. Thus, the terms and conditions of the AGPL cover the whole combination.

As a special exception, the copyright holders of [name of library] give you permission to load such card decks at runtime, regardless of the licence on the decks, without having the provisions of AGPL s13 apply to the card decks. If you modify this library, you may extend this exception to your version of the library, but you are not obliged to do so. If you do not wish to do so, delete this exception statement from your version.