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:
- 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
- The interface library I wrote itself is then released under the GPL
- The interface library is only used to communicate via a generic text pipe to external command-line chess engines
- 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.
- 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:
- NOT release the source for my UI
- Release the source of the interface library I built (if necessary)
- Use one or more chess engines and bundle them as external command-line utilities that ship with a binary version of my UI
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.