Games come in all shapes and sizes — big and small, AAA and super-indie, made by companies with hundreds of developers and by lone wizards. They're rarely written from scratch with only the game's own code; more often you write the game tools and the editor while building the game itself in parallel. Behind this multi-billion-dollar industry there is code, a lot of code, a whole lot of code. Game engines and frameworks are powerful tools that help a developer give shape to their ideas and build captivating game worlds. They are the framework on which all game universes are built — bundling hundreds of tools, libraries and resources, letting developers turn lines of code into a theatre for a single spectator.
There are well over a hundred game engines, and each one has at least one feature that no other has. No single engine has all of them combined, and that's wonderful — otherwise such an engine would conquer the world. Hmm, Unreal 5, is that you? It's sometimes useful to skim an engine's release notes to stay on top of the latest news. Maybe you're building your own solution and this article will spark some new ideas. Ready to learn that your favourite game was made not in Unity, but in the holy SDL?
When I worked at the EA St. Petersburg studio, there was a dedicated engineer who tracked changes across new versions and maintained a HUUUUGE table of which feature lives in which engine. Unfortunately the table really was enormous — something like 800+ description columns across more than a hundred engines — and there was no way to copy it. A pity, because the work behind it was truly titanic. Keeping it up to date took no less effort, which is why it warranted a separate position. But the list of engines was freely available, and if you have the time you can put one together yourself. I won't describe the specifics of each engine — obviously every one of them is powerful, versatile, packed with features, and so on. I'll just drop a link to GitHub and a couple of games; if something catches your eye you can follow the links and dig into the details yourself. I keep a small table of game engines and the games made with them. If you don't see something, add it in the comments. The principle behind this list: I've touched each of these with my own hands — somewhere there was an interesting game, somewhere I tried to build an example, somewhere I fixed a bug or added a feature.
Engines usually support bindings to other languages or scripts; next to each name I'll note the license and the main language it's written in. Keep in mind that a binding or a script is a trade-off between the engine's own performance and the speed of developing the game/app — and the latter often wins.
nCine (MIT / C++)
An open-source game engine that gives developers the means to build 2D and 3D games across various platforms. It offers an extensive toolset for game development, including support for many operating systems, graphics, audio, animation and physics. Worth studying for its component system and its event system.
MonoGame (MPL / C#)
github.com/MonoGame/MonoGame · alternative FNA
A development framework built on top of the Microsoft XNA platform. It provides tools and libraries for building cross-platform games, supporting several operating systems including Windows, macOS, Android, iOS and Linux. I studied this engine alongside C#, as practice in using the language. And the projects built on it are popular and well known.
RayLib (zlib / C / Lua)
A lightweight, easy-to-use library for building games and applications. Written in C and supporting several platforms (Windows, macOS, Linux), it provides access to graphics, audio and input resources. A great tool for beginning game developers. It supports several programming languages (C, C++, C#, Python). I didn't find any well-known games made with it, but there's a good game-development tutorial. The engine was interesting for how it implements the Lua–C binding.
Love2d (MIT / C++ / Lua)
github.com/love2d/love · StoneKingdoms
A minimalist but powerful framework for building 2D games. It has an active community and lots of available libraries and plugins. The community keeps extending the engine's functionality and helps create a wide variety of games. I ran into this engine while helping develop StoneKingdoms (an open-source Stronghold clone, made with the blessing of the original game's authors).
LWJGL3 (Apache 2.0 / Java)
github.com/LWJGL/lwjgl3 · libGDX · jMonkeyEngine
A library for building cross-platform 2D and 3D applications and games in Java. It gives access to low-level libraries such as OpenGL, OpenAL and GLFW, supports multithreading and broad capabilities for graphics, audio and input. I dug into the Mindustry sources, and looked at the library itself in parallel.
Cocos-Engine (Proprietary / C++)
github.com/cocos/cocos-engine · cocos2d-x
It offers a rich asset library, animation and physics tools, and support for various programming languages including C++, JavaScript and Lua; it's widely used for building colourful, interactive games on many platforms. I first ran into the engine back in 2014 at EA — several of the St. Petersburg studio's projects were built on it.
Phaser (MIT / JS)
It supports sprites, tilemaps, animations, parallax backgrounds and other graphical elements, making visual creation relatively easy and efficient. It includes the Arcade Physics engine for handling collisions, gravity and other physical effects in a game. Very simple to develop with, especially if you don't know HTML — in one evening, just for fun, I knocked together a clone of the Chrome dino with asteroids and Neanderthal-eating :)
Babylon.js (Apache 2.0 / TypeScript)
github.com/BabylonJS/Babylon.js
It uses WebGL to render 3D scenes, delivering good performance. It supports rendering with PBR and lighting, including real-time ray tracing. It has an active, extensive developer community that writes plugins and extends its functionality. As with the next entry on the list, I used it to learn JS for self-development.
PixiJS (MIT / TypeScript)
It's widely used for building web games, interactive animations, ad banners and other visual applications. Thanks to its performance and flexibility, it remains popular among web developers.
The Forge (Apache 2.0 / C++)
github.com/ConfettiFX/The-Forge
It supports several platforms including Windows, Linux, Android, iOS and the new generation of consoles. The engine is built for maximum performance, with optimised algorithms to keep games running smoothly even on weak devices (according to the authors). It gives access to modern graphics APIs such as Vulkan and DirectX 12. I noticed this engine after the team was mentioned among the developers of one of the Spider-Man games. I tried to build the examples from their site, but it didn't work out.
HaxeFlixel (MIT / Haxe)
Although it provides powerful development tools, it's fairly hard for game-dev beginners. It will definitely take time to get comfortable with the framework and its architecture (which isn't exactly absent, but isn't always present either). Despite its popularity, it has relatively limited resources and documentation compared to other game engines. The community has been developing slowly of late.
Kha (zlib / Haxe)
A low-level library for building games and multimedia applications, focused on portability. You can think of it as a more powerful version of the SDL library. I was looking for a framework to replace SDL2 — everything's great, tons of features. If it were written in C++ it would be priceless.
PixelBox.js (MIT / JS)
A library for building pixel-art and retro-styled games and apps in the browser using JavaScript. It gives developers a toolset (not a very large one, honestly) for working with pixel graphics, audio and input, suited to making games in the style of 8-bit and 16-bit consoles. A relatively new and little-known library, but it offers good tools for retro-style games. I built a game from the examples and realised eight-bit games just aren't for me.
OpenFL (MIT / Haxe)
A framework for building multimedia and interactive applications, including 2D and 3D games, animations, visualisations and much more. It's a modern alternative to Adobe Flash and lets you build cross-platform applications using the Haxe language. I really enjoyed Papers, Please back in the day and went to see what and how this little marvel was made — and picked up a bit of Haxe along the way.
SFML (zlib / C++)
github.com/SFML/SFML · ObEngine
SFML (Simple and Fast Multimedia Library) is a free, open-source library for building multimedia applications and games. Written in C++, it offers a simple, clear interface for working with graphics, audio, networking and input — a good choice for beginners to get acquainted with a well-designed API. There are a couple of good projects, but alas their sources are closed.
SDL2 (zlib / C)
I've used this library since 2009 and have never found a real alternative for its simplicity and pluggable modules. It's used mostly not as a standalone framework but as an addition to existing ones to ease porting — it lets you spin up a minimal application for almost any platform from Windows to HaikuOS, on top of which you can then add the functionality you need. Games built with SDL2 include well-known projects: "Hearthstone: Heroes of Warcraft" by Blizzard Entertainment, "Stardew Valley" by ConcernedApe, "Terraria" by Re-Logic and many others. These games use different engines and frameworks, but rely on SDL to open a window, render and handle input. It's supported by the folks at Valve.
Even though SDL isn't a full-blown game engine, building games with it is fairly simple. This is my weekend project, made with SDL + C++ + JS as configs (github.com/dalerank/Akhenaten).
Flame (MIT / Dart)
Flame Engine is a game-building engine written entirely in Dart. It lets you build colourful games that (per the developers) can run on various platforms, including mobile devices and web browsers. It's designed to integrate with the Flutter ecosystem, making it handy for mobile developers. I spotted it on my kid's phone — some run-of-the-mill idler about ants that shamelessly begged for money and showed an ad every five seconds; I weaned it off the ads and handed it a pill for greed. Along the way I learned there's this interesting Dart engine. I tried running the examples: on Windows it didn't work (about a year and a half ago), on Linux and Android it launched.
It's not all as rosy as the examples suggest, though. See the comment from ASGAlex in the discussion.
Allegro (zlib / plain C)
A cross-platform library aimed at building games. It's low-level enough to deliver good performance under large volumes of data. On the whole it abstracts the developer away from routine chores without closing off the option of reworking everything to your own taste. That said, Allegro isn't a game engine — more of a Swiss-army harvester of features; you'll have to write the game yourself. The most famous example of its use is Factorio, but for over a year now the author has been moving away from Allegro toward their own home-grown solutions.
AndEngine (Apache 2.0 / Java)
github.com/nicolasgramlich/AndEngine
An ancient engine, no longer in development. Some of its games: "Cannon Ball", "Zombie Dash", "Plumber". The dawn, so to speak, of mobile game development — it gave a start to other popular engines, and individual borrowed pieces of its source code and architecture show up in LibGDX, Cocos2d, Godot Engine, Panda3D, Phaser. It had a good API, which made it a decent choice for prototyping and trialling small features. I used it in a couple of small Android games when I needed to build and show an MVP "yesterday".
GameMaker (Licensed)
Even the greenest developer can make a game; it's so popular that schools have started using it in programming classes — I did a lab assignment on it with my son. Hotline Miami it was not, but in a week we managed to put together a bare-bones Angry Birds clone. Visual programming is, of course, a convenient thing up to a point, but I still prefer C++ and proper code. Somewhere on a forum I found a slogan for the engine: once upon a time a game was created here, then a second, and a third… and so it went, every time someone opened GameMaker. Personally I didn't like the engine for being over-simplified, though to each their own.
Defold (Apache 2.0 / C++)
The engine itself is written in C++, very well optimised, with a good Lua binding. It supports iOS, Android, HTML5, Windows and macOS. It makes heavy use of a component architecture — almost every system in the engine is built as a component and can be swapped for your own or rewritten, which makes creating and managing components very convenient. It's one of the engines that supports collaborative work through plugins. I haven't seen any famous games on it; the engine drew my interest mainly for its hot-reload of (Lua) scripts, achieved through a sandbox for each running script. It uses a lightweight Lua VM that's restarted on the fly when the script's code changes.
GB-Studio (MIT / C)
github.com/chrismaltby/gb-studio
The project was born at the "Bored Pixels 3" game jam in a week, and then grew into a full-fledged engine for building GameBoy-style mini-games. Simple, intuitive and easy to use. It really can build a ROM for the GBA — that's actually how I got acquainted with it, when I was trying to make a simple application for that platform.
TileEngine (MIT / C)
An open-source graphics engine for building 2D games using tile maps, sprites and palettes, letting you make games stylistically similar to late-90s NES/Sega titles. The engine also reimplements, in software, various hardware tricks of the consoles of that era. Per-Column Offset — a wobble effect often associated with old TVs and monitors, though it was first implemented on the Sega MD. Per-Pixel Displacement — shifts pixels on screen, creating distortion and the illusion of image deformation; it was used in 2D games to create water-surface effects and other distortions. And many others. These days the repo is barely updated — the author is writing a second version of the engine. The engine drew my interest above all for how it implements various sprite effects, all sorts of overlays, mosaics and layers.
Godot (MIT / C++)
Godot's story began in 2007, when the Argentine developer Juan Linietsky started working on a game engine called "D.". At the time he also worked at Square Enix's Argentine office on the team building the studio's in-house engine. In 2014 the engine was first published on GitHub and within a month gathered its first thousand stars; that same year the author received a grant from Mozilla to continue development, a year later GitHub and Microsoft also handed out grants, and the repo crossed its first 10k stars. Godot became the platform for a multitude of games, including indie projects and major commercial titles, and is interesting — again — for its component-based approach to development. In terms of components, assets, tutorials and community size it can genuinely compete with Unity/Unreal. There are many interesting editor features that are absent or limited in other editors — for example, the ability to configure anything and everything through internal scripts, from the game to the editor itself.
CryEngine (Proprietary)
CRYENGINE · mirror · Lumberyard · O3DE
For a while the engine sources were available on GitHub, but now, to access the current sources, you have to request credentials on a site that's been down for over half a year. The engine is very interesting for its use of cutting-edge tech (as of late 2017). It shipped with a powerful editor called Sandbox that let you create and edit levels, add objects and textures, and tweak logic right during gameplay in active-pause mode — one of the first engines to apply BT (Behavior Tree) to any object on the scene. The immersiveness of Prey and the ability to interact with objects amazed me back then, so as soon as the engine became publicly available I started figuring out how it works. Amazon forked it in 2015 for their LumberYard and continued development, and it eventually turned into O3DE.
Flax (MIT / C++)
github.com/FlaxEngine/FlaxEngine
An engine from one of the architects of Frostbite; its key feature is the ability to write scripts in "C++" — it's not real C++, of course, but it's very close. If, like me, you're comfortable using curly braces, you should like this engine. As long as you don't ask it for templates, it's almost C++. It recently gained hot-reload for C++ scripts too, which really speeds up development. The engine is fairly mature — development has gone on since 2012 — but the sources used to cost money. I noticed it because of its syntax: C++ isn't very popular as a scripting language in game engines.
Panda3D (MIT / C++)
Panda3D's development started in the early 2000s as a project of New York University under Dr. David Fox and Disney Interactive Studios. The engine was built for multimedia applications and presentations, and was later opened to the community. It's interesting above all for its shader library, most of which are patented by Disney — though nothing stops you from peeking at the implementation.
OGRE (MIT / C++)
github.com/OGRECave/ogre · CopperCube (paid support)
I worked with this engine at Transas, where it powered a video-surveillance system and an operator's workstation. Not only with it, of course — paired with Qt. At the time the engine was fairly powerful, with support for newfangled features, good documentation and a friendly community. These days the authors highlight the ability to compile it for the web in a couple of clicks (ogre/emscripten).
DagorEngine (now BSD / C++)
github.com/GaijinEntertainment/DagorEngine
Well, what can I say — a good engine from an equally well-known studio. Four years went into adapting it for the Switch and Apple TV. War Thunder and Cuisine Royale ran on it. Fairly hard to learn — clearly written by programmers for programmers. It rewards those who master it with the ability to run on any iron with hardware vaguely resembling a CPU and a GPU. My opinion: it should have been opened up 8 years earlier — back then there was a chance to compete with Unreal. Big platforms — everything available, they even built it for Baikal CPUs. Mobile platforms, judging by mobile War Thunder, are supported too. The snails did great, while the potato folks are in no hurry to open-source anything.
Irrlicht (C++)
This is the engine I started my game-dev acquaintance with; for a while I supported the NerpaGUI UI framework, which was almost "official" for the engine. It had a full UI editor in the style of Qt, with reflection and scripts inside the widgets (that was 2008–09). Surprisingly, the engine is still maintained — the last commit was a couple of weeks ago. Maintained, but not developed or changed; everything stayed at the level of the late 2000s.
Unreal (C++)
github.com/EpicGames/UnrealEngine
A magnificent engine, a true gem among game engines! This engine can breathe life into the most ambitious projects — you just need to scrounge up 64 GB of RAM somewhere, since 32 no longer cuts it. Blueprints is a brilliant solution for code-free programming that opened the doors of game dev to anyone who wanted in. And the Unreal C++ dialect, it seems, will soon be the new standard. The number of plugins written for the engine will soon top a million — it's probably easier to say what plugins haven't been written, and usually it all gets open-sourced, or a nominal five bucks for access to the code.
X-Ray (MIT / C++)
The sources of the first S.T.A.L.K.E.R., partially leaked online, plus the community's huge effort reversing the original, have led to the game on this engine looking better than the original today. Features? Its own memory allocator, its own vector math, its own strings, its own containers — the only thing not home-grown is DX9, a classic of 2000s game dev. That's roughly how it was all done in the early 2000s, with varying degrees of zeal, and there really were reasons for it.
Unity (Proprietary / C++ / C#)
A powerful engine, but plain hell for a programmer. I worked with it in 2014 on the optimisation team and supported the shader compiler. Hard for both beginners and seniors — probably one of the hardest I've encountered (to maintain). Tons of legacy code that nobody wanted to fix or change (2014–16), while new features got piled on at the snap of a finger. Many tools were missing at the time — the shader editor appeared much later. Performance was probably the engine's sorest spot, especially when a device was short on memory. For instance, Sims Mobile on Android with 2 GB of RAM loaded in 30 seconds, while on a similar device with 1 GB it took 4 minutes. Loads of memory reallocations on internal structures, where needed and where not. In the end I had to write a callback-storage array from scratch — the old version, when adding a single element (one element, to be precise), would lock the whole engine, make a copy of itself and delete the old one. For Sims Mobile, where every chair could have up to a hundred callbacks for different actions (and they could be added or removed too), this was a real problem. And there could be hundreds of such objects on a level. In the end our version of the array made it into the master branch. Even minor updates managed to break the engine's internal API, and it was all smeared with some unimaginable amount of crutches to keep things working for users.
Memory leaks are their own saga too — they were there, they're still there, and most likely they'll never be fixed. No surprise why Cities devours 32 GB on my laptop and then dips a bit into swap.
Conclusion
That turned out to be quite a hodgepodge of memories — each engine has its own quirks, each is interesting, each has hundreds, if not thousands, of person-hours of development poured into it. And each has found its own niche.
Other engines I've run into, but never went beyond a look:
- Bevy (Rust)
- Ceramic (MIT/Haxe)
- Pygame (LGPL/Python)
- Dome (MIT/C)
- Mach (MIT/Zig)
- PythonArcade (MIT/Python)
- ClanLib (zlib/C++)
- Just a Neat Game Library (zlib/C++)
- Tetra (MIT/Rust)
- Ursina (MIT/Python)
- Tofu (MIT/C/Lua)
- Ultraviolet (MIT/C#)
- Macroquad (MIT/Rust)
- GDevelop (MIT/Java)
- Stencyl (Haxe)
- Heaps (Haxe)
- MicroStudio (MIT/JS)
- TIC-80 (MIT/C)
- AGS (C++)
- Oxygine (C++)
- FlatRedBall (C#)
- Starling (ActionScript)
- LITIengine (Java)
- Duality (C#)
- Stride (C#)
- NeoAxis (C#)
- WickedEngine (C++)
- jMonkeyEngine (Java)
- Fyrox (Rust)
- Magnum (C++)
- Lumix (MIT/C++)
- CastleGame (Pascal)
Updated, engines suggested by readers:
- DragonRuby
- Cocos example-projects
- ogre-next
- UNIGINE (Proprietary / No Sources)
- UPBGE
- ThreeJS (MIT/JS)
- study-game-engines
- Construct3 (Proprietary / No Sources)
- o2 (MIT/C++)
- ebitengine (MIT/Go)
- KorGE (MIT/Kotlin)
- Helm (Haskell)