1

I'm considering using parts of a GNU Affero General Public License v3 (GNU AGPL v3) licensed library in a commercial context, but we obviously can't afford to release our whole code-base.

We would only need the library for a crawler-like step in the backend. If we use the library in the crawler to generate data and push it into a database, and have our web-app hosted by another program/process entirely that reads from the database, are we legally required to release any of our source code? The web-facing ("distributed") code would not call the AGPL-v3 licensed code, only use it's generated output.

Any insight is greatly appreciated!

  • 1
    Welcome to Programmers.SE. See also programmers.stackexchange.com/a/198403/144896 – dcorking Jan 27 '15 at 11:58
  • 1
    You wrote AGPLv3 - I assumed you meant Gnu AGPL V3 gnu.org/licenses/agpl-3.0.html - as the original Affero GPL stops at V2. I submitted an edit making that clear so please speak up if that is not the case. I think the answer to your question is the same whichever version you are subject to. – dcorking Jan 27 '15 at 14:03
  • This question would be a great fit for the new stackexchange site Open Source Stackexchange which is currently in commit phase and needs people to commit to it so it can go into beta. – Philipp Mar 24 '15 at 15:41
4

In this case, the difficult legal test is deciding whether your data-consuming application can legally be considered "combined with" your AGPL data-producing application. The FSF proposes that two programs must communicate "at arms length" to be considered separate works. (The tricky bit about this rule is that no one is entirely sure how long programs' arms are.)

First, we can rule out any AGPL requirements being transfered via data output, by consulting the GPL FAQ. There is a question that directly addresses this (from the other side -- trying and failing to make GPL rules apply to generated data):

Is there some way that I can GPL the output people get from use of my program? For example, if my program is used to develop hardware designs, can I require that these designs must be free?

In general this is legally impossible; copyright law does not give you any say in the use of the output people make from their data using your program. If the user uses your program to enter or convert his own data, the copyright on the output belongs to him, not you. More generally, when a program translates its input into some other form, the copyright status of the output inherits that of the input it was generated from.

So the only way you have a say in the use of the output is if substantial parts of the output are copied (more or less) from text in your program...

Thus, as long as the AGPL crawler doesn't include any GPL-licensed data in its output (and I see no reason whatsoever why a Web crawler would do so), then the generated data itself caries no burden of AGPL responsibility.

Still, it could be the case that the data-consuming code might be legally considered part of the same program as the AGPL data-producing code, in which case the AGPL would apply to the entire work. Without seeing your architecture (and possibly without the final ruling a judge), it's not possible for me to say whether the two components can be called one work, but the information you've presented strongly suggests the two components appear to be separate works, legally speaking. Again, from the FAQ:

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).

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.

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.

It seems that writing to and reading from a database falls in the same broad category as "pipes, sockets and command-line arguments." Your data-consuming code could run without the data-producing code running on the same computer at all: you could have one system generate a database, and then pass the database to another system that consumes it. From this point of view, it seems clear to me (through not a surefire legal certainty) that the programs are separate works, and a user who interacts with your data-consuming Web process is not also interacting with your data-producing AGPL code.

2

For copyright, a program and the data that the program operates on (or the data that come out of the program) are considered to be completely separate works and the copyright license of the one does not affect how you can license the other.
The one exception is if the program copies (part of) its internals to the output. Then the output is considered to be a derived work of both the input and the program portions that were copied over and the licenses of both influence what you can do.

For example, it is perfectly possible to write a fully closed-source application using an editor that is distributed under a strong copyleft license (like GPL or AGPL). The license of the editor does not influence in any way how I can license my code.
An example of the exceptional case is when you use Bison to generate a parser. The output from Bison contains significant portions of code written by the Bison authors, so they have a say in how you can use that output. (Incidentally, the portions that Bison copies over are specifically exempted from the GPL requirements that the rest of Bison falls under).

  • One could argue that there is, by definition, always a part of the program's internals copied to the output. Where to draw the line? – Brecht Machiels Aug 30 '16 at 12:01
  • Where to draw that line is up to the legal system. But in general I believe the line is drawn at "recognizable parts that are the result of creative effort". If you want the copyright (license) on your program to apply also to its output, you must be able to point at parts of the output and say that it is the direct result of your creative efforts. – Bart van Ingen Schenau Aug 30 '16 at 12:35
0

The AGPL is the Affero General Public License, and offers some protection for users from proprietary lock-in when they use a web service powered by free code.

There are a couple of recent versions from different authors (Affero, Inc, and the Free Software Foundation respectively):

Know which one you are subject to.

Your lawyer needs not only to decide whether you meet the definition of 'distribution' in your jurisdiction, but also whether your entire code base meets the definition of 'linking'. Because you only need to publish the source code that links to the library. In general terms, code that only reads a database populated by AGPL code is unlikely to be considered 'linked' to that code so you won't have to publish the source for that, though I don't know of precedent or opinion for that.

Update There is guidance from the FSF (authors of the GNU AGPL) that says:

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.

If the two programs remain well separated, like the compiler and the kernel, or like an editor and a shell, then you can treat them as two separate programs—but you have to do it properly. The issue is simply one of form: how you describe what you are doing. Why do we care about this? Because we want to make sure the users clearly understand the free status of the GPL-covered software in the collection.

*(Emphasis mine) From the GPL FAQ which would also apply to the GNU AGPL http://www.gnu.org/licenses/gpl-faq.html#GPLInProprietarySystem *

An alternative is to purchase a commercial license from the author(s) of your library with terms that suit your business better, update or otherwise negotiate with the author(s) to ensure they intended to permit your planned use.

More general information at AGPL - what you can do and what you can't

This is not legal advice but background information, and I am not a lawyer.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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