Reference quest

Editor Guide. Learn the editor workflow that makes Godot fast: scene tree, inspector, debugger, and dock rhythm.

10-20 min · Godot 4.7
Godot editor orientation

Use the editor as a daily production loop

Learn the panels and shortcuts by workflow: scene tree, inspector, script editor, debugger, project settings, then the shortcuts that speed up real iteration.

What to practice

A useful first editor loop

  1. Create a focused test scene.
  2. Add the smallest set of nodes needed.
  3. Expose tuning values in the Inspector.
  4. Run with F6 and inspect Remote.
  5. Save reusable node branches as scenes.
Section 1 of 7

Daily Workflow

The normal loop is: create or open a scene, select nodes, edit properties, run, inspect the live tree, then commit the working pattern into reusable scenes.

3 practices

Use scenes as prefabs

Ctrl+Shift+A

Instance reusable scenes into other scenes. This is the Godot habit that replaces many Unity prefab and Unreal Blueprint Class workflows.

Practice Create Player.tscn, then instance it into Level01.tscn.

Run the smallest useful scene

F6

Use Run Current Scene while building a player, pickup, menu, or enemy. Switch to F5 once the whole project flow matters.

Practice Open a test scene and make F6 your default iteration key.

Split work by node responsibility

Scene tree

Keep each node's job obvious: movement script on the character body, detection script on the area, animation on the animation node.

Practice Rename three nodes so their role is clear at a glance.
Section 2 of 7

Scene Tree

The Scene dock is the project structure you touch most. Parent nodes define transform ownership, lifecycle order, and reusable scene boundaries.

4 practices

Pick the right root

New Scene

Use Node2D for 2D gameplay, Node3D for 3D, Control for UI, and Node for managers or pure logic scenes.

Practice Create one scene with each root type so the dock layout becomes familiar.

Add children intentionally

Ctrl+A

Add CollisionShape2D under bodies, Sprite2D under visual roots, Area2D under sensors, and Timer under objects that own timing.

Practice Build a Player root with Sprite2D, CollisionShape2D, Camera2D, and a small script.

Save branches as reusable scenes

Right click

When a subtree becomes a reusable object, save it as its own scene instead of duplicating the full hierarchy.

Practice Turn a pickup node tree into Coin.tscn and instance it twice.

Use groups for loose relationships

Node tab

Groups are useful for player, enemy, interactable, saveable, and damageable categories without hard references.

Practice Add your player to a player group and detect it from an Area2D.
Section 3 of 7

Inspector

The Inspector is where exported variables, node properties, signals, resources, and scene overrides become visible.

3 practices

Expose tuning values

@export

Use @export for speed, jump strength, damage, cooldowns, and scene references you need to tune without opening code.

Practice Export speed and jump_velocity on a CharacterBody2D script.

Reset risky changes

Right click

Right-click properties to reset to default, copy values, or inspect property paths before wiring scripts.

Practice Change a node's scale, reset it, then copy the position value.

Connect signals from the Node tab

Node dock

Signals are Godot's clean event wiring. Use them for buttons, areas, timers, animation finishes, and game-state notifications.

Practice Connect an Area2D body_entered signal to its own script.
Section 4 of 7

Script Editor

The script editor is strongest when you use type hints, exported values, find-in-files, and debugger links instead of treating it like a plain text box.

3 practices

Use lifecycle methods deliberately

_ready

_ready() is setup, _process(delta) is frame logic, _physics_process(delta) is physics logic, and _input(event) is event handling.

Practice Move movement code from _process to _physics_process if it touches collision.

Search before guessing

Ctrl+Shift+F

Find in Files is the fastest way to understand how a project names actions, groups, autoloads, and signals.

Practice Search for Input.is_action_pressed and inspect every action name.

Lean on typed GDScript

: Type

Type hints improve completion and make refactors safer. Use them for exported values, function parameters, and return types.

Practice Add return types to three small functions.
Section 5 of 7

Debugging

Debugging in Godot means watching the running scene, not only reading prints. The Remote tree and debugger tabs show what actually exists at runtime.

3 practices

Inspect the live scene tree

Remote

Run the game, switch Scene from Local to Remote, then inspect spawned nodes, transforms, and live property values.

Practice Spawn one object at runtime and confirm it appears in Remote.

Use breakpoints for state bugs

F9

Breakpoints let you inspect variables when a condition happens instead of printing every frame.

Practice Break inside a pickup signal and inspect the entering body.

Watch Output and Debugger together

Bottom dock

Use Output for errors and prints, Debugger for stack traces, monitors, profiler data, and remote object inspection.

Practice Trigger one error intentionally, then follow the file link back to the script.
Section 6 of 7

Project Settings

Project Settings control the engine-level defaults that make tutorials work: input actions, autoloads, display size, physics layers, and export behavior.

3 practices

Create Input Map actions first

Input Map

Use action names like move_left, move_right, jump, attack, interact, pause. Code should read actions, not raw key names.

Practice Add four movement actions and test them in the Input Guide.

Name physics layers

Layer Names

Named layers keep collision matrices readable when you add players, enemies, world, pickups, projectiles, and sensors.

Practice Name at least Player, World, Enemy, Pickup, and Sensor.

Use Autoloads for global services

Autoload

SaveManager, AudioBus, Settings, and GameState are reasonable autoloads. Regular gameplay objects are usually not.

Practice Create a tiny GameState autoload with a score variable.
Section 7 of 7

Shortcuts

Shortcuts matter because they reduce iteration friction. Learn the keys that change what you do every minute, not obscure commands.

4 practices

Run project

F5

Runs the main scene configured in Project Settings. Use this when testing the full game flow.

Practice Set your main scene, then run it with F5.

Run current scene

F6

Runs the open scene. Best for isolated player, UI, enemy, pickup, or level testing.

Practice Make a test scene and run only that scene.

Add node

Ctrl+A

Opens the node picker. Type the node name immediately instead of scrolling.

Practice Add an Area2D, CollisionShape2D, and Timer without touching the mouse.

Focus selected

F

Centers the viewport camera on the selected node. Essential when scenes get large.

Practice Select a distant node and focus it in 2D or 3D view.
Input entry point Set actions before wiring movement.Physics next Choose bodies and collision patterns.Save systems Persist progress after the loop works.
Tutor Checkpoint

Lock the pattern in

Before jumping to the next page, turn the idea into one tiny scene or script. That is where the Godot habit sticks.

Unity habit

The editor is lighter, so iteration depends more on clean scene structure.

Unreal habit

Expect fewer wizard flows and more direct scene/script ownership.

Godot habit

Use docks, quick open, debugger, and remote scene tree as daily tools.

Try this

Debug one running scene with the Remote tab and inspect live node values.

Next up
Input Guide Core Systems
→

Related Guides

Asset Pipeline Guide ReferenceUnity to Godot Migration MigrationScene Builder Interactive Labs