Godot

Godot is a free, MIT-licensed game engine with no royalties, no revenue thresholds, and a download measured in tens of megabytes. That licensing position — combined with a genuinely pleasant editor and a fast iteration loop — has made it the default recommendation for solo developers and small teams, particularly in 2D where it is arguably the strongest engine available.

Architecturally it takes a different bet from Unity. Instead of empty containers with components attached, Godot gives you a tree of nodes, each a specialized object that does one thing — Sprite2D draws, CharacterBody2D moves with collision, Timer counts down, AudioStreamPlayer plays sound. Any subtree can be saved as a scene and instanced inside another, which makes "scene" simultaneously Godot's level, its prefab, and its component. Once that clicks, most of the engine follows from it.

TL;DR

Quick Example

A complete 2D player controller in GDScript:

The scene tree it belongs to:

Save that tree as player.tscn and it becomes a reusable unit you can instance in any level.

Core Concepts

Nodes and the scene tree

Every node has a type that determines what it can do, and inheritance is real — CharacterBody2D extends PhysicsBody2D extends CollisionObject2D extends Node2D extends Node. Position, visibility, and pausing propagate down the tree, which is why hierarchy is a design tool rather than just organization.

Scenes as composable units

A scene is a saved node tree with one root. Instancing a scene inside another gives you the prefab workflow, and because scenes nest arbitrarily, the same mechanism composes an entire game:

Editing enemy.tscn updates all twelve. There is no separate prefab concept to learn.

Signals

Signals are Godot's decoupling mechanism, and using them well is most of what distinguishes a maintainable Godot project from a tangled one.

The rule of thumb: call down, signal up. A parent may call methods on its children (it knows they exist); a child should emit a signal rather than reaching upward for a parent it can't guarantee.

GDScript vs. C#

Most projects use GDScript — the tight coupling to the node system and the absence of a compile step make it noticeably faster to work in. C# is a reasonable choice for teams that already know it or need .NET libraries, and the two can be mixed in one project.

_process vs. _physics_process

Both receive delta and both require you to multiply rates by it. Physics moves belong in _physics_process or you'll get inconsistent collision behavior on machines with different frame rates.

Working in Godot

Autoloads (singletons)

An autoload is a scene or script loaded once and available globally by name — the idiomatic home for game state, audio management, and scene transitions.

Useful and easy to overuse — everything in an autoload is global mutable state. Keep them few and focused.

Resources

A Resource is Godot's serialized data object, equivalent to Unity's ScriptableObject: shared, saved as a file, editable in the inspector.

Assign a .tres file to any node that needs it. Designers tune values without touching code, and one asset backs every instance.

Groups

Groups tag nodes for bulk operations without maintaining your own registries:

Exporting

Export templates produce builds for Windows, macOS, Linux, Android, iOS, and web. Web export is unusually good — a Godot game runs in a browser via WebAssembly with no plugin, which makes itch.io distribution and game jams straightforward. Console export requires third-party porting partners, since the platform SDKs are under NDA and can't ship in an open-source engine.

Best Practices

Signal up, call down

A child that reaches for get_parent().get_parent().score breaks the moment the tree changes. Emit a signal and let whoever cares connect. This single habit is the difference between scenes that are genuinely reusable and scenes that only work in one place.

Use @onready instead of _ready boilerplate

@onready var sprite := $Sprite2D resolves after the node enters the tree, which is when children are guaranteed to exist. It replaces a block of assignments in _ready and fails loudly if the path is wrong.

Enable static typing

Typed GDScript is faster at runtime, catches errors at parse time, and drives autocompletion. It's optional, and turning it on project-wide is one of the cheapest quality improvements available.

Prefer move_and_slide over manual collision math

CharacterBody2D/3D handle slopes, walls, and floor detection with behavior players expect. Reimplementing that on top of raw Area2D overlap checks is a well-trodden path to subtle movement bugs.

Keep scenes independently runnable

Press F6 and a scene should run on its own. If it crashes without a parent providing something, it's coupled to a context it shouldn't know about. This is Godot's built-in test for whether your composition is clean.

Use unique_name_in_owner for stable references

Marking a node with % (%HealthBar) gives you a name-based reference that survives moving the node in the tree — far more robust than a long $Path/To/Node string.

Disconnect what you connect on dynamic nodes

Signals to freed nodes are cleaned up automatically, but connections to long-lived autoloads from short-lived nodes will accumulate. Use CONNECT_ONE_SHOT for single-fire cases and disconnect in _exit_tree where lifetimes differ.

Common Mistakes

Reaching up the tree with node paths

Doing physics in _process

Freeing a node in the middle of its own callback

Loading resources inside a loop

Putting everything in autoloads

Forgetting that queue_free() is deferred

The node is still valid for the rest of the frame. Check is_instance_valid(node) before touching a reference you may have queued for deletion, or guard with if node and not node.is_queued_for_deletion().

FAQ

Is Godot ready for commercial games?

Yes, and it has been for several years — shipped commercial titles include Brotato, Cassette Beasts, Dome Keeper, and Halls of Torment, among many others. The honest caveats: 3D tooling is less mature than Unity's or Unreal's, console porting requires a third-party partner, and the third-party asset ecosystem is much smaller. For 2D commercial work, none of those are significant.

Godot or Unity?

Godot for 2D, for solo and small-team projects, for anyone who wants a permissive license with no revenue conditions, and for anyone who values a fast iteration loop. Unity for large 3D projects, mobile-heavy studios, teams that need the asset store, and situations where hiring for existing Unity experience matters. Godot's licensing is genuinely part of the technical decision — MIT with no royalty means no future terms change can affect a shipped game.

Should I learn GDScript or use C#?

GDScript unless you have a concrete reason otherwise. It's designed around the node system, has no compile step, and every tutorial and community answer is written in it. C# is the right call if your team already knows it, you need .NET libraries, or you have measured hot paths that need the performance. You can use both in one project.

How is 2D actually different from Unity's 2D?

Godot's 2D is a separate rendering and physics stack with its own coordinate space in pixels, not a 3D scene viewed orthographically. Practically this means pixel-perfect rendering is straightforward, 2D physics is genuinely 2D, and there's no class of bugs from a stray Z position. It's the clearest technical reason to pick Godot for a 2D project.

Can I use Godot for non-game applications?

Yes — the Control node hierarchy is a complete UI toolkit with anchors, containers, and themes, and Godot exports to desktop and mobile. It's used for tools, data visualizations, and kiosk applications. It's an unusual choice against Electron or a native toolkit, but it's a real one, especially where you want heavy custom rendering.

What changed in Godot 4?

Substantial rewrites: Vulkan rendering with a modern lighting pipeline, GDScript 2.0 (annotations, typed arrays, lambdas, first-class signals), a new physics engine, and improved multithreading. The API changed enough that Godot 3 tutorials often don't apply directly — check the version on anything you follow.

Related Topics

References