I have a proprietary application that I want to distribute and sell. The application uses a GPL v3 licensed binary/library.

Since I don't want to distribute the source of my application and also want to provide convenience to my users, instead of supplying the GPL v3 library with my application bundle, can I provide a URL link at installation time which the user clicks to download the necessary GPL v3 library to their computer, necessary for my application?

That way, I would not be distributing the GPL v3 licensed library with my app, merely helping the user download it and then the library would be available to my application.

Edit 1:

To add another example to this method, how was Apple distributing XCode which was proprietary but which was making use of gdb and other gpl licensed components under the hood to work?

  • 2
    I couldn't find a duplicate, but there's no way this question isn't a duplicate. Mar 18, 2018 at 2:33
  • @whatsisname I was hoping others had asked this question before but alas I couldn't anything in my search.
    – user300122
    Mar 18, 2018 at 2:39
  • @jd11: did you follow whatisname's advice and read the GPL FAQ, especially gnu.org/licenses/gpl-faq.html#GPLInProprietarySystem?
    – Doc Brown
    Mar 18, 2018 at 15:55
  • So just read that part. Looks like it will be fine to do this if: 1. another component can provide the functionality of the GPL component 2. Clearly inform the user that GPL component is GPL.
    – user300122
    Mar 18, 2018 at 16:25
  • 2
    @Zymus: huh? Where did you read the OP intends to use "GPL v3" for their code? Quite the opposite.
    – Doc Brown
    Mar 18, 2018 at 18:42

3 Answers 3


To make sure you won't get sued, be prepared to prove that your proprietary application will also work without any GPL V3 components. Then no one can claim you made a derivative work. If you cannot prove this, better stay away from this route.

You could, for example, provide and distribute a small closed-source lib which is ABI compatible to the GPL lib you want to use, but has only some restricted functionality. And then you tell your users how to replace the lib by the GPL component on their machine.

This boils down to the "loophole" discussed in this former SE post:

  • A is your closed-source program
  • B is your "stub-lib"
  • C is the GPL lib
  • and D is a GPL-licensed adapter (which is not required if B and C are ABI compatible)
  • To add another example to this method, how was Apple distributing XCode which was proprietary but which was making use of gdb and other gpl licensed components under the hood to work?
    – user300122
    Mar 18, 2018 at 15:18
  • I am not an Apple user, but if I had to guess, I think the GPL license was one of the reasons why Apple switched to lldb and clang, which have a way less restrictive license. However, this is a legal question, and IANAL.
    – Doc Brown
    Jan 28, 2019 at 17:11

Not distributing the binary of the library does not shield you from legal risk. The question you should be asking is not "can I legally distribute a GPL v3 licensed library with my proprietary app", but "can I legally distribute a proprietary app compiled with a GPL v3 licensed library?"

This question does not yet have a definitive answer. What, exactly constitutes a derivative work under copyright law as applied to software has not yet been fully nailed down. According to the FSF, what you want to do is not permitted by the GPL.

I personally agree with Linus Torvalds' opinion that in some cases, the FSF's view that linking GPL code always requires releasing both parts under the GPL is overbroad. I believe the definition of "derivative work" is in practice narrower than the FSF's definition, due in part to the purely functional (legal term, not programming term) nature of much software, especially software that implements or describes standardized APIs. However, while I find Linus' argument persuasive, a judge or jury may not.

If you want to avoid legal risk, you should not distribute a proprietary app linked with GPL code.

This also depends on the language in question. In C and C++, and probably other languages as well, the bodies of preprocessor macros are copied into your source code before it is submitted to the compiler. Does the library contain macros? Does your program use them? Are these macros copyrightable material? Does using those macros constitute a derivative work? In C++, if a module uses templates provided by a library, the compiled code for those templates appears in the binary of the module. Are those templates copyrightable material? Does using those templates constitute a derivative work? In many languages, certain short functions/subroutines can be explicitly or automatically in-lined. Does your binary contain in-lined code from a library? Is that code copyrightable material? Does using it constitute a derivative work? In languages with inheritance, does inheriting from a class create a derivative work of that class?

The precise details of how, exactly, your program makes use of the library matter. If your program's binary contains code from the library, which it very well might, depending on the language and compiler details I just mentioned, it is very likely a derivative work.

Furthermore, the precise terms of the library's license matter. Does the license explicitly permit the use of short macros and templates, as the Gnu LGPL v3 does, but the Gnu GPL v3 does not?

Response to edit 1: There is a difference between using an external program via command-line invocation and linking a program with a library. If XCode executes GDB without linking to it, and Apple provides the corresponding source code of their version of GDB, then Apple is in compliance with the terms of the GPL. It does not matter that XCode contains proprietary components, as long as those components are not combined with GPL code in a single program. See the GPL FAQ entry on "mere aggregation".

On the other hand, if a company were to create a debugger by linking a proprietary binary with GDB, and not releasing the source code of the combined program under the GPL, they would not (according to the FSF, see above) be in compliance with the terms of the GPL.

  • To add another example to this method, how was Apple distributing XCode which was proprietary but which was making use of gdb and other gpl licensed components under the hood to work?
    – user300122
    Mar 18, 2018 at 15:18
  • @jd11: the GPL FAQ covers the answer to that question. Stop asking questions on this site until you read the GPL FAQ, the answers are already there. Mar 18, 2018 at 18:28
  • @whatsisname, I did read the FAQ as you pointed out. If you're still sure that I missed some part, I'd be happy to read it, please point it out, otherwise it devolves to "RTFM" and the main question remains unanswered which is that is it okay if I only communicate with the GPL v3 components using command line arguments like XCode was doing with GDB?
    – user300122
    Mar 18, 2018 at 19:15
  • @jd11: I know no one likes to be told to "RTFM", but software licensing is something you can't just "figure out as you go". You should be able to confidently know how XCode works license wise for example, before even considering to use a GPL library. Mar 18, 2018 at 19:22
  • @jd11 In order to understand a complex subject, you need to break it down into more basic elements, then learn how those elements relate. In the case of software licensing: What is copyright in the first place? What can be copyrighted? What cannot be copyrighted? What is a derivative work? What is not a derivative work? What is the relationship between a work and its derivative works? What is the relationship between a derivative work and the work it derives from? You cannot understand software licensing at the deep level you want to, by examining it superficially. Mar 18, 2018 at 20:32

If the GPL library is not integral to the program, and is only e.g. a plug-in for some extra small feature, or if it performs a key function but is one option of several others, selectable by the user, then what you are proposing can be ok.

Otherwise, if your program must have the GPL present in order to work, it is a derivative work and you must abide by the terms of the GPL. The fact you are trying to dodge it won't work. It's no different than writing a novel with a character named "Frodo Baggins" is going to be ruled a derivative work even if you aren't distributing the original works. By basing your software off the GPL software, its creative "essence" becomes part of yours and so thus you have to play by the GPL's rules.

This is the position of the FSF lawyers, and the GPL has prevailed every time it has been challenged in court.

  • What about commercial IDE companies making use of gdb in their software? Most of these IDEs are proprietary and yet they make use of gdb, how does that work?
    – user300122
    Mar 18, 2018 at 2:40
  • Also, wasn't Apple shipping Xcode IDE with gdb binaries where XCode IDE wasn't open source but still making use of gdb?
    – user300122
    Mar 18, 2018 at 3:04
  • 2
    @jd11: they are probably integrating it through command line invocation. This is all covered in the GPL FAQ which you should read. Mar 18, 2018 at 4:00
  • 2
    "being a plugin" does not necessarily mean something is "an extra small feature", or vice versa. If the program and the GPL lib do some communication in a wrong way, the GPL might be violated, how "small" the feature even is. I think this part of the answer is very dangerous advice.
    – Doc Brown
    Mar 18, 2018 at 18:38
  • 1
    @whatsisname: but that's my point - a "plugin" may not trigger the viral aspectof the GPL, when it is clearly isolated from the main program by means of processes and/or communication. If the "feature" in the plugin is "small" or "big" is not only 100% subjective, but also 100% irrelevant for the GPL.
    – Doc Brown
    Mar 18, 2018 at 19:33

Your Answer

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