Licensing software that uses a proprietary library under GPL-3.0 without linking exceptions: what are the implications?

Question

NOTE: Changed the person in example from "I/me" to "PersonXYZ"

Given, hypothetically:

• PersonXYZ wrote some software (will refer to as SoftwareXYZ) that uses a proprietary library (will refer to as LibraryABC).
• PersonXYZ licensed that software under GPL-3.0 without adding any linking exceptions.
• PersonXYZ is not the author of the proprietary library, someone other than PersonXYZ has copyright on it (will refer to as PersonABC).

Then, what exactly are the implications for doing the following:

• CONVEY-SOURCE-CODE: Conveying only the "source code" of PersonXYZ's software

  Maybe this would be fine as per (GPL-3.0 / Section 4: Conveying Verbatim Copies)

  You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.

  But nobody (except PersonXYZ) would ever be able to avail themselves of the permission to GPL-3.0 / Section 6: Conveying Non-Source Forms. So if someone can only avail themselves of some of the permitted actions in GPL-3.0 then is the software really GPL-3.0 licensed?

• CONVEY-OBJECT-CODE: Conveying the "object code" of PersonXYZ's software without distributing "Corresponding Source":

  NOTE: PersonXYZ would not be able to convey the "Corresponding Source" as this includes the proprietary library and PersonXYZ doesn't have permission to convey it in any form.

  I don't see how this would make sense as GPL-3.0 / Section 6: Conveying Non-Source Forms states:

  You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: ...

  As per GPL FAQ / DeveloperViolate PersonXYZ's would not really be liable in any way but the resulting "object code" will not be conveyable by anyone without violating GPL so it is not clear how the software is then actually released under GPL-3.0? Maybe it is not released under GPL-3.0 even though PersonXYZ labeled it as such?

  There is also GPL-3.0 / Section 12: No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.

The GPL FAQ has the following to say on somewhat similar cases:

What legal issues come up if I use GPL-incompatible libraries with GPL software? (#GPLIncompatibleLibs)

If you want your program to link against a library not covered by the system library exception, you need to provide permission to do that. Below are two example license notices that you can use to do that; one for GPLv3, and the other for GPLv2. In either case, you should put this text in each file to which you are granting this permission.

But it is not entirely clear that you have to do this if you only distribute/convey source code and not object code, as this does not mention distribution/conveying here nor does it make it clear what the basis for this FAQ entry is, maybe it is just section 6?

Any insights into the implications of these scenarios and this situation would be helpful.

Answer 1

When you distribute source code that's available under the GPL, you can simply do it (provided you preserve markings, etc.). It doesn't matter that the source code won't build into a meaningful executable without some proprietary library. If what you're distributing is a preferred form for modifying the work, it doesn't matter if that work builds into anything at all -- it could be full of fatal syntax errors, for all the GPL cares.

Possibly the way in which you distribute the unbuilt source with the binary could create a derivative, rather than an aggregate, in which case people would not be able to distribute the resultant source-plus-library derivative. But if the library is omitted or is legally merely in aggregate with the source, then there is no problem distributing the source.

I think you correctly identify the problem with distributing the binary built from such a source-plus-library combination:

But nobody would ever be able to avail themselves of the permission to GPL-3.0 / Section 6: Conveying Non-Source Forms.

Indeed the author of the GPLv3-licensed source may distribute such a binary, but no on else may, since the author has forbidden it.

So if someone can only avail themselves of some of the permitted actions in GPL-3.0 then is the software really GPL-3.0 licensed?

The binary built from such a combination (built by someone other than the author) is beholden to the requirements of the GPLv3, which have become impossible to satisfy. Analogously, I could release software today under terms like, "You may modify and/or redistribute this software as long as the Gregorian calendar year is prior to 1900 CE." This is technically a license that includes specific permissions, but which is contingent on a condition that is impossible to satisfy. It really is under such a license, but that fact isn't very meaningful insofar as it does not change the rights recipients may practically enjoy.

Note that the built binary may have a different license than whatever subset of the source the author chooses to release. Assuming I am the sole author, I may distribute my source under the GPLv3 and distribute a built binary (whose corresponding source is identical to or a subset/superset of my GPLv3 source code) under proprietary terms. This is no different from my ability to distribute the source code under multiple terms simultaneously.

This might actually be done sensibly when an author wants to distribute a binary under a proprietary license, but deliberately deny people the right to build their own modified binaries. The author offers a binary alongside some subset of their own source under the GPLv3, either in hopes of community goodwill (that any part whatsoever is free) or to solicit improvements.

Answer 2

This is a my understanding after further consideration and the response from apsillers for these scenarios:

• Conveying Verbatim Copies (of "source code")

  In brief: Always okay, for everyone.

• Conveying Modified Source Versions.

  In brief: Never okay for anyone except PersonXYZ.

• Conveying Non-Source Forms.

  In brief: Never okay for anyone except PersonXYZ.

NOTE: Some of this are consequences of the content of the GPL FAQ - if that is wrong then the consequences may be wrong also. My view is that it is safer to work within the interpretation of GNU/FSF even it it may be more strict or prohibitive than what the actual situation is as long as it is not clearly contradictory to license text.

Conveying Verbatim Copies of "source code" of SoftwareXYZ.

No restrictions whatsoever as per GPL-3.0 / Section 4: Conveying Verbatim Copies

Conveying Modified Source Versions of SoftwareXYZ.

For PersonXYZ (i.e. the copyright holder to SoftwareXYZ) it is permitted as they own the copyright to SoftwareXYZ [GPLFAQ#DeveloperViolate].

For everyone else:

A pertinent question here is whether SoftwareXYZ and LibraryXYZ (referred to as SoftwareXYZ ⟶ LibraryXYZ) constitute together a single "Program" which is work based on SoftwareXYZ (more on this later).

If SoftwareXYZ ⟶ LibraryXYZ is a single program then the only way someone other than PersonXYZ is permitted by license to convey modified source versions is if the owner of the copyright of the proprietary library LibraryABC (i.e. PersonABC) released LibraryABC under a GPL compatible license. This does not occur in this scenario so nobody except PersonXYZ can distribute modified source versions.

The specific part of GPL-3.0 prohibiting such action is GPL-3.0 / Section 5: Conveying Modified Source Versions

You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:

• [...]
• c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.
• [...]

Important implications of the quoted texts are:

• The word work in 5b "entire work, as a whole" refers to "work based on the Program" from the first paragraph.
• If SoftwareXYZ ⟶ LibraryXYZ constitute one program, then "whole of the work" refers to SoftwareXYZ ⟶ LibraryXYZ and "and all its parts" refers to SoftwareXYZ and LibraryXYZ

As to whether or not SoftwareXYZ ⟶ LibraryXYZ constitute one program we can consider the following from the GPL FAQ:

What is the difference between an “aggregate” and other kinds of “modified versions”? (#MereAggregation)

[...]

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.

This would cover all cases that I would refer to as "using a library". Specifically it would cover cases of using library in C++, C, Go, Rust, JVM, CLR, NodeJS among other things.

There are potentially some cases "using a library" that may be not be covered by this excerpt but is not clear what they would be.

There are also potentially some cases of things which are not clearly "using a library" which may be covered.

Answer 3

PersonXYZ could dual-license the code.

PersonXYZ could (if he/she is the sole copyright owner), if the code can run on POSIX system, and if the proprietary LibraryABC is available as a shared library, implement some plugin machinery.

Practically speaking, on Linux, use dlopen(3) with dlsym(3) and document and define an API to interface with LibraryABC. Your users are then allowed to either buy and call the proprietary LibraryABC or to recode an open source variant of it.

PersonXYZ then put the legal burden on the users of SoftwareXYZ

A related discussion is about GCC plugins. The FSF deployed legal tricks (the so called GCC runtime exception) to discourage development of proprietary GCC plugins (technically they remain possible, legally probably not).

A related example is ncurses. it is a library sharing the API of the original proprietary curses library.

Observe that you can publish under GPLv3+ a code using an API provided by costly software. A typical example would be some GPLv3+ code using specific APIs of proprietary Lisp implementations (e.g. Franz Lisp). Others could adapt SoftwareXYZ to run on SBCL.

You can also publish under GPLv3+ some code using API specific to Oracle databases or to some IBM PL/1 compiler for mainframes or to SAP HANA

You might not have many users interested by your code.

A GPLv3+ program can be written in a computer language that almost nobody uses or understands (such as LSE). Read also about bootstrapping compilers. See this question giving a practical example (I am probably the one knowing the most CAIA, and I don't understand it very well, but am working on RefPerSys; J.Pitrat, the author of CAIA, passed away in october 2019) and Bismon as another example (I am the main author of Bismon; it can be seen as a programming language whose specification is not written yet for non-technical reasons).

MicroSoft Word is a program scriptable in some version of Basic. MicroSoft Excel is an interpreter. You could publish an Excel spreadsheet under GPLv3+, and people would need a proprietary program to run that spreadsheet. I don't have Windows or Excel, so I could not run such a program, but I am allowed by the GPLv3+ license to study it (probably using LibreOffice).