This content originally appeared on DEV Community and was authored by Jimmy McBride
If you’re new to Godot, you’ve probably seen the word Node thrown around everywhere.
And that’s because — in Godot — everything is a Node.
Scenes, characters, UI elements, even background music… all of it.
Think of Nodes like Lego bricks. Each one has a specific purpose, and when you start snapping them together, you can build literally anything — from a main menu to a full 3D world.
🧱 What Is a Node, Really?
A Node is the most basic building block in Godot.
It’s a single piece of functionality — like “draw a sprite,” “play a sound,” or “run this script.”
Every Node has:
- A name — how you reference it in the tree.
- A type — what kind of thing it is (like
Sprite2D,Camera2D,Timer, etc.). - A parent and children — Nodes form hierarchies.
- And optionally, a script attached for custom behavior.
You can think of it like this:
Player (Node2D)
├── Sprite2D
├── CollisionShape2D
└── Script (GDScript or C#)
Each part of the player — the art, the physics, the logic — is just another Node.
🌲 The Scene Tree
When you look at your project in Godot, everything is organized in a scene tree.
Every scene (yes, every .tscn file) is actually just a saved tree of Nodes.
For example, your main scene might look like this:
MainScene
├── Player
│ ├── Sprite2D
│ └── Camera2D
└── EnemySpawner
├── Timer
└── Marker2D
Each node has a parent, and each parent can have children.
If you move or delete the parent, everything underneath it moves or deletes too — just like folders and files.
That’s why you’ll often hear people say:
“Once you understand the scene tree, you understand Godot.”
🧩 Different Types of Nodes
There are hundreds of node types in Godot, but here are a few of the main categories you’ll use constantly:
| Node Type | Purpose |
|---|---|
Node2D / Node3D
|
Anything that exists in 2D or 3D space (position, rotation, scale) |
Control |
UI elements like buttons, labels, panels |
AudioStreamPlayer |
Plays sounds or music |
Area2D / CollisionShape2D
|
Detects overlaps and collisions |
Timer |
Runs code after a delay or on a loop |
Node |
The most basic type, purely for logic or grouping |
Each Node type comes with built-in properties and functions.
For example, Node2D has position, rotation, and scale.
You can move it with a single line:
GDScript
extends Node2D
func _process(delta):
position.x += 1
C#
public partial class Mover : Node2D
{
public override void _Process(double delta)
{
Position = new Vector2(Position.X + 1, Position.Y);
}
}
🪜 Parents, Children, and Hierarchies
Nodes don’t live alone — they live in hierarchies.
If you move a parent node, all its children move with it.
If you delete a parent, its children go too.
That’s powerful because it lets you build self-contained systems.
Your Player node might have a Camera2D, Sprite2D, and CollisionShape2D as children — all following the player automatically.
You can also communicate easily:
GDScript
# From a parent to a child
$ChildNode.visible = false
# From a child to its parent
get_parent().do_something()
C#
// From a parent to a child
GetNode<Node2D>("ChildNode").Visible = false;
// From a child to its parent
(GetParent() as ParentClass)?.DoSomething();
It’s a simple but elegant system.
You don’t need a big “GameObject” class or complex component setup — Nodes are the components.
🧱 Scenes: Reusable Node Trees
Here’s the best part: a Scene in Godot is just a saved tree of nodes.
You can make a Player scene, save it, and then drag it into your Level scene — and it becomes a single node with all its children tucked neatly inside.
LevelScene
├── Player (instanced scene)
├── Enemy (instanced scene)
├── Background
└── UI
That means you can design your Player once and reuse it in every level.
Godot’s scene system is modular by design — build small, combine big.
⚙️ Adding Behavior with Scripts
Nodes can do a lot on their own, but when you want custom logic, you attach a script.
GDScript
extends Node2D
@export var speed = 200
func _process(delta):
position.x += speed * delta
C#
using Godot;
public partial class Player : Node2D
{
[Export] public float Speed { get; set; } = 200f;
public override void _Process(double delta)
{
Position += new Vector2(Speed * (float)delta, 0);
}
}
That’s it — you’ve just given your node behavior.
Scripts turn nodes from static data into dynamic, interactive parts of your game.
Every script “extends” the node it’s attached to — meaning it is that node.
extends Node2D means your script is a Node2D with extra powers.
⚡ Signals: How Nodes Talk to Each Other
Signals are Godot’s event system.
They let nodes communicate without directly depending on each other — which keeps your code clean.
GDScript
# Player.gd
signal died
func die():
emit_signal("died")
# MainScene.gd
func _ready():
$Player.connect("died", self, "_on_player_died")
func _on_player_died():
print("Player died!")
C#
// Player.cs
[Signal]
public delegate void DiedEventHandler();
public void Die()
{
EmitSignal(SignalName.Died);
}
// MainScene.cs
public override void _Ready()
{
var player = GetNode<Player>("Player");
player.Died += OnPlayerDied;
}
private void OnPlayerDied()
{
GD.Print("Player died!");
}
That’s it — your MainScene knows when the Player dies, but the Player doesn’t care who’s listening.
It just says “Hey, I died!” and anyone connected gets the message.
🕹️ Example: Building a Simple Player
Let’s put it all together.
Scene Tree
Player (CharacterBody2D)
├── Sprite2D
├── CollisionShape2D
└── Camera2D
GDScript Version
extends CharacterBody2D
@export var speed = 200
func _physics_process(delta):
var input = Vector2.ZERO
input.x = Input.get_action_strength("ui_right") - Input.get_action_strength("ui_left")
input.y = Input.get_action_strength("ui_down") - Input.get_action_strength("ui_up")
velocity = input.normalized() * speed
move_and_slide()
C# Version
using Godot;
public partial class Player : CharacterBody2D
{
[Export] public float Speed { get; set; } = 200f;
public override void _PhysicsProcess(double delta)
{
var input = Vector2.Zero;
input.X = Input.GetActionStrength("ui_right") - Input.GetActionStrength("ui_left");
input.Y = Input.GetActionStrength("ui_down") - Input.GetActionStrength("ui_up");
Velocity = input.Normalized() * Speed;
MoveAndSlide();
}
}
You’ve got:
- A node for position and physics
- Children for visuals and collision
- A script to control movement
That’s a playable character — no boilerplate, no setup pain, just nodes working together.
🧠 Wrapping Up
Once you understand Nodes, everything in Godot makes sense.
You stop thinking in terms of “objects” or “entities” and start thinking in trees — small, simple parts that combine into something powerful.
This content originally appeared on DEV Community and was authored by Jimmy McBride
Jimmy McBride | Sciencx (2025-11-06T15:01:04+00:00) Understanding Nodes in Godot (For Absolute Beginners). Retrieved from https://www.scien.cx/2025/11/06/understanding-nodes-in-godot-for-absolute-beginners/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.