This will be a very large post, but I felt it necessary to give an explanation of the fundamental concepts surrounding this matter. I hope that this will be a useful contribution to the subject at hand.
I’m glad this is sparking conversation, and this time hopefully from a slightly different perspective than the constant arguing over the GPL text. I’m approaching this from the aspect of copyright law itself, rather than the license text. Also note that there are some posts arguing about Blender’s license choice, and I’m not sure why that’s being brought up, as it has no relevance to the matter being discussed. Blender is licensed under the GPL, and that’s not changing. Let’s not argue about which licenses might or might not be better.
Let me preface my response with some disclaimers, and dismissing some misunderstandings.
First and foremost, I am not a lawyer (as clearly stated in the things linked by the OP), and this is simply my interpretation. Further, there are many citations going around of several people’s statements on their interpretation of these licensing questions, so I’d like to remind everyone that opinions are not facts, and opinions don’t change reality (obviously this includes my opinions as well). If you are truly interested in these matters, I’d like to invite you to read up on the legal texts surrounding matters of copyright and licensing, rather than quoting others’ opinions (again, this includes my opinion). Note that even a lawyer’s opinion is still not a fact, while it might be a more informed opinion, it still is just that, an opinion, and in fact, lawyers disagree all the time. Ultimately these matters are for courts to decide. Though I acknowledge the value of several opinions, cumulatively.
I’d also like to highlight that I’m a strong believer in open source, and pro open source advocacy is a big part of my life. I am a true believer in an open source future, and I am invested in this cause. I am also of the opinion that fanaticism has no place in a healthy community, though sadly, this has been a continual struggle within the FOSS movement. Additionally, I have been part of the Blender community for over a decade, and have contributed to core Blender code for some 5 years, both as a volunteer, and as a paid employee of the Blender Foundation (note that I am not currently involved with any of the Blender organisations in any official capacity).
That being said, for the purpose of full disclosure, I am opposed to the GPL. Though that’s not due to any philosophical or moral questions, but rather because I simply consider it a poorly constructed license, which I believe creates too much uncertainty among people (and courts) all interpreting the license differently. The license’s ambiguity ends up being harmful to the community. This is to say that my intention with sparking this discussion is not to create an anti open source flame war, but rather to try to promote a healthier open source environment.
I will concede that due to my personal position on the GPL, my assessment could be somewhat biased, even though I try to stay objective when evaluating these matters. It is also notable that my assessment of the copyright issues as linked by the OP, actually has nothing to do with the GPL. It is an assessment of copyright law and fair use, which applies to any licensed material, no matter the license, and in fact this applies even to material under proprietary licenses.
Now as for some of the misunderstandings I’ve seen in this thread and elsewhere:
-
Core Blender code: nothing has changed regarding Blender’s own source code, nor have I ever claimed that it has. Blender is free forever (note that in this context free does not mean gratis). Blender’s source is protected under copyright law, and is licensed under the terms of the GPL. Blender’s license cannot be changed without agreement of all Blender copyright holders, which includes basically anyone who ever contributed code to Blender (outside of an employment contract with the BF, which has a clause transferring your IP to the BF). Code copied from Blender still has to be distributed under the GPL, and as long as copyright exists, this will never change.
-
The situation in the EU hasn’t changed: Indeed nothing changed here, the US Supreme Court ruling obviously only has jurisdiction over the US. In the EU, software copyright is defined by the Computer Programs Directive from 1991. This directive explicitly exempts APIs from being subject to copyright. With this, it has always been extremely unlikely that the GPL would ever be found to be enforceable on add-ons for GPL licensed software. The situation here hasn’t really changed since 1991. My reaction was simply to a change in the situation in the US, as, according to my interpretation, the US is now a little closer to the EU in this matter (though not completely, I’ll expand more on this below).
-
No US law has been changed: Yes, this is true. However, this ruling is still of extreme relevance. The US operates within the common law legal system, which is heavily based on precedent. Within this system there is a concept of “binding precedent”. Binding precedent is set by a court ruling, and applies to any court below its jurisdiction. Binding precedent guides how courts rule in the US, and once a higher (or the same) court has ruled on a matter, any subsequent cases of similar nature are extremely unlikely to have a different outcome, or to disagree with the set precedent. Since this ruling was made in the US Supreme Court, which is the highest court in the country, with nation-wide jurisdiction, the ruling sets binding precedent for every court in the US.
-
Court ruled on API re-implementation, not API use: Yes, I am aware of this, and I’ll expand on why it is still relevant in a moment.
Ok, with those things out of the way, let’s get onto a more detailed analysis of the matter at hand.
There seems to be a lot of misunderstanding about copyright, fair use, and licensing, so let’s do a little overview.
Copyright is the legal framework that protects things that people make. Generally, under copyright law, if you make something, you can do whatever you want with it, and everyone else can do almost nothing with it. The terms of copyright vary somewhat between different media, such as textual works, audio-visual works, etc. But generally, under copyright, people are basically allowed to look at your work, and not much else.
Having a work that people can look at, and not really do much else with is not particularly useful for many kinds of work, like software, for instance (though software has some exceptional rights of its own under copyright law). For this reason, there is such a thing as a license. A license gives people extra permissions that they would not otherwise have under copyright law. These extra permissions can be conditional, but they can’t impose additional restrictions on top of copyright law.
Think of it like a driving license. When you get a driving license, you gain the permission to drive, but only under the condition that you follow traffic rules. If you break these rules, you can lose your license. However, the driving license doesn’t add any restrictions to what you could already do before you had the license, such as, say, your right to walk in public spaces.
A license, under copyright law, is just like that. For instance, the GPL says you can redistribute the code, but only if you do so under the same terms. That is a condition, but not a restriction. If you had not been given a license, you could not redistribute the code at all. So the license gives you this extra permission, but with a condition attached to it. On the other hand, a license can’t, say, require you to release all the code you ever write under the same terms, as that’s not a condition on a permission given to you by the license, rather, this would be a restriction on something that you were previously already allowed to do, namely, the permission to publish your own original code under whatever terms you feel like (this is a purely illustrative, hypothetical example. I have never come across a license that tries to claim such a requirement).
As a side note, copyright is why public code does not necessarily mean open source. Code that is released in public without any license attached to it is not open source. Without a license, the default protections of copyright apply (this is what it means when you see “all rights reserved”, which is just an explicit way to highlight what already happens by default anyway), and that means that there is very little you can legally do with the code.
But this is not the full picture. With what we described here, you wouldn’t be allowed to post a quote from a book, a film critic wouldn’t be allowed to post a screenshot of a film, a music theorist wouldn’t be allowed to use musical snippets in an analysis, unless they had a license. This is very restrictive, and would stifle many forms of expression (works that incorporate parts of other works are called “derivative works”). This is why copyright law has a set of exceptions called “fair use”. This applies whenever a derivative work is deemed to incorporate too little of the original work to be of significance, or if it’s satire, or, in some cases, if it is transformative enough. There is a big set of rules and factors that come into play when a court decides whether or not something is fair use, and it is admittedly a fuzzy and complicated subject.
So how is copyright enforced? Well, a copyright holder, also called an intellectual property (IP) holder (the plaintiff), who considers that their intellectual property has been infringed upon, can file a lawsuit against the alleged infractor (the defendant).
Let’s suppose that the plaintiff’s work did not have any license attached to it (i.e. all rights reserved), and let’s look at the steps a court would take. First, the court has to define whether or not the defendant’s work is derivative of the plaintiff’s work at all. If that is not found to be the case, then the lawsuit ends here, there is nothing more to look into, as the defendant has not incorporated any of the plaintiff’s IP in their work, and thus they cannot be infringing on that IP.
In reality, such a lawsuit would rarely end at this stage, as it’s uncommon for someone to even start a lawsuit about something that it clearly not derived from their IP. More likely, the defendant’s work is found to infringe on the plaintiffs IP in some way. In this case, the lawsuit moves on to a fair use evaluation. Here, the court will find if the defendant’s work incorporated the plaintiff’s IP in a manner that it limited enough to fall under the fair use exception. If it is found to be fair use, the defendant wins the case, and their work is found not to be infringing on the the plaintiff’s copyright. On the other hand, if it is not found to be fair use, the defendant’s work is found to be infringing on the plaintiff’s copyright, and likely some form of compensation will be required. Either way, this is the end of the case.
Now let’s suppose that the plaintiff’s work had a license attached to it. In this case, the same two evaluations as described above take place. Only after the fair use evaluation, if the defendant’s work is not found to make fair use of the plaintiff’s work, the court will move on to a license evaluation, where it will be determined if the defendant’s work was allowed by the license terms. This is the final step that decides if the defendant was indeed infringing or not. But note that license evaluation is the last step in the process. If the defendant’s work is not infringing on the plaintiff’s IP at all, or if it falls under fair use, a license evaluation is not necessary at all, as the work was allowed by law, even if it had no license attached to it (which, remember, can only add permissions, not take them away). So a license evaluation is only necessary if the defendant fails the two previous legal tests.
Having this basic understanding of copyright litigation, let’s move on to a more relevant example.
Let’s first look at the situation in the EU (the simpler case). As I stated before, in the EU, APIs are not subject to copyright. This means that if you come up with an API, you cannot claim property over it. Of course, an implementation of an API (as in, the actual code behind the API, which actually does things) is still subject to copyright.
So let’s suppose someone made a program (the host), which provides an API for plugins. Now someone develops a plugin for this program, which is composed entirely of original code, copying no code from the host, except for the API calls (basically the names of some functions, and some data structures), and they release it under their own terms, without permission from the host’s developer. Then the host’s developer sues the plugin developer for copyright infringement. As usual, the court will go through the described steps. First checking if the plugin infringes on the host’s IP. At this stage, already, an EU court is extremely unlikely to find it to be infringing, as the only thing the plugin and the host have in common is a few function names and data structures, i.e. the API, which is not subject to copyright. Note that the plugin doesn’t copy any code implementing that API, it just calls some functions with the same name as those implemented by the host, which is the very definition of an API.
As we can see, the plaintiff’s case failed at the very first step, unless the court finds the plugin to be infringing on the host in a way other than API use. Notice how this means that we didn’t even reach license evaluation, as this use-case was permitted even without a license. So we didn’t even have to check if a license was attached at all, as it is completely irrelevant.
Now let’s look at how this case would play out in the US. In the US, API copyright is not explicitly defined in the law, so we don’t really know if APIs are subject to copyright or not. So upon finding that the only thing shared between the plugin and the host is an API, the court would have to decide whether or not an API is subject to copyright (yes, courts also have the responsibility of defining things that are not specified by the law, which in the US then becomes part of case law. This is the binding precedent I mentioned earlier).
Alternatively, the court can avoid defining whether or not APIs are subject to copyright, by evaluating the case under an assumption. So, assuming that APIs are subject to copyright, let’s move to the next step, which is fair use evaluation. Now, if the defendant’s work is found to make fair use of the host’s API, then the defendant wins the case, no matter if APIs are subject to copyright or not. Because even assuming that the plugin was infringing in the first step, it is found not to be infringing in the second. This means that the court can get away with not defining whether or not APIs are subject to copyright. Only in case it is not found to be fair use, the court would need to rule on API copyright. Because in this case, the plugin is found to be infringing, only under the assumption that APIs were, in fact, subject to copyright, and therefore the court needs to decide on this matter as well, in order to find the plugin to be infringing or not.
This last example is very similar to Google v. Oracle except for one notable difference. In Google v. Oracle, Google was sued by Oracle (it’s called Google v. Oracle and not the other way around, because this was actually a new case where Google appealed to the Supreme Court to revert the decision of a lower court on the Oracle v. Google case), for copying their API declaration. Here, Google made an original implementation of APIs owned by Oracle, and copied the API declaration (only the declaration, not any of the implementation code). Think of this as someone implementing a new and original 3D application, but exposing a Python API identical to Blender’s API, such that Blender plugins could work with the new application. In this case, the court found it easier to rule it fair use, under the assumption that APIs are subject to copyright, rather than actually deciding whether or not APIs are subject to copyright. So Google won the case, on the basis of their re-implementation making fair use of Oracle’s IP, without the court actually making a decision on the matter of API copyright (which is unfortunate, as a ruling making APIs not subject to copyright would have massively simplified things, and would have been more beneficial for software freedom).
My interpretation of this ruling is that it must also make the use of APIs (such as in a plugin) fair use. There are a few things supporting my interpretation.
Firstly, an API re-implementation copies all the functions/data structures of an API, while a plugin only makes use of some of those APIs, meaning that the amount of copied material (remember, this is only about some function names) is much smaller, making it even more likely to be seen as fair use by a court.
The other thing supporting my interpretation, is that otherwise, a legal paradox would occur. Let’s suppose that someone re-implements Blender’s API in a new application (as we saw, this is probably fair use, and therefore not subject to Blender’s license), and they release this new application under a permissive license, say MIT. Now, a plugin made for this new application can definitely be released under any terms, as the MIT license doesn’t have conditions on license terms. This plugin, by using this API which is identical to Blender’s API, would automatically also be compatible with Blender. Is the plugin now infringing on Blender’s license? That wouldn’t make any sense, as it would render the legality of an API re-implementation useless, as any plugin developed for the new application is still bound by the original application’s license (which the plugin developer wouldn’t even necessarily be aware of).
The point is that if an API is deemed too esoteric or abstract for a re-implementation to be an infringement, it seems very unlikely that a court would find calling some of the API to be concrete enough to be an infringement.
And to anyone who will claim that in such a case, the plugin itself is not infringing, but the user would be infringing by combining the plugin with Blender, note that the GPL explicitly does not restrict usage in any way. It only puts conditions on distribution. You are free to do anything you want with a GPL licensed program on your own computer, even combine it with proprietary programs.
You might also argue that a plugin is derivative work, not simply because of the actual words contained in the code, but because without the host it is not particularly useful. But note that this is not generally what courts have found. This is a relevant case, that involved an enhancement board for the NES console, in which case the court found the add-on board not to be infringing. Notably, in an earlier similar case, the court ruled against the addon board maker, however the distinguishing factor (as noted by the court in the NES case), was that this board actually contained significant portions of circuitry copied from the host platform. So it seems that courts are primarily interested in whether or not there is actual material being copied, and not particularly interested in the relationship between the two works.
A court would often rule such things as fair use, in order not to stifle innovation, and to avoid monopolies. Enabling people to work off of each other’s work is generally considered good for technological advancement, and this is one of the main reasons fair use is even a thing. But a court will be more likely to rule that something is not fair use, if it’s hurting the original creator’s business.
So my argument is based on the idea that I find it extremely unlikely that a court would ever find a plugin to be a derivative of the host, unless it actually copied code, additionally to calling APIs. This was my opinion even before this recent Supreme Court ruling, and the ruling simply strengthened my position to the point that I felt comfortable releasing this GPL-incompatible add-on.
Some additional things of note are that this court ruling was not unanimous, and the dissenting opinion of one of the Justices was, in part, motivated by the notion that based on the circumstances, this fair use ruling “makes it difficult to imagine any circumstance in which declaring code will remain protected by copyright.” So they went even further than me in their assessment of copyright and fair use of APIs, and their (quite qualified) opinion of the ruling seems to support my argument.
I’d also like to point out that Blender’s current “official” position on the licensing matter contradicts itself. The currently accepted notion is that you can make a Blender add-on which consists of a GPL licensed Python portion, and a closed source binary, called by the Python code, as long as they are not shipped together.
This simply makes no sense at all. If you consider that the Python portion, which communicates with Blender is a derivative work of Blender, and therefore must comply with Blender’s license, how can it call into a closed binary without it being an infringement? The communication between the add-on and Blender happens through an API, just as much as the communication between the add-on and the compiled binary. Also, if you subscribe to the idea that something is derivative if it cannot exist without something else, the add-on must be derivative of both Blender and the compiled binary.
Additionally, the GPL specifically allows you to bundle covered works with other works under different terms (they call this an “aggregate”), so shipping things together or separately has no bearing on the applicability of the GPL, as it is rather defined in terms of “communication” (which in itself is of questionable enforceability, as we saw). Furthermore, even under the assumption that shipping things separately would form some legal barrier, how is separately shipping a closed binary that talks to a GPL licensed add-on, any different from shipping a closed add-on that talks to the GPL licensed Blender.
If you interpret copyright law and the GPL in such way that an add-on must be covered under the same license as the GPL licensed host, then, anything that talks to the add-on must also be covered by the same license. There is no way to have it both ways without a severe contradiction. Either the whole thing must be GPL compatible, or not, there is no middle-ground.
Note that, previously, this was not Blender’s official position. Blender’s position in the past has been that everything that talks to Blender (even indirectly, through such a “bridge”), must be licensed under the terms of the GPL. This interpretation has morphed over time, as it was found to be too limiting, considering new technologies being developed. However, this simply creates an artificial workaround to combine closed source software with Blender, while pretending that you are not combining closed source software with Blender. It’s no better than simply combining the closed source software with Blender directly, and it has no basis on a an actual interpretation of the legal framework surrounding this matter, but is rather based on the perception of openness.
With this, I hope to have clarified my position, and hope to have helped inform someone. I expect that from here anyone interested in this matter will do their own research and not base their conclusions on my opinion, or anyone else’s opinion.
Ok, I guess that covers most of it. Thank you for reading this far!
