NEW

Post Top Ad

Blossom Themes

Wednesday, December 21, 2011

Why we need a stronger copyleft for artists, and how this might be accomplished.


Currently, art copylefts are weak with respect to code. If I'm a programmer and I want to write code that's specifically for use in libre software, all I have to do is slap the GPL on it and I'm done. If someone uses my code in their program, they either have to GPL their program or I can force them to stop distributing it.

Artists don't receive the same protection. If I want to make a piece of art (be it an image, model, sound file, etc) for use in libre software, I'm out of luck. As it stands, all the people using my art have to do is share their modifications to my art and they're free to do whatever they want with the code. There aren't currently any acceptable libre licenses that cover a situation in which a program loads a specific art file. (Mind you, as an artist, it doesn't matter to me if someone loads my file in a proprietary editor, the same way it wouldn't matter to me as a coder if someone loaded my GPLed code into a proprietary text editor. More on this later.)

Over the last couple of years, a number of artists who have been frustrated by this particular issue have come to me and asked me what could be done about it. Many of them have asked me to include a noncommercial licensing option on OpenGameArt to address this issue. Unfortunately, NC licenses are incompatible with free software and as such I'm not able to include them on OGA without seriously violating the stated mission of the site. NC licenses do somewhat address this issue (although mostly by accident), but the problem with them is that they're far too broad about how you can use the media in question. A better solution is needed.

So, a few months after OpenGameArt.org was founded, I had a discussion on the debian-legal mailing list about licensing that would expand the copyleft for artists by (in short -- please read the details of my plan before criticizing) forcing the programs that load a specific piece of media to also be licensed with a strong copyleft.

At the time, I was politely shot down. In their defense, at that point I was just a random person off the street with yet another random idea for yet another random license. Two and a half years later, I'm now recognizable by at least two or three members of the FOSS community (making me a small-time contributor instead of just a random dude) and I've had long discussions with people about the specific provisions of what exactly a license like this would require and how it would interact with free software.

Now, the key here is that for something to be free software (or compatible with free software), it can't prohibit "bundling". Bundling in this case is the idea of including multiple separate programs in the same archive. For something to be free software, the license must allow it to coexist peacefully with proprietary software.

In any case, for the purpose of this discussion, I'll refer to this hypothetical media license as the Foo License. Any media released under the Foo License would require that any code that specifically references that piece of media be licensed under a strong copyleft (such as the GPL or the Foo License or others -- we can define these by enumerating them specifically or just listing a set of requirements). If a program does not specifically reference the piece of media covered under the Foo License, then the program would not trigger the share-alike requirement.

To give specific examples of this, if I write a game that loads a certain sprite that's covered by the Foo License, my game code would need to have a strong copyleft. Conversely, if I distribute an image viewer (or editor) along with a bunch of images that are covered by the Foo License, the image viewer would not fall under the sharealike clause because there's nothing in the code that tells it to reference a single, specific Foo Licensed image.

Now, some game engines are clearly generic. If you run that engine on a specific data file or point it at a specific tree, the resulting game could be completely different from one stored in a different data file. The Doom engine is a specific example of this, although there are many, many others. In this case, the engine itself is completely generic, and would fall outside the scope of the Foo License. What is not generic here are the scripts and data files that define the actual game. In these cases, while the engine itself is generic, the script layer is not, because it has to reference specific items in order to load them and tell the game engine what to do with them. A generic engine like this is essentially a VM, and much like the GPL, the Foo License would not cover that the VM that runs the code.

One argument I've seen against this is that it's possible in some cases for people to construct specific, inconvenient examples of how you might skirt the requirements of the license. I can't deny that those situations exist, however the same sorts of situations exist for the GPL, and coding around them is a fairly effective deterrent (not to mention the fact that deliberately circumventing a license puts you on shaky ground anyway). It's been done, but it's not done all that often and it tends to make things inconvenient for both programmers and their customers. In any case, no edge case like this that anyone has brought up before has rendered the license non-free, so even if the Foo License is imperfect, it would still, like the GPL, work in most cases.

So, I'm looking for comments on this, but before you comment, please make sure you've read this carefully. Below is some copypasta that I'll use to answer you if you ask a question that I've already addressed. Please consider these answers before you ask, and if you're guessing that I'm going to respond with one but you believe it doesn't apply, explain why. :)
  • [ ] While your example could conceivably get around the intent of the license, it would be inconvenient to implement and doesn't render the license non-free. In any case, the GPL has similar edge cases.
  • [ ] The program you mentioned is a generic viewer/editor and is not programmed to reference *specific* media files.
  • [ ] In your example, the engine would not be covered because all of the media is referenced in a completely separate script layer, which *would* be covered.
  • [ ] In your example, the engine would be covered because it references the media in question by name.
  • [ ] I understand your wariness, but the fact that this hasn't been done in the past don't make it not worth considering.
  • [ ] Just because there are multiple ways we could decide how to address this issue, doesn't mean that it's ambiguous. It must means we need to talk about which way would be best and settle on a decision (see additional comments).'
  • [ ] While it may initially seem that the GPL would cover this case, the FSF has clarified (see "Non-functional Data") that art is data, and the linking requirements in the GPL do not apply in the case of art.  Thus, even if the art itself is GPLed, the FSF doesn't consider it "linking", and the share-alike requirement is not triggered. (Added 12/28)
Okay, bring it on. I love a good controversy. :)

Bart Kelsey
OpenGameArt.org

No comments:

Post a Comment

Post Top Ad

Blossom Themes