Open Source Game Engines 2026 Deep Dive — Godot 4.4, Defold, Bevy, GameMaker LTS, Phaser, Construct 3, Stride, PixiJS, LÖVE, Cocos, O3DE

The Unity runtime fee announcement of September 2023 split the game industry into a before and after. The policy was retracted in days, but ever since, indie developers cannot stop thinking about "what besides Unity." By May 2026, Godot 4.4 powers roughly 12% of new Steam releases, Bevy reached version 0.16 and is now a serious ECS engine, and Defold, GameMaker, and Phaser hold their respective niches firmly.

This article maps the open source game engine landscape as of May 2026 — engine-by-engine characteristics, build targets, the Korean and Japanese indie scenes, real shipped titles, and the trade-offs versus Unity 6 and Unreal 5.5.

1. Why Open Source Game Engines — Life After the Unity Runtime Fee

The September 2023 Unity runtime fee saga rewired the political landscape of game engines. The proposal to charge $0.20 per install was retracted within days after a near-revolt by the indie community, but during that week Godot's Patreon backers quadrupled and Defold's downloads doubled. Throughout 2024 and 2025 you kept hearing the phrase "insurance learning" — main projects still go on Unity, but side projects are run on open source engines just in case.

The appeal of open source engines is not just zero cost. Under MIT or Apache 2.0 there is no license-fee or revenue dispute at all, you can fork or modify the engine itself, and except for the closed console SDKs, every line of code is auditable on GitHub. The biggest value to a studio is the safety net: if the engine company goes under, your team can keep maintaining the engine in-house.

2. Godot 4.4 / 4.5 — The De Facto Open Source Standard

Godot is an MIT-licensed engine started in 2014 by Argentine developers Juan Linietsky and Ariel Manzur. The 4.0 release in 2023 introduced a Vulkan renderer and a Forward+ pipeline, finally earning the "yes, real 3D now" verdict. As of May 2026 the 4.4 stable line and a 4.5 beta run side by side. A huge advantage for indie collaboration is that the core scene files (*.tscn) are plain text — Git diffs actually work.

The primary scripting language is GDScript, with C# (via .NET 8), C++/Rust through GDExtension, and the official visual scripting introduced in the 4.x line. GDScript is a Python-flavored dynamically typed language with smooth IDE integration and hot reload.

extends Node2D

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

func _physics_process(delta: float) -> void:
    var direction = Input.get_axis("ui_left", "ui_right")
    velocity.x = direction * speed
    if Input.is_action_just_pressed("ui_up") and is_on_floor():
        velocity.y = jump_velocity
    move_and_slide()

The scene graph is a simple parent-child tree of Node, Node2D, Node3D, and signals are a first-class event system that decouples components. Android (NDK) and iOS builds are supported, web builds ship via WebAssembly plus WebGL 2 or WebGPU (beta). Console builds for Switch, PS5, and Xbox require a commercial license through the W4 Games partner.

3. Godot W4 Games — The Commercial Publishing Arm

W4 Games was founded in 2022 by several Godot core members to fill in the commercial infrastructure around the engine. They offer paid console porting kits, a multiplayer backend (W4 Cloud), and QA tooling. In 2025 they officially announced licensed build pipelines for Nintendo Switch and Sony PlayStation 5. For indies this "engine open source, console builds via a commercial partner" split is a sensible governance model.

W4's fundraising — an $8.5M seed in 2023 and a Series A in 2025 — is frequently cited as proof that open source game engines can develop sustainable business models. Developers can keep using Godot as-is without any W4 contract, and only pay when they actually need console builds.

4. Defold — Lua-Based Mobile Casual Specialist

Defold was acquired in 2014 by Candy Crush maker King and spun off as a nonprofit (Defold Foundation) in 2020. The license is the OSI-approved Defold License (an Apache 2.0 variant) — zero royalties even for commercial use and full source disclosure. It embeds a Lua 5.1 runtime and produces tiny binaries: Android APKs under 5 MB are routine.

local function init(self)
    self.velocity = vmath.vector3(0)
    msg.post(".", "acquire_input_focus")
end

local function on_input(self, action_id, action)
    if action_id == hash("touch") and action.pressed then
        self.velocity.y = 300
    end
end

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

Two things make Defold competitive. First, its build system is cloud-based, so you can produce Android, iOS, web, and desktop binaries without installing any local SDKs. Second, hot swap and hot reload are rock solid, letting designers tune balance live in a running mobile build. Coming out of King, the engine is heavily optimized for endless runners and match-3 style casual games and has strong share in the Finnish mobile casual scene.

5. Bevy 0.16 — The Flag of Rust ECS

Bevy is a Rust game engine started by Carter Anderson in 2020 and dual-licensed MIT/Apache 2.0. The 0.16 release in April 2026 brought a Bevy Editor alpha, full GLTF 2.0 import, a WebGPU backend on wgpu 24, and simplified ECS schedulers. It is still pre-1.0, but each release cycle is 3–4 months long and migration guides between 0.x releases are well written.

Bevy treats ECS (entity-component-system) as a first-class paradigm. Game objects are entity IDs, and behavior is expressed as system functions operating on component data.

use bevy::prelude::*;

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

fn apply_velocity(time: Res<Time>, mut query: Query<(&mut Transform, &Velocity)>) {
    for (mut transform, velocity) in &mut query {
        transform.translation += velocity.0 * time.delta_secs();
    }
}

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Update, apply_velocity)
        .run();
}

Bevy's weaknesses are obvious. The editor just hit alpha and the asset pipeline does not yet match the GUI workflows in Godot or Unity. Rust compile times can hurt large projects. That said, the "code is the source of truth" culture of Rust fits well with multiplayer servers and simulation projects, which makes it an attractive option for code-centric teams.

6. GameMaker LTS / 2024.x — Home Base of Pixel Indies

GameMaker (formerly GameMaker Studio 2) is a 2D-focused engine built by YoYo Games in 1999 and now owned by Opera. A 2023 pricing overhaul made non-commercial use permanently free, and a Long Term Support (LTS) track was introduced in 2024 to accumulate minor updates within each yearly line. Licensing differs from Unity and Unreal — desktop licenses are flat fee, while mobile and console are revenue-based.

GameMaker uses its own scripting language, GML (GameMaker Language). It is dynamically typed with C-style syntax and a rich built-in library of 2D-specific functions for sprites, rooms, and instances. The YYC compiler translates GML to C++ for native performance on consoles and mobile.

// Player object, Step event (GameMaker GML)
var move_h = keyboard_check(vk_right) - keyboard_check(vk_left);
hspeed = move_h * 4;

if (place_meeting(x, y + 1, obj_ground)) {
    if (keyboard_check_pressed(vk_space)) {
        vspeed = -10;
    }
} else {
    vspeed += 0.5; // gravity
}

Iconic GameMaker titles include Undertale, Hotline Miami, Hyper Light Drifter, and Forager. For 2D pixel RPGs and platformers it still has a faster development loop than Godot.

7. Phaser 3.85+ / Phaser 4 Beta — The Web 2D Standard

Phaser is an MIT-licensed HTML5 game engine built by Richard Davey in JavaScript/TypeScript. Version 3.85 stable shipped in November 2025, and 4.0 is in beta with a WebGPU backend and a redesigned component system. It is the de facto standard for ad games, educational mini-games, and instant games on KakaoTalk and LINE.

import Phaser from 'phaser'

class MainScene extends Phaser.Scene {
  preload() {
    this.load.image('player', 'assets/player.png')
  }
  create() {
    const player = this.physics.add.sprite(100, 100, 'player')
    this.input.keyboard?.on('keydown-SPACE', () => {
      player.setVelocityY(-300)
    })
  }
  update() {}
}

new Phaser.Game({
  type: Phaser.AUTO,
  width: 800,
  height: 600,
  physics: { default: 'arcade', arcade: { gravity: { x: 0, y: 600 } } },
  scene: MainScene,
})

Phaser shines because it integrates trivially with React or Vue and ships straight to a CDN. Its limitations: no real 3D support (a different space from Babylon.js and Three.js), and mobile native builds need wrappers such as Cordova or Capacitor.

8. Construct 3 — No-Code Drag-and-Drop in the Browser

Construct 3 is a browser-based no-code 2D engine from UK studio Scirra. You build game logic without writing a single line of code, using "event sheets" that read like if-then tables. The license itself is subscription-based (about $99/year), but the HTML5 output is free to distribute.

It is strong in education, game jams, and lightweight indies. Many school code clubs teach a first game in Construct, and a meaningful share of itch.io game jam entries are Construct projects. It is not a full-code engine, but you can drop JavaScript blocks in, so the ceiling is higher than it first appears.

9. Stride (formerly Xenko) — A .NET / C# Game Engine

Stride is a C# game engine born inside Japan's Silicon Studio as Xenko and donated to the .NET Foundation in 2020 to become open source. It is MIT licensed, with a custom PBR pipeline and Vulkan/DirectX 12 backends. It is attractive to developers who like Unity's C# workflow but are allergic to Unity's licensing policies.

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

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

    public override void Update()
    {
        var dt = (float)Game.UpdateTime.Elapsed.TotalSeconds;
        var move = Vector3.Zero;
        if (Input.IsKeyDown(Keys.W)) move.Z -= 1;
        if (Input.IsKeyDown(Keys.S)) move.Z += 1;
        Entity.Transform.Position += move * Speed * dt;
    }
}

Stride's ceiling is community size. There are few active maintainers and almost no high-profile shipped titles, so learning resources and the plugin ecosystem are thin. Still, if your studio has a hard requirement to stay in C# and .NET, Stride deserves a serious look.

10. PixiJS 8 — The Standard WebGL/WebGPU 2D Renderer

PixiJS is less a game engine and more a "2D renderer" — a library that pushes a scene graph of sprites and filters through WebGL or WebGPU at speed. It is often the backend behind Phaser or custom game frameworks. The 8.0 major shipped in spring 2024 with default WebGPU support, modularized ESM, and a new asset API.

import { Application, Assets, Sprite } from 'pixi.js'

const app = new Application()
await app.init({ background: '#1099bb', resizeTo: window, preference: 'webgpu' })
document.body.appendChild(app.canvas)

const texture = await Assets.load('https://pixijs.com/assets/bunny.png')
const bunny = new Sprite(texture)
bunny.anchor.set(0.5)
bunny.position.set(app.screen.width / 2, app.screen.height / 2)
app.stage.addChild(bunny)
app.ticker.add(() => { bunny.rotation += 0.01 })

PixiJS is strong outside games too. Interactive data visualization, ad creatives, and canvas-based editors — anywhere you need "2D canvas + 60 fps + thousands of sprites" — is PixiJS territory.

11. LÖVE 11.5 — Lua 2D for Hobbyist Joy

LÖVE (love2d) is a lightweight Lua 2D framework distributed under the zlib license. Version 11.5 shipped in 2024, and there is a love.js port for mobile and web. A working "Hello World" game fits in under 30 lines, making it one of the gentlest learning curves in the catalog.

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

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

function love.draw()
    love.graphics.circle('fill', player.x, player.y, player.r)
end

LÖVE's limits are clear: no official console build path, multi-platform packaging is largely a do-it-yourself affair, and 3D is essentially unsupported. Still, indies have shipped Mari0 and BYTEPATH on it, and every year a meaningful fraction of Ludum Dare entries are LÖVE games.

12. Cocos Creator 3 / Cocos2d-x — Giant of the Chinese Mobile Scene

Cocos is an open source 2D engine from China's Chukong that absolutely dominated the Chinese mobile market from 2013 to 2018. Cocos2d-x is the classic C++-based engine, and Cocos Creator 3 is the newer editor with TypeScript and light 3D support. Public statistics put 30+ of China's top 100 mobile games for 2024 revenue on Cocos.

Licensing splits between MIT (Cocos2d-x) and a custom EULA (Creator), but both are royalty-free for commercial use. Outside China it loses ground to Phaser and Defold, but it remains a top pick for casual studios in Southeast Asia and Latin America.

13. MonoGame and FNA — XNA Lives On

XNA was Microsoft's .NET-based game framework from 2004 to 2013. After Microsoft killed it, the community built two open source clones: MonoGame (MIT) and FNA (Microsoft Public License). Beloved titles including Stardew Valley, Celeste, and Bastion all run on the XNA → MonoGame/FNA lineage.

public class Game1 : Microsoft.Xna.Framework.Game
{
    private SpriteBatch _spriteBatch;
    private Texture2D _texture;

    protected override void LoadContent()
    {
        _spriteBatch = new SpriteBatch(GraphicsDevice);
        _texture = Content.Load<Texture2D>("player");
    }

    protected override void Draw(GameTime gameTime)
    {
        GraphicsDevice.Clear(Color.CornflowerBlue);
        _spriteBatch.Begin();
        _spriteBatch.Draw(_texture, new Vector2(100, 100), Color.White);
        _spriteBatch.End();
        base.Draw(gameTime);
    }
}

MonoGame offers a "low-level" experience: no GUI editor, code-driven game construction. The fact that Stardew Valley 1.6 updates still ship on MonoGame is proof enough that the project is alive and well.

14. Heaps.io and HaxeFlixel — Haxe Game Engines

Haxe is a meta-language that can compile one codebase to JS, C++, Java, Python, and C#. Heaps.io (MIT) is the engine used by Motion Twin to build Northgard and Dead Cells, with OpenGL and DirectX backends and both 2D and 3D support. HaxeFlixel is a simpler 2D framework.

Dead Cells alone validates Heaps.io — a metroidvania that has sold over 5 million copies, built on Haxe and Heaps. The English-language community is smaller than that of Godot or Bevy, which creates an entry barrier for Korean and Japanese indies.

15. PlayCanvas and Babylon.js 8 — Two Giants of Web 3D

PlayCanvas is a WebGL 3D engine from the UK, fully open source under MIT. Its cloud IDE supports real-time collaborative editing, and although Snap acquired the company in 2022 the open source policy remains unchanged. It shows up frequently in AR ad campaigns and mobile web games.

Babylon.js 8 is the Microsoft-sponsored, Apache 2.0 WebGL/WebGPU 3D engine. The 8.0 major in July 2025 made WebGPU the default backend and added IBL Shadows and Node Material Editor v2. The deep treatment is in the separate WebGPU/WebGL post, but in the game engine view, just remember: PlayCanvas and Babylon.js are the two pillars of web-based 3D games.

16. Three.js + React Three Fiber — Not a Game Engine, but You Can Build Games

Three.js is technically a 3D rendering library rather than a game engine, but it is more than enough for lightweight web games or interactive content. Combined with React Three Fiber (R3F) you get a component model for scenes that feels natural to React developers. There is a separate deep dive on these, so this catalog only places them in context — "lighter than Babylon.js, more code-centric than PlayCanvas, and a different space than Phaser."

17. O3DE (Open 3D Engine) — AAA-Quality Open Source

O3DE is the Apache 2.0 full-3D engine Amazon released in 2021, derived from its Lumberyard engine (originally licensed CryEngine) and donated to the Linux Foundation's Open 3D Foundation. Traces of CryEngine DNA remain, and it targets AAA work with multi-GPU support, large worlds, and simulation.

O3DE is familiar to senior developers coming from Unity or Unreal, but the learning curve is steep. The editor is heavy and build configuration is tricky. Still, the ability to ship AAA quality without any license fees makes it attractive to defense, autonomous driving, and industrial simulation companies.

18. Flax Engine — A Unity-Style Free Option

Flax is a C#/C++ engine by Polish developer Wojciech Figat, with a generous free-for-indies model — companies with under $250K annual revenue pay nothing, larger ones owe 4% royalties. The editor UX looks remarkably similar to Unity's, which makes it one of the first stops for teams considering a Unity migration. Vulkan/DirectX 12 backends, a custom PBR shader pipeline, and visual scripting are all included.

By the strict open source definition it is a hybrid — source available plus a commercial license — but practically free for most indies. Builds are small and the team can negotiate console SDK licensing partnerships.

19. GDevelop — Another Axis of No-Code

GDevelop is an MIT-licensed no-code 2D engine started by French developer 4ian (Florian Rival). It uses an event-sheet model similar to Construct 3 but ships a free offline desktop app. Since 2024 a GDevelop AI beta lets you prototype games from natural language, putting it at the front of the natural-language game generation trend.

It is heavily used in school coding clubs, by solo indie developers, and for lightweight marketing games. Build targets include HTML5, desktop (Electron), and mobile (Cordova).

20. Unity 6 and Unreal 5.5 — Comparing with the Commercial Engines

A discussion of open source engines that ignores Unity 6 (the LTS line is 6000.x) and Unreal 5.5 is incomplete. Unity 6 adds GPU Resident Drawer, Render Graph, BIRP/URP/HDRP convergence work, and ECS 1.5; in 2024 the install-fee policy was scrapped and pricing returned to revenue-based subscriptions. Unreal 5.5 stabilizes Lumen and Nanite, integrates MetaHuman Creator, and previews the Verse language.

The decision logic is simple — if AAA graphics are mandatory and license cost is not the bottleneck, pick Unreal; if you need mobile, mid-tier graphics, and a giant asset store, pick Unity; if you want free, open source, and mid-tier graphics, pick Godot; if you want Rust ECS and code-centric development, pick Bevy.

21. The Common Stack — Physics, Audio, Shaders

Engines change but the subsystems often stay. For physics, 2D leans on Box2D (and its LiquidFun fork), while 3D mainly uses Bullet, NVIDIA PhysX, Jolt (chosen by Horizon Forbidden West), or Rapier (Rust). Godot 4 lets you pick between its own Godot Physics and Jolt.

For audio, commercial engines lean on FMOD and Wwise, while the open source camp typically uses OpenAL Soft, MiniAudio, or SoLoud. Shader languages split by platform — HLSL (DirectX), GLSL (OpenGL/Vulkan), MSL (Metal), WGSL (WebGPU) — and engines wrap them in their own DSL (Godot's .gdshader, Unity's ShaderLab, Unreal's material graph).

22. Tilemap, Sprite, and 3D Modeling Tools

Asset production tools deserve a separate roundup. For 2D tilemap editors, Tiled (.tmx format) and LDtk are the de facto standards and both are free. For sprite work, Aseprite (paid but GPL source), Krita (GPL), and Pixelorama (MIT) are the main players. 3D modeling has its own deep dive on Blender — but for the game engine view, the key fact is that Blender 4.x is the de facto standard for game asset workflows.

Asset libraries include itch.io, OpenGameArt.org, Kenney.nl (where one person has released nearly his entire portfolio under CC0), and CGTrader. For indies trying to keep art costs down, starting with a free Kenney.nl pack has become almost a standard move.

23. Networking and Multiplayer Stack

Multiplayer is the part that most splits by engine. Unity has Mirror, FishNet, and Photon as defaults; Unreal has its own deeply capable replication system. Godot 4 ships MultiplayerSpawner and MultiplayerSynchronizer since 4.0, with ENet (reliable UDP) as the default transport. Bevy has third-party crates like bevy_replicon and lightyear.

For server hosting there are GameLift (AWS), PlayFab (Microsoft), and Pragma Engine, but for indies a self-hosted dedicated server on a VPS is often more cost-effective. Korean indies frequently land on NHN Cloud dedicated instances; Japanese indies use ConoHa or Sakura.

24. The Reality of Mobile and Console Builds

Mobile builds run through Android NDK + Gradle and iOS via Xcode. The biggest cost for indies is actually the Apple Developer Program ($99/year) and the code signing infrastructure. Android starts with a one-time$25 Play Console fee. Godot, Defold, and GameMaker all have solid mobile build pipelines.

Consoles are a different story. Switch, PS5, and Xbox are closed SDKs under NDA. Godot ships via W4 Games; Bevy has no official console build. Unity and Unreal both have official console paths, but Nintendo, Sony, and Microsoft all require "shipped title" credentials, so targeting console as your very first game is essentially impossible.

25. The Korean and Japanese Indie Scenes

The Korean indie scene has grown rapidly through the 2020s. Busan Indie Connect Festival (BIC), the indie publishing arms at Kakao Games and Smilegate, and the KRAFTON Jungle indie incubation program at Krafton form a real support infrastructure. The Korean Godot community on GitHub and Discord tripled in members between 2024 and 2025, and global interest in Korean indies has surged since MintRocket's "Dave the Diver."

Japan has Tokyo Game Show (TGS), BitSummit in Kyoto-area Fukuoka rotation, and the Kyoto Bit2Bit community. RPG Maker culture is strong, and the retro scene around Famicom homebrew and NES dev is still alive. Sony Music Entertainment Japan operates indie publisher Unties, and Nintendo runs an active indie program (Nindies).

26. Shipped Title Case Studies — What Was Built on What

The best evidence when evaluating an open source engine is the list of shipped titles. Godot has Brotato, Halls of Torment, Cassette Beasts, Dome Keeper, Buckshot Roulette, and Road to Vostok, all validated on Steam. Brotato in particular is repeatedly cited — a solo developer (Blobfish) sold over one million copies.

Defold has Family Island (King) and Heroes Adventure among many mobile casual titles. Bevy lacks a marquee shipped title yet, but indies like Tunnet and Foresight are in development. Phaser powers many KakaoTalk and LINE instant games and a steady stream of ad creatives. GameMaker is home base to landmark titles like Undertale, Hotline Miami, and Hyper Light Drifter.

27. Books and Learning Resources — Game Engine Architecture and Beyond

To go beyond using engines and actually understand "why are they designed like this," Jason Gregory's Game Engine Architecture (3rd edition, 2018) is the standard text. Robert Nystrom's Game Programming Patterns (free online) explains how ECS, observer, and command patterns sit inside an engine.

Engine-specific resources include Godot's official docs (docs.godotengine.org), which are exceptionally well organized, and the free Bevy Cheatbook (bevy-cheatbook.github.io) as a reference. YouTube channels like GDQuest, HeartBeast, and Brackeys shape the indie learning curve.

28. Engine Selection — Recommendations by Scenario

Two big rules: (1) if console is mandatory, choose a commercial engine (or Godot + W4); (2) if you want zero license-dispute risk, choose an MIT or Apache 2.0 engine (Godot, Bevy, PlayCanvas, Babylon.js, MonoGame).

29. References

• Godot Engine official docs — https://docs.godotengine.org/
• Godot 4.4 release notes — https://godotengine.org/article/godot-4-4-overview/
• W4 Games — https://w4games.com/
• Defold Engine — https://defold.com/
• Defold Foundation — https://defold.com/foundation/
• Bevy Engine — https://bevyengine.org/
• Bevy 0.16 release — https://bevyengine.org/news/bevy-0-16/
• GameMaker — https://gamemaker.io/
• GameMaker pricing (2023) — https://gamemaker.io/en/blog/gamemaker-is-now-free
• Phaser — https://phaser.io/
• Phaser 4 beta — https://phaser.io/news/2024/12/phaser-v4-beta-released
• Construct 3 — https://www.construct.net/
• Stride Engine — https://www.stride3d.net/
• PixiJS — https://pixijs.com/
• LÖVE — https://love2d.org/
• Cocos Creator — https://www.cocos.com/en/creator
• MonoGame — https://monogame.net/
• Heaps.io — https://heaps.io/
• HaxeFlixel — https://haxeflixel.com/
• PlayCanvas — https://playcanvas.com/
• Babylon.js — https://www.babylonjs.com/
• Open 3D Engine (O3DE) — https://o3de.org/
• Flax Engine — https://flaxengine.com/
• GDevelop — https://gdevelop.io/
• Unity 6 — https://unity.com/releases/unity-6
• Unreal Engine 5.5 — https://www.unrealengine.com/en-US/unreal-engine-5
• Tiled Map Editor — https://www.mapeditor.org/
• LDtk — https://ldtk.io/
• Kenney.nl — https://kenney.nl/
• OpenGameArt — https://opengameart.org/
• itch.io Game Jams — https://itch.io/jams
• Game Engine Architecture (Jason Gregory) — https://www.gameenginebook.com/
• Game Programming Patterns (Robert Nystrom) — https://gameprogrammingpatterns.com/
• BIC Fest (Busan Indie Connect) — https://www.bicfest.org/
• BitSummit — https://bitsummit.org/