Examples
133 projects that open straight in the editor. Every one is plain GDScript that builds its own scene, so there is nothing to import.
Bouncing ball
A ball crossing the screen and bouncing off the edges. The smallest loop there is: read delta, move, invert the velocity.
Follow the mouse
Two shapes chasing the same target, one with lerp and one with move_toward. The lag between them is the whole lesson.
Orbit and spin
Three nested Node2D and two rotations. The child orbits because the parent turns, and the grandchild orbits the child.
Chase and flee
The runner flees the mouse and the chaser follows the runner. Both use direction_to, only the sign changes.
Screen wrap
An Asteroids ship and eight rocks that leave one edge and come back on the other. Two calls to wrapf do it.
Mouse trail
A Line2D that gains a point where the pointer is and drops the oldest one once it is full. The width curve and the gradient do the fade.
Draw with the mouse
Hold the left button to draw. Each stroke is a new Line2D, and the right button clears the canvas.
Follow a curve
A Curve2D built point by point, drawn with tessellate and walked by three PathFollow2D. Progress is the only thing that changes.
Spring damper
A critically damped spring and a lerp follower tracking the same moving target. The spring keeps up, the lerp trails behind.
Grid snap
A free position moving in a loop and the same position passed through snapped. The blue square only ever sits on a grid node.
Bob and float
Nine shapes on the same sine wave, each one a phase step ahead of the last. No Tween and no AnimationPlayer.
Frame vs delta
The same speed constant applied with and without delta, with a distance readout on each row. The second one is only as fast as the frame rate.
Platformer
Gravity, jump and floor detection with CharacterBody2D, over platforms built from code.
Box pile
Sixteen boxes dropped between two walls. The first thing to try when you want to see the solver work.
Joint chain
Twelve links pinned to each other and a heavy weight at the end. Click to push the chain and watch it settle.
Spring joints
Three springs with the same rest length and different stiffness and damping, side by side.
Area detector
A zone that counts what falls through it, using the body_entered and body_exited signals.
Vision cone
Twenty eight rays fanned toward the mouse. Each one turns red where it hits a wall, which is line of sight in its simplest form.
Shape cast
A box that asks where it would stop before moving. The ghost is the safe fraction the cast returns.
One way platforms
Jump through the blue platforms from below and land on them from above. One property does all of it.
Bounce and friction
Three balls dropped from the same height with three PhysicsMaterial settings. The bounce value is the whole difference.
Conveyor belt
Two belts that never move a pixel. constant_linear_velocity drags whatever is touching them.
Impulse blast
A wall of 54 boxes and a click that pushes them away, with the force falling off by distance.
Physics drop
Click to drop a RigidBody3D on the floor and watch it stack. The ones you spawn clear themselves after ten seconds.
Domino chain
Twenty pieces on a curve and one impulse on the first. Everything after that is the solver.
Hinge door
A door held by a hinge with an angle limit. Click to push it and see where the limit stops the swing.
Jelly cubes
Three SoftBody3D cubes landing with different stiffness. The mesh itself is what deforms.
Particles
An emitter that follows the mouse, with a procedural dot texture and a color ramp. CPU particles, the ones the web renderer draws.
Explosion burst
A one_shot spark layer over a one_shot smoke layer, restarted together. Click to move the blast, or wait for the timer to fire it again.
Movement trail
A dot walking a route and an emitter that only runs while it moves. emitting comes from the measured speed, and local_coords keeps the trail behind.
Fire and smoke
Two stacked emitters with different color ramps, an additive flame and a mixed smoke plume above it. Click to blow a breeze through both.
Rain and splash
Rain with a lifetime sized to the fall, and a pool of one_shot emitters bursting on the floor line. Click to add a splash of your own.
Confetti burst
Two cannons firing paper strips with gravity and spin. A constant color_initial_ramp hands each piece a flat palette color.
Control gallery
The basic controls on one screen, each one reporting to the same label through its signal.
Containers tour
The same four boxes handed to four containers. Layout in Godot is picking who arranges the children.
Anchors and presets
Six panels pinned with layout presets. Resize the game panel and every one keeps its corner.
Theme by code
The same three nodes twice, and the difference is a handful of add_theme overrides.
Rich text
Bold, color, wave, shake and rainbow, all of it BBCode tags inside one label. No animation node involved.
Progress and timer
A Timer filling a bar, with pause and resume. The bar reads time_left, it does not count on its own.
Drag and drop
Chips moving between slots. Three methods do all of it: _get_drag_data, _can_drop_data and _drop_data.
Tree view
A scene tree with two columns, built from a nested dictionary by one recursive function.
Inventory list
An ItemList with multi selection, dropping the selected rows and putting them back.
Tabs and splits
A side panel and three tabs sharing the width. Drag the divider and both sides follow.
Node graph
Four nodes with ports you can wire by dragging. GraphEdit draws the curve, accepting the connection is your call.
Color picker
The full picker wired to a live preview, the hex readout and a row of saved swatches.
Popups and dialogs
A context menu and two dialogs, each one reporting back through its own signal.
Keyboard focus
Nine buttons wired in a ring through focus_neighbor, walked with tab and the arrow keys. UI that works without a mouse.
Virtual joystick
A stick that clamps to its ring and drives a dot around. On a phone the same code answers to touch.
Responsive dashboard
Six cards in a grid that goes from three columns to two when the viewport gets narrow.
Primitives tour
The six primitive meshes on a spinning ring, each one with its own material: metal, rough and emissive.
Wave grid
A grid of 196 cubes riding a sine wave. Two nested loops on setup, one line of math per frame.
Move a cube
WASD driving a CharacterBody3D around pillars, with a camera that trails behind. No mouse look.
Orbit camera
Drag with the left button to swing the camera around the centerpiece, and use the wheel to zoom. Yaw, pitch and distance are the whole state.
Look at target
Eight cones running look_at on the same moving orb. One call per frame replaces all the trigonometry.
Solar system
Nested Node3D pivots, each spinning at its own rate. A moon orbits its planet and inherits the planet orbit for free.
CSG shapes
A box kept in intersection with a sphere, drilled by three cylinders that switch between subtraction, union and intersection every two seconds.
MultiMesh forest
Four thousand trees drawn by two MultiMeshInstance3D nodes, with a per instance color on the crowns.
Sprites in 3D
Billboarded Sprite3D gems over a texture painted pixel by pixel in code, each one named by a Label3D. The center sign keeps billboard off for comparison.
Lights tour
The same geometry and the same white material three times. A cull mask gives each light its own third of the scene.
Reflection probe
Metallic spheres mirroring a colored room without screen space reflections. Three roughness values show how fast the mirror turns into a blur.
Transform basics
Five boxes and five Transform3D written by hand: identity, origin, rotated Basis, scaled Basis and the three combined. A ghost marks where identity sits.
Canvas shader
A fullscreen canvas shader animated by TIME. Change a uniform, save, and the project reloads.
Palette swap
The sprite stores palette indices instead of colors, so cycling the palette repaints the whole art.
CRT screen
Barrel curve, scanlines and chromatic split over a plain 2D scene. The whole look is one fullscreen pass.
Vignette and grain
Desaturation, vignette and film grain over a 3D scene, in eleven lines that read the screen texture.
Spatial shader
A sphere whose vertices ride a wave while the emission pulses, written in a spatial shader.
Dissolve
A noise texture built in GDScript and a discard in the shader, with a burning edge at the threshold.
Rim light
The angle between the normal and the view, raised to a power. Three shapes, three rim powers.
Toon shading
Lighting quantized into bands inside the shader light function, with a hard specular dot.
Sky shader
A procedural sunset with stars, written as shader_type sky. The sun disc follows the light node.
Depth fog
A quad in front of the camera reading DEPTH_TEXTURE, so the fog knows how far every pixel is.
Heat haze
Noise pushing the screen UV around, masked to the lower half so the difference is easy to see.
Water plane
Waves in the vertex shader with the normal recomputed from the derivative, so the light follows them.
Infinite grid
One plane and no texture. fwidth keeps every line a pixel wide no matter how far the camera is.
Triplanar mapping
Four meshes with no UV map, textured by projecting from the three world axes and blending by normal.
Noise viewer
The six FastNoiseLite types side by side, same seed and no fractal, so the character of each one shows.
Terrain from noise
A heightmap turned into an ArrayMesh with SurfaceTool, colored by height through vertex colors.
Island generator
Noise multiplied by a radial mask and painted into an Image band by band. Click for another island.
Maze generator
A perfect maze carved by a backtracker. The passages appear in the order they were dug, colored by that order.
Dungeon rooms
Rooms placed without overlapping, then a random walk digging the corridor between each pair.
L-system tree
A string rewritten four times by two rules and then read as turtle moves, one Line2D per branch.
Flow field
Noise gives every point on the screen an angle. The arrows show the field and the particles follow it.
Marching squares
The contour of a noise field, redrawn as the threshold sweeps. The field never changes, only the cut.
ImmediateMesh lines
A mesh cleared and rebuilt vertex by vertex every frame, with a line strip and a line surface.
SurfaceTool solid
The same solid committed twice from SurfaceTool, flat and smooth. Only the smooth group changes.
GridMap voxels
A MeshLibrary built at runtime and a GridMap filled from a heightmap, one cube per cell.
TileMap by code
A TileSet whose atlas is an Image painted pixel by pixel, placed cell by cell on a TileMapLayer.
Geometry helpers
Three Geometry2D calls with the result drawn: polygon intersection, convex hull and polygon offset.
Agent 2D
A navigation region baked from code and an agent touring four corners through it. Click anywhere to send it somewhere else.
Agent 3D
The same idea in three dimensions, with the NavigationMesh baked from primitive meshes at load. Click the floor to pick a destination.
Dynamic obstacles
Three obstacles stepping in and out of the navigation mesh. Every swap rebakes the region and the agent takes whichever lane is still open.
AStarGrid2D
A grid where walls block cells and the yellow ones cost six times more to cross. The result is the cheapest route, not the shortest one.
AStar2D graph
Forty points linked by distance, with AStar2D routing between two of them. Nothing here is a grid, the graph is whatever you connect.
Seek and flee
Seek and flee are the same two lines with one sign flipped. The drawn vectors are the desired velocity, the current one and the difference between them.
Wander
Each agent aims at a point that only slides a little around a circle in front of it. That is what makes wandering read as intent instead of noise.
Boids
Seventy two boids running separation, alignment and cohesion against everything inside a small radius. Each one is colored by how many neighbors it can see.
Patrol state machine
An enum and a match block driving patrol, chase and return. The strip at the bottom is the last few seconds of state.
Follow and limits
A Camera2D with position smoothing and the four limit properties. The yellow cross is the camera center, so you can watch it stop at the border while the player keeps walking.
Screen shake
Trauma decaying over time, sampled from FastNoiseLite into the offset and the roll of the camera. A blast fires every 1.2 seconds and the slider scales it.
Zoom and pan
Drag to pan and roll the wheel to zoom at the pointer instead of the screen center, which is two lines of math on top of Camera2D.zoom.
Render to texture
A 3D scene rendered inside a SubViewport and shown as the texture of a monitor standing on a 2D screen.
Split screen
Two SubViewports side by side with one camera each, both looking at the same World3D. Each pane follows its own cube.
Minimap
A zoomed out Camera2D on a SubViewport that shares the World2D of the game. The HUD sits outside that world, which is why it stays out of the map.
Parallax layers
Three Parallax2D layers with different scroll_scale, repeated by repeat_size so the ridges never run out while the camera pans.
Third person 3D
A SpringArm3D that pulls the camera in when a wall gets between it and the character. The readout compares spring_length with the length the arm actually got.
Tween easings
Five squares crossing the screen, one per transition curve. The fastest way to see what each easing does.
Tween chains
One tween running four steps in a row. tween_callback lights up the step on screen and parallel puts two properties on the same step.
Animation by code
A position track and a color track written key by key at startup, with no .anim file. The timeline below shows the same keys the code inserted.
Curve resource
A Curve built point by point and read with sample(t). The graph is drawn from the same resource that moves the square, next to a square driven by plain time.
Sprite frames by code
An eight frame walk cycle painted into Image buffers at startup and fed to an AnimatedSprite2D. The strip at the bottom is the SpriteFrames itself.
Skeleton 2D
An articulated arm made of a single Polygon2D skinned to two bones. Rotating a Bone2D moves the vertices weighted to it.
Squash and stretch
The same jump with the same timing on both sides, and only the right one tweens scale. Three extra lines are the whole difference.
State driven anim
Idle, windup, dash and recover, each with its own tween. Entering a state kills the tween of the previous one so they never fight over the same property.
Skeleton 3D pose
A six bone chain added by code, posed every frame with set_bone_pose_rotation. Each BoneAttachment3D carries the mesh that rides its bone.
Tone generator
Sine, square and saw written sample by sample into an AudioStreamGenerator. The Line2D draws the same wave the buffer is being filled with.
Spectrum bars
A generated saw sweep routed to its own bus and measured by AudioEffectSpectrumAnalyzer. The marker is the source frequency, the bars are what the analyzer reads.
Step sequencer
A clickable grid of notes running in a loop. Every lit cell adds a decaying voice to the same generated buffer.
Collision sounds
Bodies falling through pegs, with one blip built in code and retuned by pitch_scale from the speed each body carried into the impact.
Bus effects
A generated pluck routed Voice into FX into Master, with reverb and distortion you switch on and the peak level of every bus on screen.
Positional audio
A moving source with max_distance and attenuation, next to a bar showing the same falloff AudioStreamPlayer2D applies to the generated tone.
Input map by code
Five actions added with InputMap.add_action at startup, none of them declared in project settings. The panel lists the keys each one answers to and lights up while it is held.
Gamepad viewer
Sticks, triggers and buttons read straight from Input and drawn as they move. With nothing plugged in it says so, and the arrow keys still drive the ui vector.
Mouse modes
The four values of Input.mouse_mode behind four buttons. The dot rides on event.relative, which is what keeps working once the pointer is captured.
Touch and gestures
Drag a card with one finger and pinch it with two. The same handler falls back to the mouse button and the wheel, which is the path a desktop browser takes.
Key rebinding
Click a key, press another one, and the action moves to it. Stealing a key from another action leaves that one unbound, which is the case a rebind screen has to handle.
Custom signals
One node declares a signal and never learns who listens. Five panels connect to it and light up when their slot comes.
Node groups
Seventy two squares split into four groups. One call_group reaches every member of a band without a single reference.
Save and load
A dictionary of scene state written to user:// as JSON, with the file contents shown next to the live values.
Custom resource
A Resource with class_name used as typed data. Six items share the script and every card redraws from the changed signal.
Object pool
Two fountains spawning at the same rate, one allocating every particle and one taking them back from a pool. The counters do the arguing.
Benchmark panel
Frames per second, static memory and node count sampled every frame into three live graphs, while a wave of nodes is added and removed.
Seeded random
Three columns from three generators. The two that share a seed produce the same numbers every time, the third does not.
Callables and lambdas
Six operations kept in an array as Callables, five lambdas and one method with bind, each one handed to Array.map over the same numbers.