I have gone through a number of GPL-related questions, the most recent being this one:


I'm trying to see how this would work, so bear with me. I have a simple GUI interface for a game of Chess. It essentially can send/receive commands to/from an external chess engine (ie: Tong, Fruit, etc). The application/GUI is similar in nature to XBoard ( http://www.gnu.org/software/xboard/ ), but was independently designed.

After going through a number of threads on this topic, it seems that the FSF considers dynamically linking against a GPLv2 library as a derivative work, and that by doing so, the GPLv2 extends to my proprietary code, and I must release the source to my entire project. Other legal precedents indicate the opposite, and that dynamic linking doesn't cause the "viral" effect of the GPL to propagate to my proprietary code.

Since there is no official consensus that can give a "hard-and-fast" answer to the dynamic linking question, would this be an acceptable alternative:

  1. I build my chess GUI so that it sends/receives the chess engine AI logic as text commands from an external interface library that I write
  2. The interface library I wrote itself is then released under the GPL
  3. The interface library is only used to communicate via a generic text pipe to external command-line chess engines
  4. The chess engine itself would be built as a command-line utility rather than as a library of any sort, and just sends strings in the Universal Chess Interface of Chess Engine Communication Protocol ( http://en.wikipedia.org/wiki/Chess_Engine_Communication_Protocol ) format.
  5. The one "gotcha" is that the interface library should not be specific to one single GPL'ed chess engine, otherwise the entire GUI would be "entirely dependent" on it. So, I just make my interface library so that it is able to connect to any command-line chess engine that uses a specific format, rather than just one unique engine. I could then include pre-built command-line-app versions of any of the chess engines I'm using.

Would that sort of approach allow me to do the following:

  1. NOT release the source for my UI
  2. Release the source of the interface library I built (if necessary)
  3. Use one or more chess engines and bundle them as external command-line utilities that ship with a binary version of my UI

Thank you.

Edit: For what it's worth, this is so I can keep my own code private, as I may want to re-use some of my rendering code in other independent projects. This is not a commercial attempt to just write a cheap UI to effectively "wrap" someone else's engine and profit from their hard work. In the end, I wrote my own simple chess engine (little more than a legal move validator, really) instead of using a GPL'ed component.

  • 1
    AFAIK the Interface-As-A-GPL-Wrapper is moot. Why don't you just create two independent programs and make clear what the licenses for each are, so users know that they get two programs: A Chess GUI and a Chess program? I'd like to incorporate GPL-covered software in my proprietary system. Can I do this?
    – hakre
    Oct 31, 2012 at 9:34
  • Have you considered making a dynamically-loaded "plugin" type system? Make your GUI completely separate and NOT bundled in anyway with the GPL AI... Then, write a GPL licensed wrapper around the AI to interface with your program. I believe if you do this it's a deep dark gray area, but how would they sue you? You provided a tool. It's not your fault users are combining a GPL licensed plugin with your proprietary program. Note, if this is intended to go commercial or anything, definitely contact a lawyer about all of this though!
    – Earlz
    Nov 5, 2012 at 16:07

2 Answers 2


Take a look at this.

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.

According to that, GNU does not consider communicating through a pipe to be a derivative work, most of the time anyway.

  • 2
    Considering that the GPL is a legal agreement, the guidance you quoted is surprisingly vague. Oct 9, 2012 at 20:41
  • This is still not "yes or no", and adds more ambiguity. However, it does help.
    – Cloud
    Oct 9, 2012 at 20:44
  • @RobertHarvey The page I linked is not the actual GPL but an FAQ about it. AFAIK it's not legally binding in any way. I think they are trying to give the intention of the license without boxing them in with respect to any future legal issues.
    – CrazyCasta
    Oct 9, 2012 at 20:47
  • 1
    Welcome to the eternal grey of technological legal issues. It doesn't get any better if you stick to close source, become a non-profit, incorporate, offshore it, make money, or hire a lawyer.
    – Philip
    Oct 9, 2012 at 21:42
  • 2

No, I don't think it's ethical to incorporate GPL software into your close-sourced project. Any action that begins with an attempt to "bypass" the GPL is probably violating the spirit of the GPL. I don't find it an acceptable solution.

If your software runs GPL code, then your software should be GPL. That's the sort of give and take relationship that the FSF is trying to foster.

But to tone down the rhetoric, proprietary projects can indeed make use of GPL'd software as long as they're "at arms length". Your code can run on GPL'd operating systems, your code can ask for webpages served by a GPL'd server, and your proprietary user interface can even call on a chess program to pick the next move. But if you include the GPL'd chess engine, you MUST include the license and make the chess engine source code available. And you can change the chess engine, but if you make it specifically so only your UI can use it, you are violating the GPL.

And even then, if you're profiting from GPL'd code... Come on dude, contribute back to the community.

  • 4
    By that line of reasoning, any web browser connecting to a GPL'd web server or programs making calls to the GPL'd Linux kernel should be GPL'd as well.
    – Blrfl
    Oct 9, 2012 at 22:11
  • 3
    The original question was about legality, not ethics. Ethical and Legal are not always equivalent.
    – user53019
    Oct 9, 2012 at 22:43
  • It is not the intent (from an ethics standpoint) to make the chess engine the major component of my app. I just want to have on on-hand so the user can test the UI (among other features). I would not consider the engine to be the "selling point". Back to the issue at hand, I would first like to address the legality.
    – Cloud
    Oct 9, 2012 at 22:48
  • @Blrfl - There is a difference between connecting to a remote web server and using a library on the same machine. I would agree with Philip in this regard.
    – Ramhound
    Oct 10, 2012 at 11:55
  • @Ramhound: How far away do the packets have to go before the web server is considered "remote?" I think the FSF understood the value of networked services that don't have to check each others' licenses and decided that the ramifications of drawing its line at the process boundary were worth living with. Even if all of Dogbert's project doesn't end up GPL'd, the parts that are add something to the free software ecosystem that wasn't there before.
    – Blrfl
    Oct 10, 2012 at 12:18

Your Answer

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

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