LabHub

Blog

Game Engines in 2026 — A Deep Comparison of Godot 4.3, Unity, Bevy, Unreal 5.5, Defold, and Stride

2026-05-15 · 17 min read · #game-dev#godot#unity#bevy#unreal#defold#stride#raylib#libgdx#gamemaker#indie-game#deep-dive#english

한국어English日本語

Introduction: The Game Engine Map in 2026

Unity's September 2023 Runtime Fee announcement shook the indie game industry twice. Once with the announcement itself, and once again with the new ecosystem the departing developers built around the gap that Unity left. The policy was effectively reversed in April 2024, but the lesson stuck: once trust collapses, it doesn't snap back.

As of May 2026, the engine market roughly looks like this:

This piece walks through each engine's 2026 status, its strengths and honest limitations, and a decision framework for picking one. We close with a snapshot of how Korean and Japanese studios actually use these engines today.

1. The Unity Runtime Fee Disaster — What Actually Happened

September 2023: The Announcement

On September 12, 2023, Unity Technologies announced the Runtime Fee. The core of it:

  1. Once a game crossed a revenue/install threshold (Personal plan: USD 200,000 annual revenue plus 200,000 installs), Unity would charge a per-install fee.
  2. The policy would apply from January 1, 2024, and Unity would retroactively estimate past installs for already-shipped games.

Backlash was intense. Massive Monster (Cult of the Lamb), Innersloth (Among Us), and Mega Crit (Slay the Spire) all issued public statements. Several developers declared they would never build on Unity again. The real fear: piracy, reinstalls, and demo-booth instances might count as billable installs.

September to October 2023: Walk-Backs

Unity quickly issued partial corrections via Twitter (X): "Already shipped games are excluded", "One install per user only", "Personal plan won't be subject to the new policy". But the trust damage was done. CEO John Riccitiello stepped down in October 2023.

April 2024: Full Reversal

New CEO Matthew Bromberg announced on April 9, 2024 that the Runtime Fee was being fully canceled. To recover revenue, Pro and Enterprise plan prices went up 8 to 25 percent. The Personal plan remained free for users under USD 200,000 in annual revenue.

And Yet, Market Share Did Not Recover

itch.io statistics from 2024 showed Unity new-project share down more than 40 percent year over year, and Godot new-project share more than doubled in the same window (per itch.io statistics and the GDC 2024 Godot session). The cost of trust lost once is structurally high.

Lessons

2. Godot 4.3 — The New Indie Default

Where Godot Stands in 2026

Godot is an MIT-licensed open source game engine. It was the biggest winner of the 2024 Unity exodus. As of May 2026, the stable version is 4.3 with 4.4 in beta. Steam releases built on Godot rose from about 2 to 3 percent before the incident to roughly 8 percent (unofficial SteamDB estimates).

The 4.x Technical Leap

GDScript vs C# Choice

# GDScript: Python-like syntax, best-integrated with the engine
extends CharacterBody2D

@export var speed: float = 200.0
@export var jump_velocity: float = -400.0

func _physics_process(delta: float) -> void:
    if not is_on_floor():
        velocity.y += get_gravity().y * delta

    var direction := Input.get_axis("move_left", "move_right")
    velocity.x = direction * speed

    if Input.is_action_just_pressed("jump") and is_on_floor():
        velocity.y = jump_velocity

    move_and_slide()

// C#: same logic, with static types and stronger IDE support
using Godot;

public partial class Player : CharacterBody2D
{
    [Export] public float Speed = 200.0f;
    [Export] public float JumpVelocity = -400.0f;

    public override void _PhysicsProcess(double delta)
    {
        Vector2 velocity = Velocity;
        if (!IsOnFloor())
            velocity.Y += (float)(GetGravity().Y * delta);

        float direction = Input.GetAxis("move_left", "move_right");
        velocity.X = direction * Speed;

        if (Input.IsActionJustPressed("jump") && IsOnFloor())
            velocity.Y = JumpVelocity;

        Velocity = velocity;
        MoveAndSlide();
    }
}

Choice criteria:

Godot's Honest Limitations

3. Unreal Engine 5.5 — The AAA Default

Nanite, Lumen, MetaSounds

The three big UE5 features remain the differentiation point in 2026.

Blueprint vs C++

Unreal supports two ways of writing game logic.

// C++ AActor example
#include "MyCharacter.h"

AMyCharacter::AMyCharacter()
{
    PrimaryActorTick.bCanEverTick = true;
    GetCharacterMovement()->MaxWalkSpeed = 600.0f;
    GetCharacterMovement()->JumpZVelocity = 700.0f;
}

void AMyCharacter::MoveForward(float Value)
{
    if (Controller != nullptr && Value != 0.0f)
    {
        const FRotator Rotation = Controller->GetControlRotation();
        const FRotator YawRotation(0, Rotation.Yaw, 0);
        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
        AddMovementInput(Direction, Value);
    }
}

Blueprint expresses the same logic as a visual node graph. The 2026 norm is C++ plus Blueprint hybrid, where designers iterate fast in Blueprint and programmers refactor hotspots into C++.

Licensing — Epic Games Royalty

When It Fits

When It Does Not Fit

4. Bevy 0.15 — Rust ECS, Growing Fast Without an Editor

Identity

Bevy is a Rust-based data-oriented ECS (Entity Component System) game engine. Dual-licensed MIT or Apache 2.0. As of May 2026, 0.15 is the stable release; 1.0 has not yet shipped.

The ECS Paradigm

use bevy::prelude::*;

#[derive(Component)]
struct Player;

#[derive(Component)]
struct Velocity(Vec2);

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, spawn_player)
        .add_systems(Update, (movement_system, gravity_system))
        .run();
}

fn spawn_player(mut commands: Commands) {
    commands.spawn((
        Player,
        Velocity(Vec2::ZERO),
        Transform::default(),
    ));
}

fn movement_system(
    time: Res<Time>,
    mut query: Query<(&mut Transform, &Velocity), With<Player>>,
) {
    for (mut transform, velocity) in &mut query {
        transform.translation.x += velocity.0.x * time.delta_seconds();
        transform.translation.y += velocity.0.y * time.delta_seconds();
    }
}

ECS's strengths are cache efficiency from data-oriented design and automatic system parallelization. It excels at simulations, top-down shooters, and tower defense with tens of thousands of entities.

Strengths

Limitations

Who Uses It

5. GameMaker Studio 2 — The 2D Giant

Opera Ownership, Simplified Pricing

GameMaker was created by Mark Overmars in 1999, passed through YoYo Games, and was acquired by Opera Software in 2021. Since November 2022 the pricing model has been simplified: non-commercial use is free, desktop/mobile shipping is one-time or subscription, and consoles require separate licensing.

GML (GameMaker Language)

// Player Create event
hsp = 0;
vsp = 0;
grv = 0.5;
move_speed = 4;
jump_height = 10;

// Player Step event
var key_left = keyboard_check(vk_left);
var key_right = keyboard_check(vk_right);
var key_jump = keyboard_check_pressed(vk_space);

hsp = (key_right - key_left) * move_speed;
vsp += grv;

if (place_meeting(x, y + 1, obj_wall) && key_jump)
{
    vsp = -jump_height;
}

// Horizontal collision
if (place_meeting(x + hsp, y, obj_wall))
{
    while (!place_meeting(x + sign(hsp), y, obj_wall))
    {
        x += sign(hsp);
    }
    hsp = 0;
}
x += hsp;

GML reads like C mixed with JavaScript and is approachable for beginners. GameMaker 2026 supports both GML Visual (drag and drop) and GML Code.

Notable Releases

Strengths and Weaknesses

6. Defold — King-Owned, Optimized for Mobile 2D

Identity

Defold is a free 2D game engine owned by King (the Candy Crush studio). The source has been open since 2020 under a developer license with no revenue share. Mobile shipping is first class.

Lua-Based Workflow

-- player.script
function init(self)
    self.velocity = vmath.vector3()
    self.speed = 200
    self.gravity = -1000
    msg.post(".", "acquire_input_focus")
end

function update(self, dt)
    self.velocity.y = self.velocity.y + self.gravity * dt
    local pos = go.get_position()
    pos.x = pos.x + self.velocity.x * dt
    pos.y = pos.y + self.velocity.y * dt
    go.set_position(pos)
end

function on_input(self, action_id, action)
    if action_id == hash("left") then
        self.velocity.x = -self.speed
    elseif action_id == hash("right") then
        self.velocity.x = self.speed
    elseif action_id == hash("jump") and action.pressed then
        self.velocity.y = 500
    end
end

Strengths

Weaknesses

Notable Releases

7. Stride — Open Source C# Engine

Identity

Stride (formerly Xenko) was developed by Silicon Studio and donated to the .NET Foundation in 2018. MIT-licensed. C# only for game logic makes it the natural Unity alternative.

Code Example

using Stride.Engine;
using Stride.Core.Mathematics;

public class PlayerController : SyncScript
{
    public float Speed = 5.0f;

    public override void Update()
    {
        var deltaTime = (float)Game.UpdateTime.Elapsed.TotalSeconds;
        var direction = Vector3.Zero;

        if (Input.IsKeyDown(Stride.Input.Keys.W)) direction.Z -= 1;
        if (Input.IsKeyDown(Stride.Input.Keys.S)) direction.Z += 1;
        if (Input.IsKeyDown(Stride.Input.Keys.A)) direction.X -= 1;
        if (Input.IsKeyDown(Stride.Input.Keys.D)) direction.X += 1;

        if (direction.Length() > 0)
        {
            direction.Normalize();
            Entity.Transform.Position += direction * Speed * deltaTime;
        }
    }
}

Strengths and Weaknesses

8. raylib — Simple C Library, Beloved for Learning

Identity

raylib is a simple game programming library in C, created by Ramon Santamaria ("raysan5"). Licensed under zlib/libpng. Almost no dependencies. Since 2025, Raysan maintains it full-time via Patreon.

Hello World

#include "raylib.h"

int main(void)
{
    InitWindow(800, 450, "raylib basic example");
    SetTargetFPS(60);

    Vector2 ballPos = { 400, 225 };

    while (!WindowShouldClose())
    {
        if (IsKeyDown(KEY_RIGHT)) ballPos.x += 2;
        if (IsKeyDown(KEY_LEFT)) ballPos.x -= 2;
        if (IsKeyDown(KEY_UP)) ballPos.y -= 2;
        if (IsKeyDown(KEY_DOWN)) ballPos.y += 2;

        BeginDrawing();
            ClearBackground(RAYWHITE);
            DrawCircleV(ballPos, 30, MAROON);
            DrawText("Move the ball with arrow keys", 10, 10, 20, DARKGRAY);
        EndDrawing();
    }

    CloseWindow();
    return 0;
}

Who Uses It

Limitations

9. libGDX — Java/Kotlin, Still Going

libGDX is a Java game framework from 2009, maintained by Aurelien Ribon, Mario Zechner, and others. Apache 2.0 licensed. Desktop, Android, iOS (via RoboVM or MOE), and HTML5 (GWT) targets.

public class MyGdxGame extends ApplicationAdapter {
    private SpriteBatch batch;
    private Texture img;
    private Vector2 position;

    public void create() {
        batch = new SpriteBatch();
        img = new Texture("badlogic.jpg");
        position = new Vector2(100, 100);
    }

    public void render() {
        if (Gdx.input.isKeyPressed(Input.Keys.RIGHT)) position.x += 5;
        if (Gdx.input.isKeyPressed(Input.Keys.LEFT)) position.x -= 5;

        ScreenUtils.clear(0, 0, 0, 1);
        batch.begin();
        batch.draw(img, position.x, position.y);
        batch.end();
    }
}

Notable: Slay the Spire (Mega Crit Games, 2019), Overwhelmingly Positive on Steam, more than 15 million copies sold. The mod community still runs on libGDX in 2026. LibKTX has become the de facto Kotlin DSL standard.

10. LÖVE / Phaser / pygame — 2D Specialist Options

LÖVE 11.5 / 12.0 Beta (Lua)

function love.load()
    player = { x = 400, y = 300, speed = 200 }
end

function love.update(dt)
    if love.keyboard.isDown("right") then
        player.x = player.x + player.speed * dt
    elseif love.keyboard.isDown("left") then
        player.x = player.x - player.speed * dt
    end
end

function love.draw()
    love.graphics.rectangle("fill", player.x, player.y, 50, 50)
end

Phaser 3.80 / 4 Beta (TypeScript/JavaScript)

The number one framework for web games. Automatic WebGL to Canvas fallback, built-in Arcade and Matter physics, the default in the Steam-on-Web era.

pygame 2.6 (Python)

import pygame

pygame.init()
screen = pygame.display.set_mode((800, 600))
clock = pygame.time.Clock()
player = pygame.Rect(400, 300, 50, 50)

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]: player.x -= 5
    if keys[pygame.K_RIGHT]: player.x += 5

    screen.fill((0, 0, 0))
    pygame.draw.rect(screen, (255, 0, 0), player)
    pygame.display.flip()
    clock.tick(60)

pygame.quit()

11. Engine Usage in Korea and Japan

Korea

Japan

12. What to Pick — Decision Matrix

Project typeFirst choiceSecond choiceNotes
AAA 3D open worldUnreal 5.5In-houseLumen/Nanite
Indie 3DGodot 4.3Unity 6Godot consoles via W4 Games
Indie 2D pixel artGodot 4.3GameMakerBoth excellent
Mobile casual 2DDefoldUnityBuild size favors Defold
Mobile midcoreUnityCocos CreatorAds/IAP integration
Web/browserPhaserConstruct 3Bevy WASM also viable
Learning/hobbyraylibLÖVE / pygameSimplicity
Simulation-heavyBevy 0.15Unity (DOTS)Rust ECS
Cinematic adventureUnreal 5.5UnitySequencer/MetaHuman
Solo RPGGodotRPG Maker MZGDScript fast iteration

By Team Size

By Budget

By Platform

Closing: The Engine Landscape in 2026 Is Multipolar

Before September 2023, the answer to "what engine should I use as an indie?" was nearly automatic: Unity. In May 2026 the answer is more complex. That is a good thing. The market is no longer hostage to one company's policy changes.

Three criteria for choosing:

  1. Genre and platform of the game: 2D pixel goes Godot/GameMaker; AAA 3D goes Unreal; simulation goes Bevy.
  2. Existing team skills: C# leans Unity/Stride; Rust leans Bevy; designer-friendly leans GameMaker.
  3. License and governance stability: Open source (Godot/Bevy/Stride) is structurally less exposed to license changes.

The engine is not the game. Finishing the game matters 100 times more than picking the engine. But if you plan to spend a year or more on the project, the three criteria above deserve another 30 minutes of thought.

References

Comments

No comments yet.

Sign in to leave a comment