Menu

© 2026 UhiyamaLab

JPEN
BLOGTOOLSPRODUCTNOTES

Godot Technical Notes

Technical notes for Godot game engine. All 64 articles are organized as a learning path you can follow in order, from fundamentals to advanced topics.

Scenes and Nodes in Godot - A Complete Guide to the Basics

Basics2025-12-06

A practical explanation of scenes and nodes, the two concepts at the heart of Godot Engine, including performance considerations and best practices.

Organizing a Godot Project - Folder Structure, Naming Conventions, res:// and user://

Basics2026-07-09

Illustrated guide to keeping a Godot project tidy: folder structures (by type and by feature), Godot's naming conventions (snake_case / PascalCase), the difference between res:// and user://, and how to manage the project with git.

How to Set Up VSCode / Cursor as Godot's External Editor

Basics2025-08-13

How to configure VSCode or Cursor as Godot's external editor to improve your workflow with AI completion, advanced debugging, and LSP integration.

GDScript Syntax Basics - Variables, Functions, Control Flow, Arrays and Dictionaries

Basics2026-07-09

A beginner's guide to the basic syntax of GDScript, the language that drives Godot games. Variables and types, functions, if/for/while/match, arrays and dictionaries, one at a time with small working examples.

Sponsored

Debugging Techniques and print_debug - Fixing Bugs Efficiently in Godot Engine

Basics2025-12-08

How to fix bugs efficiently by making strategic use of Godot Engine's debugging tools and the print_debug function, written for beginners through intermediate developers.

Complete Guide to Static Typing in GDScript: Better Performance and Fewer Bugs

Basics2025-12-08

Master static typing in GDScript to prevent bugs before they happen and get the most out of performance. Practical techniques with code examples.

Controlling Pause Behavior with Process Mode

Basics2025-06-20

A guide to Godot Engine's pause system and the Process Mode property on nodes. Covers the basics, building UI that keeps running while paused, cutscene and dialogue use cases, and performance considerations.

Custom Nodes and Editor Extensions (class_name, @icon, @export)

Basics2026-02-08

How to define custom node types with class_name and make them pleasant to use in the editor with @icon and @export. Covers custom Resources and EditorInspectorPlugin as well.

Sponsored

Extending the Godot Editor with EditorPlugin (@tool, Custom Docks, Inspector)

Basics2026-02-08

How to add custom docks, toolbar buttons, and inspector plugins using Godot's @tool annotation and the EditorPlugin class. Covers plugin.cfg setup through best practices.

Writing Unit Tests in Godot with GUT

Basics2026-02-08

How to write automated tests with the Godot Unit Test (GUT) addon. Covers writing tests, assertions, signal tests, and scene tests.

_process vs _physics_process: Choosing the Right One

GDScript2025-12-10

The difference between _process and _physics_process, the basics of variable and fixed timesteps, and best practices for choosing between them.

Connecting Nodes with Signals

GDScript2025-12-06

How to use Godot's signals to keep UI, sound, and game flow loosely coupled, explained with concrete game implementation examples.

Sponsored

await and Coroutine Basics

GDScript2025-12-08

How to use Godot 4's await to write readable waiting logic for timers, animations, dialogue, and cutscenes, explained with game implementation examples.

Managing Data Across Scenes with Autoload

GDScript2025-06-20

How to use Godot's Autoload to manage the data and features your whole game shares: score, settings, volume, scene transitions, and more.

Managing AI and Player States with a State Machine

GDScript2025-12-06

How to organize player and enemy AI states in Godot with a state machine, from the enum/match approach up to state classes, with practical examples.

OOP Design Patterns in GDScript

GDScript2026-02-08

Composition, decorator, and factory patterns that help as your Godot game grows, explained from the pain of inheritance-only design through to working implementations.

Sponsored

Managing Dependencies and Avoiding Cyclic References

GDScript2025-12-10

Why references between Player, HUD, Inventory, and ItemData get tangled in Godot, and how to keep dependency direction clean with signals, Autoload, WeakRef, and argument passing.

Choosing the Right Input Check Method

Input2025-06-20

How to choose between Godot's is_action_pressed, is_action_just_pressed, and is_action_just_released, with real examples for movement, jumping, variable jumps, charge attacks, and UI.

Managing Key Bindings with InputMap

Input2025-06-20

How to map keyboard, mouse, and gamepad input to in-game actions with Godot's InputMap, covering 8-way movement, in-game rebinding, and saving and restoring settings.

Choosing the Right 2D Physics Body

Physics2025-12-08

How to choose between Godot's StaticBody2D, RigidBody2D, CharacterBody2D, and AnimatableBody2D, using players, enemies, crates, floors, and moving platforms as examples.

Sponsored

CharacterBody2D Motion Modes

Physics2025-06-20

How to choose between Grounded and Floating Motion Mode on Godot's CharacterBody2D, using platformers, Metroidvanias, top-down RPGs, and twin-stick shooters as examples.

Area Detection and Triggers with Area2D

Physics2025-12-08

How to use Godot's Area2D for item pickups, enemy detection ranges, event triggers, and damage-over-time hazards, starting from signals and collision layers/masks.

Organizing Collision Detection with Collision Layers and Masks

Physics2025-06-20

A practical guide to Godot's Collision Layer and Collision Mask, using players, enemies, walls, attack hitboxes, and item pickups as examples, plus a checklist for tracking down detections that don't fire.

move_and_slide vs move_toward: Implementing Knockback

Physics2025-06-20

The difference between move_and_slide() for CharacterBody2D and move_toward() for easing values toward a target, covering knockback, the classic wall-clipping mistake, and velocity decay.

Sponsored

3D Character Movement with CharacterBody3D - Gravity, Jumping, and a Third-Person Camera

Physics2026-07-09

3D character movement in Godot from the ground up. Gravity and is_on_floor on CharacterBody3D, WASD movement and jumping, converting input into camera-relative directions, and a third-person camera with SpringArm3D, with working code and diagrams.

AnimatedSprite2D vs AnimationPlayer: When to Use Which

Animation2025-06-20

A beginner-friendly guide to choosing between Godot's AnimatedSprite2D and AnimationPlayer, based on real production situations like sprite playback, attack hitboxes, sound effects, and UI polish.

Advanced AnimationPlayer Techniques

Animation2025-12-08

How to sync Godot's AnimationPlayer with game logic using keyframes, tracks, method calls, and the RESET animation.

Smooth Animation with Tween

Animation2025-12-06

How to implement value changes over time with create_tween() for UI effects, damage flashes, HP bars, moving platforms, and more, covering easing, chaining/parallel, and await.

Sponsored

White Flash on Damage with the modulate Property

Animation2025-06-20

How to implement a white flash when a character takes a hit in Godot, using the modulate property and Tween. Covers the HDR principle, handling rapid consecutive hits, when to reach for shaders, and wiring it into a hit reaction.

Managing Complex Animation with AnimationTree and State Machines

Animation2025-12-08

How to efficiently manage complex character animation such as idle, walk, run, and jump using Godot's AnimationTree and state machines, explained through state graph thinking and practical code examples.

3D Skeletal Animation in Godot: AnimationPlayer and AnimationTree

Animation2026-02-08

A practical guide to Godot 4's Skeleton3D and bones, 3D animation playback with AnimationPlayer, directional blending with BlendSpace, and foot placement with SkeletonIK3D.

Control Nodes and Layout Containers - Building Responsive UI in Godot Engine

UI2025-12-08

How to build responsive UI that adapts to any screen size using Godot's Control nodes and layout containers, covering anchors, choosing the right container, nesting, and Size Flags with practical examples.

Sponsored

Building Consistent UI with the Theme System - Unified Design in Godot

UI2025-12-08

How to manage your UI's look in one place with Godot's theme system, covering the five theme items, inheritance priority, StyleBoxFlat, and implementing a dark mode toggle with practical examples.

Building a Simple Dialogue System (Text, Choices, and Branching)

UI2025-12-08

How to build an extensible dialogue system in Godot with a typewriter effect, choices, branching, and data-driven design backed by JSON.

Designing an Inventory System: Item Management with Resources and Signals

UI2025-12-08

How to design an extensible inventory system in Godot that separates data, logic, and UI using Resources and signals, explained through a three-layer architecture and a practical end-to-end flow.

Godot 3D Space Fundamentals with Node3D and MeshInstance3D

Rendering2025-12-08

The essentials for starting 3D development in Godot: what Node3D and MeshInstance3D each do, the Y-Up right-handed coordinate system, Transform3D, and how parenting and pivots work, with practical code examples.

Sponsored

Godot Camera2D Techniques: Smooth Follow, Screen Shake, and Dynamic Zoom

Rendering2025-12-08

Practical techniques for getting the most out of Godot's Camera2D: smooth follow with lerp, trauma-based screen shake, dynamic zoom with Tween, and a boss intro sequence that combines all three.

Godot 2D Lighting Basics: Adding Depth with PointLight2D and Shadows

Rendering2025-12-10

How to implement 2D lighting and shadows in Godot with PointLight2D and LightOccluder2D: the three elements of light source, occluder, and subject, how shadows work, when to use DirectionalLight2D instead, and building a flashlight.

Explosions, Smoke, and Magic Effects with GPUParticles2D

Rendering2025-12-08

How to build explosion, smoke, and magic effects with Godot's GPUParticles2D: the three required elements, shaping a particle's lifetime with ParticleProcessMaterial, One Shot and Explosiveness, and optimizing with pooling.

Fragment Shader Basics: Controlling Color and Effects Per Pixel

Rendering2025-12-08

A careful introduction to fragment shaders in Godot, starting from the difference between CPU and GPU. Covers color manipulation and dynamic effects with COLOR, UV, and TIME, building a hit flash, and performance optimization by avoiding if statements, with concrete code and diagrams.

Sponsored

Introduction to VisualShader: Building Shaders by Connecting Nodes

Rendering2026-07-09

A beginner's guide to Godot's VisualShader. Learn through diagrams how to build shaders by connecting nodes instead of writing code, the main node types and how they connect to Output, how it maps to code shaders, and when to use each.

Making Use of SubViewport: Minimaps, 3D Previews, and Render Textures

Rendering2025-12-08

An explanation of Godot's SubViewport starting from the core concept of an independent virtual screen. Covers building minimaps, 3D inventory previews, and security-camera-style render textures, plus performance optimization through Update Mode and resolution, with concrete code and diagrams.

Full-Screen Post-Processing Shaders: Screen Effects with hint_screen_texture

Rendering2026-07-09

A guide to post-processing shaders that affect the whole screen in Godot. Covers the CanvasLayer plus full-screen ColorRect setup, reading the rendered screen with hint_screen_texture, standard recipes like vignette, chromatic aberration, and CRT scanlines, and a hands-on damage flash.

Local Co-op with Split Screen: Building Split Views with SubViewport

Rendering2026-07-09

How to build a two-player local co-op split screen with Godot's SubViewport. Covers the layout of two side-by-side SubViewports, sharing one world through world_2d/world_3d, routing input per player, and performance considerations, with diagrams and code.

Sponsored

Audio Management Basics: Mastering AudioStreamPlayer and Audio Buses

Audio2025-12-10

Godot audio from the ground up with AudioStreamPlayer and Audio Buses. Covers playing sound effects without cutting out, splitting BGM/SFX/Voice into buses, centralized control with an AudioManager singleton, slider volume control, and bus effects like reverb, with code and diagrams.

Sound Design with AudioBus Effects: Reverb, Compressor, and EQ

Audio2026-02-08

How to shape acoustic space by applying reverb, compressor, EQ, and other effects to Godot's AudioBus. Covers the roles of the three main effects, processing order (chains), dynamically applying reverb when entering a cave, and settings by use case, with code and diagrams.

3D Audio and Spatial Sound: Conveying Distance and Direction with AudioStreamPlayer3D

Audio2026-02-08

How to implement 3D spatial audio with Godot's AudioStreamPlayer3D. Covers choosing an attenuation model, separating listener from camera with AudioListener3D, the Doppler effect, Area3D reverb zones, distance filtering, and performance optimization, with code and diagrams.

Adaptive Music: Building Situation-Driven Soundtracks with AudioStreamInteractive

Audio2026-02-08

How to implement adaptive music that changes with the game situation using Godot 4.3+'s AudioStreamInteractive and AudioStreamSynchronized. Covers clip switching versus layering, transition timing, and building an exploration/combat music switcher, with code and diagrams.

Sponsored

NavigationRegion2D and Navigation Meshes - Building a Map Your AI Can Walk On

Navigation2025-12-08

How NavigationRegion2D and navigation meshes work in Godot. Covers the difference from physics-based movement, baking the walkable area, keeping distance from walls with agent_radius, and handling moving obstacles with NavigationObstacle2D, all explained with diagrams.

Pathfinding with NavigationAgent2D - Chasing and Patrolling Enemy AI

Navigation2025-12-08

How to implement chasing and patrolling enemy AI that avoids obstacles using Godot's NavigationAgent2D. Covers the basic processing cycle, what get_next_path_position actually returns, chase and patrol implementations, agent-to-agent avoidance with RVO, and optimizing path recalculation, with code and diagrams.

Stealth Game Vision Systems - Building an FOV with Area3D and RayCast3D

Navigation2026-02-08

How to implement a stealth game FOV (field of view) system by narrowing down with Area3D, checking the view angle with a dot product, and confirming line of sight with RayCast3D. Covers the three-stage check, multiple raycasts, and staged alert levels, with code and diagrams.

Designing AI with Behavior Trees - GDScript Implementation and Enemy AI

Navigation2026-02-08

Flexible AI design with behavior trees (BT) in Godot. Covers how BTs differ from state machines, the four node types, implementing Sequence/Selector/Leaf, assembling an enemy AI tree, and the Blackboard pattern, with code and diagrams.

Sponsored

Creating and Using Custom Resources - Data-Driven Design in Godot

Data2025-12-08

How to build data-driven design in Godot with custom resources (classes extending Resource). Covers separating logic from data, editing in the Inspector and saving to .tres, deriving subtypes through inheritance, staying safe at runtime with duplicate(), and choosing between JSON, CSV, and SQLite, with diagrams throughout.

Implementing a Save/Load System - Choosing Between JSON, ConfigFile, and Custom Resources

Data2025-12-08

An illustrated guide to the three main ways to persist game data in Godot (ConfigFile, JSON, and custom resources), from the basics of user:// through implementation, when to use which, and tamper resistance. Includes a hands-on checkpoint save.

Getting Started with TileMapLayer - Tilemap Basics, Collision, and Multiple Layers

Data2026-07-09

The basics of building 2D maps with TileMapLayer in Godot 4.3+. Covers the relationship between TileMapLayer and TileSet, adding collision to tiles via physics layers, splitting ground and decoration across multiple layers, and placing tiles from script with set_cell, all illustrated.

Setting Up Autotiling with the Terrains Feature

Data2025-06-20

A step-by-step walkthrough of Godot 4's Terrains (autotiling) feature, with editor screenshots, from creating a TileMapLayer node through understanding Peering Bits, painting a map, and procedural generation from GDScript.

Sponsored

Implementing Localization with TranslationServer

Data2026-02-08

A practical, illustrated guide to Godot's TranslationServer localization system, from creating and registering a CSV translation file and displaying text with tr(), through placeholders, switching languages at runtime, and auto-detecting the OS language.

Flexible Object Checks with Node Groups

Scene2025-06-20

Godot's group feature tags nodes so you can manage them by role. Covers checks with is_in_group, broadcasting commands with call_group, performance caveats, and when to use metadata, class_name, or duck typing instead, all with diagrams.

Using Marker2D as a Management Node

Scene2025-06-20

How to use Marker2D to manage spawn points, weapon muzzles, and effect anchors. Covers the difference from Node2D, attaching data with @export, using global_position, and tips for keeping markers organized.

Mass-Producing NPCs with Editable Children and Scene Inheritance

Scene2025-06-20

How to efficiently produce enemy and NPC variations in Godot. Covers scene inheritance for managing only the differences and propagating parent changes, one-off tweaks with Editable Children, and when to use data-driven Resources instead.

Sponsored

Stabilizing FPS in Godot: Frame Rate Management and Optimization

Performance2025-12-10

How to eliminate stutter in Godot games. Illustrates the difference between physics ticks and rendering frames, V-Sync and max_fps, physics interpolation that kills jitter for good, and a measurement-first approach to optimization.

The Complete Guide to Object Pooling - Killing Stutter in Godot Through Reuse

Performance2025-12-10

Object pooling in Godot, explained to remove instantiation spikes. Covers reusing objects instead of creating and destroying them, the trap where _ready() isn't called, fully stopping processing and collisions, building a bullet pool, and deciding when to adopt it, with diagrams and code.

Dynamic Loading and Resource Management in Godot - load, preload, and Background Loading

Performance2026-02-08

A practical guide to choosing between load() and preload() in Godot, asynchronous background loading with ResourceLoader, building a loading screen with a progress bar, and managing memory with WeakRef, explained with diagrams and code.

Building Your Godot Project for Every Platform

Build2025-12-10

A reliable guide to exporting Godot projects to Windows, macOS, Android, and Web. Illustrates export templates and PCK files, common traps like case sensitivity, the header settings Web needs, build size optimization, and a final pre-ship checklist.

Sponsored