Everything in Godot is a node, and games are trees of nodes grouped into scenes. Learn the node model, how scenes compose and instance, and why this structure makes Godot so approachable.
Godot builds games from nodes — small objects that each do one thing: a Sprite2D draws an image, a CharacterBody2D moves with physics, a Label shows text, a Timer counts down. You assemble nodes into a tree, where a parent’s transform and lifecycle flow to its children. This "compose from many small nodes" model is the core idea of the whole engine.
Everything you build is a NODE. Nodes form a TREE (parent -> children):
Player (CharacterBody2D) <- moves with physics
├── Sprite2D <- draws the character image
├── CollisionShape2D <- its physics collider
├── Camera2D <- follows the player
└── AnimationPlayer <- plays animations
A parent's position/visibility/lifecycle flow down to its children (move the
Player and the Sprite + Camera move with it). Each node does ONE job; you
compose them into behavior. That composition is the heart of Godot.A scene is a saved tree of nodes — your Player, a Coin, a whole Level. Scenes are Godot’s reusable unit: you build one scene and instance it many times (fifty enemies from one Enemy scene), and scenes nest inside other scenes (a Level scene contains Player and Enemy instances). This scene-instancing model is how you keep a project modular and avoid duplication.
A SCENE = a saved tree of nodes you can reuse + instance.
Enemy.tscn (a scene: CharacterBody2D + Sprite + Collider + script)
Coin.tscn (a scene: Area2D + Sprite + Collider)
Level.tscn (a scene that INSTANCES many Enemy + Coin scenes)
Main.tscn
└── Level (instance of Level.tscn)
├── Player (instance of Player.tscn)
├── Enemy (instance of Enemy.tscn) x50
└── Coin (instance of Coin.tscn) x20
Build a scene once, instance it everywhere. Editing Enemy.tscn updates every
enemy. Scenes = Godot's reusable building blocks (like prefabs).You spawn scenes at runtime by loading the scene resource and instantiating it, then adding it to the tree. This is how bullets, enemies, and pickups appear during play. Preloading the scene once and instancing many times is the standard spawning pattern, connecting the editor’s scenes to your game’s dynamic behavior.
# preload the scene resource once (loaded at compile time)
const BULLET = preload("res://Bullet.tscn")
func shoot():
var bullet = BULLET.instantiate() # create an instance of the scene
bullet.position = global_position # place it where the shooter is
get_parent().add_child(bullet) # add it to the scene tree -> it's live
# spawn enemies, pickups, particles the same way: preload -> instantiate ->
# set position -> add_child. This is the core runtime spawning pattern.Godot’s editor is where you assemble scenes visually: the Scene dock shows the node tree, you add nodes from a searchable list, set their properties in the Inspector, and attach a script to give a node behavior. Understanding that the editor is just a visual way to build the same node tree you can also manipulate in code demystifies the workflow — the editor and scripts are two views of one structure.
The Godot editor, oriented:
Scene dock (top-left) the node TREE of the current scene — add/arrange nodes
FileSystem (bottom-left) your project's files (scenes, scripts, assets)
Inspector (right) properties of the SELECTED node (position, texture...)
Viewport (center) visual preview; drag nodes around
attach a Script to a node (right-click > Attach Script) -> give it behavior
Key insight: the editor just builds the same node TREE you can also create/edit
in code. Visual editing + scripting are two views of ONE structure. Godot is
free, open-source, and a small download — the ideal engine to learn by doing.