I've never been a fan of the GPL, but while working on this game, I've really come to hate it. For example, I was working on some code to allow people to choose passwords, and I thought it might be nice to include cracklib in order to tell people whether or not they are choosing a good password. While investigating the license, I learned that it was originally GPL, but then converted to LGPL because the authors wanted it to be as widely used as possible. However, LGPL isn't the best way to do that. There's some myth that the LGPL is like the BSD license in that it lets people include your library in their program without infecting their program with your library's license. It's only true under some very specific circumstances, which aren't circumstances I cared to utilize. So I tried to make my own, realized it sucked, then gave up.
Unfortunately, I don't think most people who choose the GPL really understand what it means. It's just "the free software license" and they like free software, so they choose the free software license. Saves them the trouble of having to hire a lawyer to write all that "INCLUDING THE IMPLIED WARRANTIES OF" nonsense, which everyone assumes they need or else they'll be sued into bankruptcy.
Other people use the BSD license, but then some GPL fool comes along and incorporates their code into their program, placing it under the GPL license. Then any changes made to the previously BSD licensed code are then only available under a GPL license. Thus the thing spreads like a virus, even though some people refuse to see it that way.
Some day I'll want to release my game as open source, but I won't want it to be GPL. Why should it be when I haven't been able to use any GPL code while writing it? ...and I won't want it to be BSD either because what good is a license that allows my code to become GPL when I don't want it to be GPL? ...and at the same time, I don't want to make my code incompatible with other free software licenses, since the idea is for the code to be available for other people to use, and incompatible licenses don't help that goal.
It's a license whose only requirement is that the code not be relicensed under some other license. So, if you create a derivative work, that derivative work must be licensed under the anti-viral license, but it specifically allows using the work as part of a greater work without the requirement that the other components of the greater work assume the same license. So some of the source for a program can be Anti-Viral, and some can be BSD, and some can be public domain, but none of it can be GPL because the GPL requires that the entire project become GPL. Thus, the license is anti-viral, in that it protects the code from the GPL license, and also protects entire projects in which the code is used from being relicensed under the GPL, and it does all of this while remaining compatible with any non-viral license that exists presently or in the future.
Indeed, the anti-viral license itself isn't incompatible with the GPL, but rather, the GPL is incompatible with the anti-viral license. If a future version of the GPL drops its viral components, it becomes compatible with the anti-viral license automatically.
I also left out the typical nonsense disclaimers which usually appear in software licenses. It's all just outdated shit from the era when you would buy software that came with licenses that said "you have not bought this computer program, but rather, you have bought only the media on which it is contained" thus claiming that you were bound by the license agreement even if you don't copy the program or make a derivative work because the software was "licensed" to you rather than "sold" to you. Although court rulings have cleared up the nonsense, it still remains in software licenses today because software licenses are mostly copy and paste work of previous licenses, since people largely have no idea what they are doing when they write them. Indeed, nothing requires you to accept a software license to use software, and even click-through license agreements fail based on the legal requirement that contracts cannot be unilateral and you already had the right to use the software before clicking the button, but nonsense licenses continue to exist. Ever wonder why there's so much uppercase text in them? It's because certain contract terms aren't enforcible unless they appear in bold type, but back in 1980, bold type wasn't all that easy, particularly in plain text files. Copy and paste for 31 years and you have difficult-to-read uppercase text on web pages and in print, where bold text is quite simple, but seemingly no one remembers why the text is uppercase at all, so they don't make it bold.
There's no need for any of it. If someone is going to sue you, seeing "you can't sue me" in your license isn't going to convince them not to. ...and do you really think a court will hold you responsible for some buggy code you wrote, or might they find that responsibility lies with the person who found something on the internet for free and expected it to work flawlessly? Sure, courts can make stupid decisions, but just as your license won't keep you from being sued, it won't eliminate stupidity either. Also, you might be hit by a bus tomorrow. Shit happens.
So the license just explains what it is and why it is what it is, and leaves it at that, leaving it short enough for anyone who even mildly cares to have time to read it.
I also left out BSD-style clauses about attribution of code sources. I don't see any reason to burden people with such nonsense in the modern age. You can take any library and with a simple internet search figure out who its authors are, and the kind of people who are interested in things like taking someone else's work and slapping their name on it unmodified aren't going to be dissuaded by the license anyway. In the end, it seems like an effect of people not wanting to give away something for nothing, and wishing to at least become famous if not rich. ...but it doesn't matter: If a lot of people use your code, you'll be famous.
Basically, this license is about the removal of stupid distinctions. If your code calls my code, why does whether it's part of the same program or a separate program determine whether it is a derivative work? If I write a function and give it to you, why does using that function in your program make your program a derivative work, while compiling it as a separate program and then using fork() and exec() to call it not make it a derivative work? There's no reason to think that it matters other than to have an excuse to spread like a virus.