Godot Glossary
Quick definitions for Godot and game dev terms
@
@export
A GDScript annotation that exposes a variable in the Godot Inspector panel, allowing you to edit it without changing code.
Coming from Unity [SerializeField]; Unreal UPROPERTY(EditAnywhere).
Exported values are stored per instance in the scene, so two copies of the same script can carry different numbers. Export what a designer should tune; keep runtime counters as plain vars.
@onready
A GDScript annotation that initialises a variable when the node enters the scene tree. Commonly used with $ node references.
Coming from Roughly Unity's Awake-time GetComponent caching.
`@onready var sprite := $Sprite2D` resolves once instead of every frame. Without it, a $ lookup at the top of a script runs before children exist and returns null.
A
AnimationPlayer
A node that can animate almost any property on a timeline, including position, colour, visibility, shader parameters, and function calls.
Coming from Unity Animation and Animator; Unreal Sequencer used for gameplay.
It is not limited to skeletal animation. Animating a custom exported variable or firing a method from a track is normal practice.
AnimationTree
A node for complex animation logic: state machines, blend trees, and transitions. Built on top of AnimationPlayer.
Coming from Unity Animator controller; Unreal Animation Blueprint.
Reach for it when you have states that blend into each other. A two-state idle and walk is usually cheaper to drive from code with AnimationPlayer.
Area2D/3D
A node that detects when other physics bodies enter or exit its space. Used for triggers, collectibles, and damage zones.
Coming from Unity Collider with isTrigger enabled; Unreal TriggerBox or an overlap component.
It detects without blocking. It needs a CollisionShape2D child or body_entered will never fire, which is the most common reason a pickup does nothing.
Autoload
A scene or script that loads automatically when the game starts and persists across scene changes. Used for global managers such as audio or save data.
Coming from Unity's DontDestroyOnLoad singleton; an Unreal GameInstance subsystem.
Godot registers it as a real node in the tree, so it has _ready(), signals, and a scene position. You do not write the instance plumbing yourself.
C
CanvasLayer
A node that creates a separate 2D rendering layer. Used for UI such as a HUD or menus that should not move with the camera.
Coming from Unity Canvas set to Screen Space Overlay; Unreal UMG on the viewport.
If your score label scrolls away with the level, it is under a Node2D instead of a CanvasLayer. This is the usual cause.
CharacterBody2D/3D
A physics body type for player-controlled characters. Provides move_and_slide() for movement with collision handling.
Coming from Unity Rigidbody plus CharacterController; Unreal Character with CharacterMovement.
Your code owns the velocity and the engine resolves the collision. Set velocity in _physics_process, then call move_and_slide(); is_on_floor() is only accurate after that call.
G
GDExtension
A system for writing Godot extensions in C, C++, Rust, or other compiled languages. Used for performance-critical code.
Coming from Unity native plugins; Unreal C++ modules.
Unlike older module builds it does not require recompiling the engine, so an extension ships as a library next to your project.
GDScript
Godot's built-in scripting language. Python-like syntax with optional static typing, designed specifically for game development.
Coming from Fills the role of C# in Unity or C++ and Blueprints in Unreal.
Typing is optional but worth writing. `var speed := 300.0` is a float forever; `var speed = 300.0` is a Variant that will accept a string later and fail somewhere else.
GI
Global illumination. GI describes lighting that includes interactions between surfaces, such as bounced light. In Godot, GI techniques supplement direct lights with indirect illumination.
For example: Light hits a red wall and gives the nearby floor a red tint.
Choose a GI method for the scene.. Renderer support depends on the method.
Groups
A tagging system for Nodes. Add nodes to groups like 'enemies' or 'collectibles', then query or call methods on all members.
Coming from Unity tags, but a node can hold many at once.
Membership is changeable at runtime, and `is_in_group("player")` inside a body_entered handler is the standard way a pickup checks who touched it.
I
Input Map
Project settings where you define named input actions (like 'jump' or 'move_left') and bind them to keys, buttons, or axes.
Coming from Unity Input Actions; Unreal Enhanced Input actions.
Gameplay code should ask for an action name, never a key code. Set the actions up before you write the controller; retrofitting means touching every line that read a key.
J
Jolt Physics
A high-performance 3D physics engine integrated into Godot 4, used in place of the older GodotPhysics 3D backend.
Coming from Comparable in role to PhysX in Unity or Chaos in Unreal.
It affects 3D only; 2D physics is unchanged. Check which backend your project targets in Project Settings before you tune 3D behaviour.
L
LightmapGI
Baked global illumination. LightmapGI calculates lighting ahead of time and stores it for use in the game. It suits mostly static environments; changing baked geometry or lights requires a new bake.
For example: Bake a room whose walls and lamps stay in place, then check moving objects separately.
Add LightmapGI; prepare lightmap UVs and bake.. Baked lightmaps display in all three renderers. Baking needs RenderingDevice-capable hardware.
M
move_and_slide()
A CharacterBody method that moves the body along its velocity, handles collisions, and slides along surfaces.
Coming from Unity CharacterController.Move() with slope handling built in.
It reads the body's velocity property rather than taking an argument, and it must be called from _physics_process for is_on_floor() to be meaningful.
MSAA
Multisample antialiasing. MSAA smooths geometry edges by taking extra coverage samples. It helps silhouettes look cleaner, but does not fix every kind of texture or shading shimmer.
For example: Compare a diagonal platform edge with MSAA off and at 2×. Check the GPU cost too.
Project Settings → Rendering → Anti Aliasing → Quality → MSAA 3D. MSAA 3D is available in all three renderers.
N
Node
The fundamental building block in Godot. Characters, UI elements, sounds, cameras, and most game pieces are Nodes. Nodes form a tree hierarchy.
Coming from Closest to a Unity GameObject plus one component, or an Unreal SceneComponent.
A Node is already typed: Sprite2D draws, CharacterBody2D moves and collides. You compose behaviour by combining typed nodes, not by attaching components to a generic object.
P
PackedScene
A resource that stores a scene. Used with preload() or load() and instantiate() to create copies of a scene at runtime.
Coming from A Unity prefab reference you would Instantiate.
instantiate() creates the object but leaves it outside the tree, where nothing runs. It only becomes live when a parent calls add_child(), and that parent owns its lifetime.
Q
queue_free()
Safely deletes a Node at the end of the current frame. The preferred way to remove or destroy nodes.
Coming from Unity Destroy(gameObject); Unreal Destroy().
The node still answers for the rest of this frame and is gone on the next. Guard a reference you may have freed with is_instance_valid() before touching it.
R
Resource
A data container (textures, scripts, materials, custom data). Resources are shared by reference and can be saved as .tres files.
Coming from Unity ScriptableObject and assets; Unreal Data Asset.
Resources hold data, not a node tree. If the thing has children and a transform it is a scene; if it is a table of stats, it is a .tres Resource.
RigidBody2D/3D
A physics body driven by the physics engine. Used for objects that should respond to gravity, forces, and collisions realistically.
Coming from Unity Rigidbody with no CharacterController; an Unreal actor with Simulate Physics on.
Do not set position directly on one. Apply forces or impulses and let the simulation move it, or you will fight the solver every frame.
S
Scene
A saved tree of Nodes that can be reused (instanced) throughout your project. Scenes are like prefabs in Unity or Blueprints in Unreal.
Coming from Unity Prefab, Unreal Blueprint Class.
A scene is just a .tscn file with one root node. Any scene can be a level, a reusable object, or a UI panel; the root node decides which.
SceneTree
The global object managing all active scenes. Access via get_tree(). Used for pausing, changing scenes, groups, and timers.
Coming from Unity's SceneManager plus the Time and pause plumbing.
`get_tree().create_timer(1.0).timeout` is the shortest delay in the engine, and `get_tree().call_group()` calls a method on every node in a group.
SDFGI
Signed distance field global illumination. SDFGI approximates indirect lighting around the camera using distance-field representations of the scene. It is useful for larger environments, but can show light leaks and changes between detail levels.
For example: Measure a large outdoor scene while moving the camera, not just while standing still.
WorldEnvironment → Environment → SDFGI. Forward+ only.
ShaderMaterial
A material that uses a custom shader written in Godot's GLSL-like shading language, for advanced visual effects.
Coming from Unity ShaderLab or Shader Graph material; Unreal material instance.
Uniforms marked with the shader's own export syntax appear in the Inspector, so a shader parameter can be tuned or tweened like any other property.
Signal
An event system for decoupled communication between Nodes. A node emits a signal, and other nodes connect to it to react.
Coming from UnityEvent, C# delegate, or an Unreal Blueprint event dispatcher.
Declare with `signal died`, fire with `died.emit()`, listen with `enemy.died.connect(_on_enemy_died)`. The emitter never needs to know who is listening, which is the whole point.
SSAO
Screen-space ambient occlusion. It darkens tight corners and contact areas using the camera image, helping objects feel grounded. It adds occlusion, not bounced light.
For example: Look where a crate meets the floor. SSAO can make that contact easier to read.
WorldEnvironment → Environment → SSAO. Forward+; simplified in Compatibility since Godot 4.6. Not Mobile.
SSGI / SSIL
Screen-space global / indirect lighting. SSGI means screen-space global illumination. Godot offers SSIL: screen-space indirect lighting. It adds small-scale bounced light from visible surfaces, but is not a complete GI solution or a direct replacement for another engine’s SSGI.
For example: Use it to supplement a GI setup. Off-screen or hidden surfaces cannot contribute reliably.
WorldEnvironment → Environment → SSIL. Godot SSIL: Forward+ only.
SSR
Screen-space reflections. SSR uses visible scene information to add reflections to surfaces. It can show a moving character on a shiny floor, but cannot reliably reflect things outside the camera view.
For example: Turn the camera: a reflection may disappear when its source leaves the screen.
WorldEnvironment → Environment → SSR. Forward+ only.
StaticBody2D/3D
A non-moving physics body. Use it for walls, floors, platforms, and anything other bodies collide with but should not move.
Coming from Unity collider on a static GameObject; Unreal static mesh with collision.
Cheapest body type there is, because the engine never integrates motion for it. Level geometry should almost always be static.
T
TileMapLayer
A node for building 2D levels from a tile set. Each layer is its own node, with its own tiles, collision, and rendering order.
Coming from Unity Tilemap plus Tilemap Renderer; Unreal Paper2D tile map.
Modern Godot puts each layer in its own node rather than nesting layers inside one TileMap, so background, ground, and hazards can carry different collision and z ordering.
Tween
An animation system for smoothly interpolating properties over time. Created with create_tween() and chained with tween_property().
Coming from DOTween in Unity; Unreal timelines for simple property moves.
A tween created with create_tween() is bound to the node's lifetime and dies with it, so a freed node never leaves an animation running against nothing.
V
Viewport
A node that creates its own rendering surface. The root of every scene tree is a Viewport. Used for split-screen, minimaps, and render targets.
Coming from Unity RenderTexture and a second Camera; Unreal SceneCapture.
A SubViewport rendering a second camera into a texture is how minimaps, security monitors, and portal effects are built.
VoxelGI
Voxel-based global illumination. VoxelGI represents a scene region as a grid of small volumes to calculate indirect light and reflections. Bake its scene data, then use it with dynamic lighting.
For example: Try a small room first. Thin walls can leak light through the voxel representation.
Add a VoxelGI node, fit its volume, and bake.. Forward+ only.
_
_physics_process(delta)
Called at a fixed rate, 60 times per second by default. Use it for physics code, movement, and collision checks.
Coming from Unity FixedUpdate(); Unreal's fixed-step physics tick.
Setting velocity in _process instead of here is the most common cause of jitter for developers arriving from Unity.
_process(delta)
Called every rendered frame. Use it for non-physics logic such as animation and UI updates. Delta is the time since the last frame in seconds.
Coming from Unity Update(); Unreal Tick().
Frame rate varies, so always multiply movement by delta. Anything touching a physics body belongs in _physics_process instead.
_ready()
A virtual function called when a Node and all of its children have entered the scene tree. Used for initialisation.
Coming from Unity Start(); Unreal BeginPlay().
It runs bottom-up: children are ready before their parent, so a parent can safely touch its children in _ready() but not the other way round.