Beyond Thesis: Does the GPL go too far and what makes a derivative work?

After the analysis of several people (including myself) about the inclusion of GPL’ed WordPress code, I think the debate over Thesis has mostly subsided with Chris on the losing end.  However, the reason the debate was so huge has a lot more to do with what people thought Thesis was doing and why they felt it should (or should not) be subject to the GPL.  Although it turns out to be a poor test case, the fact remains that there are several heavily grey areas in the GPL, especially when dealing with dynamic, object-oriented code.  Linux module developers have been dealing with these issues for a long time and there still remains a lot of questions.  As a disclaimer once again:

  • This post now has nothing to do with Thesis. I’ll talk totally in abstract and simple examples to try and explore the GPL
  • I am a developer, not a lawyer, and I intend to look at these issues from a technical perspective.
  • The GPL is a license.  It deals with copyright law.  It defines who is allowed to copy & distribute the software (everyone).
  • The GPL doesn’t prevent you from charging for the software, but anyone you sell it to inherits the copyright and can then copy & distribute it as they see fit.
  • The GPL has been tested in court a few times. The biggest issue is that these cases have dealt really with embedded systems where they should have been providing the source, but weren’t. See Harald Welte vs. Sitecom, vs. D-Link, and BusyBox vs. Monsoon Multimedia.
  • The GPL stood up well in these tests. However, they did little to answer the fundamental question of what constitutes a derivative work of source code when dealing with dynamic & scripted code.

What is a derivative work?

Basically, anytime you copy and modify something that is copyrighted, you are producing a derivative work. Let’s start with what US copyright law defines as a derivative work: 17 U.S.C. § 101 says ”

“derivative work” is a work based upon one or more pre-existing works, such as a translation, musical arrangement, dramatization, fictionalization, motion picture version, sound recording, art reproduction, abridgment, condensation, or any other form in which a work may be recast, transformed, or adapted.”

It seems clear and obvious that source code can produce a derivative work, the key being is it “recast, transformed, or adapted“? Please note that these are legal terms, not computer coding terms (which don’t mean the same thing). US Copyright Office Circular 14: Derivative Works goes on to say:

A typical example of a derivative work received for registration in the Copyright Office is one that is primarily a new work but incorporates some previously published material. This previously published material makes the work a derivative work under the copyright law. To be copyrightable, a derivative work must be different enough from the original to be regarded as a “new work” or must contain a substantial amount of new material. Making minor changes or additions of little substance to a preexisting work will not qualify the work as a new version for copyright purposes. The new material must be original and copyrightable in itself. Titles, short phrases, and format, for example, are not copyrightable.

So what’s clear here is that 1) You must have incorporated the original material in some way and 2) The original material must be significant (short lines of code, common tidbits, etc don’t count). This is where the Abstraction/Filtration/Comparison test comes in.

Now let’s look at what the GPL says is a derivative work. My examples will be with regards to writing plug-ins, themes, and extensions. This is where the Thesis debate was originally derived and where there still exists a lot of great area. From the GPL FAQ‘s:

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, which must be treated as an extension of both the main program and the plug-ins. This means the plug-ins must be released under the GPL or a GPL-compatible free software license, and that the terms of the GPL must be followed when those plug-ins are distributed.

If the program dynamically links plug-ins, but the communication between them is limited to invoking the ‘main’ function of the plug-in with some options and waiting for it to return, that is a borderline case.

Even the GPL writers acknowledge how grey this area is. As we’ll see, I think their interpretation already over-reaches the legal limits of copyrights. It’s also important to read the FSLC’s opinion with regard to WordPress Themes:

The PHP elements, taken together, are clearly derivative of WordPress code. The template is loaded via the include() function. Its contents are combined with the WordPress code in memory to be processed by PHP along with (and completely indistinguishable from) the rest of WordPress. The PHP code consists largely of calls to WordPress functions and sparse, minimal logic to control which WordPress functions are accessed and how many times they will be called. They are derivative of WordPress because every part of them is determined by the content of the WordPress functions they call. As works of authorship, they are designed only to be combined with WordPress into a larger work.

Some Simple Test Cases

So let’s look at some simple code examples and see where things break down. I’ll provide three pieces of code:

Able has written:

[sourcecode language=”ruby”]
#Able has released this code under the GPL
class Foo
def perform_work
puts "Able’s Foo has performed work"

Baker has written:

[sourcecode language=”ruby”]
#Baker has licensed this privately and very strictly
class Foo
def perform_work
puts "Baker’s Foo has performed work"

Charlie has written a

[sourcecode language=”ruby”]
class BigFoo < Foo
def do_it_all
perform_work #Who’s work?

First a sticking point: WordPress calls include() to include a theme. My example has the supposedly derivative work calling the dependency. I don’t believe the flipflop is relevant because the GPL FAQs use the same answer for both scenarios. I’ve done it this way for simplicity and ease-of-understanding.

So is Charlie’s work derivative of Able’s? It’s dependent on either Able’s or Baker’s to be sure. but derivative?
The key argument for themes is “They are derivative of WordPress because every part of them is determined by the content of the WordPress functions they call”. This is almost entirely the definition of inspiration. What seems to matter is “Did Charlie refer to Able’s code or Baker’s code when developing his own code?”. However, I believe this argument breaks down as well.


When you’re talking about a creative work, inspiration is a key factor. Fan fiction runs up against this wall. Fan fiction is derivative because someone else’s intellectual property (their characters, settings, plot lines, etc) have been used to create your work. Fan fic has been consistently found to be derivative and subject to copyright claims. But there is a very big difference between Charlie’s work and a piece of fan fiction. When you sell a fan-fic book, the original author’s characters are actually incorporated into what you’re selling. However, Charlie’s work does not significantly incorporate any bits of Able’s code, at least at the time of distribution. The key is that the in-memory combination occurs with the end user, who is not distributing ANY code and therefore is not required by the GPL to do anything. What you incorporate into your distribution is really the issue, not inspiration.


This becomes a major distinction. Charlie is not selling or distributing Able’s source, only his own. The incorporation must happen at the time of distribution. With non-compiled source code, the incorporation happens with the end user when they run the software. So here is a more apt analogy: Monopoly the board game. Let’s say I create my own board for a board game, with its own set of rules and no shared ideas (beyond those common to all board games, such as having a big card board piece on which you play). Now I wish to sell this board and only the board. In order to use my board game, I instruct you the end user to use the pieces from a Monopoly game because they work very well with my game. My game was even designed with using these exact pieces in mind (I was inspired by Monopoly pieces, although other pieces COULD work…that’s totally up to the people playing). However, you must obtain the Monopoly game on your own. My board game will not work without Monopoly pieces, so it is dependent but not derivative. The two pieces are combined at someone’s kitchen table to produce the final product. So it is clear that having distributed only my own original work, regardless of where my inspiration came from, no copyright is inherited from the original product.


So Charlie’s code contains no code from Able. Charlie wrote it all himself. Copyright law seems to stop right there. Having failed a test for substantial similarity and a lack of distribution of anything under the GPL, the GPL can exert no copyright over Charlie’s code. In fact, this is a copyright issue that has been settled many times. In Lewis Galoob Toys, Inc. v. Nintendo of America, Inc., or the GameGenie case, the court decided that interoperability does not create a derivative work. Much like our coding examples and WordPress themes, the GameGenie wouldn’t work without a Nintendo. It was once again clearly dependent, but not derivative. This argument becomes even clearer when we refer only to binaries.


I think in the end it’s clear that the GPL over-reaches in its determination of what constitutes a derivative work. This is where the “infectious” moniker comes from. It tries to ‘claim’ copyright over completely original works that it has no authority over. My examples deal with the very precise cases of dynamic scripting (non-compiled) code, distributed via source only, where no shared code exists between the GPL’ed and non-GPL’ed product, so please be cautious about reading into the too much with regards to things like Linux Kernel Modules or the like. Finally, I’m really enjoying the overall debate (I do love the GPL), and the great attitude everyone I’ve talked to (on both sides) has taken. Let’s continue that, for the good of all OSS.

18 thoughts on “Beyond Thesis: Does the GPL go too far and what makes a derivative work?”

    1. Thanks Demetris,

      The Washington Law article was extremely enlightening and I felt it says very much the same thing with regards to plugins: “the answer in this example depends on questions of copyrightability, incorporation, substantial similarity, market demand, and public policy”. Market demand is a topic I didn’t delve into, but I would say that with few exceptions, a plugin or theme does not in any way supplant demand for the original product and is, once again, therefore not a derivative work.

  1. I’m curious. In the example code you gave, isn’t it possible that ONE of Able or Baker infringes on the other? Isn’t it possible that, despite the derivation status of Charlie’s code, Baker might be derivative of Able or vice versa?

    The problem is that this analogue is difficult to apply to WordPress. There aren’t many things that have the same functions, same classes, into which themes & plugins plug.

    The abstraction layer idea is nice though.

    1. Hi Frederick,

      My assumption was that Able and Baker developed their code totally independently, and even that their code does totally different things. However, you’re very much correct that there is a line where creative input says that it is impossible for two works to be substantially similar without one having been inspired by the other (Which is why we don’t get two Paul Simons both writing “The Sounds of Silence” on opposite sides of the world. If two people wrote that identical song, then one really MUST have been derived from the other).

  2. I really like the way you’ve analyzed the GPL in general in this post, and cleared up the derivative vs. dependent question.

    I have a question. Is the following analogous to what you’re saying about the dependency/derivative thing?

    Say I write a C program using the MySQL client library (and for the moment let’s forget Sun’s OSS exception that essentially nullifies the infectious GPL clause) and I don’t bundle the MySQL client library, permitting it to be, instead, dynamically linked on the user’s end. The question of dependency and derivation are murky so far.

    Then say that a third party, let’s call them Orical, makes a client library COMPATIBLE with MySQL in all function calls, but which interacts with Orical’s database instead of MySQL, and which is licensed under a restrictive commercial license.

    Would this summarize the argument that my program is not derivative of MySQL nor Orical? The issue, I think, is that my program wouldn’t be dependent on MySQL, since an alternative to MySQL exists. Sure, my program might not be derivative, but it’s not dependent either.

    This invokes other questions, like Sun’s JDK vs OpenJDK.

  3. The GPL doesn’t prevent you from charging for the software, but anyone you sell it to inherits the copyright and can then copy & distribute it as they see fit.

    That’s not accurate. The copyright holders still retain the copyrights. Users are given certain (inalienable) rights *under the GPL” but the creators still retain copyrights.

    1. @Eric,

      It’s possibly not worded well, my intent was to say that the CODE inherits the copyright. As in it retains the copyright of the original creator

  4. I might be the only one, but I found it quite funny that you used Ruby (and its delicious syntactic sugar) for you example code. +1 internets for you, sir.

    Great Post. Very Reasoned. GPL isn’t perfect, but is what WP has chosen and what we’re stuck with. Now if we could all agree on the spirit AND the letter of the license, we could possibly move on.

  5. I was researching this months ago and decided that I don’t like the GPL anymore… perhaps the LGPL is more suited. perhaps what I’d really like is an ALGPL So if people use my software and change it they have to give me the changes (even if it’s on there box) but plugins and apps linked to it don’t have to be shared, by the source.

    I don’t much care about wordpress though, but this is making me think about using GPL for anything that might have plugins.

  6. So what’s clear here is that 1) You must have incorporated the original material in some way and 2) The original material must be significant (short lines of code, common tidbits, etc don’t count).

    In your citation of the Copyright Act’s definition of “derivative work” you’ve omitted the second sentence, wherein works that do not directly incorporate material from the original are still characterized as derivative works.

    Furthermore, the issue is not whether “material” is incorporated, but whether protected “creative expression” from the original is incorporated. This is why trivia books about a TV series,
    answer keys to a textbook, and unauthorized stories based on another author’s characters/universes/creations have all been found to be infringing derivative works. (Your citation of the Galoob v. Nintendo case is a poor example because the court’s ruling was that Galoob’s device did not constitute a copyrightable work and thus could not be found to be infringing of copyrights.)

    For software, the “creation” of the programmer is not merely the text of the source code, but the organizational combination of the various functional aspects of the program (in other words, the intellectual and creative decisions of the programmer as expressed in the code). A plug-in or module which is written to avail itself of the organizational structure of the program is effectively incorporating the copyrightable aspects of the original software in a derivative work — and preparation of such derivative works is one of the exclusive rights of the copyright holder as set forth in Title 17 §106(2).

  7. I apologize for using WordPress as an example, but most are familiar with it, and the Able/Baker example is too basic.

    Many WordPress themes rely heavily on the WordPress api, and derive much of there functionality from it. Themes are not output, they become part of the program when installed. As a stand alone program they are useless.

    Here is a simple argument. If somebody wants to claim that an at least moderately complex theme is not a derivative work because it is not competing with the original copyright holder, then what happens if the theme designer decides to start shipping WordPress with their theme because it is required for it to work? I think most would agree this would now make the theme a derivative work that is competing in the market place.

    So with the above in mind, I just don’t believe that by simply telling people to go download WordPress “over there” to make my program work is good enough to get away with hijacking the freedoms that the theme developer was granted and required by the GPL to pass on.

    I think there are plenty of projects out there that this same argument can be applied to.

    I am hoping that the GPL v3 solves some of these issues, but I need to take another hard look at it with all of the new possible loopholes in mind.

  8. I set out to find a good article arguing for the idea that Themes are not derivative works.

    I think this might be the best article on the subject, though I don’t necessarily feel that one could argue that the GPL would not apply to themes and plugins because they not only require WP to function, they typically require more than a little bit of the core code to be embedded into the theme in order for the theme to function.

    Each time a WP function is used in the theme code it is actually invoking large chunks of WP code. A function exists to allow a single line to run many lines, and potentially other functions as well building in a large web of integration within the original code.

    Now, there are many aspects of a theme that could be considered original work. CSS, JS, and images might be dependent on the Core php, but they do not use any of the php. This seems much more closely related to the board game illustration you posited.

    Anyways, thank you for this well written article supporting proprietary rights.

  9. Drew –

    This was a really well written piece and make many of the same arguments that I’ve been considering for a while now. I think that your conclusions are spot on.

    In general, I don’t have an issue with GPL (although I’m a much bigger fan of MIT or BSD) I do take issue with the over-reaching that GPL often leads to.

    This is the sort of common sense understanding of GPL that needs to be expanded.

  10. The big issue to me is the slippery slope of the overreaching GPL claims, such as claiming that wordpress themes or plugins are derivative works of wordpress.

    The claim that enhancing what people can do with their installed copy of wordpress constitutes a derivative work is almost as absurd as claiming that worpress is a derivative work of php, apache, mysql, or even linux.

    Furthermore (since this is really an argument on the copyright aspect of derivative works not GPL), what would happen if companies like Microsoft started claiming that anything that calls their API’s, shares memory space, or somehow enhances Windows is now a derivative of their product?

    Violating the GPL only means that you don’t have the rights specially granted by the license. But what happens when privately licensed copyrights start overreaching the way GPL has?

    One of the biggest arguments that wordpress people use is the analysis from the Software Freedom Law Center ( but that is hardly objective because the SFL wrote the GPL. Furthermore, an item in the GPL FAQ certainly is not a binding part of the license itself.

    It is my opinion that some people, such as Matt Mullenweg, use the GPL more as a power grab than anything else. In their opinion, if something touches WordPress in any way, it falls under the scope of the GPL. And if you don’t use the GPL in your theme or plugin, they completely shut you out of the community.

    People would be outraged if Microsoft sued Mozilla, claiming that Firefox was a derivative of Windows. Why then are so many people allowing WordPress to claim that anything that runs on WordPress falls under GPL?

  11. My thoughts were the exact same when I took a look at how does a WP theme look like, my first thoughts were:

    how does my WP theme know that the_title() is implemented by WP or possibly a WP clone?

    but yes this is generally an interesting debate.

  12. I think it’s strange that this GPL-issue is so much discussed. There is a much bigger GPL-issue in the media world (HTPC, NMT, XBMC, Boxee) which doesn’t get any attention at all.
    What’s happening?: is distributing a fork of GPL v2 XBMC Media Center software. They ship this software with a closed source unique executable without license. At the moment, they only offer a downloadable version of their Media Center but very soon they will release Boxee Box (shipped with this software). (a community driven Foundation) and Boxee are friends (Boxee donated a substantial amount of money) but there is a third party,, involved who did exactly the same thing. went hard on Voddlers’ copyright infringement but they don’t mind Boxee; to me this is a very strange and disputable attitude. Especially since has many downstream suppliers, which should be protected.
    When your talking about commercializing GPL: Both Boxee and Voddler are financed by Venture Capital. In total around 35 million US-dollar…..

Leave a Reply

Your email address will not be published. Required fields are marked *