[PD] gpl vs creative commons

Chris McCormick chris at mccormick.cx
Tue Jan 29 10:04:55 CET 2008

On Tue, Jan 29, 2008 at 09:08:18AM +0100, IOhannes m zmoelnig wrote:
> Roman Haefeli wrote:
> >
> >ask a lawyer to check in detail, if this is true. however, if licenses
> >could cross 'levels of abstractions' in the sense of pd patches being
> >affected by the license of pd, 
> afaik, licenses do not cross "levels of abstractions".

In this particular case, Hans is wrong and you guys are right, but it's
quite complicated, depending on the type of work which is created and
the license of the software. Let me try to explain (IANAL and I am also
sleep deprived :) ).

Hans wrote: "I think that if you write a patch that uses a Pd library that
is covered by the GPL, technically, your patch is covered by the GPL."

This would only be true if you were:
a) Distributing the GPL library/external with your patch.
b) 'Linking' your patch with the original software.

On count (a) you generally don't distribute externals with your patch -
you expect people to download and install them themselves. Distributing
the patch on it's own is fine even if it used a commercially licensed
external - it's up to other users to procure a license for that
commercially licensed external in order to run your patch. Infact,
if you are not distributing the result, you can do whatever you want
(including linking commercial code or whatever) in the comfort of your
own home and nobody can stop you.

On count (b), I don't think anybody would 'link' a Pd patch with Pd
since that would require the patch to be turned into a data segment and
linked into the Pd binary and a special hook would be required to load the
linked binary segment directly into Pd at runtime instead of reading
it from a .pd text file. In other words, if someone made a stand-alone
application with the Pd file compiled into the binary and then distributed
that, then they would probably be required to adhere to the GPL license
of the externals used (e.g. if they used the linker program to link
the patch into the application). This area is quite fuzzy because some
people even contend whether dynamically linking things is covered by
the GPL - this has probably changed with GPL 3.0 which probably makes
it more explicit (but would still allow an interpereted .pd file no
problems at all). If the developer/distributor used pure Pd then they
wouldn't have to worry about that because it's BSD (except they would
have to flash the Pd license to the user at some point).

It's conceivable that someone would write some software that had
an EULA which specified that works created with that software were
covered by the same license as that software (crossing "levels of
abstraction"). Microsoft's Hotmail service does something like this -
when you create a hotmail account you agree that all data and emails
that pass through their server are owned by them. As for whether this
would stand up in court or not is a different matter. Especially
interesting in this regard is whether code is speech or not because as I
said, the type of work created matters a lot as different works are
considered in different ways under the law.

> however, if i have a collection of abstractions published under the GPL, 
> then i think i don't cross this magical border.

There is no "magical border". There is just different software with
different licenses and different types of works (which are treated
differently under the law) created with those bits of software. 99% of
the time you are going to be fine and you are going to be able to
license your work in whatever way you want, independently of the
software. When the work is itself a computer program it seems more
complicated but actually really isn't.

> next comes the question, what is the difference between an abstraction 
> and an external non-abstraction object. afaik, GPL does not dissolve 
> just because of languages used. (that is: porting of code from one 
> language to another is (to my knowledge) not really affected by the GPL 
> (e.g.: you can chose the license again) as it usually involves re-coding 
> an algorithm rather than re-using pieces of code.; but this is unrelated 
> to the language a library is written in)

Yep. The copyright covers the text of the source code. So if you
re-write the source code in a different language you have created a new
and different text. This is akin to re-writing a novel with different
words and characters and place names, but with the same basic plot. It's
completely legal. In the case of algorithms though, watch out because
under certain jurisdictions they may be covered by software patents
which will bite you in the ass.

The principal difference between and abstraction and an external is that
an external is 'linked' with the Pd binary (dynamically at runtime
usually) whilst an abstraction is interpereted. Interpereted works are
not covered by the GPL, but linked code is.

> finally, i am still unsure about the "static linking" clause, and how it 
> affects an interpreted language.

It doesn't in the case of the GPL.

> i guess, if you have a  patch that depends on a GPL'ed pdlib, and you 
> are distributing your patch with this library (e.g. for convencience 
> reasons), then you are kind of _statically linking_ and thus your patch 
> is automatically GPL'ed too.

I really don't think so, unless you are actually using a linker program
to link the .pd file with the Pd binary, which is very unlikely. If I am
wrong then ALL YOUR BASE BELONG TO MILLER and I am switching to
supercollider. :)




More information about the Pd-list mailing list