Is it allowed for a proprietary application to run a binary under the GPL?

Question

Licenses for software and other works

If there is an application under the gpl license, does the proprietary program have the right (without having to open its source code) to run its executable? In general, is software and proprietary software allowed within the same GPL product?

Answer 1

> whether the proprietary program has the right
The program has no rights. The person has rights. :-)
> Is it allowed for a proprietary application to run a binary under the GPL?
I wonder how you see a world in which the correct answer to this question is no? So, why can't you run GNU Emax or GoldenDict from under Windows?
> In general, is GPL software and proprietary software allowed within the same product?
Also an amazing question. Makos, Android or Ubuntu - is it not “one product” in your opinion?
If you have a specific question about a specific situation, then it's probably worth asking. :-)
PS
[from comments]> Specific question: if I build ffmpeg with x264 support (which makes ffmpeg GPL license), and don't link "my" program to ffmpeg libraries, but run ffmpeg executable file by calling exec, or start, and then read it output via stdout, can I be required to open the source code of "my" program?
Hardly. I am not aware of such precedents.
> Another question: if there is a software product that is a distributed system, i.e. he has, say, 10 executable files that communicate with each other, say, via sockets, and one of these 10 executable files contains GPL code, do you need to open this 1 or all 10?
Let me quote the GNU GPL FAQ:

What is the difference between a "compilation" and other kinds of "modified versions"?
A "collection" consists of a number of individual programs distributed together on a single CD or other medium. The GPL allows you to make and distribute a collection even if the licenses of other software are non-free and incompatible with the GPL. The only stipulation is that you may not release the collection on terms that prevent users from exercising the rights that separate licenses of each of the programs would give them.
Where is the boundary between two separate programs and one two-part program? This is a legal matter that the judges ultimately decide. We believe that the correct criterion takes into account both the mechanism of the interaction (starting processes, communication channels, remote procedure calls, function calls in a shared address space, etc.) and the content of the interaction (what kind of information is being exchanged).
If modules are included in the same executable, they are definitely combined in one program. If modules are designed to work by linking in a common address space, this almost certainly means that they are combined into one program.
In contrast, communication channels, *sockets*, and command-line arguments are communication mechanisms typically used between two separate programs. So when used for interoperability, modules are usually separate programs. But if the content of the interaction is deep enough, if there is an exchange of complex internal data structures, this can also be a reason to consider the two parts as components of one larger program.

— https://www.gnu.org/licenses/gpl-faq.ru.html#MereA... (emphasis mine)
From myself I will add that:
— Precedents when someone was forced to release a program because it was designed for messages over sockets with a copyleft program are still unknown to me.
- But in general, your desire to circumvent copyright by any means on a crooked goat, in order to give your users as little as possible * less * freedom, causes nothing but disgust.

Answer 2

Thanks, looks like I found the answer to my question in the GNU FAQ :

If I write an external module for use with a GPL-released program, what requirements does that impose on the licenses under which I can distribute my module? (#GPLAndPlugins)
It depends on how the program uses its plugins. If a program uses fork or exec calls to do this, then modules are separate programs, so they are not required by the host program's license.
If a program is dynamically linked with modules and they call functions from each other and share common data structures, we are convinced that they form a single program that should be considered an extension of both the main program and the modules. This means that you must release the module under the GPL or a compatible free software license, and distribute it with source code in a way that is compatible with the GPL.
The case when the program is dynamically linked with modules, but the communication between them is limited to calling the “main” function of the module with some arguments and waiting for the return from the function to occur, can be considered as a limiting case.