01Scenes and Nodes in Godot - A Complete Guide to the Basics
A practical explanation of scenes and nodes, the two concepts at the heart of Godot Engine, including performance considerations and best practices.
Basics
10 notes01
02Organizing a Godot Project - Folder Structure, Naming Conventions, res:// and user://
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.
03How to Set Up VSCode / Cursor as Godot's External Editor
How to configure VSCode or Cursor as Godot's external editor to improve your workflow with AI completion, advanced debugging, and LSP integration.
04GDScript Syntax Basics - Variables, Functions, Control Flow, Arrays and Dictionaries
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
05Debugging Techniques and print_debug - Fixing Bugs Efficiently in Godot Engine
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.
06Complete Guide to Static Typing in GDScript: Better Performance and Fewer Bugs
Master static typing in GDScript to prevent bugs before they happen and get the most out of performance. Practical techniques with code examples.
07Controlling Pause Behavior with Process Mode
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.
08Custom Nodes and Editor Extensions (class_name, @icon, @export)
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
09Extending the Godot Editor with EditorPlugin (@tool, Custom Docks, Inspector)
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.
10Writing Unit Tests in Godot with GUT
How to write automated tests with the Godot Unit Test (GUT) addon. Covers writing tests, assertions, signal tests, and scene tests.
GDScript
7 notes
01_process vs _physics_process: Choosing the Right One
The difference between _process and _physics_process, the basics of variable and fixed timesteps, and best practices for choosing between them.
02Connecting Nodes with Signals
How to use Godot's signals to keep UI, sound, and game flow loosely coupled, explained with concrete game implementation examples.
Sponsored
03await and Coroutine Basics
How to use Godot 4's await to write readable waiting logic for timers, animations, dialogue, and cutscenes, explained with game implementation examples.
04Managing Data Across Scenes with Autoload
How to use Godot's Autoload to manage the data and features your whole game shares: score, settings, volume, scene transitions, and more.
05Managing AI and Player States with a State Machine
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.
06OOP Design Patterns in GDScript
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
07Managing Dependencies and Avoiding Cyclic References
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.
Input
2 notes
01Choosing the Right Input Check Method
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.
02Managing Key Bindings with InputMap
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.
Physics
6 notes
01Choosing the Right 2D Physics Body
How to choose between Godot's StaticBody2D, RigidBody2D, CharacterBody2D, and AnimatableBody2D, using players, enemies, crates, floors, and moving platforms as examples.
Sponsored
02CharacterBody2D Motion Modes
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.
03Area Detection and Triggers with Area2D
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.
04Organizing Collision Detection with Collision Layers and Masks
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.
05move_and_slide vs move_toward: Implementing Knockback
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
063D Character Movement with CharacterBody3D - Gravity, Jumping, and a Third-Person Camera
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.
Animation
6 notes
01AnimatedSprite2D vs AnimationPlayer: When to Use Which
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.
02Advanced AnimationPlayer Techniques
How to sync Godot's AnimationPlayer with game logic using keyframes, tracks, method calls, and the RESET animation.
03Smooth Animation with Tween
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
04White Flash on Damage with the modulate Property
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.
05Managing Complex Animation with AnimationTree and State Machines
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.
063D Skeletal Animation in Godot: AnimationPlayer and AnimationTree
A practical guide to Godot 4's Skeleton3D and bones, 3D animation playback with AnimationPlayer, directional blending with BlendSpace, and foot placement with SkeletonIK3D.
UI
4 notes
01Control Nodes and Layout Containers - Building Responsive UI in Godot Engine
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
02Building Consistent UI with the Theme System - Unified Design in Godot
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.
03Building a Simple Dialogue System (Text, Choices, and Branching)
How to build an extensible dialogue system in Godot with a typewriter effect, choices, branching, and data-driven design backed by JSON.
04Designing an Inventory System: Item Management with Resources and Signals
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.
Rendering
9 notes
01Godot 3D Space Fundamentals with Node3D and MeshInstance3D
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
02Godot Camera2D Techniques: Smooth Follow, Screen Shake, and Dynamic Zoom
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.
03Godot 2D Lighting Basics: Adding Depth with PointLight2D and Shadows
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.
04Explosions, Smoke, and Magic Effects with GPUParticles2D
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.
05Fragment Shader Basics: Controlling Color and Effects Per Pixel
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
06Introduction to VisualShader: Building Shaders by Connecting Nodes
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.
07Making Use of SubViewport: Minimaps, 3D Previews, and Render Textures
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.
08Full-Screen Post-Processing Shaders: Screen Effects with hint_screen_texture
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.
09Local Co-op with Split Screen: Building Split Views with SubViewport
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
4 notes
01Audio Management Basics: Mastering AudioStreamPlayer and Audio Buses
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.
02Sound Design with AudioBus Effects: Reverb, Compressor, and EQ
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.
033D Audio and Spatial Sound: Conveying Distance and Direction with AudioStreamPlayer3D
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.
04Adaptive Music: Building Situation-Driven Soundtracks with AudioStreamInteractive
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
Navigation
4 notes
01NavigationRegion2D and Navigation Meshes - Building a Map Your AI Can Walk On
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.
02Pathfinding with NavigationAgent2D - Chasing and Patrolling Enemy AI
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.
03Stealth Game Vision Systems - Building an FOV with Area3D and RayCast3D
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.
04Designing AI with Behavior Trees - GDScript Implementation and Enemy AI
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
Data
5 notes
01Creating and Using Custom Resources - Data-Driven Design in Godot
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.
02Implementing a Save/Load System - Choosing Between JSON, ConfigFile, and Custom Resources
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.
03Getting Started with TileMapLayer - Tilemap Basics, Collision, and Multiple Layers
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.
04Setting Up Autotiling with the Terrains Feature
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
05Implementing Localization with TranslationServer
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.
Scene
3 notes
01Flexible Object Checks with Node Groups
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.
02Using Marker2D as a Management Node
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.
03Mass-Producing NPCs with Editable Children and Scene Inheritance
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
Performance
3 notes
01Stabilizing FPS in Godot: Frame Rate Management and Optimization
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.
02The Complete Guide to Object Pooling - Killing Stutter in Godot Through Reuse
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.
03Dynamic Loading and Resource Management in Godot - load, preload, and Background Loading
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.
