Question: Best way to open-source an engine to the community

I'd say putting it up on GitHub would be the best option, paired with the open source license of your choosing. Personally, I'd go for GPL, but I care a lot about people sharing their changes, but you may not. You can make the assets open as well, but if you don't you'll want to include at least some basic ones.

Don't be discouraged if nobody really picks it up and runs with it, though. There are many Sonic engine options out there these days. Doesn't help that most fan games seem to be one-man affairs (would love to be proven wrong on that).

 

Like billy said, put it on GitHub if you want.
Although I'd wait until it's fully done until i release it. So people have the full experience.

 

Don't forget to setup a license so you can get properly credited for the work. Here's some comparison charts to get you started.

 

Put it up on GitHub, use a license like MIT or BSD (this will allow people to rework the engine into something usable for a commercial project, like how Freedom Planet and Spark the Electric Jester used Sonic Worlds; GPL forbids people to do that!), explicitly state that the Sonic assets are not released under an open source license and belong to SEGA, and you should be good to go.

 

GPL does not forbid selling your software. Basically if you GPL a game, people are actually paying for non-open assets (much like how the original Doom is now) because they have to release their changes. This will make it less attractive to people who want to use it for commercial games, however.

 

Wha?

GPL makes it more attractive for commercial use. Anyone that wants to hold onto code that isn't theirs are irrational assholes. There is benefit to sharing your code: outsiders can improve it, and you can just take their changes without needing permission.

 

Please reconsider using MIT, BSD, or Apache 2.0;

GPL will discourage people from using your code with existing MIT/BSD/Apache code.

--

Please reconsider not using GPL.

GPL will add extra restrictions that will limit the amount of people that can use your code.


GPL is a viral license
This means, anything you combine with GPL, must also be under GPL.
This is bad, because relicensing existing work to GPL is not always practical.

First of all, most new open source software is MIT licensed(at least on Github's ten million+ repositories https://github.com/blog/1964-open-source-license-usage-on-github-com)



GPL is incompatible with MIT, BSD, Apache, and most other licenses
This is bad because it means people can't easily use their own MIT code with your engine to add new features.



What if someone has made a good graphics engine in MIT license,
and then they want to combine MIT code with your GPL code for the 2D physics so they can make this?:

https://www.youtube.com/watch?v=ZxXycBv3Rlk

If you use GPL, they can't do that, they have to relicense all of their code just to use a part of your engine,
and most people won't relicense, they just wouldn't bother because your GPL code is incompatible with their license.

If you use MIT, BSD, or Apache 2.0; your code can be used in many more projects; and more people can build on top of your code.


More and projects have switched from GPL to MIT/BSD/Apache recently; because MIT/BSD/Apache is compatible with more existing code bases, AND you still receive credit and the possibility of others contributing back code. And for many many MIT licensed projects, people DO contribute back code and have dozens of contributors.

People won't be contributing back any code at all if your GPL license means they can't use your code in the first place

 

It's a good thing that GPL is the way it is. If you can't get code relicensed: oh well. Either forget about it, find a GPL (or compatible) equivalent, or write your own version. It's for the best, the folks at FSF know what they're doing.

I strongly encourage you to consider GPL over other options. A good example is the Doom community, that's the prevalent license there, and it has served them very, very well for numerous reasons.

An even better example: Linux. Android OS is built on it, and thus you can pull anything you want from it. You can make any version you want, with anything from anywhere so long as it's GPL or compatible. I emphasize that you can indeed use non-GPL code in GPL projects, so long as the licenses are compatible.

Bull-fucking-shit. That's the entire point of GPL, is to maximize sharing code! Your statement is only true if other people are using projects not licensed under the GPL.

Point is, if it's under the GPL, you can use any and all code that is also under the GPL. Sure, it's "viral" and limits your options to work outside of it, but the benefits far, far outweigh that (frankly, insignificant and irrelevant) drawback.

And damn them all for doing so. The vast majority of anything that actually matters is still under GPL and will remain so for good reason.

Don't get me wrong, the others aren't terrible licenses or anything (at least not MIT/BSD, I don't know enough to comment on others), but they are prone to potential abuse. The GPL is strict for this very reason.

Actually, no. Most free software projects are under the GPL (and for good reason). Going GPL may restrict your use of code from other projects under incompatible licenses, but you're actually going to have a lot more available to you if you do go with GPL.

Dammit. Don't do this, please. James is full of it. I might be arrogant (I'll admit as much!), but do consider the facts. Consider the benefits and the drawbacks. There is a reason the GPL has so well established itself, and the fact that there are projects that abandon it for mere convenience to use non-free code does not diminish the value and strong ethical standard of the GPL; it just means that those who move away from it are being unethical and lazy pricks.

If you choose to go for another license, you weaken the GPL as a whole. It is the best option practically and ethically, but it only works when everyone cooperates. Don't be a part of the problem, be a part of the solution. Truly free software does not tolerate non-free uses of code, or even the potential for it.

Sure, it's a little Borg-like. Doesn't matter, though, the excellent results of the FSF's work speak for themselves.

 

So... what happens when someone violates your GPL or otherwise licensed project? Can you sue them? Do you get money?

 

Yes. BusyBox sued companies using their stuff without providing the source code.

Also, the main reason GPL works for Doom is that the engine and the game assets are separate. The Doom engine is released under the GPL, and any derivatives or modifications have to also be under a GPL license. HOWEVER, that's just for the engine that runs the game. The game assets - the stuff that makes the engine run Doom - are under a proprietary license, and you have to pay id Software to use it. You don't have to use the original asset files, you could make your own and run them with the engine; that's what FreeDOOM is doing.

Sonic fangames, however, tend to have the engine and the game assets intertwined together, generally due to the technology used in the community. (Fusion, Game Maker, etc. combine code and assets into a single blob.) As such, a GPL license can't work well here, because you can't partially open source it. You can't abstract out the game engine from the assets. And even then, if you did have an engine that was able to abstract everything, you'd still have to code in the behaviors of objects unique to your game: if you didn't want to give away how you did that awesome boss battle, you would have to have a scripting language implemented in the engine that read code from the asset files, which is a lot of overhead for a 2D platformer game, and making a scripting language and testing it can be a total pain in the ass.

(For the record, that's how modern Doom mods are made: DECORATE, ACS, ZScript are used to bend the game engine from the asset files.)

For over a decade, the Sonic fangame community used its own informal "license": If used, please give credit. A more formal version of this would most likely be the 2-Clause BSD license. This is effectively what Sonic Worlds is licensed under, including Sonic Worlds Delta. If it was under the GPL, I would have to force Strife to open source the MFA for Freedom Planet, because he made changes to the code that were not released under GPL. Same goes for Lake and his indie game Spark the Electric Jester. That would be pretty shitty to do to these guys.

So, what I'm saying is, unless you have a clear way to keep the engine and assets completely separate entities without impacting the ability for users to create game projects for the engine, you should use a more permissive license.

 

By the way, I recommend http://tldrlegal.com for reading up on software licenses. Though it does look like their site is a little broken at the moment.

 

For cases like this, licensing/linking exceptions are what you want. You can totally partially open source it, provided that you actually do make the proper exceptions (and remember that you can't un-GPL something once you've applied the GPL to it -- you (as the author) can absolutely make later versions proprietary again, but there's nothing you can do to stop someone redistributing older, GPL licensed versions of the code). Heck, you can make various parts ISC/BSD/MIT licensed, as long as the license is compatible with the GPL (and all those I listed except original BSD are, there are several examples of projects with parts GPL, parts other licenses, like FFmpeg). There's also absolutely nothing stopping you from licensing it more permissively later on if you decide that the GPL is too restrictive, although older modified releases would be still under the GPL.

Adding a scripting language is pretty standard and usually ends up with Lua being linked in because it's robust and relatively little effort (admittedly, still effort) to add.

Assets can be and are often totally combined into one big binary in GPL'd projects, assets aren't part of the code and can absolutely be differently licensed. As long as the assets are replaceable in your source tree, you're golden.
Look at Firefox's licensing for a fairly public detail of how that works, and why there are things like IceWeasel and the lot.
also, Doom's enemy logic is part of the GPL'd code, only the graphics+sound aren't -- if they cut it out and provided entry points to add your own enemy logic, they could have separately licensed it

The GPL takes no rights away from the author -- your code is your own. It just grants rights to other people, and ensures that others can't just use your sources without others being able to do the same to their modified versions.

All that being said, I kind of like using the ISC license -- it's short and sweet and you don't have to think too much about it.
It's extremely, extremely permissive and boils down to "do whatever you want, but keep my name on it," however. It's like the MIT/X11 license, but shorter.