Skip to content
←

✍️ 필사 모드: Game Engines in 2026 — A Deep Comparison of Godot 4.3, Unity, Bevy, Unreal 5.5, Defold, and Stride

English
0%
정확도 0%
💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

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:

  • AAA incumbent: Unreal Engine 5.5 (Nanite, Lumen, MetaSounds)
  • New indie default: Godot 4.3 (Vulkan/Metal, GDScript/C#)
  • Rising star: Bevy 0.15 (Rust ECS, growing despite no editor)
  • 2D giants: GameMaker Studio 2, Defold, LÖVE
  • Niche but strong: Stride (C#), raylib (C), libGDX (Java/Kotlin)
  • Web/mobile specialists: Phaser, pygame

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

  • EULA-change-retroactive risk: When picking a licensed engine, the question "can this vendor unilaterally change the terms?" became a first-class concern.
  • Rediscovery of open source value: Godot, Bevy, and Stride all carry MIT or Apache licenses and are forkable.
  • Multi-engine competence: A studio that bets everything on one engine is exposed to price/policy shifts.

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

  • Vulkan renderer (Forward+, Mobile, Compatibility): A full rewrite from the OpenGL ES base of pre-4.0. Metal backend officially supported for macOS and iOS.
  • Dedicated 2D renderer: Separate 2D pipeline from 3D. Pixel-perfect mode, 2D lighting, normal map support.
  • GDScript 2.0: Static typing, async/await, lambdas, improved signals.
  • C# support (.NET 8): Mono dependency removed, .NET 6 to 8 migration completed.
  • GDExtension: Native C++ extensions compile dynamically, no engine recompile needed.

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:

  • 2D, rapid prototyping, small team: GDScript
  • Existing C# experience, static types, larger codebase: C#
  • Mobile build size: GDScript wins (C# ships with the .NET runtime).

Godot's Honest Limitations

  • AAA 3D: No Lumen/Nanite-class features. PBR and GI exist but not at Unreal's level.
  • Console porting: No official support. W4 Games (founded by core Godot developers) sells commercial console SDKs.
  • Asset store: Sparse compared to Unity Asset Store. GitHub and itch.io fill the gap with free assets.
  • Mobile ads/IAP: Not as deeply integrated as Unity. Third-party GDExtensions handle it.

3. Unreal Engine 5.5 — The AAA Default

Nanite, Lumen, MetaSounds

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

  • Nanite: Virtualized micro-polygon geometry. LOD is essentially automatic; cinema-quality assets can be used directly.
  • Lumen: Real-time global illumination. Dynamic GI and reflections without lightmap bakes.
  • MetaSounds: Node-based procedural audio. Sound designers can work without code dependency.
  • 5.5 additions: MetaHuman Animator improvements, Sequencer Curves UI rework, Niagara simulation optimizations, World Partition with DataLayers stabilized.

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

  • Under USD 1,000,000 quarterly revenue: free.
  • Above that: 5 percent of revenue.
  • Epic Games Store release: royalty waived.
  • Non-game uses (film, automotive viz): separate seat licensing.

When It Fits

  • AAA 3D games (open world, shooters, RPGs)
  • Cinematic-heavy adventure titles
  • Projects where visual fidelity is the differentiation
  • VR headset titles (Lumen/Nanite plus OpenXR)

When It Does Not Fit

  • 2D pixel art games (possible but the engine's strengths go unused)
  • Mobile casual (build size, build time)
  • Solo developer projects (steep editor learning curve)

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

  • Rust memory safety: Data races caught at compile time.
  • Modular plugin system: The engine itself is a stack of plugins. Drop what you do not need.
  • Fast compile options: Dynamic linking plus mold linker delivers sub-second incremental builds.
  • WebAssembly is first class: wasm builds work out of the box.

Limitations

  • No editor: As of May 2026, the official GUI editor is alpha/experimental. Everything is code.
  • Backward compatibility: 0.x minor releases ship frequent breaking changes.
  • 3D maturity: Standard PBR exists but no Lumen/Nanite-equivalent.
  • Asset pipeline: glTF-first, FBX needs conversion.

Who Uses It

  • Simulation-heavy games (colony sims, RTS, RPG-likes)
  • Rust backend developers building games
  • Technically curious solo developers
  • Tiny Glade (Pounce Light) used Bevy components in their custom engine

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

  • Undertale (Toby Fox, 2015) — the breakout title that cemented GameMaker's reputation.
  • Hotline Miami (Dennaton Games, 2012)
  • Hyper Light Drifter (Heart Machine, 2016)
  • Forager (HopFrog, 2019)
  • Nuclear Throne (Vlambeer, 2015)

Strengths and Weaknesses

  • Strengths: 2D workflow speed is unmatched. Sprite to Object to Room flow is intuitive.
  • Weaknesses: No real 3D. Console licensing is separate. GML does not transfer to other ecosystems (career lock-in).

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

  • Build size: Tiny mobile builds (Hello World around 1 MB).
  • Instant hot reload: Code changes apply to the running game live.
  • Cross-platform: iOS, Android, HTML5, Switch, PS4, PS5, Xbox.
  • No revenue share: No royalty at any revenue level.

Weaknesses

  • Lua only: No direct C# or C++ (native extensions are possible).
  • 3D is weak: Possible but rarely used.
  • Closed editor: Engine is open source, but developer license agreement required.

Notable Releases

  • Family Island (Melsoft Games)
  • Petsville (King internal title)
  • Many indie mobile puzzle and casual games

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

  • Strengths: Unity-like component plus entity model. C#-friendly. Free and open source.
  • Weaknesses: Small community, so fewer learning resources. Mobile support is weak. Console porting is custom work.
  • Best fit: 1 to 5 person team shipping a desktop PC 3D game in C#.

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

  • Game-dev learners (C learning plus immediate visual feedback)
  • Small tools and utilities (editors, visualization tools)
  • Game jam entries
  • Cogmind (Grid Sage Games) tooling, Cataclysm: Bright Nights mods
  • One of the most-used non-Unity tools in the 2024 GMTK Jam

Limitations

  • It is a library, not an engine: scene graph, editor, asset pipeline all need to be built.
  • Not a fit for large projects.

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
  • License: zlib
  • Strengths: Extreme simplicity, gentle Lua learning curve, single .love file distribution
  • Weaknesses: Mobile builds are DIY (love-android, love-ios), no console
  • Notable: Balatro (LocalThunk, 2024) — built in Lua and LÖVE, 2024 GOTY contender, more than 5 million copies sold.

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()
  • pygame-ce (Community Edition) is the de facto mainstream. 2.6 is mid-migration to SDL3.
  • Dominant for education and prototypes, rare in commercial releases.

11. Engine Usage in Korea and Japan

Korea

  • Nexon: In-house engines (MSL, Aurora) plus Unreal, and Unity for some mobile titles. KartRider Drift runs on Unreal 4.
  • Netmarble: Heavy on Unity (Seven Knights series). Some Unreal adoption (Ni no Kuni Cross Worlds).
  • Smilegate: Lost Ark uses an in-house engine, Crossfire on Unreal, mobile lines on Unity.
  • Pearl Abyss: Black Desert runs on the proprietary Black Desert Engine. Crimson Desert ships in 2026.
  • Kakao Games: Mostly publishing; varies by studio (Odin on Unreal 4, Archeage War on in-house).
  • Shift Up: Unreal Engine 5 (Stellar Blade; portions of Goddess of Victory: Nikke).

Japan

  • Cygames: Granblue Fantasy Relink on in-house engine, Princess Connect on Unity, Project Awakening shelved.
  • CyberAgent (CA Game): Unity dominant.
  • Capcom: RE Engine in-house (Monster Hunter Wilds, RE4 Remake, Street Fighter 6).
  • Square Enix: Luminous Engine, Crystal Tools, and others mixed with Unreal/Unity. FFXVI used in-house.
  • FromSoftware: In-house engine. Elden Ring DLC, Armored Core VI.
  • Nintendo: First party uses in-house engines (Splatoon, Zelda), second/third party often Unity or Unreal.
  • Konami: eFootball has completed its move to Unreal 5.
  • Sega: Yakuza/Like a Dragon on Ryu Ga Gotoku engine, mobile on Unity.

Indie Trends

  • Korean indies: visible Unity to Godot movement (BIC festival 2024 and 2025 submission stats).
  • Japanese indies: mixed across GameMaker, Unity, and Godot. RPG Maker still relevant.

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

  • Solo: raylib, LÖVE, pygame, Godot, GameMaker
  • 2 to 5: Godot, Unity 6, Stride, Bevy
  • 5 to 20: Unity 6, Unreal 5.5, in-house
  • 20 and up: Unreal 5.5, in-house

By Budget

  • Free/open source first: Godot, Bevy, Stride, raylib, libGDX, LÖVE, Phaser, pygame, Defold
  • Royalty on success: Unreal (5 percent over USD 1M/quarter), Unity (subscription tiers)
  • One-time license: GameMaker

By Platform

  • Desktop PC: All
  • Mobile: Unity, Defold, Godot, Unreal, GameMaker
  • Console (PS5/Xbox/Switch): Unreal, Unity, Defold, GameMaker (each console SDK separately)
  • Web (HTML5/WebAssembly): Phaser, Bevy, Godot (experimental), Unity (limited)
  • VR: Unreal 5.5 (OpenXR), Unity, Godot (XR plugin)

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

현재 단락 (1/386)

Unity's September 2023 Runtime Fee announcement shook the indie game industry twice. Once with the a...

작성 글자: 0자원문 글자: 19,941자작성 단락: 0/386