Given that I want to extend the Covered Software through a bigger Project. The following is an example where File A is part of the Covered Software and any subsequent files are not part of the original Covered Software. The two listed Modifications are independent of each other, and cover two different scenarios. For simplicity, the example is written in Python.


File A:

def foo(x):
  out = x* 10 / 725 + 15
  return out

Modification 1:

File A:

def foo(x):
  out = x* 15 / 725 + 15
  out = x % 20
  return out

Modification 2:

File A:

from file_b import foo2
from file_c import foo3

def foo(x):
  x = foo2(x)
  out = foo3(x)
  return out

File B:

def foo2(x):
  out = x* 15 / 8025 + 15
  return out

File C:

def foo3(x):
  out = x % 20
  return out

Given my understanding of the GPL License, in the case of Modification 1, as File A is included in the GPL, this modification will be part of Covered Software. In case of Modification 2, I would assume File B would also still cover sufficient parts of the original Code and thus would have to be included in the License. But File C would not have to be included? Or would it still have to be included, since File A cannot function without File C.

Thus, two clarifications:

  • What exactly is covered with “contains any Covered Software.”
  • Does the Covered Software has to be functional after its Modifications, without additional files? o If “functional” is the bottleneck, simply writing a condition around this would also be possible, so I am unsure if this even can be specified
  • 1
    Is your question or is the program we're talking about specifically about GPL version 2.0? The term "Covered Work" does not appear in that version; it appears in GPL v3.0 though. In GPL2, the term "Program" is used instead and basically means the same thing as what "Covered Work" refers to in GPL3.
    – Brandin
    Commented May 2 at 11:07
  • I have mixed up GPL and MPL, that ofcourse changes the whole question. I am sorry, I have changed it now
    – Blacx
    Commented May 2 at 11:56
  • 1
    That makes a lot of sense, I will do that
    – Blacx
    Commented May 2 at 11:59
  • 1
    I have created a new question: opensource.stackexchange.com/questions/14757/… And I have updated the tag on this question to reflect the correct tag
    – Blacx
    Commented May 2 at 12:04
  • 2
    I was reminded of this old question where - also MadHatter - explains IMHO very illustrative and well how copyright works on a codebase by using tarp analogy: opensource.stackexchange.com/questions/10141/… Commented May 2 at 12:34

2 Answers 2


I think you're looking at this from the wrong end. The relevant question is not *how much connection can there be between two parts and still have them be separate works", the question is "how little connection can there be and still have them be a single work". You repeatedly use the term "Covered Software" as if it had a special meaning in GPLv2 terms, but this term appears nowhere in the GPLv2.

GPLv2 s2 says that

You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that [...]

b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.

So unless you have good reason to think that one or more of the changes you make isn't part of this "work based on the Program", it all has to be released under GPL. What file your code is in has nothing to do with whether or not it's part of this work-based-on-the-program.

If some of what you're adding is so far separated from the work-based-on-the-program as to constitute a separate work in copyright terms, then it wouldn't be affected by the GPL's requirements. As the FSF notes, this is not a settled field of law, but in their opinion

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.

In short: to be safe, release your larger project under GPL in its entirety. If you are sure that some of what you've added constitutes a separate work, then that doesn't need to be released under GPL - but you had better be very sure of your reasons for thinking so.


In your example, all the modifications you showed seem to be based on the original software version; File C seems to represent your own modifications to the original foo calculation. Such changes are your own work, of course, but if you're modifying the GPL code, then the GPL allows such modifications only on the condition that you release them under the same license as well (the GPL).

Does the Covered Software has to be functional after its Modifications, without additional files? o If “functional” is the bottleneck, simply writing a condition around this would also be possible, so I am unsure if this even can be specified

There's nothing in the GPL v2 or v3 that says that the software needs to be functional by any definition. Nor does it need to be complete in a programming sense. In your example, if you publish the source code under the GPL but do not supply File C, then this would merely be a programming language violation, not a license violation.

What the GPL forbids is that you release a binary version of that code (e.g. a compiled .pyc file of File C) without also supplying the original source code version of that file as well. See also: https://www.gnu.org/licenses/gpl-faq.html#GPLRequireSourcePostedPublic

The GPL also allows that you charge a development fee before you give someone a copy of File C, if you wish -- but once you supply File C (with or without a fee), then the user that you give it to must be allowed to use File C under the same conditions as the rest of the code (the GPL).

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.