[Eniko]

Last night I was looking at the scale3x and scale4x algorithms, to see if they were any more complex than scale2x, to possibly implement for PC users. Anyway, I noticed something on the download page:

License

You are allowed to use the Scale2x implementations in your program if it's released with the GPL license, or alternatively under all the following conditions:

• the program is not used in commercial activities.
• the whole source code of the program is released with the binary.
• derivative works of the program are allowed.

Instead, you are free to use the algorithm, but please call the effect "Scale2x".

Since there's the possibility that my project may make a bit of money is there anyone who can explain to me the lawyerspeak of the GPL license? Are you not allowed to use scalenx (and possibly nxSaI or hqnx? I'll need to check those for licenses) in a commercial venture? Does everything that uses the algorithm have to be released under the GPL?

This license stuff is so confusing. x_x

[EvilDragon]

Basically, the GPL is easy: You can use any GPL licensed program in ANY other program, regardless if it is commercial or not.

However, if you use the scale2x sourcecode IN your program, your program automatically falls under the GPL AND you have to release the full sourcecode to anybody who requests it (and you have to keep the original author mentioned).

So, while you can still sell it, you have to release the sourcecode and anybody else is free to use it, change it or even sell it.

The only way without releasing your sourcecode would be calling scale2x as external binary. If unchanged, you only have to provide the link to the sourcecode of scale2x, if changed, you need to release the changed sourcecode (but ONLY the one of scale2x, not of your program).

However, running external binaries doesn't always make sense...

[Eniko]

Thanks for the quick response, ED. So if I get this right, for a potential commercial closed-source project the safe bet is to compile the scale2x source as a DLL and publish the source for that with GPL license, but none of the rest?

What happens if I use the algorithm without using the source to implement a scale2x pixel shader? Would that still require me to publish my source under the GPL license? What if it's a modified version of scale2x? How far would it have to be modified? Or does none of the GPL license stuff apply because I'm using the mathematical algorithm, not the sourcecode?

This post has been edited by Eniko: 30 December 2008 - 05:55 PM

[ledow]

Thanks for the quick response, ED. So if I get this right, for a potential commercial closed-source project the safe bet is to compile the scale2x source as a DLL and publish the source for that with GPL license, but none of the rest?

It depends on who you ask, but this should be fine. So long as the DLL is a "complete work" on it's own, with all it's source code available under the GPL, this should work. However, it's a legal question, not a technical one. This, for instance, is how the NVIDIA drivers work on Linux... they put a "dll" of a kind into the kernel (GPL) and then call it from the NVIDIA driver (proprietry). Some people still don't believe that is legitimate but nobody has kicked up too much a fuss about it. BTW: GPL comes in many versions, and GPL 3.0, for instance, may consider this situation differently.

What happens if I use the algorithm without using the source to implement a scale2x pixel shader?

If I remember correctly from my own investigations several years ago, the algorithm is perfectly okay to copy (but you may not be able to refer to it by the names that you know it by) and reimplement, it's their actual implementation that is covered by the software license. I think I even read wording to that effect on their webpages but you'll want to double-check. You can't "copyright" an algorithm (but you can patent it in some countries!) and the GPL is a copyright licence.

Would that still require me to publish my source under the GPL license?

Unless you based the code off GPL licensed code, then no. But even "modified versions" or potentially even "using the GPL code as a reference" are going to cause you problems unless they are GPL licensed too. This is in the realm of "cleanroom reverse-engineering" and you can't just do that by pretending you didn't read the original source...

What if it's a modified version of scale2x? How far would it have to be modified?

If you modify the source, your modifications would have to be published as GPL (the license differs on exactly who you have to distribute that source to etc.). Any "modification" would be seen as GPL-based code. Even the wording of the word "modify" suggests that any end-product is GPL licensed. You would have to completely re-implement the algorithm from scratch without looking at the GPL code.

Or does none of the GPL license stuff apply because I'm using the mathematical algorithm, not the sourcecode?

If you *don't* refer to the GPL source code in your re-implementation of the algorithm, you're fine in terms of copyright. This means even looking at how the GPL code handles a certain structure, copy/pasting/modifying etc. If they hold a patent on the algorithm (I very much doubt it) and it's enforcable in your country (even less likely) then they can still "get you" for that.

It's a legal grey area. Even the Linux kernel people won't answer questions about whether the NVIDIA driver is "legal" etc. and it causes flamewars all the time. The usual advice, even from Torvalds et al, is to "consult a lawyer" because it's not a technical issue but a legal one (including definitions of "derivative works", etc.). My advice would be to either:

1. Write your own version of these scaling algorithms, not looking at anything but the published algorithms and NOT referring to the GPL code. (And then publish it because I'm sure a LOT of people are in the same position as yourself - I'd be surprised if there didn't already exist some libraries for this).

2. Use the GPL code but abide strictly by the terms of its license.

3. Find another scaling algorithm which doesn't have the same restrictions (there are others!) and don't use any scaling algorithm covered by any terms that might cause you work/trouble/consternation.

[Squidge]

DLLs are confusing. Some people say that since you are including the binary in your code indirectly (by loading it at runtime), you are still loading GPLd code and thus are 'tainting' the code. Others say thats like commercial closed-source applications under Linux not being allowed to use any dynamic libraries.

So I'd say your best choice is to write your own version of the source code using the algorithm.

[lardman]

If you link against GPL (including in a dll/so) your code has to be GPL too afaik, that's why the LGPL was created to allow commercial use of shared libraries.

Basically if you use this code you'll have to release your source.

You should to be able to re-implement the code yourself using a description of the algorithm though, but that doens't mean copy& replace variable names from the original source

[Tempel]

I'll throw my voice behind others here in saying that your own implementation of this apparently unpatented, freely described algorithm should be perfectly legal for a closed-source project.

However, the most surefire way to know if you'll get sued is to ask the owner if they'll sue. Just send Andrea Mazzoleni, the creator of Scale2x an email explaining what you plan to do -- stress that it's your own implementation, not using the GPL'd code -- and ask if that's okay.

Although personally i think you'd be better off releasing your work free and open anyways, but that's a whole different argument.

[Eniko]

Thanks for all the advice guys. My pixel shader is completely my own, based on the mathematics explained on the website of the scale2x algorithm. So that should be fine, I'll just have to rename it I guess?

Doesn't look like my game will support hqnx then, though. The only way to implement that is through the source code since the theory isn't explained, and it's also under the GPL instead of LGPL license. Of course I suppose I could drop Maxim Stepin a line asking him how he feels about things when I get that far. I'll probably drop Andrea Mazzoleni a line too, just cause it's good form.

However, the most surefire way to know if you'll get sued is to ask the owner if they'll sue. Just send Andrea Mazzoleni, the creator of Scale2x an email explaining what you plan to do -- stress that it's your own implementation, not using the GPL'd code -- and ask if that's okay.

While this seems a logical way to approach the problem I'm not sure if something like that would actually mean anything legally. >_>

I sure am glad Pygame and Twisted are covered under the LGPL and PyOpenGL under BSD. At least, I think BSD is safe.

This post has been edited by Eniko: 30 December 2008 - 10:03 PM

[Tempel]

While this seems a logical way to approach the problem I'm not sure if something like that would actually mean anything legally. >_>

If it came down to it, you might be able to trot it out in court as permission (not a lawyer, so not really sure). But if you're taken to court, you're already in trouble (legal costs alone, even if they get repaid later), and there's no guaranteed way to avoid that.

I sure am glad Pygame and Twisted are covered under the LGPL and PyOpenGL under BSD. At least, I think BSD is safe.

BSD is very safe. Only requirements are to include the creator's copyright notice and not use the creators' names in promotions. About the only things more permissive than BSD are MIT and public domain.

[Squidge]

What happens if you setup a specific API for communication with filters created by the public? Then you could provide your commercial work as usual, and if people wanted certain filters such as hqnx, then they can go download the pre-compiled dll, or the source code for that dll, drop it in your programs directory (or plugins dir, or wherever), and you program notices and allows the use of said filter.

That way the filters are neither incorporated into your code, nor distributed with your product. They are free, open-source, downloadable plugins. Later on, if another filter comes available, people can actually port them themselves.

[Svartalf]

Thanks for the quick response, ED. So if I get this right, for a potential commercial closed-source project the safe bet is to compile the scale2x source as a DLL and publish the source for that with GPL license, but none of the rest?

What happens if I use the algorithm without using the source to implement a scale2x pixel shader? Would that still require me to publish my source under the GPL license? What if it's a modified version of scale2x? How far would it have to be modified? Or does none of the GPL license stuff apply because I'm using the mathematical algorithm, not the sourcecode?

If you're using the pure algorithm, you should be fine. Having said this, proving it may be painful- you may find that it's a bit difficult to produce an alternate version of the code, as you can copyright the ideal exp​ression of that idea, and have a hell of a time convincing a court of your having separately implemented the actual algorithm. Moreover, having the game be GPLed isn't always a bad thing. Keep in mind that Quake3's engine and gameplay code is GPLed, but the assets themselves are very much iD's and requires you license them for alternate game use, or to purchase if you're just playing the game.

[sindbad]

@Squidge
That should work. It's very similar to the way kparts work, where there aren't any license issues when using a GPL kpart in a closed-source program.

This post has been edited by sindbad: 31 December 2008 - 12:13 AM

[Svartalf]

I sure am glad Pygame and Twisted are covered under the LGPL and PyOpenGL under BSD. At least, I think BSD is safe.

BSD is completely so. LGPL is safe so long as your mods as needed are propagated back to that community and you don't try to prohibit reverse engineering efforts on your own code. GPL's only nasty if you want to keep it to yourself. Understandable, really.

@Squidge
That should work. It's very similar to the way kparts work, where there aren't any license issues when using a GPL kpart in a closed-source program.

Watch out, though... An end-user can link that beastie in, but they can't legally distribute the configuration as the loaded config produces a derivative work as far as Copyright and the GPL are concerned. You can send them out separately, but the end-user doesn't have legal rights to distribute the resultant config.

[Klaus]

Another possibility would be to just release your source code under the GPL, allowing others to share your code, but release the assets (graphics, sound, levels, ...) under a proprietary license. This is just what ID Software does when they release the source code to their engines. You would be able to make a profit from your work (assuming it's any good ), and others could learn from your code (again assuming it's any good ).

[Eniko]

Another possibility would be to just release your source code under the GPL, allowing others to share your code, but release the assets (graphics, sound, levels, ...) under a proprietary license. This is just what ID Software does when they release the source code to their engines. You would be able to make a profit from your work (assuming it's any good ), and others could learn from your code (again assuming it's any good ).

I don't think I want to think about all the horrible repercussions of an open-source MMO client, really. Sure some good could come of it, but even from the perspective of the playing community people are inevitably going to use it to "win the game" through scripting and botting, and then nobody wins.

Plus I'm reluctant to just hand over the fruits of my labour for anyone who can find an artist to make assets for them to make an MMO when it's taken me over a decade to acquire the skills to make a relatively playable indie MMO. It probably sounds selfish but... what's in it for me?