GPLv2 - Multiple AI chess engines to bypass GPL

Question

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

https://stackoverflow.com/questions/3248823/legal-question-about-the-gpl-license-net-dlls/3249001#3249001

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.

Answer 1

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.

Answer 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.