[no subject]

Can I use the GPL for a plug-in for a non-free program?
-------------------------------------------------------

    If the program uses fork and exec to invoke plug-ins, then the
plug-ins are separate programs, so the license for the main program
makes no requirements for them. So you can use the GPL for a plug-in,
and there are no special requirements.

    If the program dynamically links plug-ins, and they make function
calls to each other and share data structures, we believe they form a
single program, so plug-ins must be treated as extensions to the main
program. This means that linking the GPL-covered plug-in with the main
program would violate the GPL. However, you can resolve that legal
problem by adding an exception to your program's license which gives
permission to link it with the non-free main program.

    For more details, see the question above that starts with, "I am
writing free software that uses a non-free library."


What is the difference between "mere aggregation" and "combining two
modules into one program"?
---------------------------------------------------------------------

    Mere aggregation of two programs means putting them side by side on
the same CD-ROM or hard disk. We use this term in the case where they
are separate programs, not parts of a single program. In this case, if
one of the programs is covered by the GPL, it has no effect on the other
program.

    Combining two modules means connecting them together so that they
form a single larger program. If either part is covered by the GPL, the
whole combination must also be released under the GPL--if you can't, or
won't, do that, you may not combine them.

    What constitutes combining two parts into one program? 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.