The Antiviral License

The Antiviral License is designed to allow freely available source code to be used for nearly any purpose, including closed-source commercial software, while protecting the code from viral licenses such as the GNU General Public License.

The only requirement of this license is that the license of any source code covered by this license must not be modified. This license has no requirements about what license you choose for any other code you use alongside the code you receive under this license. Therefore you may use it alongside public domain and BSD licensed code and compile all of the code into a single program, but you may not include any GNU GPL code because the GNU GPL requires that you relicense any code which is compiled into the same program (which it considers to be a derivitive work) under the GNU GPL, which is the only thing that the Antiviral License does not give you permission to do.

Continue reading if you want more detail about this license. Otherwise, that's all there is to it.

Design Goals

The license was designed with the following goals in mind:

Incompatibility with Viral Licenses

When writing code, I do not get to use viraly-licensed code that is otherwise available on the internet. This is for one of two reasons. Sometimes I'm writing closed-source programs that I simply don't want to release the source code for. Other times I'm writing something I want to release without restrictions on use. Virally-licensed code isn't useable in either case.

For that reason, I feel strongly that viral licenses shouldn't benefit from my code, and I certainly don't want to see viral licenses further promoted by the existance of virally-licensed software which benefits from my public domain code.

This wouldn't really be an issue were it not for the popularity of the GNU GPL. After all, I don't really care what license people choose for their software. If they want to be stupidly restrictive with it then that is their choice. However, the GPL is known to many as simply being "the" free software license. Many people choose it not because they actually want what it is about, but simply because they want to release their code for free and believe that they must have a license, perhaps because they've seen so much "THIS SOFTWARE IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE" and they assume that without a similar license they'll be sued out of existance and, not knowing how to write a license themselves, they simply choose one that seems popular and is freely available to use.

An example of this is cracklib, a library which checks password strength in order to allow software to warn users that their password is weak. I recently wanted to use this library in some software that I was writing, but it is unfortunately licensed under the LGPL. While researching the license of cracklib, I found that it had originally been licensed under the GPL license, but that the developers decided that having such a library be as widely available as possible was in the best interest of the world, and so they changed the library to the LGPL license, which is believed by many to be nearly the same thing as making it public domain, or in other words, GPL in name but not in practice. This, however, simply isn't true. The LGPL only allows code to be used in non-LGPL projects in some very specific circumstances. Would you like to avoid annoying your users with missing libraries by compiling the simpler ones into your software? Well, no LGPL for you, as it requires that it be possible to replace the library with a different version, which people can't do if it's compiled into your program. While I was sure it would be already installed on most Linux systems, I was similarly sure it wouldn't already be installed on most Windows systems. ...but checking just now, I see it isn't installed on my Linux system, so apparently even that assumption wasn't safe. So to use cracklib, I'd have to go from having a program people can just download and run (as everyone has OpenGL and it already has zlib compiled in) to having one which doesn't work and requires them to download something else. Most people give up at that point because when you encouter that situation, you never know how many things you'll need to download before the software works, and often times it never works. ...and while I assume that the authors, per their desire to see the software used as much as possible, probably wouldn't care if I used their code anyway, I can't do so as long as the license is LGPL, and being a community project, tracking down all of the authors to ask them for a more permissive license would be difficult. Thus I simply decided not to use it.

Thus, I believe the GPL is too popular. It'd be fine if people were only using it because they know exactly what it means and what it requires, but often times I get the feeling that isn't the case, and the truth is people just want to give their code away and don't know any other way. It doesn't help matters at all that the GNU foundation chooses to redefine the word "free" so that they can misinform people about their license and at the same time claim they aren't lying. It's one thing to disagree about which license is better and which freedoms are more important, but to simply redefine the word so that it exactly matches what your license offers so that you can claim it is the only truly free license and all others are non-free is quite manipulative.

All of this makes me want the GPL to just disappear. There was a need for it at one time, when nearly all software was closed-source and people needed a stepping stone to encourage more sharing, and the world certainly owes it a thank you for accomplishing that, but the time when that was needed has passed. No one anymore requires the promise of free software in return for releasing their code. People now just want to be nice and give things away. People often release code as public domain or with a BSD or other similarly non-restrictive license. Even the code for closed source commercial games is often released after some time. Open source is now something that people appreciate for what it is, and so all that a license like the GPL accomplishes now is to tie up code that would otherwise be more free with a bunch of silly restrictions.

Lack of Silly Distinctions

If I write a function and give it to you, why should using that function in your program make your program a derivitive work of my code? ...and if we assume that it does, then why should compiling my function as a seperate program and then using fork() and exec() to call it not make your program a derivitive work of my code? In both cases, my code does something you need, and in both cases, your program doesn't work without my code. So what's the difference?

The GNU GPL claims this is an important distinction because the act of compiling the program creates a derivitive work. This is a silly idea. Combining two things does not make a derivitive work. Does writing in the margins of a book create a derivitive work? What if I then decide to sell the book after I've done this? What if people actually want this new book and consider it an improvement on the previous version? What if the original author of the book hates this and wants to prevent me from selling it? Do you think copyright law will prevent me from buying his books and writing my notes in the margins?

...and what if, out of some unfortunate set of circumstances, the courts decide this is a derivitive work, and so I instead release my notes on the internet with instructions about where to write which notes on which pages? Do we then complain that this is still a derivitive work? If so, are we complaining that I created a derivitive work when writing in my copy of the book, or that other people are creating derivitive works when they write in their copies?

Sure, if I take a book and insert or delete words all over, I've created a derivitive. Most people would also consider it a derivitive if I inserted paragraphs with more information here and there. A few might consider it a derivitive work if I add an extra chapter to the beginning. Indeed, if it's a chapter about what a moron the author is and what flaws to look for while reading the book, the author might take offense. However, if I'm purchasing his book and inserting a few loose pages at the beginning, there's little he can do as I've already paid him for the copy. He might try to claim it's a derivitive work simply to have more control over it, but most people agree that, while the line between a derivitive work and a non-derivitive work exists on a continumn, that doesn't mean we toss out the idea of a line and consider everything a derivitive. ...and most people would consider a critique on a book which is inserted into the beginning of it to be a seperate work, even if it exists alongside the origional work and is useless without the origional work.

I see things the same way with computer software. I might write some code to do something, but if you want to put it in your code, and preserve the license of my code while using a different license for the code you wrote, why should I care? You wrote your code so you should choose the license for it.

What bothers me about the GPL is that it makes this choice for you. If you want to use any GPL code anywhere in your program, then all of the code in the program must be licensed under the GPL. As such, the GPL infects other free code with itself simply by existing alongside it. If then the infected code is modified, those changes are available only under the GPL license, even if, had someone originally found that code under a different license, they would have happily released their changes with fewer restrictions. Thus it is quite possible that a lot of the popularity of the GNU GPL is not because of it's merits but instead simply because of it's infectious nature. (I say "infectious" because, with the recent popular term "viral video," the word "viral" has nearly been redefined to mean that something is popular because many people like it.)

Compatibility with Other Free Licenses

Because of my dislike for viral licensing, I don't want my own license to be viral as well. Thus it is a requirement that it not require the license of other code to change. People using public domain or BSD licensed code should be able to use my code as well without changing the license of the public domain or BSD licensed code they use. By not being silly about what constitutes a derivitive work, this is quite easy to accomplish, as different pieces of code in a project can exist side-by-side with different licenses.

Thus, the Antiviral License doesn't try to claim you're creating a derivitive work simply because you want to use some code you receive under this license. If you use a source code file in a program, simply put a comment at the top indicating it is covered by this license, and license the rest of your code however you like. You might even just copy a function into another file and add comments about the license of just that one function, although that's somewhat in the gray area and so most people might rather you keep it in a seperate file unless there's some extraordinary reason why that isn't possible. Sure, we may not agree in all cases whether or not you are creating a derivitive work, but we all also have common sense, and so in most cases we'll agree, and when we don't, one of us will likely just not give a fuck because it's such a gray area that it isn't worth worrying about. On the contium between shaking someone's hand and ripping off an arm, there's a gray area where the action becomes a crime. That doesn't mean that everyone calls the police when someone shakes their hand harder than they would have liked. Instead, people just don't shake hands very hard, and at the same time, most people don't call the police for minor assults if no damage was done and there wasn't intent to cause harm. People deal with gray areas all the time and what is and isn't a derivitive work is just another gray area. Just because it is a gray area doesn't mean we need to play dumb about it, as if we aren't capable of using reason.

Free Use of Code for Any Purpose

I wanted a software license that would allow people to use the code in any way they see fit to use it, wether that be free and open source projects or commercial and closed source projects.

Some people don't like the idea of their free code being used for commercial profit, but the way I see it, free market forces effectively force developers to charge less for their code when much of it is freely available for anyone to use. We already see such benefits with free compilers like the GNU C compiler. When compilers were expensive, it wasn't possible for random people to implement simple software and thus even simple software was costly. Then, once random people were given access to a free compiler, trivial software became unprofitable since anyone could rewrite simple software and release it for lower cost, or even free. The same happens even when commercial software includes freely available code. The more freely available code there is, the more likely it is that anyone can glue it together to make more complex software, and thus anyone selling that more complex software now has to sell it at a lower price or lose customers to competition which is using that free code to develop that more complex software at a lower cost. Thus, even if people do use my code in closed-source commercial projects, I and everyone else still benefits from less expensive software.

Indeed, the only sensible reason to use the GPL that I can imagine is if you are a company releasing some code for the purpose of appealing to the open source community, but at the same time, you don't want to decrease development costs of your competition in the commercial software business. Releasing the code as GPL prevents other companies from using it in software they develop that may compete with your own business. However, a simple "no commercial use" license would accomplish the same thing without being viral, although it may not be as appealing to the open source community without the GNU GPL name.

Lack of Attribution Requirements

I also dislike attribution requirements. Sure, it isn't much to ask, but it is however quite pointless. Keeping someone's name at the top of their source code isn't a big deal, but requiring that compiled programs also display the name creates a burden on developers to keep a list of all the names they need to display. It additionally becomes plain silly when the license dictates the exact wording of the attribution, such that software is required to claim it is written by twenty different people when in reality 90% of the code was written by someone else.

It's also just plain silly. Anyone who uses your code is going to know who wrote it even without those attribution requirements. Anyone who doesn't know can find out with a quick search of the internet. So then what is the purpose of attribution requirements? I don't see where there's a need for them. If your code is really so wonderful that you deserve fame and recognition for it, you won't get that fame and recognition from the "about" option in the "help" menu. It'll come from everyone just knowing that it was you who wrote that code. Thus, there is no requirement for attribution, but if developers choose to do so, they can still give you credit anyway.

Lack of Nonsensical Legalese

In the early days of software, it wasn't entirely clear how copyright applied to software. ...and naturally, many developers wanted as much control over their software as possible. Sometimes you would receive software along with a notice which told you that you hadn't purchased the software, but merely the media that contains it, as publishers feared accidentally giving you copy rights to the software. Other times you would receive software from developers which wanted more control over what you do with the software, and so they would include a license which told you that, because software must be copied from storage media into your computer's memory, you were bound by the license agreement as you otherwise had no right to make that copy, and thus you were also bound to everything else the license mentioned. Yet other developers wanted the freedom to earn money from code which may not actually do what it was designed to do, and so they included the ever-so-common "THIS SOFTWARE IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE."

In the years since, the law has been settled, and we now know how licenses apply to software. Like books and other copyrighted works, you do not need a license to buy software, nor do you need a license to use it, as copyright law allows you to copy the software into your computer's memory in as much as doing so is required to use it. Thus, none of this legalese is required. Indeed, much of it isn't even valid. When you buy software, because there is no requirement to accept the license, you do not have to accept the license. Even if the software prompts you with a click-through license agreement, that is not valid either, as contract law does not allow contracts that are unilateral -- you must receive something in compensation for what the other party to the contract receives, but you already had the right to use the software because you purchased it, and thus you gain nothing by agreeing to the contract. ...and even if the developer then takes the clever route of making the agreement a requirement of using an online service which the software utilizes, there's still the issue of that implied warranty of merchantability, which requires that software you purchase do what it was advertised to do. Thus you are entitled to a refund if the software refuses to do what it was advertised to do when it refuses to work because you will not agree to the license. Indeed, even if you do agree to the license, some jurisdictions do not allow the implied warranty of merchantability to be disclaimed. The law is strange in that sometimes it doesn't allow companies to fuck over customers.

However, most people don't know any of that. Consumers believe that licenses give developers the ability to write their own laws. Developers believe that the law gives comsumers the right to sue them for nearly anything. ...and, well, technically it does, but only because you can sue anyone for anything. Wether or not you'll win your case, if indeed it isn't just trown out by the first judge who takes a look at it, is an entirely seperate matter.

There's nothing in modern license agreements that really needs to be in them for any legal reason. Much of it is just the result of copy and paste over the years. That's why much of it is in uppercase text. When you disclaim implied warranties, the disclaimer must appear in bold type in the agreement, but in the early days of software, bold type wasn't available, and so uppercase was used. Copy and paste for a few decades and you find uppercase text in print and on web pages where bold type is easily available, but no one remembers why that text is uppercase anyway. They've just always seen it that way and so assume it must be required, just as they assume everything else they see in licenses is required.

So, sure, people who use your software may be entitled to an implied warranty of merchantability, but if you fail to provide it, they're merely entitled to a refund. If they paid nothing, you refund nothing, and if they paid $100 for your software, you really should either fix it or give them their money back. ...and if someone decides to sue you because they downloaded some free code from the internet which they subsequently used in some medical equipment which subsequently killed thousands of people, who do you think the courts will side with in that case? On one side you have someone who wrote some code which they gave away with the honest belief that it worked correctly. On the other side you have a company who found some junk on the internet, assumed it was just fine, and used it to build medical equipment. Sure, the courts might make the wrong decision, but then, you also might be hit by a bus tomorrow. Shit happens, and nothing you do can prevent it. Except maybe never going outside. ...but then, sometimes busses do crash through walls.

The Text of the License

This page is it, I guess.

Since, unlike the GPL, this license is compatible with other free licenses, the exact wording of the license isn't really all that important. It isn't like there has to be an exact version of the license text because if anyone changes a single word it becomes a different and incompatible license. So just write your own version of the license, or if you'd rather, just include a link to and make my version a little more popular. Agreements still apply even if they aren't written by a lawyer and even if they lack phrases no longer used in modern English, so it isn't like there's an incorrect way to do this. Just clearly state what you want your code used for and that will be fine.

Indeed, what prompted me to create this license is that the authors of cracklib didn't simply state their intentions but instead felt the need to use license text written by someone else. Why don't we all stop doing that, and instead, everyone just say whatever we want?