Skip to content
←

Split View: 게임 엔진 2026 — Godot 4.3 / Unity / Bevy / Unreal 5.5 / Defold / Stride 비교 심층 가이드

|

게임 엔진 2026 — Godot 4.3 / Unity / Bevy / Unreal 5.5 / Defold / Stride 비교 심층 가이드

들어가며: 2026년의 게임 엔진 지도

2023년 9월 Unity의 런타임 수수료 발표는 인디 게임 업계를 두 번 흔들었습니다. 한 번은 발표 그 자체로, 또 한 번은 발표 이후 떠나간 개발자들이 만들어낸 새 흐름으로. 2024년 4월 정책이 거의 전면 철회되었지만, 신뢰는 한 번 무너지면 쉽게 복구되지 않는다는 사실이 산업 전체에 각인되었습니다.

2026년 5월 현재 게임 엔진 시장은 대략 다음과 같이 구분됩니다.

  • AAA 지배자: Unreal Engine 5.5 (Nanite, Lumen, MetaSounds)
  • 인디 새 표준: Godot 4.3 (Vulkan/Metal, GDScript/C#)
  • 신흥 강자: Bevy 0.15 (Rust ECS, 에디터 없음에도 성장)
  • 2D 거인: GameMaker Studio 2, Defold, LÖVE
  • 틈새 강력자: Stride (C#), raylib (C), libGDX (Java/Kotlin)
  • 웹/모바일 특화: Phaser, pygame

이 글은 각 엔진의 2026년 현재 상태, 강점과 한계, 그리고 "어떤 프로젝트에 무엇을 골라야 하는가"를 정리합니다. 한국·일본 게임사의 실제 사용 현황도 마지막에 담았습니다.

1. Unity 런타임 수수료 사태 — 무슨 일이 있었나

2023년 9월: 발표

2023년 9월 12일, Unity Technologies는 "Runtime Fee"를 발표했습니다. 골자는 두 가지였습니다.

  1. 게임이 일정 매출/설치 수 기준선(Personal 플랜: 연 매출 USD 200,000 + 200,000회 설치)을 넘으면 설치당 수수료가 부과된다.
  2. 2024년 1월 1일부터 적용되며, 이미 출시된 게임의 과거 설치까지 소급 추정할 수 있다.

업계 반응은 격렬했습니다. Cult of the Lamb 개발사 Massive Monster, Among Us의 Innersloth, Mega Crit(Slay the Spire)이 공개 비판 성명을 냈고, 일부는 "Unity로는 다시는 만들지 않겠다"고 선언했습니다. 해킹/리인스톨/시연 부스 데모로도 과금 위험이 있다는 점이 핵심 문제였습니다.

2023년 9월~10월: 수정 발표

발표 직후 Unity는 트위터(X)를 통해 "이미 출시된 게임은 제외", "한 사용자 당 한 번만 카운트", "Personal 플랜은 새 정책 적용 안 함" 등 여러 수정 사항을 단계적으로 발표했습니다. 하지만 신뢰는 이미 깨졌고, John Riccitiello CEO는 2023년 10월 사임했습니다.

2024년 4월: 정책 철회

새 CEO Matthew Bromberg는 2024년 4월 9일, 런타임 수수료 정책 전면 철회를 발표했습니다. 대신 Pro/Enterprise 가격을 8~25% 인상하는 방식으로 매출을 보전했습니다. Personal 플랜은 사실상 무료(연 매출 USD 200,000 미만)로 유지되었습니다.

그러나 시장 점유율은 회복되지 않았다

itch.io의 2024년 통계에 따르면 Unity 신규 프로젝트 비율은 사태 이전 대비 40% 이상 감소했고, Godot 신규 프로젝트는 같은 기간 2배 이상 증가했습니다 (수치는 itch.io 공식 통계 및 GDC 2024 Godot 세션 발표 기준). 한 번 잃은 신뢰의 비용은 그만큼 큽니다.

교훈

  • EULA 변경 소급 적용 리스크: 엔진 라이선스를 고를 때 "이 회사는 한 번 정한 약속을 깰 수 있는가?"가 핵심 질문이 되었습니다.
  • 오픈 소스의 가치 재발견: Godot, Bevy, Stride 같은 오픈 소스 엔진은 라이선스 자체가 MIT/Apache이고, 포크 가능합니다.
  • 다중 엔진 역량의 가치: 한 엔진에만 묶인 스튜디오는 가격/정책 변경 리스크에 노출됩니다.

2. Godot 4.3 — 인디 게임의 새 표준

2026년의 위치

Godot은 MIT 라이선스의 오픈 소스 게임 엔진입니다. 2024년의 Unity 이탈로 가장 큰 수혜를 본 엔진이고, 2026년 5월 기준 안정 버전은 4.3, 4.4 베타가 진행 중입니다. Steam 출시 게임 중 Godot로 만들어진 비율은 사태 이전 2~3%대에서 2026년 8% 수준까지 상승했습니다 (SteamDB 비공식 추정).

4.x 시리즈의 기술적 도약

  • Vulkan 렌더러 (Forward+, Mobile, Compatibility): 4.0 이전의 OpenGL ES 기반에서 Vulkan으로 완전히 재작성. Metal 백엔드도 macOS/iOS용으로 정식 지원.
  • 2D 전용 렌더러: 3D와 분리된 별도 2D 파이프라인. 픽셀 퍼펙트, 2D 라이트, 노멀 맵 지원 강화.
  • GDScript 2.0: 정적 타입, async/await, lambda, signal 개선.
  • C# 지원 (.NET 8): Mono 의존성 제거하고 .NET 6 → 8 마이그레이션 완료.
  • GDExtension: C++로 네이티브 확장을 컴파일하는 방식. 엔진 재컴파일 없이 동적 로딩.

GDScript vs C# 선택

# GDScript: Python 같은 문법, 엔진과 가장 잘 통합됨
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#: 같은 로직, 정적 타입과 더 강한 IDE 지원
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();
    }
}

선택 기준:

  • 2D, 빠른 프로토타이핑, 소규모 팀: GDScript
  • 기존 C# 경험, 정적 타입 선호, 대규모 코드베이스: C#
  • 모바일 빌드 크기: GDScript가 더 작음 (C#은 .NET 런타임 동봉)

Godot의 한계 (정직하게)

  • AAA 3D 그래픽: Lumen/Nanite 같은 최첨단 기능 없음. PBR과 GI는 지원하나 Unreal 수준은 아님.
  • 콘솔 포팅: 공식 지원 없음. W4 Games(Godot 핵심 개발자들의 회사)가 상용 콘솔 SDK를 제공.
  • 에셋 스토어: Unity Asset Store에 비해 빈약. 다만 GitHub와 itch.io에 무료 에셋 풍부.
  • 모바일 광고/IAP: Unity의 통합 수준이 아님. 서드파티 GDExtension 사용.

3. Unreal Engine 5.5 — AAA의 디폴트

Nanite, Lumen, MetaSounds

UE5의 3대 기능은 2026년에도 여전히 차별화 포인트입니다.

  • Nanite: 가상화된 마이크로 폴리곤 지오메트리. LOD를 사실상 자동화하여, 영화 품질 에셋을 그대로 사용 가능.
  • Lumen: 실시간 전역 조명. 빛 베이크 없이 다이내믹 GI/리플렉션.
  • MetaSounds: 노드 기반 절차적 오디오. 사운드 디자이너의 워크플로우를 코드에 의존하지 않고 구현.
  • 5.5 신규: MetaHuman Animator 개선, Sequencer Curves UI 재작업, Niagara 시뮬레이션 최적화, World Partition + DataLayers 안정화.

Blueprint vs C++

Unreal은 두 가지 방식으로 게임 로직을 작성합니다.

// C++ AActor 예시
#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는 비주얼 스크립팅으로 같은 로직을 노드 그래프로 표현합니다. 2026년 트렌드는 C++ + Blueprint 혼합이 표준이고, 디자이너가 Blueprint로 빠르게 반복하고 프로그래머가 핫스팟을 C++로 리팩토링하는 방식이 정착됐습니다.

라이선스 — Epic Games Royalty

  • 분기 매출 USD 1,000,000 미만: 무료.
  • 그 이상: 매출의 5%.
  • Epic Games Store 출시: 로열티 면제.
  • 비게임 분야 (영화, 자동차 비주얼라이제이션 등): 별도 시트 라이선스.

적합한 프로젝트

  • AAA 3D 게임 (오픈월드, 슈터, RPG)
  • 시네마틱 큐 신이 핵심인 어드벤처
  • 비주얼 충실도가 매출의 핵심 차별화 포인트인 작품
  • VR 헤드셋 타깃 작품 (Lumen/Nanite + OpenXR)

부적합한 프로젝트

  • 2D 픽셀 아트 게임 (가능하지만 엔진의 진가가 안 살아남)
  • 모바일 캐주얼 (빌드 크기, 빌드 시간)
  • 1인 개발자 작품 (에디터 학습 곡선)

4. Bevy 0.15 — Rust ECS, 에디터 없이도 무서운 성장세

정체성

Bevy는 Rust로 작성된 데이터 지향 ECS(Entity Component System) 게임 엔진입니다. 듀얼 라이선스(MIT 또는 Apache 2.0). 2026년 5월 기준 0.15가 안정 버전이며, 1.0은 아직 발표 전입니다.

ECS 패러다임

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의 장점은 데이터 지향 설계로 인한 캐시 효율성과 시스템의 자동 병렬화입니다. 수만 개 엔티티를 다루는 시뮬레이션, 탑다운 슈터, 타워 디펜스에 강력합니다.

강점

  • Rust의 메모리 안전성: 컴파일 타임에 데이터 레이스 차단.
  • 모듈러 플러그인 시스템: 엔진 자체가 플러그인의 집합. 필요 없는 건 빼면 됨.
  • 빠른 컴파일 옵션: dynamic linking 모드와 mold linker 조합으로 1초대 인크리멘털 빌드.
  • WebAssembly 지원: wasm 빌드 1급 시민.

한계

  • 에디터 없음: 2026년 5월 현재 공식 GUI 에디터는 알파/실험 단계. 모든 것이 코드로.
  • 하위 호환성: 0.x 시리즈는 마이너 업데이트마다 breaking changes 빈번.
  • 3D 그래픽 성숙도: 기본 PBR은 있으나 Lumen/Nanite급 기능은 없음.
  • 에셋 파이프라인: glTF 위주, FBX는 변환 필요.

누가 쓰는가

  • 시뮬레이션 헤비 게임 (콜로니 시뮬, RTS, RPG-likes)
  • Rust 백엔드 개발자가 게임을 만들 때
  • 기술적 호기심이 강한 개인 개발자
  • Tiny Glade(Pounce Light)는 Bevy의 일부 기능을 차용 (자체 엔진 + Bevy 컴포넌트)

5. GameMaker Studio 2 — 2D 거인

Opera 소유, 가격 모델 단순화

GameMaker는 1999년 Mark Overmars가 만든 후 YoYo Games를 거쳐 2021년 Opera Software가 인수했습니다. 2022년 11월부터 가격 모델이 단순화되어, 비상업적 사용은 무료, 데스크톱/모바일 출시는 일회성 또는 구독, 콘솔은 별도 라이선스입니다.

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은 C와 JavaScript를 섞은 듯한 문법으로, 초보자에게 친숙합니다. 2026년 GameMaker는 GML 비주얼(드래그앤드롭)과 GML 코드 모두 지원합니다.

대표작

  • Undertale (Toby Fox, 2015) — GameMaker의 명성을 견인한 결정적 작품.
  • Hotline Miami (Dennaton Games, 2012)
  • Hyper Light Drifter (Heart Machine, 2016)
  • Forager (HopFrog, 2019)
  • Nuclear Throne (Vlambeer, 2015)

강점/약점

  • 강점: 2D 워크플로우가 압도적으로 빠름. 스프라이트 → 오브젝트 → 룸의 흐름이 직관적.
  • 약점: 3D는 사실상 지원 안 함. 콘솔 라이선스 별도 구매 필요. GML이 다른 언어로 전환되지 않음 (커리어 종속성).

6. Defold — King 소유, 모바일 2D 최적

정체성

Defold는 Candy Crush의 King이 소유한 무료 2D 게임 엔진입니다. 2020년부터 소스 공개(개발자 라이선스, 수익 셰어 없음). 모바일 출시가 1급 시민입니다.

Lua 기반 워크플로우

-- 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

강점

  • 빌드 크기: 모바일 빌드가 매우 작음 (Hello World 약 1MB대).
  • 즉시 핫 리로드: 코드 변경이 실행 중인 게임에 바로 반영.
  • 크로스플랫폼: iOS, Android, HTML5, Switch, PS4, PS5, Xbox.
  • 수익 셰어 없음: 어느 매출 구간에서도 로열티 없음.

약점

  • Lua만 지원: C#/C++ 직접 사용 불가 (네이티브 익스텐션 가능).
  • 3D 약함: 가능하나 활용 사례 거의 없음.
  • 에디터 폐쇄형: 엔진 자체는 오픈 소스이나 개발 라이선스 동의 필요.

대표작

  • Family Island (Melsoft Games)
  • Petsville (King 내부 타이틀)
  • 인디 모바일 퍼즐/캐주얼 게임 다수

7. Stride — 오픈 소스 C# 엔진

정체성

Stride(구 Xenko)는 Silicon Studio가 개발하여 2018년 .NET Foundation으로 이관한 오픈 소스 게임 엔진입니다. 라이선스는 MIT. C#만으로 게임을 만든다는 Unity 개발자의 자연스러운 대안입니다.

코드 예시

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;
        }
    }
}

강점/약점

  • 강점: Unity와 유사한 컴포넌트 + 엔티티 모델. C# 친화적. 무료 + 오픈 소스.
  • 약점: 커뮤니티 규모가 작아 자료 부족. 모바일 지원이 약함. 콘솔 포팅 직접 작업 필요.
  • 적합: 데스크톱 PC 3D 게임을 C#으로 만드는 1~5인 팀.

8. raylib — C 언어 학습 게임 라이브러리

정체성

raylib은 Ramon Santamaria("raysan5")가 만든 C로 작성된 단순한 게임 프로그래밍 라이브러리입니다. 라이선스 zlib/libpng. 의존성 거의 없음. 2025년부터 Raysan이 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;
}

누가 쓰는가

  • 게임 개발 입문자 (C 학습 + 즉시 시각적 피드백)
  • 작은 툴/유틸리티 (에디터, 시각화 도구)
  • 게임잼 단기 작품
  • Cogmind의 Grid Sage Games, Cataclysm: Bright Nights 일부 모드
  • 2024년 GMTK Jam 최다 사용 비-Unity 도구 중 하나

한계

  • 엔진이 아니라 라이브러리: 씬 그래프, 에디터, 에셋 파이프라인 모두 직접 구축.
  • 대규모 프로젝트에는 부적합.

9. libGDX — Java/Kotlin, 여전히 살아있다

libGDX는 2009년에 시작된 Java 기반 게임 프레임워크입니다. Aurelien Ribon, Mario Zechner 등이 메인테인. Apache 2.0 라이선스. 데스크톱, 안드로이드, iOS(RoboVM 또는 MOE), HTML5(GWT) 빌드.

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();
    }
}

대표작: Slay the Spire (Mega Crit Games, 2019) — Steam 평점 압도적 긍정, 1500만 카피 이상. 2026년에도 모드 커뮤니티가 libGDX 위에서 동작합니다. Kotlin DSL 지원으로 LibKTX가 사실상의 표준이 되었습니다.

10. LÖVE / Phaser / pygame — 2D 전문 옵션들

LÖVE 11.5 / 12.0 베타 (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
  • 라이선스: zlib
  • 강점: 극단적 단순함, Lua의 학습 곡선, 단일 .love 파일 배포
  • 약점: 모바일 빌드는 직접 (love-android, love-ios), 콘솔 미지원
  • 대표작: Balatro (LocalThunk, 2024) — Lua + LÖVE로 만든 2024년 GOTY 후보, 500만 카피 이상

Phaser 3.80 / 4 베타 (TypeScript/JavaScript)

웹 게임 1위 프레임워크. WebGL/Canvas 자동 폴백, Arcade/Matter 물리 엔진 내장, Steam-on-Web 시대의 디폴트.

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)가 사실상의 메인스트림. 2.6 기준 SDL3 전환 진행 중.
  • 교육용/프로토타입용으로 압도적, 상업 출시는 드뭄.

11. 한국·일본의 게임 엔진 사용 현황

한국

  • 넥슨: 자체 엔진(MSL, Aurora) + Unreal + 일부 모바일 타이틀에 Unity. KartRider Drift는 Unreal 4.
  • 넷마블: Unity 비중 높음. 세븐나이츠 시리즈 등. 일부 Unreal 도입 (니노쿠니 크로스 월즈).
  • 스마일게이트: 로스트아크는 자체 엔진, 크로스파이어는 Unreal, 모바일 라인 Unity.
  • 펄어비스: 검은사막 자체 엔진(Black Desert Engine), Crimson Desert 2026 출시 임박.
  • 카카오게임즈: 퍼블리싱 위주, 개발사별 상이 (오딘은 Unreal 4, 아키에이지 워는 자체).
  • 시프트업: Unreal Engine 5 (스텔라 블레이드, 승리의 여신: 니케 일부).

일본

  • Cygames: Granblue Fantasy Relink는 자체 엔진, Princess Connect는 Unity, Project Awakening 보류.
  • CyberAgent (CA Game): Unity가 압도적 다수.
  • Capcom: RE Engine 자체 엔진 (몬스터헌터 와일즈, RE4 리메이크, 스트리트 파이터 6).
  • Square Enix: Luminous Engine, Crystal Tools 등 자체 + Unreal/Unity 혼용. FFXVI는 자체.
  • FromSoftware: 자체 엔진. Elden Ring DLC, Armored Core VI.
  • 닌텐도: 1st 파티는 자체 엔진(Splatoon, Zelda 자체), 2nd/3rd 파티는 Unity/Unreal.
  • Konami: eFootball은 Unreal 5로 전환 완료.
  • Sega: Yakuza/Like a Dragon은 Ryu Ga Gotoku 자체 엔진, 모바일은 Unity.

인디 트렌드

  • 한국 인디: Unity → Godot 이동이 가시화 (BIC 페스티벌 2024~2025 신규 출품작 통계).
  • 일본 인디: GameMaker, Unity, Godot 혼재. RPGツクール(RPG Maker)도 여전히 유효.

12. 무엇을 선택할까 — 의사결정 표

프로젝트 유형1순위2순위비고
AAA 3D 오픈월드Unreal 5.5자체 엔진Lumen/Nanite
인디 3DGodot 4.3Unity 6Godot 콘솔은 W4 Games
인디 2D 픽셀 아트Godot 4.3GameMaker둘 다 우수
모바일 캐주얼 2DDefoldUnity빌드 크기는 Defold
모바일 미드코어UnityCocos Creator광고/IAP 통합
웹/브라우저 게임PhaserConstruct 3Bevy WASM도 옵션
학습/취미raylibLÖVE / pygame단순함
시뮬레이션 헤비Bevy 0.15Unity (DOTS)Rust ECS
시네마틱 어드벤처Unreal 5.5UnitySequencer/MetaHuman
1인 개발 RPGGodotRPG Maker MZGDScript 빠른 반복

팀 규모 기준

  • 1명: raylib, LÖVE, pygame, Godot, GameMaker
  • 2~5명: Godot, Unity 6, Stride, Bevy
  • 5~20명: Unity 6, Unreal 5.5, 자체 엔진
  • 20명 이상: Unreal 5.5, 자체 엔진

예산 기준

  • 무료/오픈소스 우선: Godot, Bevy, Stride, raylib, libGDX, LÖVE, Phaser, pygame, Defold
  • 로열티 OK (성공 시): Unreal (5% over USD 1M/quarter), Unity (subscription)
  • 일회성 라이선스: GameMaker

플랫폼 기준

  • 데스크톱 PC: 모두
  • 모바일: Unity, Defold, Godot, Unreal, GameMaker
  • 콘솔 (PS5/Xbox/Switch): Unreal, Unity, Defold, GameMaker (각 콘솔 SDK 별도)
  • 웹 (HTML5/WebAssembly): Phaser, Bevy, Godot (실험적), Unity (제한적)
  • VR: Unreal 5.5 (OpenXR), Unity, Godot (XR 플러그인)

마치며: 2026년의 게임 엔진은 다극화되었다

2023년 9월 이전, 인디 개발자에게 "어떤 엔진을 쓰면 되나"라는 질문의 답은 거의 자동이었습니다: Unity. 2026년 5월의 답은 훨씬 복잡합니다. 그게 좋은 일입니다. 시장이 한 회사의 정책 변경에 인질로 잡히지 않는다는 뜻이니까요.

선택의 기준은 결국 세 가지입니다.

  1. 만들려는 게임의 장르와 플랫폼: 2D 픽셀이면 Godot/GameMaker, AAA 3D면 Unreal, 시뮬이면 Bevy.
  2. 팀의 기존 역량: C#이면 Unity/Stride, Rust면 Bevy, 디자이너 친화면 GameMaker.
  3. 라이선스/거버넌스의 안정성: 오픈 소스(Godot/Bevy/Stride)는 라이선스 변경 리스크가 구조적으로 낮음.

엔진은 게임이 아닙니다. 게임을 끝내는 것이 엔진을 고르는 것보다 100배 중요합니다. 단, 1년 넘게 매달릴 작품이라면 위 세 기준에 30분만 더 투자할 가치가 있습니다.

참고 / References

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

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