LearnAI ToolsCareerPractice BuildsPlayContact
Lesson 523 min read

Nodes & the Scene Tree

Master Godot's core architecture — nodes, the scene tree hierarchy, common node types, and how to reference other nodes from a script.

Introduction

This is the single most important lesson in this course. Every other GDScript concept — scripts, signals, lifecycle callbacks, exported variables — exists to do something to, through, or with a node. Understanding nodes and the scene tree is understanding how Godot itself is organized.

What You Will Learn
  • Why everything in Godot, visible or not, is a node.
  • How the scene tree organizes nodes into parent/child hierarchies.
  • The most common node types you'll use across nearly every project.
  • How to reference other nodes from a script using $ and get_node().

Everything Is a Node

In Godot, a Node is the base building block for absolutely everything — a sprite, a sound player, a UI button, a physics body, a timer, even an invisible logic-only container. Every node has a small set of shared capabilities (a name, a position in the tree, lifecycle callbacks) and can be extended with specialized behavior depending on its specific type.

The Scene Tree

Nodes are organized into a tree — each node can have one parent and any number of children. A player character might be a node with child nodes for its sprite, its collision shape, and its camera, all moving together because child nodes are positioned relative to their parent.

Player (CharacterBody2D)
├── Sprite2D
├── CollisionShape2D
└── Camera2D
Think in Trees, Not Flat Lists

Because child nodes move and (by default) get freed along with their parent, structuring related pieces as children of one logical "owner" node — like a Player node owning its sprite, collider, and camera — is the core organizational habit in Godot development.

Common Node Types

Node TypeWhat It's For
NodeThe base type; a pure logic container with no visual or physical presence.
Node2D / Node3DA node with a position, rotation, and scale in 2D or 3D space.
Sprite2DDisplays a 2D image/texture.
CharacterBody2DA physics body designed for player- or AI-controlled movement.
CollisionShape2DDefines a physics body's collision shape.
ControlThe base type for UI elements like buttons, labels, and panels.
TimerFires a signal after a configurable delay.

Scenes as Reusable Node Trees

A scene is simply a saved node tree — build a Player scene once, and you can then place (instance) that same Player scene into a level as many times as needed, each instance behaving independently. This is how Godot handles reusability: not through a separate "prefab" system, but through the same scene concept used everywhere else.

Referencing Other Nodes

Use case: a script attached to one node frequently needs to talk to another node nearby in the tree — its own child, or a sibling. The $ shorthand (or the equivalent get_node() function) looks up a node by its path relative to the script's own node.

extends CharacterBody2D


@onready var sprite: Sprite2D = $Sprite2D
@onready var camera := get_node("Camera2D")


func _ready() -> void:
    print("Sprite texture:", sprite.texture)
    camera.zoom = Vector2(1.5, 1.5)
What Happens

Click Run to see what this code prints.

Common Mistakes

Avoid These Mistakes
  • Referencing a child node before it's ready — @onready (covered fully in lesson 7) ensures the reference is set up only once the node has entered the scene tree.
  • Hardcoding long, fragile node paths ($Player/Sprite2D/Weapon/Muzzle) instead of exporting a NodePath or restructuring the tree for simpler access.
  • Renaming a node in the editor and forgetting that any $NodeName references in scripts now point to a name that no longer exists.

Best Practices

  • Keep related nodes (a character's sprite, collider, and camera) grouped under one clear parent node.
  • Prefer @onready var references set once at the top of a script over repeated get_node() calls scattered through your code.
  • Give nodes clear, descriptive names in the editor — script code readability depends directly on it.

Frequently Asked Questions

Not exactly — a level is often built as one large scene, but a scene can just as easily be a small reusable piece (like a single enemy or a UI button) instanced inside a larger level scene.

Yes, temporarily — a node can be created in code without being added to the tree yet, but it won't receive lifecycle callbacks like _ready() or _process() until it actually enters the running scene tree.

By default, freeing a node also frees all of its children — exactly why grouping related pieces under one parent (like a Player owning its sprite and collider) is convenient for cleanup.

Key Takeaways

  • Every element in Godot, visual or not, is a Node.
  • Nodes form a tree, with child nodes positioned and freed relative to their parent.
  • A scene is simply a saved, reusable node tree that can be instanced multiple times.
  • $NodeName and get_node() look up other nodes from within a script.

Summary

Nodes and the scene tree are the foundation every remaining lesson builds on — signals connect nodes, lifecycle callbacks run on nodes, and exported variables configure nodes. Next, you'll cover control flow: if/else, loops, and GDScript's handy match statement.

Next Lesson →

Control Flow