Godot Encyclopedia

Why a web developer should care about Godot

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

If Unity feels like a corporate IDE with a subscription (because it is), then Godot is something else. MIT license, 0% royalties, a ~100 MB editor that launches faster than VS Code. Its own ecosystem, its own language, and — for a web developer — a model that is far more intuitive in places.

This encyclopedia runs parallel to the Unity encyclopedia: the same concepts, the same "through web analogies" approach, but a different engine. You can read both, or just one.

What Godot does differently

The main architectural difference from Unity: in Godot a scene is also a prefab. Any object built i…

The Godot stack and its ecosystem

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot has been on the 4.x branch since 2023 (the 4.0 release was March 2023). As of May 2026:

Godot 4.6.3 — the current stable (released May 20, 2026). The 4.6 minor branch was released in January 2026, with patches 4.6.1 (Feb), 4.6.2 (Apr), 4.6.3 (May) — stabilizing Jolt physics and editor fixes. The headline features of 4.6: Jolt became the default physics for 3D, IK returned as a node-based system (TwoBoneIK3D, FABRIK3D, plus 5 more solvers), a new editor theme (Modern), unified docking, a rewritten SSR, LibGodot (the engine as an embedded library). Godot 4.7 — in beta since April 2026…

The Godot Editor, scenes, and nodes

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Editor: the main windows

The Godot Editor is an IDE for content. The main docks (draggable, as in Unity):

3D Viewport — the scene window where you fly around and place nodes. Switchers: 2D / 3D / Script / AssetLib. Scene (top left) — the node tree of the current scene. An analog of the Unity Hierarchy. FileSystem (bottom left) — the project's files. An analog of the Unity Project panel. Inspector (right) — the properties of the selected node or resource. Node (top right) — a tab for viewing/connecting the signals of this node. This is a separate thing relative to Unity. Output / Debugger /…

GDScript, lifecycle, and signals

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

A GDScript file () usually starts with , specifying which node it inherits from:

The main methods Godot calls itself:

* — the object's constructor, even before the node is added to the tree. — the node was added to the scene tree. Parent → children (top-down). — all children are also ready. Children → parent (bottom-up). This is where you do initialization that depends on the children. / — every input event. — a fixed tick. By default 60 Hz (Project Settings → Physics → Common → Physics Ticks Per Second). — every frame (variable timestep, like Unity's Update). — the node was removed from t…

Input — the Input Map and action-based system

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

In Godot, input is a single system: you describe actions in Project Settings and access them from any script. There are no two competing APIs as in Unity (legacy Input vs Input System).

Project → Project Settings → Input Map. You create an action (for example, ) and bind to it any number of keys / gamepad buttons / mouse / touch:

This is the only configuration — there is nothing else to set up.

Polling input through Input

In a script, you read an action through the global (singleton):

input(event) and unhandledinput(event)

Physics — Bodies, Collision, Jolt

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

As of Godot 4.6, Jolt became the default physics engine for 3D — a high-performance engine used in Death Stranding 2 and other AAA games. The old Godot Physics remains available as an option and continues to be the default for 2D.

This means: predictable, scalable 3D physics out of the box. No need to integrate any third-party engines.

Nodes inheriting from that form a physics object:

Area3D — an invisible region with / triggers. Equivalent to a Unity Collider with . PhysicalBone3D — for ragdolls inside Skeleton3D. SoftBody3D — soft bodies (cloth, flags, simple jelly-like objects). Uses me…

Camera and Phantom Camera

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Camera3D — the main node

Camera3D is the node that "looks" into the scene. Only one Camera3D is active at any moment (if you're not using separate viewports). A scene can have several cameras; the active one is the one whose , or the one made active via .

* — (3D, with perspective) or (without, for isometric/2.5D). — field of view in degrees, vertical. The FPS standard is 60–90°. , — clipping planes. A large spread hurts Z-buffer precision (Z-fighting). — a bitmask: which visual layers this camera renders.

The equivalent of Unity's SmoothDamp approach. Godot has no built-in , but it has :

Rendering and Materials

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot picks a renderer when you create a project (you can change it later, but materials may need adapting):

Project → Project Settings → Rendering → Renderer → Rendering Method.

Forward+ + Vulkan — desktop, serious 3D projects, high-end visuals. Mobile + Vulkan/Metal — phones. Compatibility + WebGL 2 — the browser (this is the only path for the web target that works everywhere without COOP/COEP headers).

Compatibility was declared feature-complete in 4.3: lights, shadows, GI (lightmaps), GPU particles — all available, with some limitations.

Mesh, Material, Shader

Lighting and Shadows

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Three built-in light types (plus the upcoming AreaLight3D in 4.7):

DirectionalLight3D — the sun. Parallel rays, infinitely far away. Usually one per scene. OmniLight3D — point light (Unity's Point Light). Emits from a point in all directions with an attenuation radius. SpotLight3D — a cone from a point with an angle and a radius. AreaLight3D — an area light (since 4.7). A rectangular/disc source.

Key properties of each: * — brightness. — color. — a multiplier for indirect light from this source (in GI). — draw shadows. , — shadow artifact settings. — / (baked) / (real-time GI). In the Inspec…

Animation — AnimationPlayer and AnimationTree

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

AnimationPlayer — the main node

holds an AnimationLibrary with a set of resources and plays them. A unique Godot feature — you can animate any property of any node (or even a resource), not just Transform and Material:

Transform (position, rotation, scale) Any property (sprite alpha, , numbers, colors) Shader uniforms — via the property path Method calls (call a function on a timer in a track) Audio (start an AudioStreamPlayer) Nested animations of other AnimationPlayers

Recording animation in the editor

Select the AnimationPlayer in the scene → the Animation editor appears at the bottom.…

3D Audio and AudioBus

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

In Godot, audio is a separate server () with routing through AudioBus. A scene has several player nodes; the project has a single mixer.

AudioStreamPlayer — no positioning. Music, UI sounds, dialogue. AudioStreamPlayer2D — positional for 2D scenes (volume based on distance to the listener). AudioStreamPlayer3D — 3D-positional with attenuation, Doppler, area reverb.

Key properties of AudioStreamPlayer3D:

* — an resource (AudioStreamOggVorbis, AudioStreamMP3, AudioStreamWAV). — volume in decibels. 0 is the original, -10 is quieter, -80 is near silence. — speed/pitch multiplier. — attenuation…

UI — Control Nodes and Containers

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

In Godot, UI consists of Control nodes. This is a separate hierarchy of descendants, with its own layout engine, anchors, and events. Unlike Unity's uGUI / UI Toolkit, here there is a single, built-in UI system.

All Control nodes have: position + size — position and size in pixels. anchors + offsets — anchoring to the parent (like Unity uGUI anchors or CSS absolute). sizeflagshorizontal / sizeflagsvertical — behavior inside a container (, , , ...). theme + themeoverrides — styling.

Anchors — the Essentials

An anchor is a point on the parent to which a side of the current Control is "glued.…

PackedScene and Resource

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

PackedScene — Scene and Prefab in One

Godot's key architectural feature: a scene and a prefab are the same entity. A file stores a tree of nodes; this file can be opened as the project's root scene or instantiated as a child in another scene. Inside the engine, both variants are a resource.

In the Inspector, has the same nodes and components as . Any scene is a template that can be embedded.

In the editor: right-click a node → Instantiate Child Scene → choose a . Or drag-and-drop from the FileSystem into the Scene.

Practice — a First-Person Controller

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

We are building a playable FPS character: it walks, looks with the mouse, jumps, and shoots a ray. We use CharacterBody3D (an analog of Unity's CharacterController, but with a more feature-rich ).

The Head ↔ Player split matters: yaw (horizontal rotation) is applied to the Player (it turns the whole body and the movement direction), while pitch (vertical) is applied only to the Head (so the collider does not tilt).

In Project Settings → Input Map create: (W, ↑) (S, ↓) (A, ←) (D, →) (Space) (Mouse Left) (Escape) — usually present by default

player.gd — the Main Script

Navigation — NavigationServer and AI

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Navigation in Godot 4 consists of NavigationServer3D (the low-level server) and three high-level nodes: NavigationRegion3D, NavigationAgent3D, NavigationLink3D.

A NavigationMesh is a simplified polygonal "walkability map." It is baked from the scene's collisions. Agents pathfind across this map (A under the hood).

Baking the NavigationMesh

Assemble the static geometry. Add a NavigationRegion3D node to the scene. In the Inspector, create a new NavigationMesh resource on this node. The Bake NavigationMesh button in the top toolbar → baking.

Particles — GPUParticles3D and CPUParticles3D

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot has two particle nodes with a similar API:

GPUParticles3D — on the GPU, up to millions of particles. CPUParticles3D — on the CPU, a fallback for weak hardware and the web.

Rule of thumb: GPU where you can, CPU where you must.

ParticleProcessMaterial

The main difference from Unity's Particle System: particle behavior is defined not in the node's inspector, but in a separate resource. This is convenient — you can save it, reuse it, and override it per instance.

The main sections of ParticleProcessMaterial:

Multiplayer — MultiplayerAPI and RPC

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot has built-in high-level multiplayer: MultiplayerAPI + transports + Spawner/Synchronizer nodes. It is the analog of Unity Netcode for GameObjects.

works on top of . Transports:

ENetMultiplayerPeer — UDP, the main one for native platforms. WebSocketMultiplayerPeer — TCP/WebSocket, the only path for the web target. WebRTCMultiplayerPeer — peer-to-peer, NAT traversal via STUN/TURN. OfflineMultiplayerPeer — a stub for single-player.

The standard model is an authoritative server: one peer with ID=1 (the server), the rest are clients with ID >= 2.

Starting a server and a client

Resource loading — preload, load, threaded

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot has no separate system like Unity Addressables — the built-in mechanism covers most scenarios through a few APIs.

preload — static, at parse time

is a GDScript compiler directive. The resource is loaded when the script itself is loaded (once, then cached). It's the fastest way at instantiation time.

Pro: zero stutters at runtime. Con: the asset is always in memory as long as the script lives. Not suitable for heavy geometry that isn't always needed.

load — dynamic, synchronous

blocks the thread until it finishes loading. Suitable for lightweight resources at moments where the pause…

Building and optimization

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

In Godot a build is an Export Preset (a per-platform config) + an Export Template (the engine binary without the editor). First-party platforms: Windows, macOS, Linux, Android, iOS, Web, visionOS (since 4.5).

opens a window with the configs. Add a preset for the platform you need:

Platform (Windows Desktop, Android, Web, ...). Bundle Identifier / Package Name (for mobile/Mac/iOS). Icon and Splash. Permissions (Android — camera, location, etc.). Encryption — encrypt the pack file. Export Mode — All resources / Resources from group / By files. Debug / Release — release produces an optimized bu…

Practice — a third-person platformer with a NavMesh enemy

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

The second practical Godot capstone — a parallel to the Unity TPS chapter. We're building a third-person platformer: a character runs, jumps (with double jump and coyote time), is chased by an AI enemy along a NavMesh, and on death the player respawns at a checkpoint.

We'll use what we covered earlier: CharacterBody3D with , NavigationAgent3D, the Phantom Camera plugin for the third-person view, and a Resource as a ScriptableObject analog.

playermotor.gd — the controller

Phantom Camera for third-person

Install the Phantom Camera plugin (AssetLib → "Phantom Camera" → Install → activate in P…

gdshader in depth — vertex, fragment, light

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

In the rendering chapter we saw a basic ShaderMaterial. Here, in more detail: the structure of a 3D shader, what the vertex/fragment/light functions are, and how to write your own lighting.

Full structure of a spatial shader

What's inside: * — this is for a 3D mesh. For 2D use , for a skybox use , and so on. — flags: (transparency), (culling), (Z-buffer), (diffuse lighting model), (specular), (no lighting). — a parameter visible in the material Inspector and accessible from code via . — a variable passed from vertex to fragment (interpolated across the triangle). — modifies vertices before…

Path3D, PathFollow3D and splines

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot has built-in Path3D and PathFollow3D for movement along a spline. The curve is stored in a resource. No plugins required — it's part of the core engine.

Path3D — a container node with a resource. Describes a curve in space. PathFollow3D — a child node of Path3D. Holds a or property from which Godot computes the position along the curve. Anything placed inside PathFollow3D travels along the spline. Curve3D — a resource with an array of points, each having a position + in/out tangents (for Bezier).

Creating a Path3D in the editor

GridMap — modular levels

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

GridMap is a built-in Godot node for assembling levels from modular blocks on a 3D grid. Think: Minecraft, a Dungeon Crawler, Cities Skylines — where the world consists of reusable tile-sized "bricks".

Make a MeshLibrary resource — a set of meshes with predefined CollisionShape3D. Assign it to a GridMap node. In the Scene View you "paint" with a brush over the 3D grid — each cell gets the mesh selected from the library. Godot renders the whole GridMap with one draw call per mesh type (internal instancing).

This is both faster and more compact than ten thousand separate nodes.

Threading — WorkerThreadPool and Thread

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

In Godot the main thread handles rendering, physics, and scripts. If you procedurally generate a world map in , the game will freeze for a second or two. Threading is the way to move heavy work to background threads.

Three levels of tools

appeared in Godot 4 and is the main path. It manages the threads for you; you just submit tasks.

WorkerThreadPool — basic example

Task: procedurally generate a 1024×1024 heightmap.

The main methods: — submit, returns a . — check whether it's done. — block the main thread until it finishes (called after for cleanup). — a parallel "for each".

Decals — stickers in 3D

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Decal is a node in Godot that projects a texture onto the surfaces beneath it. It's the classic technique for:

Bullet holes on a wall Dirt on the floor, puddles Graffiti, posters Tire tracks Cracks, blood, scorch marks from explosions

It is implemented as a separate render pass and does not sit on the geometry — so you can "stick" it onto any surface without modifying meshes.

Add a Decal node to the scene. In the Inspector, set * — the main texture. (Optional) — a normal map for relief. (Optional) — an Occlusion/Roughness/Metallic mask. Rotate and scale the node: the decal's bounding box de…

@tool and EditorPlugin — extending the editor

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot is written entirely in its own language for the UI — this means that the editor itself can be extended with GDScript code. No C++ plugins, no rebuilds.

Two levels of extension: scripts — ordinary nodes with behavior in the editor. For example, a script that automatically places trees along a spline. EditorPlugin — a real plugin: adds nodes, custom docks, inspectors, gizmos.

@tool — the script runs in the editor

A regular GDScript runs only in Play Mode. Add on the first line — and the script will run right in the Scene View.

TileMap (2D) — modular 2D levels

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

This encyclopedia is about 3D, but Godot has a first-class 2D pipeline, and TileMap is the main tool for modular levels (platformers, top-down RPGs, dungeon crawlers, city builders).

TileMap architecture in Godot 4.x

With Godot 4.3 an important change happened: the classic node is deprecated in favor of nodes.

In a new project, use . One node = one layer (for example, background → details → objects).

TileSet — a with a list of all available tiles (sprite + collision + nav data). TileMapLayer — a that draws tiles from a TileSet on a coordinate grid. Tile — a cell of the TileSet: sprite sour…

XR / OpenXR — VR applications in Godot

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot has built-in OpenXR support right in the core, without separate packages. Compared to Unity this is especially nice: launching a VR project in Godot is literally a few nodes.

OpenXR in Godot — built in

OpenXR is the Khronos Group's open standard for VR/AR. It replaces the SDKs from Oculus, SteamVR, Vive Wave. In Godot 4.x OpenXR is part of the engine, activated in Project Settings → XR.

Project Settings → XR → OpenXR → Enabled = true. Choose interaction profiles: Oculus Touch, Khronos Simple, Valve Index. By default the main ones are enabled. For Android (Quest): Build Profile → Andr…

GDExtension — native plugins in C++ and Rust

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

GDScript is good for most gameplay logic, but sometimes you need to go lower: A voxel engine with millions of blocks Custom real-time shading with complex CPU math Integration with an existing C/C++ library (physics, NN inference, audio DSP) A performance hot path where even statically-typed GDScript isn't enough

GDExtension is the modern way to extend Godot at the native level. It replaced GDNative as of Godot 4.0.

You write code in C++ (via ) or Rust (via ). You compile it into a dynamic library ( / / ). You create a manifest that Godot loads at startup. In the editor your classes appear a…

C# in Godot — practice and nuances

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

GDScript is a great language, but if you come from Unity (or a serious .NET project), you'll want to work in C#. Godot supports this via a separate build — the Godot .NET edition.

How the .NET edition differs

Download the .NET variant from godotengine.org/download. The Steam version has a separate SKU "Godot Engine (.NET)".

Key differences from Unity:

* — mandatory (the code generator adds code for signals). instead of — the attribute for Inspector visibility. instead of — a different syntax. — signals are declared as delegates with the suffix. , (PascalCase) — not , . — you need to explic…

Save / Load — persisting progress

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

Godot has several built-in ways to save progress. Each fits its own task.

Paths and the user:// schema

In Godot there is a special path for all user data — *. On different platforms it points to the right place:

Windows: macOS: Linux: Android: iOS: Web: via a virtual filesystem

The main rule: never write to (it's read-only after the build). All user data goes into .

ConfigFile — for settings

saves in INI format (like Windows .ini files). Ideal for a player config: volume, resolution, key bindings.

This is readable, version-controllable, easy to edit by hand — ideal for settings whe…

Glossary — Godot terms and parallels

Konstantin Ryzhov — Tue, 26 May 2026 00:00:00 GMT

A consolidated list of the key Godot terms mentioned in the encyclopedia. In parentheses — the Unity equivalent, if there is one.

Node — the base class of everything in the scene tree. Derived classes: , , , . (Unity: GameObject, but without a stack of components — one script per node.)

Node3D (formerly Spatial) — a node with a 3D transform. (Unity: GameObject + Transform.)

Control — the base class of UI nodes. With anchors, offsets, layout. (Unity: RectTransform / Control in uGUI.)

Scene Tree — the hierarchy of live nodes in a running game. Accessed via .