5 Engineering Decisions That Made Godot The Fastest-growing Game Engine

Godot went from 47 game releases on Steam in 2020 to over 1,500 in 2025. Slay the Spire 2, built on Godot after Mega Crit scrapped two years of Unity development, hit 574,638 concurrent players on Steam. Five percent of all games released on Steam in 2024 used Godot.

That growth did not happen because of marketing. Godot has no venture capital, no sales team, no enterprise contracts. It grew because of five architectural decisions that compounded over time. If you build developer tools of any kind, these decisions are worth studying.

1. MIT license, no exceptions

Godot uses the MIT license. Not "free with conditions." Not "free until you make money." MIT.

Unity charges a runtime fee above certain revenue thresholds. Unreal takes 5% of gross revenue above $1 million. Godot takes nothing. Ever.

This matters more than it seems. When Unity announced its per-install fee in September 2023, studios with years of development invested had to evaluate whether to absorb the cost or switch engines. Mega Crit chose to rewrite. Mike Klubnika, creator of Buckshot Roulette (8 million copies sold), switched to Godot and said: "I really liked the fact that Godot was open source."

The web development world learned this lesson with open-core tools that changed pricing. Godot cannot change pricing because there is no pricing to change. The MIT license is a binding commitment to developers, and it removes a category of business risk entirely.

2. Text-based scene files

Godot scenes are stored as .tscn files. They are plain text. You can open one in any editor and read it:

[gd_scene format=3]  
  
[node name="Player" type="CharacterBody2D"]  
position = Vector2(100, 200)  
  
[node name="Sprite" type="Sprite2D" parent="."]  
texture = ExtResource("1_abc12")  

Unity scenes are binary by default. Unreal Blueprints are binary. This means:

• Version control works. Git diffs show exactly what changed in a scene. No "just merge the binary and pray."
• AI can read and write scenes. An AI tool can generate a complete scene file from a text description and inject it into a project without any binary serialization layer. Tools like Ziva use this directly to generate scenes from natural language prompts.
• Automation is trivial. Grep a scene for a node type. Sed-replace a resource path. Write a CI check that validates scene structure. All standard Unix tools work.

Web developers take this for granted. HTML, CSS, and JavaScript are all plain text. The idea of a binary-first UI description format feels alien. Game engines accepted binary scenes as normal for decades. Godot proved they did not have to.

3. A domain-specific language instead of a general-purpose one

GDScript is not Python. It looks like Python, but it is a purpose-built language for game logic. A typical GDScript file is 30-80 lines. The equivalent C# in Unity is 100-300 lines.

extends CharacterBody2D  
  
@export var speed := 200.0  
  
func _physics_process(delta: float) -> void:  
    var direction := Input.get_vector("left", "right", "up", "down")  
    velocity = direction * speed  
    move_and_slide()  

That is a complete player movement controller. Six lines. The engine handles collision resolution, delta timing, and physics integration. The developer writes game logic, not framework plumbing.

The tradeoff is real. GDScript is slower than C# for raw computation. If you need tight loops processing millions of elements, C# or C++ via GDExtension is better. But for the 90% of game code that is event handling, state transitions, and scene manipulation, GDScript's brevity means less code to write, less code to debug, and less context for AI tools to manage.

The parallel in web development: Tailwind CSS is "worse" than raw CSS in the same way GDScript is "worse" than C#. It is constrained by design. Those constraints are the point.

4. A 120 MB download that runs everywhere

The Godot editor is a single binary. 120 MB. It runs on Windows, macOS, Linux, and even in a browser via WebAssembly. No installer, no account creation, no license key, no phone-home telemetry.

Unity's editor is over 10 GB installed. Unreal is 30+ GB. Both require accounts. Both require internet connections for licensing.

This has second-order effects:

• Game jams. A developer can download Godot, create a project, and have a playable prototype in under an hour. At the GMTK Game Jam, Godot went from 13% to 39% of entries in four years.
• Education. A teacher can put Godot on a USB drive and hand it to students. No IT department needed.
• CI/CD. Godot headless exports run on any Linux box. No need to license a build server.

The lesson for tool builders: if your tool requires an account to evaluate, you are losing users who would have become advocates.

5. Composition over inheritance via the node tree

Godot's scene system uses composition. Every object in a game is a tree of nodes. A player character is a CharacterBody2D with child nodes for Sprite2D, CollisionShape2D, AnimationPlayer, and whatever else it needs. You add behavior by adding nodes, not by subclassing.

Player (CharacterBody2D)  
├── Sprite2D  
├── CollisionShape2D  
├── AnimationPlayer  
└── HealthComponent (custom)  

This is the same pattern as React's component tree, which borrowed the concept from scene graphs that game engines used decades earlier. If you understand React components, you already understand Godot's node tree.

The practical benefit: scenes are reusable. You can build a "HealthComponent" scene and instance it on any entity. You can nest scenes inside scenes. The composition is unlimited and does not require inheritance hierarchies that become brittle at scale.

The compound effect

None of these decisions is unique in isolation. Plenty of tools are MIT-licensed. Plenty use text formats. Plenty are small. But the combination produces a developer experience where:

1. You download a 120 MB binary (no account)
2. You write 30-line scripts in a language designed for the domain
3. Your scenes are text files that work with git and AI tools
4. You ship to any platform with no runtime fees
5. You own every line of source code

That combination is why Godot went from a niche curiosity to an engine that ships games earning over $10 million on Steam. It is also why the growth is accelerating: each new commercial success validates the architecture for the next wave of developers.

If you are evaluating game engines in 2026, or just interested in how architectural decisions compound into ecosystem growth, Godot is the case study.