I am writing an HTML5/JavaScript app (A) with a closed-source license, into which I wish to import data from third-party program (B). I wrote a library to read (B)'s data files, but as it is a derivative work, this library is also released under the AGPL.

I have the freedom to dual-license a portion of (A) with the AGPL as well, so as to create a self-contained AGPL component/script/plugin which can read (B)'s data files, and manipulate them for use by (A).

My question, then, is: What degree of separation must/ought I maintain between my core program (A), and the (B)-to-(A) converter/importer?

I realize that nobody here is a lawyer (or if you are, you can't give me legal advice anyway), so I'm looking more for guidelines. What is "clearly okay", what is "clearly not okay", and what lies in the middle?

Models I've considered:

  1. A completely stand-alone data converter. Users visit a URL, or run a local executable, which takes (B)'s input format, and spits out a file that can be read by (A).

  2. I host a converter on a separate server, which (A) knows how to talk to. A user provides a data file from (B) to (A), and (A) hands it off to the convertor, which responds with data (A) understands.

  3. I write a conversion plugin, which a user may install into (A), and then upload data files from (B) for the plugin to convert to (A)'s native format on demand.

  4. I write a library which converts from (B) to (A), and I load it in a separate tag, from a separate server, in my app. If successfully loaded, (A) exposes the option to the user to import data files from (B). If not successfully loaded, that functionality remains hidden.

  5. Same as #4, but the script is hosted on the same server.

I expect (1) should be perfectly permissable, as there's no question that (A) is an independent program from the converter, running on a completely different machine (or at least hosted on a different machine) than (A).

The coupling gets tighter as I move down the list. Is there any point where a line is clearly crossed? Or even in #4, is (A) sufficiently decoupled, and non-dependant on the conversion plugin to be within the spirit of the AGPL?

  • GPL-covered programs cannot apply the GPL to data they generate unless the program copies part of itself into its output. You are not required to release the library under the AGPL if all you are doing is reading data that B outputs.
    – EMBLEM
    Jun 22, 2016 at 23:21
  • 1
    @EMBLEM: Reading the data required consulting the source code of the AGPL program which I believe makes the library a derivative work.
    – Flimzy
    Jun 23, 2016 at 5:23
  • From the GPL: 'To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy." I think that could reasonably be interpreted as meaning that you actually need to copy the source code, not understand what it means.
    – EMBLEM
    Jun 23, 2016 at 5:29
  • 1
    @EMBLEM: I don't think the relevant legal precedent exists within the GPL itself, but in how courts interpret copyright laws. My Google research (and the opinion of the author of the AGPL software itself) suggests that if one can read a generated output file without consulting the source code of the generating software, no derivative work exists. If one consults the original source code, then legal precedent suggests it would likely be considered a derivative work by the courts. This is what leads to clean room reverse engineering techniques.
    – Flimzy
    Jun 23, 2016 at 5:36

1 Answer 1


I think you are reading too much in the constraints of the AGPL. If you reuse and modify AGPL-licensed code to convert data from one format to another (leaving aside any issue about the licensing of the data themselves) then you will need to make your source modifications available somehow per the AGPL, even if this happen over the network.

Beyond that, the AGPL is not much different from the GPL. The way you combine your own code and the AGPL-licensed code would be roughly subject to the same approach as if it were GPL-licensed.

These are my general rules: I would consider two pieces of code to be coupled enough for the GPL to apply to both:

  • if linked or running in the same process

  • if the GPL part is significantly modified and running separately but with some intimate communication, especially if the modification involves changing the API to suit my needs and support this intimate communication.

In light of these, I would consider that in 1 & 2 the copyleft would likely not extend to A, but in 3, 4 & 5 this is a grey area. Though there is no difference IMHO between 4 & 5. And if 3 is the only plugin in your app that would be weird.

That said to be cool, I would contact the authors of the piece of AGPL code I were to fork to explain what I want to do and what is their take on this. I would consider the interpretation --even if faulty-- of the author as something important and to respect eventually. This is to avoid any possible frustration.

I am not a lawyer and even if I were one, I would not be your lawyer anyway. So take this with a pinch of salt. This is not legal advice.

  • Thank you very much for your commentary. Your view is fairly well in line with my own reasoning on the matter. The difference I meant to convey between 4 & 5 was that the distribution of (A) and the converter would be separate in 4, but the same in 5. Perhaps that's not consequential in this case.
    – Flimzy
    Jun 22, 2016 at 20:34
  • 2
    Regarding the criteria of being linked or running in the same process; I'm unclear how this would apply to JavaScript code, as no linking takes place and (depending on the browser), all JavaScript may run in the same process regardless of its source (even scripts from unrelated web sites in different windows/tabs may run in the same process). It seems to me (in all my glorious ignorance), that the nearest analog to "same process" is something like "loaded from the same server" (4vs5), and the nearest to "linking" would be "making API calls into other JS files" (2vs3/4).
    – Flimzy
    Jun 22, 2016 at 20:37
  • My personal take for JS is: running in the same process means running in the same page or same application. The way the browser implements its threading or process model does not matter IMHO. Loaded from the same server does not matter either IMHO. Jun 23, 2016 at 8:20

Your Answer

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

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