Can proprietary-licensed software (that will be distributed, alongside with the hardware) use GPL software (distributed from package manager)?.

It's basically scientific-measurement-device, that manipulates image from usb-camera. Tools that will be used for image processing are ffmpeg, imagemagick, gnuplot, cat, cut etc (that will be installed using the package manager). These software sources won't be modified at any point in time.

Is it OK to use propriety license on how we process the data?

For example: in python (bare with me, it's just for the demonstration) /I know all of following can be done with pure Python, but that is not the question/

os.system("ffmpeg -f video4linux2 -i /dev/video0 -vframes 1 -video_size 640x480 test.jpg")
os.system("convert test.jpg -crop 110x270+230+70 cropped.jpg")
os.system("convert cropped.jpg -resize 1x270! out.txt")
os.system("cat out.txt | cut -d')' -f1 | cut -d'(' -f2  | gnuplot -p -e \"set term png;plot '<cat' with lines \" > test.png")

Is above code considered, aggregation? or derivative of GPL software? or seperate software? Could you explain me what is considered aggregation, exec, pipes, rpc, function calls within a shared address space, etc.

The GPL permits you to create and distribute an aggregate, even when the licenses of the other software are nonfree or GPL-incompatible.

Where's the line between two separate programs, and one program with two parts? This is a legal question, which ultimately judges will decide. We believe that a proper criterion depends both on the mechanism of communication (exec, pipes, rpc, function calls within a shared address space, etc.) and the semantics of the communication (what kinds of information are interchanged).

If the modules are included in the same executable file, they are definitely combined in one program. If modules are designed to run linked together in a shared address space, that almost surely means combining them into one program.

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.

Addtionally, what is arms's lengths? Is above 4 lines of python code considered arm's lengths ?

However, in many cases you can distribute the GPL-covered software alongside your proprietary system. To do this validly, you must make sure that the free and nonfree programs communicate at arms length, that they are not combined in a way that would make them effectively a single program.

Lastly, Is above 4 lines of python code considered combined program that has INTIMATE communication ? what exactly intimate communication? and Does image data considered complex data structure?

It depends on how the main program invokes its plug-ins. If the main program uses fork and exec to invoke plug-ins, and they establish intimate communication by sharing complex data structures, or shipping complex data structures back and forth, that can make them one single combined program. A main program that uses simple fork and exec to invoke plug-ins and does not establish intimate communication between them results in the plug-ins being a separate program.

Sorry, English is not my native language, and don't fully understand these paragraphs in GPL's FAQ. I, personally, like F(L)OSS, but license selection is above me.

Also, Is above 4 lines of code considered Wrapper?. And GPL licenses are irrelevant to 4 lines of code? what exactly Wrapper?

1 Answer 1


Can propriety licensed software (that will be distributed, alongside with the hardware) use GPL software (distributed from package manager)?

Yes, as long as your code and the GPL code communicate "at arm's length".

Communication "at arm's length" implies a couple of things:

  • The communication is between separate executables
  • The communication uses communication channels that are typical for communication between separate executables (like sockets, files, command-line arguments, etc.)
  • The proprietary code does not have knowledge of implementation details of the GPL code, but only uses the documented interfaces (i.e. the proprietary code can be written without ever having seen the GPL source code).
  • The proprietary code can work with any executable that provides the expected interface (name, command-line arguments, etc.) and behavior.

Your example python script ticks all the boxes for communicating "at arm's length", so you are free to license that in any way you want.

Is above code considered, aggregation?

The term "aggregation" is used when distributing software and means that multiple software packages, which are unrelated to each other in copyright terms, are being distributed together.

If you would create a single zip file of your application together with the tools it uses, then that can be described as an aggregation.

Also, Is above 4 lines of code considered Wrapper? [...] what exactly Wrapper?

In this context, a Wrapper is a piece of software specifically written to try to bypass the requirements of the GPL license.

As your example does not have that intention, it is not a Wrapper within the context of the GPL FAQ entry.

It might qualify under other definitions of the term Wrapper, but those definitions are not relevant here.

And GPL licenses are irrelevant to 4 lines of code?

The GPL license is relevant as soon as copyright protection applies to the code.

There is no lower limit in the lines of code you need to write before copyright protection applies, but a minimal creative effort must have been used to create the code. But the bar on that is pretty low.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

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