As an aspiring game developer, this is the single biggest question you must answer before beginning your project. Your game engine effects how you build your game, what kinds of issues you may run into, and even how much money you make.

Unity

Unity is first on this list for a number of reasons. It's by far the most popular engine---you'll find that any random indie title probably runs on Unity. It's backed by a ton of community support, and is probably one of the easiest to learn. This does give it a bit of a reputation for being the engine for low-budget 2D games, but that isn't exactly true. Unity is very accessible, so it gets used to make good games and not-so-good games. It's up to the developer to make the game good, not the engine.

Unity takes a very hands-off approach to engine design. It uses C#, a strongly typed language that is much more digestible than C++ (for most people). The engine handles things that should be relegated to the engine, and stays away from forcing schema upon you. Collision, rendering, and object lifecycle management are all handled. Most other things are left for you to build.

You'll certainly need to learn C# to use Unity. While there are a few visual scripting extensions in the asset store, they're not as well integrated as UE4's blueprints. One thing that is handled with a graph is the new Shader graph feature, which enables you to write shader functions without touching code.

On top of this, Unity's asset store is great and far bigger than any other game engine. There's plenty of free assets that you can use, as well as paid ones you can buy. This is particularly useful if you're not much of an artist and want to pay someone else to model things for you. You'll likely find something suitable in the asset store.

Likewise, the community support for Unity is excellent. It's one of the biggest engines, especially among indie developers. You'll find numerous tutorials for building different types of games, as well as prebuilt examples in the asset store.

One thing that isn't handled very well by Unity is multiplayer. Their UNet library is complicated and being deprecated soon. They're currently working on a solution, but as it stands, built-in multiplayer is fairly messy.

Whatever your use case is, you probably can't go wrong choosing Unity for your game. It's free if you make less than 100k per year, which makes it great for indie developers. If you make more than that, it's $420 per year, and $1,500 if you make more than 200k.

Unreal

Unreal is the engine powering Epic Game's Fortnite. In stark contrast to Unity's hands-off approach to engine design, Unreal's tries to do as much as it can to help make your job easier. It gives it a bit of a reputation for being clunky and hard to learn, but that isn't exactly true.

For example, Unreal has a number of classes to help with common tasks, and you'll have a much easier time if you try to adapt to their schema. One of these classes is "PlayerController," which handles player actions and is used quite extensively. This class in particular will be useful for nearly any game, but other classes such as "Character" may cause some people frustration.

The Character class is designed around 3D first-person shooters, and requires you to use a capsule collision component and Unreal's built-in character movement system, which definitely won't fit everything and is annoying to extend. But, this is only here for people that will be entirely satisfied with the basic movement. If you're not, Character is a child of the "Pawn" class (used for the player object itself), so you can use that class instead and handle movement how you wish.

With that out of the way, let's talk about the best feature of Unreal: Blueprints. Blueprints is a fantastic visual scripting language that enables you to create games without touching code. Unreal runs on C++, and you're certainly allowed to use both, but Blueprints are mature enough now that most developers won't have to touch a text editor unless they really want to.

Here's what they look like:

While there is a bit of a performance overhead compared to native C++, it's not drastic, and you'll only notice it when you're doing something you shouldn't do anyway (such as running huge functions every tick or spawning a billion actors).

Blueprints won't be for everyone, but they're great for people who want to create games without much programming knowledge. It's still coding, and you'll still need to be familiar with core programming concepts to make good use of them, but they're much more digestible---especially considering C++ is the primary alternative.

If you are working in C++, the full engine source code is freely available, and you're free to extend the engine however you see fit.

Multiplayer is handled well and baked into the engine from the start. Variables can be set to replicate across clients, and anything that inherits Actor will replicate movement across clients. Functions can be set to run on the server, multicast to everyone, or replicated to the owning client in the case of actors that exist on the server and client.

This feature is a lot more niche, but it's cool enough that we had to mention it. The editor itself features full VR support, so you're able to build levels with your hands in 3D space, provided you've got a VR headset.

As far as pricing goes, Unreal is free to use, but has a 5% royalty fee for every sale after $3,000 per quarter. If you're releasing on the Epic Games Store, that royalty fee is waived.

Godot

Godot is a free and open source game engine. It's built for both 2D and 3D games, and is a decent alternative to Unity and Unreal (the two biggest engines).

Godot supports quite a few languages. There's a visual scripting language, C++ support, C# support, and the option of GodotScript, their own language that has similar syntax to Python.

Godot's 2D support works in pixel coordinates, unlike Unity and Unreal that use floats to represent positions. Both have their perks, but absolute pixel coordinates will be better for most pixel art games. Normal maps and lighting is built in to the 2D system.

The 3D rendering uses a physically based rendering setup, so it's not lacking too much behind Unreal and Unity HDRP, and can still be used to make good-looking 3D games. The shader language is based in GLSL, so it should be easy to work with.

Godot is fully multiplatform, like Unity and Unreal, with support for iOS, Android, Windows, macOS, and Linux, as well as web support with HTML5 and WebAssembly.

Other Engines

There are plenty of other engines out there, especially 2D ones. Some are simply just libraries that provide rendering, such as LOVE and PyGame. If you really just want a way to draw stuff to the screen and don't care about much else, these types of engines can be useful.

GameMaker Studio and Cocos2D are both 2D engines with full editors. However, we don't recommend using these for more complicated projects, especially when the other engines have far more community support and backing. Godot would be a good alternative for 2D games.

The only other big 3D engine available for public use is CryEngine, which is currently being maintained as AWS Lumberyard.