5

Background: In the audio processing world, most programs to compose and mix music in (collectively called DAW's from now on) are commercial and closed source. These programs can extend their functionality using some common plug-in specifications.

There is one common 'free' and cross-platform specification that is widely supported (Steinberg's VST specification). There are several others, most commonly Apple's AudioUnit and Avid's RTAS- and AAX specifications. AudioUnit, RTAS and AAX are locked in to the companies' proprietary DAW platforms (Logic and Pro Tools).

For whatever reason these specifications were developed, they are nearly completely identical. However, Pro Tools and Logic refuse/don't support loading plugins from any open specifications except their own.

These specifications are so identical that creating a wrapper around all of these specifications is trivial and possible. This, then, has created a mess in which developers of audio plug-ins must separately distribute a lot of permutations of their plugins, but it has become common practice.


Situation: I created a meta-plugin/wrapper, that allows to identify itself as any format (specification) and load any format (such that you can load VSTs in Logic, for instance). The plugin is free and licensed under the GPL.

It works completely on its own. But it can, at run-time optionally load any end-user provided plug-in, or, optionally, save an emulated 'copy' of the loaded plug-in disguised as any other format. This last feature allows the unsupported format to be loaded seamlessly in any other locked-in proprietary host (but under the hood, it is still wrapped through my plug-in, just statically (not it terms of linking) and invisibly).


The question is, whether this is in violation of the GPL, when the end-user provided library loaded in my GPL program is not GPL-compatible (proprietary or closed source, for instance).

Notice that, the GPL program Audacity allows the same functionality - it can for instance load any VST-plugin, that may or may not be proprietary. I can even, through creative audio system routing, simulate the exact situation using a project in Audacity that can be routed through something like Logic, emulating the wrapped plug-in situation.

I guess the question can be boiled down to: Can GPL hosts support loading of optionally provided non-GPL plug-ins in this specific situation, where the GPL host imitates the non-GPL plug-in in what effectively seems like one plug-in?

2

IMHO your question boils down to: can a piece of GPL-licensed code load arbitrary code under non-GPL or other licenses assuming it does not know about any of this other code ahead of time?

The closest thing that comes to mind would be an OS user space such as the Linux user space. Linux does not know anything ahead of time about your program. Does its GPL license extend to your program? Since this can be a grey area for some, Linus made it clear that the GPL does not extend to user space programs.

I think the same context applies here. For the sake of clarity if you want to allow or disallow the loading of non-GPL-licensed plugins by your framework, you should make this explicit such that there is no source of confusion for your users. An explicit GPL exception would be the thing I would do if it was for me.

  • @Philippe What about freedom number 0? I guess it is like this: If you own the API, you need to specify your opinion. If you legally (Oracle vs Google) implement support for some others, then freedom number 0 tells the user that he can load what he want. – user877329 Jun 5 '16 at 15:26
  • @user877329 I am not sure I parse entirely what is your question? – Philippe Ombredanne Jun 5 '16 at 21:02
  • @Philippe "The freedom to run the program as you wish, for any purpose (freedom 0)" Doesn't that mean that I can load a proprietary plug if i which. – user877329 Jun 6 '16 at 8:18

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.