
Open Source Game Clones - madc
http://osgameclones.com/
======
daeken
Not quite ready to submit this to the list yet, but I've been working on a
Quake 3 engine clone from scratch in C# with Bridge.NET, targeting the browser
and WebGL. It's been a super fun project so far -- a few days of part-time
work and I have levels rendering nearly perfectly and I'm making progress on
character model rendering. Repo is at
[https://github.com/daeken/WebArena](https://github.com/daeken/WebArena) and
you can see a live version at
[http://demoseen.com/bridge/](http://demoseen.com/bridge/)

Still a ton to do, but I'm really digging it.

Edit to add: WASD + Space/Shift + arrows to control the camera.

~~~
westoncb
Awesome! I wrote an MD3 loader/renderer/animator years ago[0] and had a lot of
fun with it—always wanted to try loading the levels as well, though I've yet
to try it. Any comment on how difficult that was in comparison to dealing with
characters? I imagine you are pulling the data from WAD files (err.. does
quake 3 still use those?), and static geometry is in a 3D BSP tree?

[0]
[http://symbolflux.com/statichtml/oldprojects/md3library.html](http://symbolflux.com/statichtml/oldprojects/md3library.html)
(No source or anything available atm—just a screenshot and description, though
I could up it up if anyone were interested.)

~~~
daeken
The actual level loading itself is stupid easy -- I had the geometry loading
and rendering in something like two hours. The tough part is converting their
"shader" model over to something that modern GPUs can understand. That took
about a day and a half and still isn't entirely complete -- I'm missing
environment mapping and vertex deformation.

MD3 has been pretty straightforward on the whole, but I didn't design my mesh
abstraction super well out the gate, so I've mainly been redesigning that and
trying to make it futureproof. I think I have it to about the minimum repeated
code possible at this point, but I'm sure I'll reach some other snag down the
road and have to refactor again!

~~~
westoncb
Interesting—yes, I was wondering about their shader model. I glanced through
your source and saw what looked to me like some of the conversion. In any
case, the shaders you have running so far (I assume they generate the
animations on various objects in the scene) look very nice :) Good luck with
the project!

------
AdmiralAsshat
It would actually be really cool if games officially adopted this kind of
engine-based model that we see in some of the examples, where the "engine"
would be FOSS (meaning it can be ported, modded, improved, etc.), and the
"game" that is sold is the compiled binary blob graphics, assets, scripts,
etc.

In short, I guess it would basically be like selling RPG Maker games or DOOM
wad's, but without the engine itself being proprietary.

~~~
pvg
Isn't UE reasonably close to that already for most practical, if not
ideological purposes?

~~~
AdmiralAsshat
But that only works if Unity open sources the engine. A _ubiquitous_ engine is
not the same as an open engine. The fact that we now have jDoom, Doomsday, and
other enhancements to the engine that let us play Doom, Doom2, Hexen, Heretic,
etc. only work because id software released the source code. Otherwise, it
would be like any other proprietary engine, and we'd have to reverse-engineer
it if we want to be able to play those games again.

I'm sure you could argue that Unity is currently more cross-platform than
engines were 10-20 years ago and already works on
Mac/Win/Linux/Android/whatever, but we can't guarantee it will be around in 20
years.

~~~
mintplant
UE is Unreal Engine, not Unity. Presumably Unreal Engine 4, which gives full
source access to anyone who agrees to their EULA and takes patches through
GitHub.

------
kiddico
You missed the best clone of them all :P
[https://github.com/raxod502/TerrariaClone](https://github.com/raxod502/TerrariaClone)

~~~
salqadri
Just submit a PR to
[https://github.com/piranha/osgameclones/](https://github.com/piranha/osgameclones/)

~~~
katastic
It's not a real game. It's a project online to show all the bad code the guy
wrote when he was a young coder.

~~~
salqadri
Lol oh ok

~~~
kiddico
Sorry, I wasn't trying to cause confusion!

------
throwaway2016a
This is an awesome list.

I know there are many programmers that spend long hours recreating games they
like in open source. But are there artists doing the same? It would be great
if many of these projects that require a copy of the original game for the
assets could get contributions from artists willing to make open source skins
/ texture packs as well.

~~~
cr0sh
Yes: [https://opengameart.org/](https://opengameart.org/)

~~~
throwaway2016a
Thanks for the link. This looks really cool.

------
hutzlibu
Those projects are good, but I think it is a bit sad, that the open source
movement allmost only manages to produce clones of games and not a new one.
Well, let's see, if I can change that one day ... lot's of ideas, but not the
time, nor money at the moment. Common problem, I suppose ;)

~~~
krapp
To be fair, creating a new game that's _good_ takes a lot more talent across a
lot more domains of expertise than your average FOSS hacker might appreciate.
The code is just one part of it - you've got art, music, level design, story
possibly, it can be as complicated as making a movie.

Cloning an existing game is easier.

~~~
lloeki
If people want to try their hand at it, I recommend them to try to participate
in game jam warm-ups, such as MiniLD[0] for Ludum Dare. Getting your feet wet
gives quite some hint at the scope of things you have to handle.

[0]: [http://ludumdare.com/compo/minild/](http://ludumdare.com/compo/minild/)

------
salqadri
This is an amazing list; thanks a lot for sharing! Here is a link to the
underlying github repo where people can contribute to that list:
[https://github.com/piranha/osgameclones/](https://github.com/piranha/osgameclones/)

------
thriftwy
There's this best game ever, Master of Magic, which countless people tried to
rewrite over but nobody ever got anywhere. Even in this list.

Of these, Star Control (Ur-Quan Masters) is also one of the best games with
tear-dropping story which I also recommend highly. The open-source port is of
excellent quality.

------
soared
This is a good example of when a site with a lot of images would actually be
helpful - I could use some thumbnails! ('go submit a pr then')

------
microcolonel
I didn't know that Allegiance was switched to an MIT license from Shared
Source, that's awesome! I've not been running Windows natively on a computer
for some years now, and I kinda miss playing Free Allegiance with easily 200
players in a single game, so hopefully under the new license it's more likely
to be ported off of Direct3D, and then perhaps off of Windows dependence. I'm
probably not going to be the one to do it though, so maybe it'll never happen.

------
indescions_2017
Great list!

If we were to start an archival project to preserve some of these classics for
posterity, it seems there are a couple of techniques. Internet Archive's
strategy of collecting (public domain?) ROMs and exposing via JSMAME. Use an
open clone as reference and then port again to WebGL. Or for games ported to
SDL perhaps re-compile via Emscripten to Javascript.

HTML5 and browsers are becoming performant enough. Is there some other
portable emulator that might be a better target?

~~~
conradev
libretro is pretty cool:
[https://www.libretro.com/index.php/mission/](https://www.libretro.com/index.php/mission/)

------
fritzy
I should submit [https://spacewar.pro](https://spacewar.pro) as a clone of DOS
SPACEWAR

------
erikb
Really nice, but out of date it seems. A lot of the links don't work and
sometimes good alternatives aren't mentioned.

------
dimman
There’s one engine missing in that list, and it’s pretty advanced:

[http://fte.triptohell.info](http://fte.triptohell.info)

Supports a lot of the Quake based games (started out as a QW engine but is
much more today).

Had Vulkan support way earlier than vkQuake came to be. Spike, the basically
single developer behind it is really talented.

------
itomato
I'd like to see an open, multiplatform clone of Subspace.

We've had a reverse-engineered server for some time:
[https://bitbucket.org/grelminar/asss](https://bitbucket.org/grelminar/asss)

------
kzrdude
RTTR for a Settlers II remake is really good (but requires original graphics
files).

------
vog
If you didn't play it, and are into puzzle games, I strongly recommend you to
try the Pushover reimplementation. I loved that one back in the DOS times, and
the free clone contains may additional levels.

------
rodolphoarruda
How do I know which of these could be played in Ubuntu?

------
VikingCoder
I'd love it if someone made a Visual Studio Solution that correctly built as
many of these as possible.

------
axonic
I stumbled upon this when searching for examples of successful open source
games. Great list, thanks for this.

------
emodendroket
It's always seemed funny to me that there aren't a million Fantavision clones.

------
dmm
You include several clones built on Unity. These are not open source.

~~~
derefr
Is a game "not open source" if all the business-logic code and game assets are
open-source, but it relies on a closed-source engine (that it doesn't ship
with)?

Doesn't seem much different to me to e.g. writing an open-source game that
uses DirectX. DirectX is not, itself, open-source, but it's not really "part
of" the game. The game just uses its API; and could equivalently use anything
else with the same API (like the DirectX implementation in Wine.)

~~~
throwaway2016a
A purist would say that an open source game should use OpenGL. But I generally
agree. Unity is free to download so there is no monetary barrier to compiling
these games. So it's not free from a GNU sense of the word but it is free
money wise and the gameplay parts are open source.

~~~
derefr
That's not even so much what I meant. The "game" isn't the engine; and so the
"game" _is_ open source. You're free to modify and redistribute everything
that constitutes the game. To _play_ the game, you need the game engine,
similar to how running a program requires a machine (real or virtual) with a
compatible ISA. But there's nothing forcing you to use a closed-source
implementation of the game engine. If an open-source implementation of the
engine doesn't exist, you're always free to write one.

Nobody ever says that a program being written for closed-source _hardware_
necessarily implies that the program can't be open source. Because, of course,
you can just write your own open VM for that same hardware. Saying that e.g.
Gameboy Advance home-brew is all closed source, because the reference
implementation of the hardware is closed source, is nonsensical. People are
free to write, modify, and run GBA home-brew. Doing the last one just requires
an emulator for most people, which is an everyday tool for programmers (given
that many languages target _abstract machines_ like the JVM or Erlang's BEAM,
where the resulting bytecode ISA is _only_ reified as an emulator.)

~~~
rekado
> If an open-source implementation of the engine doesn't exist, you're always
> free to write one.

This is a very strange interpretation.

When a piece of software that is released under a free license has a crucial
non-free dependency, it is effectively non-free. As the software only works
with the non-free dependency, but that dependency cannot be conveyed along
with the free part, the whole thing cannot legally be distributed and thus is
non-free.

~~~
derefr
The reason I take that view, is that the ability to _use_ the software isn't
actually a part of what makes software open source! As long as people have all
the code, and can modify it, and can redistribute their modifications, the
code is open-source... whether or not you can run it.

Consider: there are also hardware platforms that have effectively ceased to
exist over the years. If you wrote a program for one of these platforms, and
it was open-source, would you now consider the program closed-source,
because—given that the platform hardware doesn't exist any more—you can't run
the software any more?

No. Why not? Because open source is about the source, not about the binary.
The source is a product in its own right, and valuable in its own right,
whether or not it can be compiled into a working program.

~~~
khedoros1
> Why not? Because open source is about the source, not about the binary.

If you have the platform and the source, but you can't run the program, then I
wouldn't consider it "open source". At least not in the usual sense of FOSS.
It's not just about the source; it's about the freedom to study and modify the
source, produce improved versions of the original binary, and distribute that
binary and the source that created it.

The division between game and platform is lower in the stack than the engine.

> The source is a product in its own right, and valuable in its own right,
> whether or not it can be compiled into a working program.

I agree with that statement, but it's a different argument than you were
making before.

~~~
hacking_again
And you won't get far with source modifications if you can't run the program.

