Game dev
Saved & recent

Game dev glossary

The words that come up when you build a game, each with a short explanation and a picture. Start anywhere. Entries link to each other where one term depends on another.

VerticesPlace the points
MeshConnect the triangles
ShadedLight the surface
TexturedMap the pattern

Math

Quantities, positions, directions and angles, and the precision needed to work with them.

Scalar

Related terms: vector, magnitude, speed

A single number that describes an amount: a speed, a temperature, a mass or a damage value. It has no direction. A vector has several components and can describe a direction as well as an amount.

Multiply a vector by a scalar to scale its length. A unit direction times a speed of 5 gives a velocity of 5 units per second. A negative multiplier reverses the direction.

5 m/s 10 m/s unit direction twice the speed
Multiplying the same unit direction by 5 and 10 doubles the speed. Both velocity arrows point right.

Vector

A list of numbers that describes a direction and a length. In 2D it has two parts, (x, y). In 3D it has three, (x, y, z).

The same type is used for positions, velocities, forces and colors. Multiply velocity by delta time and add the result to position to move an object.

X Y 5 units 3 units vector (5, 3)
The arrow (5, 3) reaches five units along X and three along Y.

Magnitude

Also called: vector length, norm

Related terms: scalar, normalization

The length of a vector, written as length(v) or |v|. A vector of (3, 4) has length 5, found with the same rule as the long side of a right triangle.

The magnitude of velocity is speed. Dividing a nonzero vector by its magnitude produces a unit vector. A zero vector has no direction, so handle it before dividing.

length(v) = sqrt(x*x + y*y + z*z)

A vector of (3, 4) makes a right triangle. Its length is √(3² + 4²) = 5.

Distance

Related terms: magnitude, displacement, squared distance

How far apart two positions are. Subtract the positions to get the displacement from one to the other, then take its length. Use positions in the same coordinate space.

Useful for pickup ranges, nearby enemies and arrival checks. If you only need to test a radius, compare squared distance with squared radius to avoid a square root. Straight-line distance does not account for walls; pathfinding does.

dot(B - A, B - A) <= radius * radius

The violet arrow shows straight-line distance from A to B. The dashed route goes around the wall.

Unit vector

Also called: normalized vector

Related terms: normalizing, magnitude

A vector with a length of exactly 1. It keeps the direction and drops the size. You get one by dividing a nonzero vector by its length, which is called normalizing. The zero vector has no direction to normalize.

Use it when you only care about which way something points. Multiply it by a speed to get a velocity.

n = v / length(v)

Divide the dashed vector by its length of 2 to reach the unit circle without changing its direction.

Dot product

Takes two vectors and returns one number. For unit vectors that number says how much they point the same way: 1 for the same direction, 0 for a right angle, -1 for opposite.

It answers questions like "is the enemy in front of me?" and "how directly does light hit this surface?". See diffuse lighting.

a · b = ax*bx + ay*by + az*bz

Project the gold unit vector onto the violet one. At 60°, 90° and 120°, the signed projections are 0.5, 0 and −0.5.

Cross product

Takes two 3D vectors and returns a third one that is perpendicular to both. Its length equals the area of the parallelogram the two inputs span.

The main use is finding a surface normal from two edges of a triangle. Swapping the inputs flips the result.

The parallelogram spans 6 square units. The blue cross product is perpendicular to it, and swapping the inputs flips the arrow to the dashed direction.

Radians

Related terms: degrees, angle, trigonometry

A way to measure an angle using a circle. One radian turns through an arc as long as the radius. One full turn is 2π radians, and a half-turn is π, or 180 degrees.

Most programming-language sine and cosine functions expect radians. Check the units an engine API expects: passing 90 where it expects π/2 produces a very different rotation.

radians = degrees * pi / 180

At one radian the arc has the same length as the radius. The reference segment shows that length laid flat.

Trigonometry

Related terms: sine, cosine, tangent, radians

The relationship between angles and lengths. On a unit circle, an angle θ measured from the positive X axis gives the point (cos(θ), sin(θ)). Cosine gives X; sine gives Y.

Multiply both by a radius to orbit a pickup or place enemies around a ring. Sine also makes repeating motion, such as bobbing. This diagram uses Y pointing up; screen coordinates may point down.

point = center + radius * (cos(t), sin(t))

The angle π/3 picks a point on the unit circle. Its horizontal and vertical coordinates are the marked values of cosine and sine.

atan2

Also called: two-argument arctangent

Related terms: trigonometry, aiming

Turns a 2D direction into an angle, accounting for which quadrant it points into. In many languages the call is atan2(y, x), with Y first, and the result is in radians. Check the API argument order.

To aim at a target, subtract the shooter position from the target position, then pass that direction to atan2. A zero-length direction has no meaningful angle; keep the previous facing instead.

angle = atan2(target.y - y, target.x - x)

All four arrows have the same absolute components. atan2(y, x) uses both signs to return the angle from +X, positive counterclockwise and negative clockwise.

Transform

Related terms: matrix, TRS, model matrix

The position, rotation and scale of an object. Engines store it as a 4x4 matrix, a grid of 16 numbers. Multiplying a point by the matrix moves, rotates and scales it in one step.

Matrices can be chained. A hand's matrix times the arm's matrix times the body's matrix gives the hand's final place in the world. Order matters: rotate then move is not the same as move then rotate.

Scale the block along its local X axis, rotate it around its pivot, then translate it. Each dashed outline shows the input to that step.

Quaternion

Related terms: Euler angles, gimbal lock

Four numbers (x, y, z, w) that store a 3D rotation as one turn around one axis. You rarely read the numbers. You build them from an axis and an angle, and combine them by multiplying.

The alternative is Euler angles: three separate turns around X, Y and Z. Those are easy to read but can hit gimbal lock, where two axes line up and one degree of freedom is lost. Quaternions do not have that problem and blend smoothly.

One quaternion rotates the arm 90° about the tilted blue axis. The violet curve follows a point at the tip.

Coordinate spaces

Related terms: local, world, view, clip space

The same point has different coordinates depending on what you measure from. Local space is relative to the object's own origin. World space is relative to the scene. View space is relative to the camera. Clip space is what the screen sees after perspective is applied.

Three matrices move a vertex along that chain. Together they are called MVP: model, view, projection.

The marked vertex is measured from the object, world and camera origins in turn. Projection produces clip coordinates, which become the displayed image coordinates after dividing by w.

Lerp

Also called: linear interpolation

Blends between two values. A parameter t from 0 to 1 picks how far along you are. At 0 you get A, at 1 you get B, at 0.5 the midpoint.

Works on numbers, vectors and colors. It is behind fades, camera smoothing and most easing.

lerp(a, b, t) = a + (b - a) * t

The same weight drives the plot and the scale below it. With endpoints 2 and 10, the halfway value is 6.

Slerp

Also called: spherical linear interpolation

Related terms: nlerp

A lerp for directions and rotations. It moves along the arc between the two at a constant turning speed.

A plain lerp between two directions cuts straight across. The result gets shorter in the middle and the turn speeds up and slows down. Slerp is the standard way to blend two quaternions. Nlerp is the cheap version: lerp, then normalize.

The markers use the same weight. Slerp follows the arc at a constant turning speed and stays at unit length. Lerp takes the chord and gets shorter in the middle.

Projection

Related terms: perspective, orthographic, projection matrix

Flattening the 3D scene onto the 2D screen. Perspective projection sends every point toward the eye, so distant things come out smaller. It is what 3D games use.

Orthographic projection uses parallel lines, so size does not change with distance. It is used for 2D games, isometric views, editors and shadow maps of the sun.

In perspective, rays converge at one eye and the farther object forms a smaller image. With parallel orthographic rays, depth leaves image size unchanged.

Bézier curve

Related terms: spline, control point, handle

A smooth curve defined by a few points. The curve starts at the first point and ends at the last. The control points in between pull it toward them without touching it.

Used for paths, camera rails, roads, UI motion and animation curves. Several curves joined end to end form a spline.

The gold and green segments show the midpoint construction at t = ½. The moving marker evaluates the same cubic for the other weights.

Barycentric coordinates

Related terms: interpolation across a triangle, point in triangle

A way to describe a point inside a triangle as a mix of its three corners. The three weights add up to 1. At a corner, that corner's weight is 1 and the others are 0.

This is how the rasterizer blends UVs, normals and colors across a triangle. It is also the standard inside test: a point is in the triangle when all three weights are between 0 and 1.

Each barycentric weight equals the area of the subtriangle opposite its vertex divided by the total area.

Handedness

Related terms: left-handed, right-handed, Y-up, Z-up, coordinate system

3D tools disagree on which way the axes point. First, which axis is up: Y in Unity, Godot and Maya, Z in Unreal and Blender. Second, with X to the right and Y up, does Z come toward you (right-handed) or go away from you (left-handed)?

A mismatch is why an imported model arrives lying on its side, mirrored, or inside out. Exporters and importers convert between conventions.

With X pointing right and Y up, Z points toward you in a right-handed frame and away from you in a left-handed frame.

Homogeneous coordinates

Related terms: w component, 4D vector, perspective divide

3D positions are stored with a fourth number, w. That extra slot is what lets a single 4x4 matrix move things as well as rotate and scale them.

A w of 1 marks a position. A w of 0 marks a direction, which moving must not change. After projection, w holds the depth. Dividing x, y and z by it is the perspective divide, the step that makes far things small.

The translation contributes w times its offset. It moves the point (w = 1) and leaves the direction (w = 0) unchanged. Below, a clip-space x of 1 lands closer to zero when divided by a larger w.

Floating-point precision

Related terms: float, double, rounding error, floating origin, epsilon

A float stores a number with a limited number of significant binary digits. Many decimal fractions cannot be represented exactly, so arithmetic rounds them. Numbers become more widely spaced as their magnitude grows.

Far from the world origin, small movements can round away and objects can jitter. Larger numeric types or shifting the world origin can help. Use a suitable tolerance when comparing approximate results.

Both lines use the same offset scale. In float32, adding 0.08 at 2²⁰ rounds to an offset of 0.125. At 2²¹ it rounds back to the start.

Epsilon

Related terms: floating-point precision, tolerance, approximate equality

A small tolerance used to decide whether two approximate values are close enough. For example, an arrival test can accept a distance below 0.01 meters instead of waiting for exactly zero.

Choose the tolerance for the units and scale of the problem. Large values may need a relative tolerance too. Machine epsilon describes a numeric type near 1; it is not automatically the right gameplay tolerance.

abs(a - b) <= max(absTol, relTol * max(abs(a), abs(b)))

Around 1.00, an absolute tolerance of 0.01 accepts the interval from 0.99 to 1.01, including its endpoints.

Geometry

What 3D models are made of before any color or light is applied.

Vertex

Plural: vertices

A corner point of a model. Besides its position, each vertex carries extra data called attributes: a normal, a UV coordinate, sometimes a color or bone weights.

The GPU reads vertices from a vertex buffer. An index buffer lists which three vertices form each triangle, so shared corners are stored once.

Six triangles share the highlighted vertex on this 80-triangle mesh. The arrow shows its outward normal, averaged from the adjacent faces.

Mesh

Related terms: polygon, triangle, tri, poly count

The shape of a model: a set of vertices joined into triangles. Artists often work with four-sided quads, but the GPU only draws triangles, so every quad is split in two.

Poly count is the number of triangles. More triangles give smoother curves and cost more to draw.

A ring built from 192 triangles. The enlarged surface quad has four vertices and a diagonal that splits it into two triangles.

Normal

A unit vector that points straight out of a surface. Lighting depends on it: the renderer compares the normal with the direction to the light to decide how bright a spot is.

If every triangle uses its own face normal, the model looks faceted. If normals are averaged at each vertex and blended across the triangle, the same mesh looks smooth.

The same mesh under the same light: face normals give flat lighting on the left; averaged vertex normals are interpolated and normalized for smooth lighting on the right. The vertices, triangle edges and silhouette stay identical.

UV mapping

Related terms: UVs, texture coordinates, unwrapping

Tells the renderer which part of a 2D image goes on which part of a 3D surface. Each vertex stores a (u, v) pair from 0 to 1 that points into the texture.

Making the UVs is called unwrapping: the model is cut along seams and flattened, like a cardboard box opened up.

The six faces share one checker texture with blue bands. Gold marks the two UV edges that meet at one seam on the cube; violet marks the same texture coordinate and surface point.

Backface culling

Related terms: winding order

Skips triangles that face away from the camera. On a closed model you never see them, so not drawing them saves about half the work.

The renderer knows which side is the front from the winding order: the order the three vertices are listed in. Counter-clockwise on screen usually means front.

The camera keeps its facing triangles and skips the dashed rear shell. The enlarged triangles show their vertex order in that camera’s view, using counter-clockwise winding as the front-face convention.

LOD

Also called: level of detail

Several versions of the same model with fewer and fewer triangles. The engine swaps to a simpler version as the object gets farther from the camera, where the missing detail is too small to see.

A visible switch between levels is called popping.

Three versions of one vessel are shown at the same display scale, with 608, 260 and 132 triangles including the inner wall and rim. At greater camera distances, fewer triangles are needed to preserve its visible shape.

Hierarchical LOD

Also called: HLOD, hierarchical level of detail

Related terms: proxy mesh, clusters, LOD, draw call

Replacing a distant group of objects with a simpler combined representation. Ordinary LOD might simplify each house separately; hierarchical LOD can replace a whole street with one proxy mesh and a combined material. Farther away, larger groups can be represented together.

The saving is not just fewer triangles. Combining objects can also reduce draw calls and the work of managing many separate objects. Proxies are usually built ahead of time, so they cost storage and must be regenerated when their source content changes. The transition distance should hide lost detail and avoid obvious popping.

The three buildings and street form one HLOD proxy with a combined material, reducing the number of separate objects as well as their geometric detail. Both views use the same scale: the proxy keeps the main roofline, while windows and balcony bands are baked into flat surfaces.

Tessellation

Related terms: subdivision

Splitting triangles into smaller triangles. The GPU can do it on the fly, adding detail near the camera and none far away. Combined with a displacement map, a flat surface gains real bumps.

In modeling tools, subdivision does the same while also rounding the shape.

The two input triangles become 128 triangles and 81 vertices; the surface stays flat. The enlarged view applies the illustrative height field h(u,v) = 1.15 sin(πu) sin(πv), with u and v from 0 to 1. Violet tracks one original triangle, and gold marks the same vertex before and after displacement.

Bounding volume

Related terms: bounding box, bounding sphere, OBB, BVH

A simple shape that fully wraps a complex object. Testing the simple shape is cheap, so it is tested first. Only if that passes is the detailed check done. Used for culling, collision and raycasts.

A BVH (bounding volume hierarchy) is a tree of boxes inside boxes. One failed test at the top rules out everything below it. Ray tracing depends on it.

Each translucent shape fully encloses the same aircraft mesh. The axis-aligned bounding box (AABB) follows world axes; the oriented bounding box (OBB) follows the aircraft’s local axes. The sphere’s radius is the farthest vertex’s distance from its chosen center. An overlap with a bound is only a candidate for a detailed test.

Billboard

Also called: camera-facing quad

Related terms: impostor

A flat rectangle that always turns to face the camera. Because you never see it from the side, a 2D image passes for a 3D object.

Used for particles, distant trees, lens flares, health bars and name tags above characters.

A flat tree image occupies one quad, split into two triangles. The dashed outline shows its earlier orientation; the facing normal now points at the lens. This outside view reveals the card’s flatness, while the pictured camera sees it face-on. The pale violet fill marks transparent image margins.

Voxel

Also called: volume pixel

Related terms: marching cubes

The 3D version of a pixel: one cell in a regular 3D grid. A voxel world stores what is inside every cell, not just the surface, so digging and destruction are easy.

The cost is memory. Voxels are drawn as cubes for a blocky look, or turned into a smooth mesh with an algorithm such as marching cubes.

Every cell stores a material, inside as well as on the surface. Lifting one voxel out leaves an empty cell.

Signed distance field

Also called: SDF

Related terms: ray marching

A function or texture that gives, for any point, the distance to the nearest surface. Outside the shape the value is positive. Inside it is negative. The surface is where it reads zero.

Distance changes smoothly, so a small SDF texture can be enlarged and still give a sharp edge. That is how games draw crisp text at any size. SDFs also give cheap outlines, glows and soft shadows. Ray marching draws whole scenes from them.

Distance fieldCut at zero

Textures and materials

Images wrapped on geometry, and the settings that decide how the surface reacts to light.

Texture

Also called: texture map

Related terms: texel

An image applied to a surface. One pixel of a texture is called a texel, to tell it apart from a pixel on screen.

Textures hold more than color. The same image format stores normals, roughness, height or any other per-point data a shader wants to read.

Further reading
LearnOpenGL: Textures
TextureZoomed: texels

Texture filtering

Related terms: nearest, bilinear, trilinear, anisotropic

Decides what color to return when a texture is stretched or shrunk and screen pixels do not line up with texels. Nearest picks the closest texel and looks blocky, which is what pixel art wants. Bilinear blends the four closest texels and looks soft.

Trilinear also blends between two mip levels. Anisotropic keeps textures sharp on surfaces seen at a steep angle, like a road.

NearestBilinear

Mipmap

Related terms: mip levels, mip chain

Smaller copies of a texture, each half the size of the one before. When a surface is far away, the GPU samples a small copy instead of the full image.

This removes the shimmering you get when many texels fall inside one screen pixel. The full chain costs about one third more memory.

The same diagnostic texture is averaged in 2×2 texel groups, from 32×32 down to 1×1. Each level has half the width and height and one quarter as many texels. Violet outlines identify the enlarged source patch and its averaged texel. This complete chain adds 341 texels to the base image’s 1,024, about one third more storage.

Virtual texturing

Related terms: texture pages, tile cache, residency, mipmaps

Splitting large textures into small tiles, often called pages, and keeping the needed tiles in a limited memory cache. When the camera sees only one corner of a huge surface, the renderer can request detailed tiles for that corner instead of loading an entire high-resolution mip level.

This can reduce GPU memory use for large environments. Tiles still have to arrive and fit in the cache: rapid camera movement or too little cache space can reveal blurry areas while detail loads. Streaming virtual textures read tiles from storage; runtime virtual textures can generate their contents on the GPU.

Further reading
Epic Games
In this streaming example, the surface lays out the virtual texture and the camera requests its four outlined pages. Matching patches fill a four-slot cache. The package is a conceptual cutaway with pages enlarged and arranged for comparison. Other pages are subdued for context; mip levels, page-table indirection and prefetching are omitted.

Normal map

Related terms: bump map, tangent space

A texture that stores a normal in every texel instead of a color. The X, Y and Z of the direction are saved as red, green and blue. A normal pointing straight out is (0.5, 0.5, 1), which is why these maps look violet.

The shader uses the stored normal for lighting instead of the real one. A flat wall then catches light as if it had bumps and grooves, with no extra triangles. The outline of the model stays flat, which gives the trick away at steep angles.

Color onlyNormal mapLit with it
Move the pointer or use the light controls.

Height map

Related terms: displacement map, parallax mapping

A grayscale texture where brightness means height. White is high, black is low. Terrain is often stored this way.

Displacement uses it to really move vertices. Parallax mapping uses it to shift the texture lookup so a flat surface seems to have depth. A normal map can be generated from a height map.

Normalized heights run from 0 (black) to 1 (white). The image and terrain share 169 samples; gold marks the same sample and its vertical displacement. Displacement moves vertices, while normal mapping changes lighting normals without moving the geometry.

Material

The recipe for how a surface looks. It names a shader and gives it inputs: textures, colors and numbers such as roughness.

A mesh gives the shape. A material gives the look. The same mesh with a different material is a wooden crate or a metal one.

One crate mesh, two material recipes. The maps below supply surface color; the same illustrative shader and lighting use high roughness for wood and low roughness for metal. The beveled frame, diagonal brace and fasteners are unchanged.

PBR

Also called: physically based rendering

Related terms: albedo, roughness, metallic

A standard way to describe materials with a few measurable properties, so they look right under any lighting. The usual inputs:

Albedo: the base color with no light or shadow baked in. Roughness: 0 is a mirror, 1 is chalk. Metallic: 0 for plastic, wood, skin. 1 for bare metal, where reflections take the color of the surface.

Roughness 0Roughness 1
Top row is non-metal, bottom row is metal. Move the pointer or use the light controls.

Texture atlas

Related terms: sprite sheet

Many small images packed into one big texture. Each image is found by its UV rectangle inside the sheet.

Objects that share one texture can be drawn together in a single draw call. A sprite sheet is an atlas whose cells are the frames of an animation.

One 64×64 image holds six sprites, with transparent padding between them. The potion and gem on the quads come from the outlined UV rectangles; their artwork and orientation match the source. With a lower-left UV origin, the potion spans u = 0.625–0.9375 and v = 0.5–0.9375.

Cubemap

Related terms: skybox, environment map

Six square textures arranged as the faces of a cube. It is sampled with a direction instead of a UV: "what color is out there, that way?".

A skybox is a cubemap drawn behind everything as the distant background. The same kind of map supplies reflections on shiny surfaces. See reflection probe.

Further reading
LearnOpenGL: Cubemaps
The cross folds into a cube around the camera. A direction from the center picks the color where it meets a face.

Wrap mode

Related terms: tiling, repeat, clamp, mirror

What happens when a UV goes outside the 0 to 1 range. Repeat starts the texture over, which is how one small brick image covers a whole wall. Mirror flips every other copy to hide the seams. Clamp stretches the edge pixels outward.

A texture made to repeat with no visible seam is called tileable.

Further reading
LearnOpenGL: Textures
All three planes sample the same texture over u = −1 to 2; dashed lines mark its original 0–1 interval. The vertical coordinate stays in 0–1. Repeat restarts the image, mirrored repeat reverses alternating copies, and clamp-to-edge extends the nearest edge colors. The source is deliberately not seamless.

Emissive

Related terms: emission map, glow

A material input for parts that give off their own light: screens, neon signs, lava, eyes. The emissive color is added after lighting, so those parts stay bright in a dark room.

By itself it does not light up nearby objects. That needs global illumination. Bloom adds the glow around it.

The same terminal with and without room lighting. Its emissive screen keeps the same brightness, while the casing and keys darken. Both views include bloom, a glow added to the rendered image. No global illumination from the screen is simulated.

Decal

A texture projected onto surfaces that are already there. Bullet holes, scorch marks, tire tracks, graffiti, puddles and footprints are decals.

The wall underneath is not changed. The decal is a separate object that can be spawned in one frame and faded out later, which makes it ideal for marks left by gameplay.

A paint-splash texture is projected diagonally across a brick corner. Its two halves meet at the shared edge, so the artwork bends with the wall while the masonry geometry and silhouette stay unchanged. Dashed violet outlines mark the texture bounds; unpainted texels are transparent.

Tangent space

Related terms: TBN, tangent, bitangent, object-space normal map

The coordinate system of a point on a surface. One axis is the normal, pointing out. The tangent runs along the texture's U direction and the bitangent along V.

Normal maps store directions in this space: blue is "straight out", red and green are "lean along U or V". That is why they look violet, and why one map works on any surface, even one that bends. The three axes form the TBN matrix that turns the stored value into a real direction for lighting.

On this cylindrical patch, T follows increasing u, B follows increasing v, and N = T × B points outward. The straight tangent touches the curved u line at the marked point. This example uses an orthogonal, right-handed UV layout and unit-length basis vectors; xT + yB + zN transforms a stored tangent-space direction into object space.

Art pipeline

How a model gets from an idea to something the engine can draw.

Asset pipeline

Also called: content pipeline

Related terms: DCC tool, import, export

The steps an asset goes through. Concept art sets the look. The model is built, often sculpted first. It is unwrapped and textured. Characters are rigged and animated. Then it is exported and imported into the engine, which converts it to its own format.

"Pipeline" also means the tools and scripts that automate those hand-offs. DCC stands for digital content creation tool: Blender, Maya, Substance, Photoshop.

One possible character workflow, read across the top and back along the bottom. The exchange file represents exported model data plus accompanying texture and animation files. Engine import converts that data into engine assets; rigging is optional for static props, and real pipelines can revisit earlier stages.

Topology

Related terms: edge flow, quads, n-gon, pole

How the polygons of a mesh are laid out. Not the shape itself, but the pattern of edges that makes it. Good topology is evenly sized quads that follow the natural lines of the form.

It decides how a mesh bends when animated, how it subdivides, and how cleanly it shades. An n-gon is a polygon with more than four sides. A pole is a vertex where many edges meet. Both tend to cause pinching.

Both elbows use the same vertices and surface. Left, a quad strip follows the bend and an edge loop wraps around the pipe. Right, four quads become eight triangles around an eight-edge pole. Poles redirect edge flow; their suitability depends on the intended deformation and subdivision.

Edge loop

Related terms: loop cut, supporting loop

A chain of edges that runs all the way around a model and meets itself, like a rubber band around an arm. Modeling tools select, add and slide a whole loop at once.

Loops decide where a mesh can bend. A joint needs several loops close together to keep its volume when it folds. Loops around the eyes and mouth let a face deform the way muscles do.

The same quad mesh in rest and 65° bent poses. Violet follows one closed 12-edge cycle; dashed segments are hidden behind the surface. Four nearby loops spread the bend across several rows of quads, compressing the inside and opening the outside. This illustrative deformation preserves each cross-section’s dimensions.

Retopology

Also called: retopo

Related terms: sculpting, high poly, low poly, decimation

Sculpting tools let artists shape a model like clay, using millions of polygons with no thought for topology. That is far too heavy and messy for a game.

Retopology is building a new, clean, low poly mesh over the surface of the sculpt, by hand or with automatic tools. The fine detail is then carried over by baking it into a normal map.

The new quad mesh follows the sculpt’s boot shape, with closer loops around the sole, ankle, and cuff. Its vertices lie on the reference surface, while its larger faces approximate the form. Fine folds can be transferred later by baking a normal map.

Baking

Related terms: high to low poly, bake maps, cage

Moving detail from one model to another by storing it in textures. For every texel of the low poly model, the baker shoots a ray to the high poly surface and records what it finds there.

The surface direction becomes a normal map. The same process captures ambient occlusion, height and color. In the game, the low poly model wears those maps and looks close to the sculpt at a fraction of the cost. Baked lighting is the same idea applied to light.

Example: a normal bake. Rays from the cage record the sculpt’s surface directions; the violet texture visualizes those vectors. Applying them changes the flat receiver’s lighting response while preserving its two triangles and straight silhouette. This example stores no lighting.

Texel density

Related terms: texture resolution, pixels per meter

How many texture pixels cover a given size in the world, for example 512 pixels per meter. If one object is dense and its neighbor is not, one looks crisp and the other blurry. The mismatch stands out more than low resolution everywhere.

Teams pick a target and check it with a checker texture. The squares should be the same size on every object.

This deliberately tiny example uses 4 texels per meter, with each checker square representing one texel. Eight squares span the 2 m wall and four span the 1 m crate. The gold cells are each 0.25 m wide: matching world-space square sizes show consistent density.

Trim sheet

Related terms: modular kit, texture reuse

One texture made of horizontal strips of reusable detail: metal bands, rows of bolts, planks, panels. Instead of a unique texture per object, each part of each mesh is mapped onto whichever strip fits.

A whole building kit can share one sheet and one material. That means less memory, fewer draw calls and a consistent look. It is the standard approach for environments.

The doorway is modeled separately, then its UVs sample four bands: molding, bolted metal, wood planks and stone. Islands rotate the same molding and grain onto vertical faces and reuse the metal band across both leaves. The mesh supplies the shape and depth; the sheet supplies surface detail.

File formats

Related terms: FBX, glTF, OBJ, PNG, EXR, WAV, import

Assets travel between tools as interchange files. For models: FBX, the industry habit, carries meshes, rigs and animation. glTF is open and modern with PBR materials built in. OBJ holds a static mesh only. For images: PNG and TGA, or EXR for HDR. For sound: WAV.

The game does not ship these. On import, the engine converts each one to its own format for the target platform, with compressed textures ready to load.

An illustrative import path: mesh and rig data, texture mip levels and audio chunks are prepared for runtime use. The rigged example fits FBX/glTF; OBJ carries mesh geometry only. Processing and packaged formats vary by engine and target, and some formats may be loaded directly.

Rendering

How a scene of triangles becomes a grid of colored pixels, many times per second.

Rendering pipeline

Also called: graphics pipeline

The fixed sequence of steps the GPU runs for every object. Vertices go in. The vertex shader places them on screen. The rasterizer finds the pixels each triangle covers. The fragment shader colors those pixels. The result lands in the framebuffer, the image that is shown.

A simplified single-sample pass: the vertex shader transforms and projects the cube, rasterization generates fragments, and fragment shading assigns face colors. Backface culling and blending are disabled, giving near and far fragments at each covered sample; their layers are offset for inspection. The depth test stores the nearer color in the framebuffer. Clipping and other stages are omitted.

Render graph

Also called: frame graph

A plan of the rendering work for a frame, showing which passes read or write each resource. Instead of manually managing every temporary render target, the developer declares what each pass needs. The graph exposes dependencies between steps such as drawing a scene, blurring it and composing the final image.

The engine can use that information to skip unused work and reuse temporary memory after its last reader finishes. A render graph organizes work inside a rendering pipeline; it does not decide the visual style or replace the shaders that draw it.

Gray arrows show writes; violet arrows show reads. The illustrative composite blends 60% scene color with 40% Gaussian blur (σ = 4 image units). The lifetime bars are derived from the declared passes: color spans 1–3 and blur 2–3, so both remain live until composite finishes.

Shader

Related terms: vertex shader, fragment shader, pixel shader, GLSL, HLSL

A small program that runs on the GPU. The vertex shader runs once per vertex and outputs where that vertex lands on screen. The fragment shader (or pixel shader) runs once per covered pixel and outputs its color.

Lighting, water, outlines, dissolve effects: all of it is shader code. Shaders run in parallel for millions of pixels, so each one must be short and self-contained.

// fragment shader: basic lighting float light = max(dot(normal, lightDir), 0.0); color = texture(albedo, uv) * light;

Further reading
LearnOpenGL: shaders
An illustrative opaque, single-sample orthographic pass: the vertex stage transforms one shield mesh, then the fragment stage computes color per fragment. UVs and normals are interpolated across the transformed triangles. The highlighted sample multiplies its texture color by a Lambert factor of 0.36.

Rasterization

Turning a triangle into pixels. The GPU checks which pixel centers fall inside the triangle and produces a fragment for each one. Values stored at the three corners, like UVs and normals, are blended across the inside.

It is the standard way games draw, because it is very fast. The alternative is ray tracing.

This example uses one center sample per pixel. A partly touched pixel remains empty when its sample lies outside the projected triangle. Filled pixel colors use perspective-correct barycentric interpolation of the three vertex colors.

Depth buffer

Also called: Z-buffer

Related terms: depth test, Z-fighting

A hidden image the same size as the screen. Each pixel stores the distance to the nearest surface drawn there so far. Before a new fragment is written, its distance is compared. If something closer is already there, the fragment is thrown away.

This lets objects be drawn in any order. When two surfaces sit at almost the same depth they flicker, which is called Z-fighting.

These opaque objects use conventional perspective depth from 0 at the near plane to 1 at the far plane, with a clear value of 1 and a LESS depth test. Darker means nearer in both themes. At the marked pixel, the cube’s depth of 0.57 wins over the sphere’s 0.70. The grayscale shows normalized, nonlinear depth values, not literal distance; shading and shadows do not change those values.

View frustum

Related terms: FOV, near and far plane, frustum culling, occlusion culling

The region of space the camera can see. It is a pyramid with the tip cut off. The field of view (FOV) is its opening angle. The near and far planes are the closest and farthest distances that get drawn.

Frustum culling skips objects that are fully outside this region. Occlusion culling also skips objects hidden behind others.

Spheres inside the frustum are drawn. Those beside it or beyond the far plane are skipped. The footprint is the ground under the visible volume.

Draw call

Related terms: batching, instancing

One command from the CPU telling the GPU "draw this mesh with this material". Each call has a fixed cost, so thousands of small calls are slower than a few large ones.

Batching merges objects that share a material into one call. Instancing draws many copies of the same mesh, such as grass or bullets, in one call.

Both rows draw the same three props from shared mesh and material references. T₁–T₃ are translation transforms: the separate draws each use one, while one instanced draw uses all three. Fewer submissions may reduce CPU overhead; the benefit depends on the workload.

Anti-aliasing

Also called: AA

Related terms: jaggies, MSAA, FXAA, TAA

Pixels are square, so slanted edges come out as stairs. Anti-aliasing softens them by giving edge pixels a partial color based on how much of the pixel the shape covers.

MSAA takes several samples per pixel at triangle edges. FXAA blurs edges it finds in the finished image. TAA uses temporal accumulation to reuse samples from earlier frames.

Both views use the same sword and pixel grid. Four fixed subpixel samples estimate coverage: two hits in the enlarged pixel give equal foreground and background weights, while its center sample misses. This simplified spatial example does not simulate FXAA or TAA.

Alpha blending

Related terms: transparency, alpha channel, alpha test

Alpha is a fourth color channel that stores opacity. 1 is solid, 0 is invisible. Blending mixes a new pixel with the one already on screen using that value.

Transparent objects must be drawn back to front, after the solid ones, or they blend against the wrong thing. Alpha test (cutout) avoids sorting by making every pixel fully on or fully off, which suits leaves and fences.

out = src * alpha + dst * (1 - alpha)

Further reading
LearnOpenGL: blending
In this conventional source-over example, the opaque scene is followed by rear blue α = 0.35 and then front amber α = 0.5. At the marked leaf, the mixed color is 50% amber + 17.5% blue + 32.5% leaf color. The panes are idealized uniform tints without refraction.

Strand-based hair

Also called: strand based hair, strand hair rendering

Related terms: groom, guide strands, hair cards, hair simulation

Hair represented as many individual curves, each describing a thin strand. Artists shape these curves into a groom. The renderer gives them width and shades them to show fine silhouettes and highlights. Hair cards instead use textured strips of mesh to suggest many hairs at once.

Rendering strands and simulating their motion are separate jobs. A smaller set of guide strands can drive the motion of many rendered hairs. The cost grows with the number of strands and their complexity, so level of detail can reduce curve counts or switch distant hair to cards.

Violet marks selected guides; the finer copper strands are interpolated from nearby guides on the same side of the part. The enlarged lock shows the same roots and curve samples. Guide motion can drive follower motion, while rendering gives strands width and shading; this plate shows a static groom.

Post-processing

Related terms: bloom, tone mapping, color grading, depth of field

Effects applied to the finished image, not to objects. The frame is treated as a texture and passed through one or more shaders.

Bloom makes bright areas glow. Tone mapping squeezes a wide range of brightness into what a screen can show. Color grading shifts the palette. Depth of field blurs what is out of focus.

This bloom pass extracts pixels whose linear luminance is at least 0.75, blurs them (Gaussian σ = 4 source pixels), and screen-blends the result over the original image. Colors remain in the 0–1 display range. Geometry, camera, and scene lighting stay fixed.

Ray tracing

Related terms: path tracing, RTX, RT reflections

Draws by following rays of light. For each pixel a ray is shot from the camera into the scene. Where it hits, more rays go toward the lights to test for shadow, and off the surface to collect reflections.

It gives correct reflections, soft shadows and bounced light, at a high cost. Most games still rasterize the scene and add ray tracing for selected effects.

One selected image sample sends a primary ray to the sphere. Ideal reflection sends the blue ray to the floor; the gold visibility ray reaches the point light unobstructed. This point-light example has a hard shadow and shows one reflection, without sampling soft shadows or diffuse indirect illumination.

Frame rate

Also called: frames per second, FPS

Related terms: frame time, V-sync, screen tearing

How many images the game shows per second. Developers think in frame time, the budget for one frame: 16.7 ms at 60 FPS, 33.3 ms at 30 FPS. All game logic and rendering must fit inside it.

A frame that takes too long misses the screen refresh and is felt as a stutter. V-sync waits for the refresh before showing a frame, which removes tearing, where two frames are visible at once.

The same constant-speed motion is sampled at steady rates from 0 ms up to, but not including, 100 ms. That interval contains three frames at 30 FPS and six at 60 FPS; common sample times give identical views. Frame spacing is 33.3 ms or 16.7 ms, rounded. The frame at 100 ms belongs to the next interval.

Render target

Also called: render texture

Related terms: off-screen buffer, framebuffer

A texture the GPU draws into instead of the screen. Once drawn, it can be used like any other texture.

A security monitor, a mirror or a minimap is a second camera rendering into a target that is then shown on a surface. Post-processing and shadow maps work the same way: draw to a target first, read it in a later step.

The security camera renders the crate and cone into an off-screen texture. The monitor then samples that same image on its screen surface. Both image views come from one computed perspective projection of the shown scene; geometry and lighting are simplified.

Motion vectors

Related terms: velocity buffer, motion blur, temporal accumulation

A texture of small arrows describing how visible surfaces move across the screen from one frame to the next. Camera movement can shift the whole view; moving objects and animated meshes need their own motion information. These are screen-space movements, not simply an object’s world-space velocity.

Effects use the arrows to find corresponding image samples in another frame. That helps temporal anti-aliasing, some forms of upscaling and motion blur. Missing or incorrect vectors can produce trails or unstable edges. Newly revealed surfaces still need special handling because the previous frame may not contain them.

With a fixed camera, the rotor turns 40°. Purple arrows use current minus previous screen position: tails mark previous positions and heads mark current ones. Only blade points visible in both frames are shown. The gold tower point has zero motion.

Temporal accumulation

Related terms: history buffer, temporal reprojection, TAA, ghosting, disocclusion

Combining new image samples with samples saved from earlier frames. The renderer uses motion vectors to align previous results with the current view, then blends trustworthy history into the new image. Reusing samples can reduce noise and shimmering without doing all the work again.

History can become unreliable when surfaces move, lighting changes or a previously hidden surface appears. Keeping it can leave ghost trails, so the renderer tests and rejects unsuitable history. Killzone Shadow Fall reused history when motion and colors agreed. Unlike the headset-pose correction described under VR reprojection, accumulation combines samples to improve image quality.

With a fixed camera and lighting, the robot moves seven pixel columns right. Motion aligns its prior samples; the wall remains fixed. In this example, matching surface/depth samples blend 75% history with 25% current. Hatched history fails the test; the gold-outlined newly revealed region uses only current samples. The coarse grid and weights are illustrative.

Deferred rendering

Related terms: forward rendering, G-buffer

In forward rendering, each object is lit as it is drawn. It is simple and handles transparency well, but the cost grows with objects times lights.

Deferred rendering splits the work. A first pass writes surface data for every pixel into several textures: color, normal, depth, roughness. That set is the G-buffer. A second pass computes lighting once per screen pixel. It copes with hundreds of lights. Transparent objects still need a forward pass.

All four buffers describe the same visible opaque surfaces; violet marks one shared sample. An illustrative lighting pass reconstructs position from depth and uses stored albedo, normal and roughness with two point lights. Normal hues schematically indicate the dominant axis (red x, green y, blue z), with stronger tint for positive components. Depth is darker near; roughness is darker for smoother surfaces.

Clustered lighting

Related terms: clustered shading, tiled lighting, Forward+, deferred rendering

Dividing the camera's viewing volume into small 3D cells, then listing the lights that can affect each cell. When shading a surface, the renderer checks that cell's list instead of every light in the scene.

Tiled lighting divides the screen into 2D regions; clustering adds slices along depth, separating nearby surfaces from distant ones in the same screen region. It can support forward or deferred rendering. Building the lists also costs time, so the benefit depends on the scene. DOOM (2016) uses clustered light assignment to organize its lighting work.

In this coarse 2 × 2 × 3 grid, the selected near and far cells share one 2D screen region but retain different light lists. Gold spheres show finite influence ranges; each list comes from sphere–cell intersections. Clustering can save lighting work when the shorter lists outweigh the cost of building them.

Stencil buffer

Related terms: stencil test, mask

A per-pixel number stored next to the depth buffer. One draw writes a value into it, marking an area. Later draws are told to pass only where the stencil matches.

It works like masking tape. Portals, mirrors, outlines around selected objects and cut-out UI shapes are built with it.

Clear to 0 and write 1 over the portal opening; the scene pass accepts only samples whose stencil equals 1. Both views use the same coarse mask. Other integer values are available. Stencil testing is separate from alpha opacity and depth testing.

Overdraw

Shading the same screen pixel more than once in a frame because surfaces overlap. Work spent on pixels that end up covered is wasted.

Solid objects are drawn front to back so the depth test rejects hidden pixels early. Transparent things cannot be skipped that way. Big smoke particles stacked on screen are a classic cause of frame drops.

The screen map looks along the blue ray through four alpha-blended smoke quads. With depth writes off, no opaque occlusion, and no discard, the marked pixel receives four fragments. The map counts full quad coverage, including transparent margins. These are illustrative contributions, not GPU timings: depth rejection, cutout/discard, and opaque draw order can change the work.

HDR

Also called: high dynamic range

Related terms: tone mapping, exposure

Rendering with brightness values far above 1. The sun really is thousands of times brighter than a lamp, and an HDR frame keeps that difference instead of clipping both to white.

A screen cannot show that range. Tone mapping applies a curve that compresses it into what the display can do while keeping detail in the highlights. Exposure scales the image first, like a camera adapting to a dark room.

Further reading
LearnOpenGL: HDR
Illustrative linear-light model at exposure 1: clipping uses y = min(L, 1), and simple Reinhard uses y = L/(1 + L). Output is normalized to a chosen 0–1 range. Swatches interpolate in linear light between dark and bright theme neutrals; values are rounded. Display ranges and tone-mapping operators vary.

Gamma

Related terms: linear color space, sRGB, gamma correction

Image files and screens do not store brightness evenly. They use a curve called sRGB that spends more values on dark tones, where the eye is more sensitive.

Lighting math is only correct on real, linear light values. So color textures are decoded to linear when read, all shading happens in linear space, and the final frame is encoded back for the screen. Skipping this gives lighting that looks too dark and blends that look muddy.

Per channel on [0,1], sRGB encodes L as S = 12.92L when L ≤ 0.0031308, otherwise S = 1.055L^(1/2.4) − 0.055. It decodes S as L = S/12.92 when S ≤ 0.04045, otherwise L = ((S + 0.055)/1.055)^2.4. The swatches blend the same dark and light theme colors 50:50 in linear light (left) or encoded sRGB (right).

Fog

Related terms: distance fog, depth fog, atmospheric perspective

Blends each pixel toward a single color based on how far away it is. It gives a sense of distance and mood.

It is also an old performance trick. Objects fade out before they reach the far plane, so the world can end closer to the camera without a visible cut.

color = mix(fogColor, color, visibility)

The same scene uses exponential distance fog on the right: v = exp[−0.065 max(d − 8, 0)], where d is camera range in arbitrary world units. Surface colors and outlines blend toward the theme’s fog color using v. This face-sampled color model keeps geometry and lighting fixed; it does not simulate volumetric scattering.

Upscaling

Related terms: resolution scale, dynamic resolution, DLSS, FSR

Rendering the frame at a lower resolution and enlarging it to fit the screen. Fewer pixels to shade means a higher frame rate.

A plain stretch is blurry. Modern upscalers such as DLSS and FSR also read previous frames and per-pixel motion to rebuild detail. Dynamic resolution lowers the internal resolution automatically when frames start taking too long.

An illustrative 32×24 cabin scene becomes 128×96 through bilinear spatial enlargement; both images are displayed at the same size for comparison. Each output pixel mixes four neighboring source samples in linear-light RGB, with clamped image borders. The highlighted pixel uses weights 15/64, 9/64, 25/64 and 15/64 for the four enlarged source samples in reading order. This smooths existing samples without recovering detail. Temporal and model-based methods can use additional inputs or learned priors; they are not depicted here.

Graphics API

Related terms: DirectX, Vulkan, Metal, OpenGL, WebGPU, driver

The interface a program uses to talk to the GPU: create buffers, upload textures, set shaders, issue draw calls. Each platform has its own. Engines hide them behind one layer so the same game runs everywhere.

The newer ones (Vulkan, DirectX 12, Metal) are lower level. They give more control and less CPU overhead in exchange for much more work.

One engine abstraction can target different graphics backends. This example selects Vulkan (solid path); Metal is an alternative (dashed path) where supported. V₀, T₀ and S₀ identify geometry, texture and shaders; the draw uses 240 indices for 80 triangles. Command encoding, shader expressions and GPU layout are schematic; platform support and performance depend on the implementation.

Compute shader

Related terms: GPGPU, GPU compute

A shader that is not tied to drawing. It reads and writes plain buffers and textures, running the same small program on thousands of items at once.

It suits any job made of many independent pieces: particles, cloth, crowd movement, culling, terrain generation. A CPU has a few fast cores. A GPU has thousands of simple ones.

Two workgroups of four invocations update eight particle positions using p′ = p + vΔt and Δt = 1 s. Positions are in meters and velocities in m/s. Each global ID writes one output; this dispatch needs no padding. Many invocations can run in parallel, without a guaranteed execution order.

Lighting

Where brightness comes from, and the shortcuts used to compute it in time.

Light types

Related terms: Directional, point, spot

A directional light has parallel rays and no position. It stands in for the sun. A point light shines in every direction from one spot and fades with distance, like a bulb. A spot light is a point light limited to a cone, like a torch.

Further reading
Unity: types of light
Light strengths are illustrative. Directional ray segments are parallel and do not locate a source. Point and spot lighting use inverse-square falloff without a distance cutoff. The spot has a hard half-angle of about 14°; its drawn cone ends at the floor, while the second sphere receives only ambient light. Engines may add finite light ranges or soften cone edges and shadows.

Diffuse lighting

Related terms: Lambert, N dot L, ambient light

The matte part of shading. Light that hits a rough surface scatters evenly, so brightness depends only on the angle between the normal and the direction to the light. Facing the light is bright. Edge-on is dark. It is one dot product.

Ambient light is a small constant added everywhere so that unlit sides are not pure black. On its own it gives no sense of shape.

diffuse = max(dot(N, L), 0)

Ambient onlyAmbient + diffuse
Move the pointer or use the light controls.

Specular highlight

Related terms: Phong, Blinn-Phong, shininess

The shiny spot where a light reflects straight into the camera. Unlike diffuse, it depends on where the viewer is, so it slides across the surface as the camera moves.

A tight, bright highlight reads as polished. A wide, dim one reads as rough. In PBR this is controlled by roughness.

DiffuseDiffuse + specular

Ambient occlusion

Also called: AO

Related terms: SSAO

Darkens creases, corners and contact points, where surrounding geometry blocks ambient light from reaching. It grounds objects so they do not look like they float.

It can be painted into a texture ahead of time, or estimated every frame from the depth buffer. The second approach is SSAO, screen-space ambient occlusion.

Both views share geometry, camera and base shading. The right adds ambient darkening from 128 cosine-weighted world-space rays per surface sample, limited to 1.2 scene units. Visibility is the escaping fraction: 1.00 at the open marker and 74/128 ≈ 0.58 beside the block. This local approximation omits direct-light cast shadows and bounced illumination.

Shadow map

The standard way to draw shadows. The scene is first rendered from the light's point of view, keeping only depth. That image records the closest surface the light can see in each direction.

When shading a pixel, its distance to the light is compared with the stored one. If the pixel is farther, something is in the way and it is in shadow. Low resolution maps give blocky shadow edges.

The 32 × 32 image is computed from the light’s viewpoint: darker texels store nearer surfaces, and lighter texels store farther ones; white is empty. The warm receiver matches its stored floor depth. The red receiver lies beyond the crate depth stored in its matching texel, so it is occluded. The stepped shadow compares receiver depth against those same coarse texels. Depth is linearized along the light camera’s axis; one perspective view of an ideal point light is shown. Floor self-shadow artifacts and depth bias are omitted.

Baked lighting

Related terms: lightmap, baking, light probes

Lighting computed ahead of time and saved into a texture called a lightmap. At runtime the game only reads the texture, so even very soft, detailed lighting is nearly free.

A bake captures one lighting setup; it does not automatically respond to moving lights or geometry. Static surfaces can use lightmaps, while moving characters sample light probes. Some systems switch or blend between separately baked setups.

The room and the block’s exposed faces use eight non-overlapping lightmap islands. Both views share the same lighting samples; violet rings mark one floor texel. This illustrative bake includes direct area-light illumination and constant ambient fill, without computing bounced light. Moving the light or block requires a new bake.

Light probes and probe volumes

Related terms: irradiance, probe interpolation, Adaptive Probe Volumes

Light probes store samples of lighting at points in space. A moving character can blend nearby samples to receive indirect light without needing its own baked lightmap. A probe volume organizes samples across a region; systems such as Unity’s Adaptive Probe Volumes can place them more densely around detailed geometry.

Probe spacing trades memory and bake cost against accuracy. Samples across a thin wall can mix incompatible lighting and cause light leaks. Some systems blend between separately baked lighting scenarios, such as day and night. That changes which stored lighting is used without recomputing every light bounce in real time.

Four fixed samples surround the moving receiver in a tetrahedron. Their weights interpolate the lighting at the chest marker. This constructed field uses one directional pattern rather than simulating light bounces; real probes store directional RGB lighting, and Adaptive Probe Volumes can use different layouts.

Global illumination

Also called: GI

Related terms: indirect light, bounce light, color bleeding

Light that reaches a surface after bouncing off other surfaces. It is why a room with one window is not black away from the window, and why a red wall tints the floor next to it.

Direct light is cheap. Bounced light is expensive, so games bake it, approximate it with probes, or compute it with ray tracing.

Both rooms share the same direct sunlight, camera, exposure and small illustrative fill. On the right, one sampled diffuse bounce from the sunlit red wall adds a red tint to the sphere, plinth and floor. Window framing and the objects block light paths. Bounces from other surfaces and later bounces are omitted.

Attenuation

Also called: falloff

Related terms: inverse square law, light range

How a light gets dimmer with distance. In the real world brightness drops with the square of the distance: twice as far, a quarter of the light.

That curve never quite reaches zero, so engines add a range past which the light is cut off. Each light then affects only nearby objects, which keeps the cost down.

brightness = power / (distance * distance)

Gold shows E(r)/E(r₀) = (r₀/r)² for unobstructed point-light illumination at normal incidence, with r₀ > 0. Twice the distance receives 25% of the reference irradiance; four times receives 6.25%. Blue dashes show an illustrative hard range R = 4r₀: the same falloff for r < R, then zero for r ≥ R. Physical falloff stays positive; engines may instead taper smoothly near the range.

Soft shadows

Related terms: penumbra, umbra, PCF, contact shadows

A light with no size gives a perfectly sharp shadow edge. Real lights have size, so part of the shadow sees part of the light. The fully dark core is the umbra. The blurry rim is the penumbra, and it widens with distance from the object.

Shadow maps are hard-edged by nature. Engines soften them by taking several samples and averaging, called PCF, or use ray traced shadows.

The same thin screen casts a sharp shadow from an ideal point source and a soft shadow from a rectangular emitter. In the umbra the screen hides the whole emitter; in the penumbra it hides only part. Rays from the emitter’s edges locate the inner and outer boundaries. Tones show the computed visible fraction of emitter area, with distance and cosine weighting omitted; the screen’s drawn thickness and fine suspension wires are ignored by this visibility model.

Fresnel

Related terms: rim light, grazing angle

Surfaces reflect more when seen at a shallow angle. Look straight down into a lake and you see the bottom. Look across it and you see the sky. Every material does this to some degree.

In a shader it is computed from the angle between the normal and the view direction. PBR uses it for correct reflections. Stylized games use it for a glowing rim on shields, ghosts and selected objects.

rim = pow(1 - dot(N, V), 5)

WithoutWith Fresnel rim

Toon shading

Also called: cel shading

Related terms: ramp, outline, NPR

A style that makes 3D look hand-drawn. The smooth falloff of diffuse light is snapped into two or three flat bands, and a dark outline is often added.

The banding is one line in the fragment shader: round the light value, or look it up in a small ramp texture.

SmoothToon

Reflection probe

Related terms: environment reflections, SSR

A point in the level that captures its surroundings into a cubemap, usually ahead of time. Shiny objects near the probe use that image as their reflection.

It is cheap but approximate: correct only at the probe's position, and blind to anything that moves. Screen-space reflections (SSR) add detail by reflecting what is already on screen. Ray-traced reflections can include objects outside the camera view.

The room, six 90° captures and enlarged ideal mirror use one analytic environment. Each sphere normal selects R = 2(N·V)N − V at the probe position, with no parallax correction or roughness filtering. The two near walls and ceiling are removed only from the cutaway. Y is up.

Ray-traced reflections

Also called: RT reflections, ray traced reflections, ray tracing reflections, RTR

Related terms: specular reflection, screen-space reflections, SSR, denoising

Reflections computed by tracing rays from a visible surface into the scene. A puddle can reflect a car outside the camera's view, provided the car is included in the scene used for ray tracing. Screen-space reflections only have the current screen's data to work with.

Tracing and shading those hits costs GPU time. Games often trace few rays, then use denoising and temporal accumulation to reduce noise. Distance limits, simplified geometry and fewer bounces save work but can leave reflections incomplete.

A reflection ray can reach geometry outside the camera's direct view. Here the mirror ray from the puddle reaches a car parked just above the top of the frame, so the ray-traced image shows the car upside down in the water. Screen-space reflections can only reuse pixels already in the image: the car is missing from their puddle, which falls back to sky. The water is treated as a flat, perfect mirror.

Volumetric lighting

Related terms: god rays, light shafts, volumetric fog, volumetric sky

Makes light visible in the air itself, like sunbeams through a dusty window. Normal lighting only colors surfaces. Volumetric lighting also accounts for the haze between the camera and the surface.

The renderer steps along each view ray and adds up how much light the air scatters toward the camera. It is costly, so it is usually computed at low resolution and blurred.

Left, lighting only on surfaces: sunlight colors the floor it reaches. Right, with volumetric lighting: the sunlit air also scatters light toward the viewer, and each shaft is brighter where a line of sight crosses more of it. The camera's view ray is marched in equal steps; filled samples lie in sunlight and add to its pixel, open ones lie in shadow. The haze is uniform and scatters light once.

Volumetric sky

Related terms: volumetric clouds, cloud rendering, atmosphere, atmospheric scattering, ray marching

A sky rendered with clouds that occupy a three-dimensional volume, usually combined with a model of light scattering through the atmosphere. Cloud density varies through space, so clouds have depth and can be viewed from below, beside or inside. A skybox supplies a distant background image instead.

The renderer uses ray marching to sample density and lighting along a view ray, combining how much light is scattered toward the camera and how much passes through. This lets clouds respond to sunlight and cast shadows. More samples cost more GPU time; lower-resolution rendering and reconstruction help keep the effect affordable.

Samples through a cloud combine density and lighting into the final pixel. This section through the sky shows how much sunlight reaches each point of the cloud: most on the sunward side, less inside and toward the base, and little on the ground in its shadow. The view ray is marched only between the bottom and top of the cloud layer, and one sample marches toward the sun to find its own light. The camera is not to scale.

VR

Rendering for a headset: two eyes, a moving head, and no room for a late frame.

Stereo rendering

Related terms: IPD, single-pass stereo, lens distortion

VR draws the scene twice, once per eye, from two cameras a few centimeters apart. That gap is the IPD, the distance between the pupils. The brain fuses the two images into depth.

Twice the work at 90 frames per second is why VR is demanding. Single-pass stereo draws both eyes in one go with instancing. Each image is also bent in advance to cancel the distortion of the headset lenses.

Each eye is a camera at its own pupil, 6.4 cm apart. The near ball shifts much farther between the two images than the far crate, and the brain reads that difference as depth. Each image is pre-distorted inward so the lens’s pincushion distortion straightens it. Single-pass stereo draws both images in one go, instancing each object once per eye. The lens coefficients are illustrative.

Reprojection

Related terms: timewarp, spacewarp, motion-to-photon latency

The head keeps moving while a frame is being drawn, so the finished image is already slightly out of date. In VR that mismatch causes discomfort. Just before display, the headset software shifts and warps the image to match the newest head position.

It also covers for missed frames: the last image is shown again, warped, so the world stays put even when the game runs late.

Left-eye images; the head turns 7° to the right per display refresh. Before each refresh the compositor rotates the finished image to the newest head orientation, so the table stays put. When the next frame is late, the same image is rotated again. The hatched strip has no rendered pixels. This example corrects orientation only, not head position.

Foveated rendering

Related terms: eye tracking, variable rate shading, VRS

The eye sees sharp detail only in a small central spot. Foveated rendering shades that spot at full resolution and the rest at lower resolution, saving a large share of GPU work.

The fixed version assumes you look at the middle of each lens. With eye tracking, the sharp region follows your gaze. Variable rate shading is the GPU feature that makes it cheap.

Each 8 × 8-pixel tile is shaded once per pixel within 9° of the gaze, once per 2 × 2 block within 18°, and once per 4 × 4 block beyond, as variable rate shading allows. Fixed foveation centers the rates on the lens; eye tracking centers them on the gaze, here the ball. In this central window of the left-eye image, the eye-tracked frame takes 3,288 shading samples for 14,400 pixels. The angles are illustrative.

Animation

Making things change over time without storing every frame by hand.

Keyframe

Related terms: in-betweens, animation clip, animation curve

A saved value at a specific time: "at 0.5 seconds the ball is here". The animator sets only the important poses. The engine fills in the frames between them by interpolating.

A set of keyframes for one motion, such as a walk cycle, is an animation clip.

Solid balls are keyframes at 0, 0.5 and 1 s; each stores a height and the curve’s slope there. Faint balls are in-betweens the engine interpolates, shown every 1/12 s; a game samples the curve at each frame’s own time. Red marks the pose at the playhead.

Animation events

Also called: animation notifies

Related terms: animation markers, events, animation clip

Markers on an animation timeline that trigger actions when playback reaches them. A footstep marker can play a sound exactly when the foot touches the floor; another can release a particle effect when a sword strikes. The marker stores when something happens, while the event handler decides what to do.

This keeps effects attached to the motion when the clip plays faster or slower. A marked interval can also describe a window, such as the active part of an attack. The animation supplies timing; gameplay code still decides whether a hit is valid.

Further reading
Epic Games
One walk clip, with footstep markers stored at both heel strikes, plays at normal and double speed. Each marker fires when playback reaches it, so the sound stays on the heel contact as the clip speeds up.

Easing

Related terms: tween, ease in, ease out, animation curve

Changes the pacing between two values. Linear motion moves at constant speed and feels mechanical. An ease-in-out starts slow, speeds up, then slows down, the way real objects with weight move.

It works by bending t before it goes into a lerp. A tween is a short animation built this way, common in UI.

smooth = t * t * (3 - 2 * t)

Ticks mark eleven frames at equal steps of t. Linear moves the same distance every frame; ease-in-out (smoothstep) moves least near both ends and most in the middle. The red line and the knobs show one moment of the tween.

Skeletal animation

Related terms: rig, bones, joints, skinning, weights

Characters are animated by moving a hidden skeleton, not the mesh itself. Each bone is a transform that is a child of another bone. Building the skeleton is called rigging.

Skinning ties each vertex to one or more bones with weights. A vertex near the elbow might follow the upper arm 50% and the forearm 50%, so the mesh bends smoothly.

The skin is drawn translucent over the skeleton that moves it. Each bone is a transform parented to the one before it, from the root at the pelvis out to the hands, feet and head. In the enlargement, each quad and vertex is colored by its skin weights, blue for the upper arm and gold for the forearm. The ring at the elbow follows each bone 50%, and the rings beside it 75% and 25%, so the bend spreads over several rows of quads.

Animation retargeting

Related terms: skeleton mapping, retarget pose, rig, IK

Adapting an animation made for one skeleton to another character. The target might have longer legs, shorter arms, or different bone names. Retargeting maps corresponding bones or limb chains and adjusts the motion for the target rig, letting several characters share a library of walks, jumps, and gestures.

Simply copying joint rotations may leave feet sliding or hands missing their targets. A matching reference pose and inverse kinematics can help preserve contacts. Retargeting transfers an existing performance; it does not create the original motion, and unusual proportions may still need manual correction.

Further reading
Epic Games
One frame of a reach, retargeted from a source rig with short legs and long arms to a target rig with long legs and short arms. Both rigs share the T-pose reference, so each local joint rotation copies across bone for bone, and the root height scales by the ratio of hip heights so both feet stay on the floor. Copied rotations alone leave the target’s fingertip above and short of the button (dashed); two-bone IK on the mapped arm chain moves it back onto the contact.

Inverse kinematics

Also called: IK

Related terms: forward kinematics, FK

With forward kinematics you rotate each joint in order, shoulder then elbow then wrist, and see where the hand ends up. Inverse kinematics goes the other way: you say where the hand or foot should be and a solver works out the joint angles.

Games use IK to plant feet on uneven ground and to make hands reach for objects.

Further reading
Epic Games: IK setups
The walk was animated on flat ground (dashed), so at the stairs its leading foot would sink into the first step and the near hand would hang at its side. For each violet chain, an analytic two-bone solver keeps the hip or shoulder fixed and finds the knee or elbow angle from the two bone lengths and the distance to the target, by the law of cosines. The skinned mesh follows the solved joints.

Animation state machine

Related terms: animator, blend tree, crossfade, motion matching

A graph that decides which clip plays. Each box is a state with a clip. Arrows are transitions with a condition. The character is in exactly one state, or blending between two during a crossfade.

A blend tree mixes several clips by a parameter, for example walk and run mixed by speed.

Each state plays a clip, shown here by one of its poses, and each arrow is a transition with its condition. The violet state, run, is the one playing now.

Motion matching

Related terms: pose search, animation database, trajectory, animation state machine

Choosing animation by searching a library of recorded poses for the best fit. The query can include the current pose, limb velocities, and the direction the character is expected to travel. A suitable moment in a clip becomes the next motion to play, with transitions smoothed to avoid a visible snap.

This reduces the need to hand-author a transition for every possible turn or stop. The library still needs good examples of the movements the game requires. Epic reports that Fortnite Chapter 5 used its motion matching system for player characters and NPCs.

Game example and further reading
Epic Games
The query is the desired path over the next second, sampled at three times, plus the current pose: foot positions and velocities. Every frame in the library is scored on both, and the lowest total plays next. Only the right turn at the same moment of the stride matches both. A real library holds far more frames.

Sprite animation

Also called: frame animation, flipbook animation

Related terms: sprite, flipbook

A sprite is a 2D image drawn in the game world. Sprite animation swaps the image several times per second, like a flipbook. The frames usually sit side by side in a sprite sheet.

The clip has its own frame rate, often 8 to 15 per second, independent of the game's frame rate.

A six-frame run cycle packed into one sprite sheet. The game draws one cell at a time and steps to the next at the clip’s 10 FPS, so each image stays on screen for six frames of a 60 FPS game.

Blend shapes

Also called: morph targets, shape keys

Alternative versions of the same mesh with the vertices moved: a smile, a blink, a raised brow. A weight from 0 to 1 slides every vertex between its normal position and the target.

Faces are animated this way, because skin moves in ways bones describe poorly. Several shapes can be mixed at once. Each one stores a position for every vertex, so they use a lot of memory.

The smile target stores a new position for every vertex of the same head mesh. At weight 0.5 each vertex sits halfway along the straight line from its rest position to its target, as the violet lines in the enlarged mouth corner show. Other targets, such as a blink, add their own offsets with their own weights.

Animation blending

Related terms: crossfade, blend weight, animation layers, mask

Mixing two or more clips so the pose is partly one and partly the other. Each clip has a weight, and the weights add up to 1.

A crossfade ramps one weight down while the next ramps up over a fraction of a second, so a walk turns into a run with no snap. Layers with a mask blend per body part: the legs run while the arms reload.

A 0.6 s crossfade from walk to run. Both clips play at one shared phase, so the same foot leads in each. Each output pose mixes their joint angles by the two weights, which always add up to 1; its color shows the mix.

Root motion

Related terms: in-place animation, foot sliding, motion warping

Movement through the world that comes from the animation itself. The clip moves the character's root bone, and the engine applies that movement to the object each frame. Feet stay planted because the travel matches the steps exactly.

The alternative is an in-place clip while code moves the character at a set speed. Control is tighter, but if speed and steps disagree the feet visibly slide.

Above, the clip moves the root, so each planted foot stays on one footprint. Below, code moves the same clip in place at a constant speed 30% faster than its steps, and every planted foot slides. Dots mark the root every 0.1 s; the character is drawn every 0.5 s, earlier frames faint.

Motion warping

Related terms: warp target, root motion, alignment

Adjusting an animation’s root movement so an action reaches a target in the level. A lunge recorded to travel two meters can be adapted to an enemy standing slightly nearer or farther away. The correction can also turn the character to face the target.

The adjustment happens during a chosen part of the clip, called a warping window. This lets one authored action fit several interaction positions. Large corrections can visibly stretch or distort the movement, so target placement and the allowed adjustment range still need care. Limb contact may need additional IK.

Further reading
Epic Games
Dots mark the root at the same 13 playback times in the authored and warped clips. Inside the warping window, frames 3 to 9, the correction is spread in proportion to the authored root movement: that part of the lunge stretches by 25% and turns 19° so the blade tip ends on the enemy.

Ragdoll

Also called: ragdoll physics

Related terms: active ragdoll

A character moved by physics instead of animation. Each limb gets a rigid body and a collider, and the limbs are linked by joints with angle limits so elbows and knees bend only the right way.

When a character is knocked out, animation is switched off and the ragdoll takes over, so it falls and settles differently every time. An active ragdoll blends physics with animation so the body can stumble and recover.

When the hit lands, animation stops and physics takes over. Each limb is a rigid body with a capsule collider, linked by joints; knees and elbows are hinges that bend one way only, up to 140° and 145°. The pelvis follows a ballistic arc while the body turns over, and on landing each limb drops about its joint until it rests on the floor. The poses are illustrative frames, not the record of one simulation.

Physics

Simulating how objects move, touch and push each other.

Collider

Related terms: hitbox, hurtbox, AABB, bounding box, trigger

A simple invisible shape used for collision checks in place of the detailed mesh. Boxes, spheres and capsules are cheap to test against each other.

An AABB is an axis-aligned bounding box: a box that never rotates. Two AABBs overlap if they overlap on every axis. A trigger is a collider that reports overlaps but does not block movement. In fighting games a hitbox deals damage and a hurtbox receives it.

The violet axis-aligned box encloses the same crate as the visible mesh. Collision checks can use the box instead of testing each board.

Rigid body

Related terms: physics body, kinematic, static

An object handed over to the physics engine. It has mass and velocity. Each step the engine applies gravity and other forces, moves it, and resolves collisions using its collider.

A dynamic body is fully simulated. A kinematic body is moved by code and pushes others without being pushed. A static body never moves, like the ground.

Further reading
Godot: Using RigidBody
Gravity moves the dynamic crate. Code moves the kinematic crate along a static slab. Dashed outlines mark earlier poses.

Physics interpolation

Also called: fixed timestep interpolation

Related terms: fixed timestep, lerp, rendering

Blending an object’s displayed pose between two completed physics updates. Physics advances in fixed steps, while the screen may draw frames at a different rate. Showing intermediate poses smooths the visible motion without changing the simulation’s collision results or increasing its update rate.

The usual previous-to-current scheme displays motion about one physics step behind the simulation timeline. That delay is a tradeoff for smoothness, especially for responsive player movement. A teleport should reset the stored poses so the renderer does not draw a fast journey across the gap.

The outlined crates mark completed physics steps. The violet crate is the halfway display pose between them, so rendering can stay smooth between ticks.

Raycast

Also called: line trace

Related terms: hitscan

Shoots an invisible line from a point in a direction and asks the physics engine what it hits first. The answer includes the object, the hit point, the distance and the surface normal there.

Used for instant-hit weapons, checking if the player is on the ground, line of sight for AI, and picking objects with the mouse.

Further reading
Godot: RayCast3D
The ray returns the first wall it reaches, the distance to the intersection and the blue surface normal at that point.

Shape cast

Also called: shape sweep

Related terms: sphere cast, capsule cast, raycast, continuous collision detection

A collision query that sweeps a shape along a path and reports what it would touch. A ray has no width; a sphere, capsule or box cast includes the space occupied by the object. A centerline can miss a pillar that the character’s shoulder would hit.

Use shape casts to test movement clearance, find ground under a character or check a wide beam. The query detects contact; gameplay code decides what to do with it. Sweeping a volume generally costs more than a ray, so choose a shape and distance that fit the question.

Further reading
Godot: shape casting
The ray misses the pillar. The swept sphere reaches the pillar when the distance between their centers equals the sum of their radii.

Physics material

Related terms: friction, restitution, bounciness

Surface properties used by the physics engine. Friction is how strongly two surfaces resist sliding: low for ice, high for rubber. Restitution, or bounciness, is how much speed survives a bounce. At 0 the object stops dead. At 1 it bounces forever.

When two materials touch, the engine combines their values into one for that contact.

Further reading
Godot: PhysicsMaterial
Both balls start at the same height. The first rebound reaches a fraction e² of that height, where e is the restitution of the contact.

Broad phase

Related terms: narrow phase, spatial partitioning, quadtree, octree, grid

Testing every object against every other is too slow: 1,000 objects means about 500,000 pairs. The broad phase throws out pairs that cannot possibly touch, using bounding boxes and a spatial structure. The narrow phase then runs exact tests on the few pairs left.

The structure is a grid, a quadtree in 2D, an octree in 3D, or a BVH. The same structures answer "what is near me?" for AI and speed up raycasts.

The dashed bounds overlap and make a candidate pair. The exact spheres still have a gap, so the narrow phase rejects the contact.

Tunneling

Related terms: continuous collision detection, CCD

Physics moves objects in steps. A fast object can be in front of a thin wall on one step and behind it on the next, without ever overlapping it. It passes straight through.

Continuous collision detection checks the whole path swept between two steps. It costs more, so it is switched on only for small fast things. Other fixes: thicker walls, smaller steps, or a raycast in place of a physical bullet.

Checking the two endpoints misses the wall. Sweeping the interval finds contact when the leading edge of the marble reaches the wall.

Joint

Related terms: constraint, hinge, spring, slider

A rule that links two rigid bodies and limits how they can move relative to each other. A hinge allows rotation around one axis. A spring pulls toward a rest length. A slider allows travel along one line.

The physics solver enforces every joint on each step. Doors, wheels, suspension, ropes, chains and ragdolls are built from them.

A hinge pivots around the pin, a spring permits extension and compression, and a slider keeps its carriage on the rail.

Collision layers

Related terms: layer mask, collision matrix

Labels that decide which objects can collide with which. Every collider is put on a layer, and a matrix says which pairs of layers interact. The player's own bullets ignore the player. Pickups react only to the player.

Ignored pairs are never tested, so this is also an optimization. A layer mask applies the same filter to a raycast: "only hit walls".

The shot layer ignores the player and can collide with the enemy. The matrix encodes the same filter in both row and column order.

One-way collision

Related terms: one-way platform, semisolid platform, collider, character controller

A surface that blocks motion from one side while allowing an object to pass through from the other. In a platformer, the player can jump upward through a ledge, then land on its top while falling. This differs from a trigger, which reports overlaps without physically blocking either direction.

The collision rule must account for which side the body approaches from, rather than simply drawing a thin platform. Games may also temporarily disable that collision for an intentional drop-through action. A suitable collision margin helps the permitted landing side catch fast-moving bodies reliably.

The same ledge admits a ball rising from below and stops a ball arriving from above.

Force and impulse

Related terms: acceleration, mass, F = ma

A force changes an object's velocity gradually. It is applied on every physics step: gravity, engine thrust, wind. Heavier objects respond less to the same force.

An impulse is an instant change in velocity, applied once: a jump, an explosion, a bat hitting a ball.

acceleration = force / mass

Further reading
Godot: Using RigidBody
A 4 N force over 2 s and an 8 N·s impulse give the same 2 kg body a final speed of 4 m/s. The force spreads the change over time.

Torque

Related terms: angular velocity, center of mass, moment of inertia

The turning version of force. Push an object in line with its center of mass and it only slides. Push off-center and it also spins. The farther from the center, the stronger the turn.

Moment of inertia is how hard an object is to spin, the rotational equivalent of mass. Lowering a car's center of mass in code is the usual fix for a vehicle that tips over.

The same push translates both crates. Moving its line of action away from the center of mass adds a lever arm and makes the crate turn.

Drag

Related terms: damping, linear damping, angular damping, terminal velocity

A force that opposes motion and grows with speed. Without it, a falling object speeds up forever and a pushed one never stops.

Engines expose it as damping on a rigid body: linear for movement, angular for spin. The speed where drag balances gravity is the terminal velocity. Tuning damping is the quick way to make movement feel heavy or floaty.

With linear damping, speed approaches the point where drag balances gravity. The no-drag line continues rising at constant acceleration.

Sleeping

Related terms: sleep, wake, resting bodies

An optimization. A rigid body that has stayed still for a moment is put to sleep and skipped by the physics engine. It wakes when something touches it or a force is applied.

A level with a thousand resting crates costs almost nothing until the player barges into them. A classic bug: code removes the floor under a sleeping object and it stays hanging in the air.

Further reading
Godot: RigidBody3D
The crate stack can sleep while at rest. Contact with a rolling marble wakes the highlighted crate so the solver can respond.

Character controller

Related terms: kinematic character, step offset, slope limit, move and slide

Player characters rarely use full physics. A realistic body slides, tips over and bounces, which makes for terrible controls. A character controller is a capsule moved directly by code. It collides and slides along surfaces but ignores forces.

It handles the rules of walking: stepping up small ledges, climbing slopes up to a limit, staying glued to the ground downhill. Much of how a platformer feels is decided here.

The capsule clears a short step and follows a gentle slope. At the steep ramp it stops while retaining its upright shape.

Cloth and soft bodies

Related terms: cloth simulation, soft body, spring-mass, rope, hair

Things that bend are simulated as points linked by springs that try to keep their length. On each step the points move under gravity and wind, then the springs pull them back into shape.

A grid of points is cloth. A chain is a rope or a strand of hair. A blob that also keeps its volume is jelly. It is expensive, so it often runs on the GPU and collides with a few simple shapes instead of the full character.

Further reading
Godot: SoftBody3D
The top corners stay pinned as gravity and wind move the other particles. Spring links pull neighbors toward their rest distances.

Engine and gameplay

The code structures and systems that make the world run and react.

Game loop

Related terms: tick, update, frame

The loop at the heart of every game. Each pass reads input, updates the world, and draws the result. One pass is one frame.

Unlike a normal app, a game does not wait for events. It runs this loop continuously, even when the player does nothing.

Every frame reads input, updates the ball position and draws the updated scene. Rendering leads back to input for the next frame.

Delta time

Also called: dt

Related terms: fixed timestep

The time that passed since the previous frame, in seconds. Multiply every movement by it and things move at the same speed on a fast machine and a slow one. Without it, a faster computer runs the game faster.

Physics is usually stepped with a fixed timestep instead, for example always 1/60 s, because simulations become unstable when the step size varies.

position += velocity * dt

At 5 m/s, 60 frames per second takes twelve small steps in 0.2 s. At 20 frames per second, four larger steps cover the same metre.

Object lifecycle

Related terms: spawn, initialization, enable, disable, destroy, callbacks

The stages an object passes through: creation, initialization, active updates, disabling and destruction. Engines call lifecycle callbacks at these stages so code can prepare data, respond each frame and clean up.

Initialize before using an object. Subscribe to events when needed, and unsubscribe when finished. Disabling a pooled object is different from destroying it. Callback names and ordering depend on the engine.

Create and initialize the door before its updates begin. Disabling suspends updates and leaves the object available to enable again. Destroying it ends its lifecycle.

Timer

Related terms: timeout, interval, deadline, scaled time, coroutine

Tracks when a duration has elapsed and triggers an action. A one-shot timer fires once; a repeating timer fires at an interval. Timers drive cooldowns, delayed explosions and enemy spawns.

A frame-based timer usually checks elapsed delta time or compares the current clock with a deadline. It fires on a later update, so timing is limited by update frequency. Choose whether pausing or slow motion should affect its clock.

Further reading
Godot: Timer
The example checks the clock every 0.4 s. A 0.7 s deadline first fires at 0.8 s. The repeating timer uses deadlines based on its original start time.

Coroutine

Related terms: yield, await, timer, multithreading

A function that can pause at a yield or await point and resume later with its local state intact. It makes sequences such as “open the door, wait, then close it” easier to express.

In common engine coroutine systems, the game loop keeps running while the coroutine waits. That does not make expensive work run on another thread: work before the next yield can still block a frame. Cancel pending sequences when their owner is gone.

The coroutine opens the door, yields during a wait and resumes to close it. The game loop keeps running throughout the wait.

Scene graph

Related terms: hierarchy, parent and child, node, game object

The tree of objects in a scene. A child's transform is relative to its parent, so moving the parent moves everything under it. Put the wheels under the car and they follow.

Engines name the nodes differently: GameObject in Unity, Actor in Unreal, Node in Godot.

The chassis is the parent and the four wheels are children. Moving the parent keeps every wheel at its local offset.

Component

Related terms: composition, game object, object lifecycle, ECS

A reusable part attached to a game object: a collider, an audio player, a health script or a renderer. In an object-based component design, a component can hold both state and behavior and receive lifecycle callbacks.

Build a door by combining a model, a collider and a door script. This is composition: assembling behavior from parts. In ECS, components are typically data while systems perform the work.

A visible model, a collider and a script are separate parts of the same door. Each handles a different job.

ECS

Also called: entity component system

Related terms: object components

A way to organize game code around data. An entity is just an ID. A component is plain data attached to it, like position or health. A system is a function that runs over every entity that has a given set of components.

Behavior comes from which components an entity has, not from a class hierarchy. Storing each component type in a tight array is also fast for the CPU cache.

The movement system selects entities with both position and velocity. The cart and drone move in the example step, while the tree has no velocity entry.

Particle system

Related terms: emitter, VFX

Draws effects made of many small pieces: fire, smoke, sparks, rain. An emitter spawns particles at a set rate. Each one gets a random velocity, size and lifetime, changes over its life, then disappears.

Particles are simple and numerous, so they are usually drawn with instancing and often simulated on the GPU.

The nozzle emits droplets with different velocities and lifetimes. Each droplet shrinks and fades as it moves toward the basin.

Prefab

Related terms: blueprint, packed scene, template, instance

A saved, reusable object with all its parts and settings: an enemy, a door, a streetlight. You place instances of it in levels or spawn them from code.

Edit the prefab and every instance updates. A single instance can override a value, like one enemy with more health. Unity calls it a Prefab, Unreal a Blueprint, Godot a Scene.

Further reading
Unity: Prefabs
All three doors inherit the prefab. The gold latch on the third door comes from a local override.

Instance

Related terms: instantiation, spawn, template, reference

One concrete object created from a class, prefab or other template. Three enemies can use the same template while each instance has its own position, health and current target.

Spawning creates an instance. Copying a reference to an existing enemy does not spawn another one. Instances may still share resources such as meshes and materials, so changing a shared resource can affect all of them.

The three crates use one template and each has its own position and health.

Reference

Related terms: object reference, pointer, handle, null, instance

A way to refer to an existing object so code can read it or call its methods. Two variables can refer to the same instance. Changing that object through one variable is then visible through the other.

A reference is different from a copy of the object. It may be empty, or its target may have been destroyed, so check validity where lifetimes can differ. Whether it keeps an object alive depends on the language and engine.

Both references still point to door #17 after a change through ref A. Either reference can read the resulting door state.

Shared data assets

Related terms: data-driven design, configuration, ScriptableObject

Reusable assets hold configuration that many objects read: weapon damage, enemy statistics or item descriptions. Each instance keeps a reference to the same data instead of copying it. Designers can tune one asset and update every object that uses it. Unity’s ScriptableObject is one implementation.

Keep shared definitions separate from changing per-instance state. Two swords may share damage and an icon while retaining different durability values. Accidentally storing durability in the shared asset makes both swords change together. These assets complement prefabs; they are not automatically a player save system.

Both shields read armor and emblem from the same asset. Each keeps its own durability.

Object pool

Also called: object pooling

Related terms: pooling, recycling, object lifecycle

Reusing objects instead of creating and destroying them. A set of bullets, enemies or effects is made up front and switched off. When one is needed it is taken from the pool and switched on. When it is done it goes back.

Creating objects during play costs time and feeds the garbage collector. A pool moves that cost to the loading screen.

Object B moves from the rack to an active slot. After use it returns to the same pool for another activation.

Events

Related terms: observer pattern, signals, delegates, message bus

A way for systems to react to things that happen without knowing about each other. One object announces "the player died". Any number of listeners that subscribed to that event are called.

The player code never mentions the UI, the audio or the score. New reactions can be added without touching it. Godot calls them signals. C# and Unreal call them delegates.

The door publishes one event. The interface, audio and quest systems react independently through subscriptions.

Camera follow

Related terms: dead zone, smoothing, look-ahead, screen shake

Game cameras rarely stay glued to the player. A dead zone is an area in the middle of the screen where the player can move without the camera reacting. Smoothing makes the camera glide toward its target with a lerp each frame.

Look-ahead shifts the view toward where the player is heading. Screen shake adds a short random offset on impacts.

Further reading
Godot: Camera2D
While the car stays in the dead zone the view holds still. Once the car leaves it, the camera shifts along the road.

Level streaming

Related terms: chunks, open world, texture streaming

Loading and unloading pieces of the world while the game runs, instead of everything at once behind a loading screen. The world is cut into chunks. Those near the player are kept in memory. Those far away are dropped.

Assets stream the same way. A texture first shows a small mip level and sharpens as the rest arrives.

Moving east changes the chunks surrounding the traveler. Violet outlines show loads, and distant chunks leave memory.

Asset dependencies

Related terms: dependency graph, asset bundle, shared assets

An asset may need other assets to work: a character uses a mesh, a material uses textures, and an animation controller uses clips. These links form a dependency graph. Loading one asset can pull in a much larger set of data than its own file suggests.

Packaging affects the result. Put a shared texture into several bundles and you may ship or load duplicate copies; put it in a shared bundle and other bundles must load that dependency. Inspect these links when memory or download sizes grow unexpectedly. Systems such as Unity Addressables help manage the graph, but grouping decisions still matter.

Both meshes need the shared material. The material in turn depends on a single texture.

Serialization

Related terms: save system, save file, JSON, binary, versioning

Turning live objects in memory into bytes that can be stored or sent, and turning them back. Save games, scene files, prefabs and network messages all depend on it.

Text formats such as JSON are readable but large. Binary formats are compact and fast. The format is the easy part. The hard parts are deciding what to save, restoring links with persistent identifiers, and migrating old saves after the game has changed.

Further reading
Godot: Saving games
The open state encodes to JSON and UTF-8 bytes. Reading those bytes back restores the state.

Persistent identifiers

Related terms: stable identity, IDs, lookup, references, remapping

Identifiers that let saved data find the same object or content after loading again. A memory address or temporary array index may point somewhere else next session. A durable identifier, or a saved mapping to a stable name, gives the loader enough information to restore the intended relationship.

Persistent identity does not require every runtime number to stay unchanged. Factorio saves a mapping between content names and numeric IDs, then remaps old IDs to current ones when loading. For individual instances, an identifier must also distinguish two objects of the same type, such as separate chests with different inventories.

The saved ID finds the same chest even though the chest occupies a different runtime slot after reload.

Save migration

Related terms: save version, schema change, backward compatibility, serialization

Updating saved data so a newer version of the game can understand it. A patch might rename an item, split one statistic into two, or add a field that older saves lack. Reading the bytes successfully is only the first step: the restored data must still make sense under the new rules.

A migration transforms the old representation, supplies appropriate defaults and records which updates have been applied. Factorio supports migrations for renamed prototypes and changed research or recipes. Test real older saves as part of regression testing, including links to content that has changed or disappeared.

The migration preserves the record ID, changes the item name and initializes the new field to zero.

Input mapping

Related terms: action map, bindings, rebinding, stick dead zone

A layer between physical buttons and game logic. Code asks "was Jump pressed?", never "was Space pressed?". Which key, button or gesture triggers each action is a binding, stored as data.

Controller support, key remapping and several devices at once then come almost for free. A dead zone ignores small stick movement near the center so a worn stick does not drift.

Further reading
Godot: InputMap
Spacebar and the controller south button feed the same Jump action. Small stick jitter within the dead zone produces no movement.

Input event propagation

Related terms: event consumption, handled input, input mapping, UI focus

The route an input event takes through possible handlers. An interface can consume an event after using it, preventing later handlers from responding to that same event. Clicking a menu button should not also fire the weapon behind the menu.

Input mapping assigns meaning to a key or button; propagation decides which system gets to react. Give interface handlers a chance to consume relevant events before gameplay handles the remainder. Consuming an event does not necessarily change the device’s held-button state, so gameplay that polls input directly also needs appropriate menu or gameplay-state checks.

The interface consumes a click on its menu button. A click outside the button can reach gameplay.

Game AI

How characters sense the world, decide what to do, and find their way.

Pathfinding

Related terms: A*, navmesh, navigation

Finding a route from A to B around obstacles. A* (A-star) is the classic algorithm. It explores a graph of positions, always expanding the one that looks closest to the goal, and returns the shortest path.

In 2D the graph is often a grid. In 3D it is usually a navmesh: a simplified mesh of the walkable floor, built from the level geometry.

A* searches four-way steps on the floor. Pale violet cells are the cells it expanded. The dark route reaches the goal using the fewest steps around the walls.

Finite state machine

Also called: FSM, state machine

Related terms: state, transition, behavior tree, animation state machine

A set of named states and rules for moving between them. A simple enemy can be in patrol, chase or attack. Exactly one state is active in a basic FSM; transitions happen when their conditions are met.

Each state can have entry, update and exit behavior. FSMs also suit doors, menus and character abilities. As transitions multiply, hierarchical states or a behavior tree can make the logic easier to manage.

Opening owns the door behavior in this frame. Reaching the open limit hands control to the open state. An obstruction while closing can send it back to opening.

Behavior tree

Also called: BT

Related terms: AI, finite state machine, FSM, selector, sequence

A tree of checks and actions that chooses what an AI character does. Nodes return success, failure or running. A selector tries alternatives until one succeeds or is still running; a sequence proceeds until a child fails or is still running.

For example, try to see, chase and attack the player; otherwise patrol. Running actions can continue across updates. A finite state machine organizes behavior around explicit states and transitions instead.

The selector tries the greeting sequence first. The check succeeded and approach is still running, so greeting waits and the patrol fallback stays idle.

Steering behaviors

Related terms: seek, flee, arrive, pursue, obstacle avoidance, traffic simulation

Simple rules that produce lifelike movement by nudging a character's velocity every frame. Seek turns toward a target. Flee turns away. Arrive slows down on approach. Pursue aims at where the target will be.

Each rule outputs a small force. They are added up, capped and applied. No path is needed in open space. In corridors they are combined with pathfinding.

steering = desired velocity - current velocity

The correction joins the current velocity tip to the desired velocity tip. Adding it to the current velocity aims the rover toward the target.

Traffic simulation

Also called: traffic AI, vehicle AI

Related terms: lane graph, car following, lane changing, traffic lights, vehicle simulation

The system that makes computer-controlled vehicles move through a road network. Each vehicle follows a route through connected lanes, adjusts its speed to keep a gap, chooses lane changes and responds to signals, junctions and obstacles. Pathfinding chooses where to go; local driving decisions control how to get there.

The visible traffic comes from many vehicles making these decisions together: one red light can produce a queue. Vehicle handling and collisions add a separate physics cost. A simulation can simplify physics for distant cars while keeping their routes and speeds, reserving detailed motion for traffic near the player.

Three cars hold following gaps while the signal is red. The perpendicular lane has green and traffic keeps moving through the junction.

Flocking

Related terms: boids, separation, alignment, cohesion, crowds

The movement of a flock, a school of fish or a crowd, produced by three rules that each member follows using only its nearby neighbors. There is no leader and no plan.

Separation: do not crowd your neighbors. Alignment: head the same way they do. Cohesion: drift toward their center. The simulated members are called boids. A spatial grid keeps the neighbor search fast.

Each fish responds to nearby fish. Separation steers away from close neighbors, alignment follows their average heading, and cohesion aims toward their average position.

Flow field

Related terms: vector field, crowd pathfinding

Instead of computing a path for each unit, compute once, for every cell of the map, which direction leads toward the goal. Any number of units then just follow the arrow under their feet.

The cost depends on the size of the map, not on the number of units. That suits armies, hordes and crowds all heading to the same place. It is built by flooding outward from the goal and pointing each cell at its cheapest neighbor.

Flooding out from the gold goal assigns each reachable cell a cost. Each arrow leads to a neighbor one step cheaper, so all three rovers can follow the same field.

Utility AI

Related terms: utility system, scoring, considerations

Every action the character could take gets a score for how useful it is right now, and the character does the highest one. Scores come from simple curves: low health pushes "heal" up, a close enemy and a full magazine push "attack" up.

Adding a behavior means adding one more scorer, not rewiring a tree. The result feels fluid and reacts to many factors at once. It is also harder to predict and debug.

Condition, energy and travel cost feed four scoring rules. At these readings, repair has the highest score.

Tactical position selection

Also called: position picking

Related terms: cover selection, position scoring, utility AI

Choosing where an AI character should stand by evaluating candidate locations. A position can score well for cover, distance to the target and a clear firing line, but poorly for exposure to another enemy. The factors and weights depend on the action the character wants to perform.

Pathfinding then finds a route to the chosen location. This separates choosing a destination from reaching it. In Killzone, position evaluation combines tactical factors into a score; changing the threats changes which position looks best. Like utility AI, the result depends on the scoring rules designers choose.

The rover gives up to 40 points for a clear view and up to 60 for being near the preferred range. It chooses the highest-scoring spot, then routes there.

GOAP

Also called: goal-oriented action planning

Related terms: planner, preconditions, effects

The AI is given a goal and a set of actions. Each action lists what it needs and what it changes. A planner then searches for a chain of actions that leads from the current situation to the goal. It is pathfinding through actions instead of through places.

Designers do not script sequences. They add actions, and plans emerge, including ones nobody expected. It costs more CPU and is harder to control than a behavior tree.

The planner finds a sequence that makes the door open. Each action adds a fact that the next one needs.

Hierarchical task network

Also called: HTN

Related terms: planning, task decomposition, methods, GOAP

An AI planner that breaks a high-level task into smaller tasks until it reaches actions the character can execute. Designers supply methods describing alternative ways to perform a task, with conditions for choosing each method. A blocked route might make the planner try another decomposition.

Unlike GOAP, which searches combinations of action effects toward a goal, an HTN follows authored task decompositions. This gives designers structure while allowing plans to adapt to the situation. Killzone 2 uses HTN planning for its multiplayer bots; a task hierarchy describes how work breaks down, not merely which behavior has priority.

The delivery task breaks into travel and handoff. With the bridge closed, the travel task expands the ferry method into a walk to the pier and boarding.

Perception

Related terms: vision cone, line of sight, hearing, awareness

How AI characters sense the world. It is kept deliberately limited so the player can outsmart them. Sight is a vision cone, an angle and a distance, plus a raycast to check nothing is in the way. Hearing is a radius around each sound.

The results usually feed an awareness value that rises over time instead of flipping at once. That gives stealth games their "suspicious" state. An enemy that always knows where you are feels like cheating.

The blue cone shows potential sight. A wall cuts it off, hiding one marker. A nearby sound reaches the rover inside the gold circle.

AI director

Related terms: encounter manager, adaptive pacing, pacing

A system that oversees encounters rather than controlling one enemy. It observes the players, estimates pressure and decides when to introduce threats or allow a break. This creates responsive pacing while individual enemies still use their own behavior logic.

In Left 4 Dead, the director tracks the highest estimated survivor intensity. After a peak, it reduces new threats, pausing mob and special-infected spawns while current combat plays out. Existing special infected can still attack, and boss encounters are unaffected by this pacing system. Think of a feedback loop: observe, decide, adjust, then observe again.

In this example the director pauses new encounters at a pressure reading of 0.72 or higher. It allows them again at 0.32 or lower.

Game and level design

Rules, choices, learning and rhythm: how games and levels play and feel.

Mechanic

Related terms: rule, interaction, system, core loop

A rule or interaction that determines what can happen in a game. Jumping, trading, taking cover and spending stamina are mechanics. A mechanic connects an action or condition to a change in the game state.

Mechanics combine into systems: jumping plus stamina plus climbing creates choices about routes and timing. A core loop describes the repeated sequence of activities that uses those mechanics.

Pressing Jump checks whether the ball is grounded. A grounded ball launches. An airborne ball keeps falling.

Core loop

Also called: core gameplay loop

Related terms: gameplay loop, meta loop, progression

The short cycle of actions a player repeats for the whole game: fight, collect loot, upgrade, fight something tougher. If that cycle is not fun on its own, no amount of content rescues it. That is why prototypes test it first.

Larger loops wrap around it: a session loop such as one run or one match, and a meta loop of long-term progression.

The garden game repeats a short cycle. Harvest a crop, sell it, upgrade the watering can and put it to use with the next crop.

Balancing

Also called: game balance

Related terms: tuning, nerf, buff, risk and reward

Adjusting rules and values so choices, challenges and rewards support the intended experience. Weapons can be useful in different situations without doing equal damage or having equal win rates.

Change damage, cost, range or cooldown, then observe what players do. Playtests explain behavior; measurements help reveal patterns. Balance depends on skill level, context and the goals of the game.

The violet cart accelerates faster and wins the 3 s trial. The blue cart has a higher top speed and goes farther in the 12 s trial. Each trial has its own distance scale.

Encounter budget

Related terms: enemy cost, spawn budget, encounter composition, balancing

A limit used to choose the enemies in an encounter. Assign each enemy a cost, then build a group whose combined cost fits the budget. This allows different compositions while keeping an intended scale of opposition. Costs are design estimates, not a guarantee that every group feels equally difficult.

In Dead Cells, combat-area length helps determine enemy population, and more dangerous monsters consume more allowance. Placement rules also restrict certain combinations and spaces. A budget therefore works with constraints: two individually cheap enemies might create an overwhelming combination. Balancing and playtesting check the results, including terrain and the player’s available abilities.

Four scouts at 2 points each and a 6-point heavy unit with one scout both use the full budget. Compare how each group plays in the encounter space.

Risk and reward

Also called: risk/reward

Related terms: balancing, tradeoff, opportunity cost

The relationship between what a player might gain and what they might lose by taking an action. A dangerous shortcut can offer more loot, while a safe route offers a smaller but more reliable return.

Risk can mean health, time, position or scarce resources. The player needs enough information to judge it. Telegraphing threats and showing rewards make the choice understandable rather than arbitrary.

The broken upper bridge shortens the route and offers three coins. The longer lower route has a complete bridge and offers one coin.

Difficulty curve

Related terms: challenge, skill, difficulty spike, onboarding

How challenge changes across a level or the whole game. Challenge can rise through tougher enemies, more complex decisions or less room for mistakes. It should be considered alongside what the player has learned and unlocked.

A sudden spike can stop progress; a long flat stretch can become dull. Introduce a skill, give room to practice, then combine it with others. Playtesting helps show where the intended curve differs from the experienced one.

This example raises the overall challenge and leaves room to practice after individual checks. Later sections combine the skills already introduced.

Pacing

Related terms: tension, intensity, encounter, difficulty curve

The rhythm of activity, tension and rest. A level might move from exploration to a fight, then to a quiet room where the player absorbs what happened. Story beats and rewards also shape that rhythm.

Difficulty is only one part of pacing. An easy chase can feel urgent, and a hard puzzle can be calm. Vary duration and intensity so important moments have space to stand out.

A chase raises the intensity, a rest section lets it fall, and the escape brings a new peak. The plotted heights are illustrative.

Onboarding

Related terms: tutorial, first-time user experience, FTUE, affordance

How a game teaches a new player what to do, how to do it and why it matters. It includes controls, goals, interface conventions and the first opportunities to use them.

A useful sequence is introduce, practice, then test. Teach jumping over a safe gap before asking for a jump above danger. Prompts, level layout and feedback can share the teaching instead of placing it all in a long opening explanation.

The first gap prompts the jump and provides a rescue floor. The second gap gives practice, and the last widens the gap and removes the prompt.

Affordance

Related terms: signifier, readability, interaction cue, onboarding

An action the game makes possible for the player, such as climbing a ladder or pushing a crate. A signifier is a cue that helps the player discover that action: a handle, a highlight or a button prompt.

Keep cues consistent with what works. If every climbable ledge has the same markings, a player can recognize a new one. A convincing handle on a door that cannot open can suggest an action the game does not actually support.

The handle signals that the door can open. Swinging it aside reveals the passage that the player can use.

Telegraphing

Related terms: wind-up, tell, anticipation, startup frames

Giving a readable warning before an action happens. An enemy raises a weapon, a danger zone appears on the floor, or a sound announces an incoming attack. The cue gives the player time to respond.

The warning should communicate timing and, when needed, direction or area. Match it to the attack that follows. Faster or subtler cues raise the demand on the player; consistent cues reward learning.

The vent marks the area before releasing its pulse. The warning and pulse cover the same radius, giving the rover time to move out of the area.

Resource sources and sinks

Related terms: economy, faucet, currency, inflation, balancing

A source adds a resource to an economy. A sink removes it. A quest that creates gold is a source; a repair fee paid to the game is a sink. Trading gold between players only moves it.

If income consistently exceeds spending, balances grow and prices or rewards can lose meaning. Track the resource over time and give players useful reasons to spend it. Crafting may sink ingredients while creating a different resource.

new balance = old balance + income - spending

The quest and discovery create coins. Repairs and upgrades remove them. This example adds and removes 70 coins.

Game feel

Related terms: juice, feedback, polish

The layer of feedback that makes actions satisfying: screen shake, a flash on hit, particles, sound, squash and stretch, a moment of slow motion, numbers popping out.

None of it changes the rules. All of it changes how the game feels in the hands. "Juice" is the informal word. It works best when the amount matches how important the event is.

Both views show the same platform contact. Squash, a flash and particles make the contact on the right easier to feel.

Coyote time

Also called: ledge grace period

Related terms: input buffering, jump buffer, game feel

A short grace period in which a character can still jump after leaving a ledge. It forgives a slightly late press, so a jump that looked possible to the player is accepted.

Track the time since the character was last grounded, and allow a jump while it is inside the grace window. Consume that opportunity when jumping. Pair it with input buffering to also accept presses made just before landing.

In this example, a press 80 ms after leaving the ledge is accepted because it falls inside a 120 ms grace window.

Input buffering

Related terms: jump buffer, input queue, coyote time, game feel

Remembering an input for a short window so it can run when the action becomes available. Press jump just before landing, and the stored press triggers a jump on landing instead of being lost.

Consume the buffered input once, or discard it when it expires. A long window can trigger actions the player no longer intends. Coyote time solves the other side of the timing problem: accepting a jump shortly after leaving a ledge.

Both presses get 120 ms of storage. The press at −80 ms survives until landing and triggers a jump. The press at −150 ms expires first.

Hitstop

Also called: hit pause, hit freeze

Related terms: impact frames

Freezing the attacker and the target for a few frames at the instant a hit connects. The pause is too short to notice consciously, but it makes the blow feel heavy and gives the eye a moment to register it.

Stronger attacks freeze for longer. It is a staple of fighting and action games, usually paired with a flash and screen shake.

Both actors hold their contact pose for three frames in this example. Their motion resumes together on the next frame.

I-frames

Also called: invincibility frames

Related terms: dodge roll, mercy invincibility

A short window in which a character cannot be hurt. A dodge roll has them in the middle of its animation, so a well-timed roll passes straight through an attack.

They are also given right after taking damage, usually with a blinking sprite, so one enemy cannot hit the player several times in a row. The name comes from measuring the window in frames.

The roll is protected from frame 4 through 9 in this example. The crossing at frame 8 falls inside that interval.

Cooldown

Also called: CD

Related terms: global cooldown, charges, timer

The waiting time after using an ability before it can be used again. It stops the strongest move from being spammed and makes the player choose when to spend it. It is usually shown as an icon that fills back up.

A global cooldown briefly locks every ability after any one is used. Charges store several uses that refill one at a time. In code it is a timer counted down with delta time.

The example ability needs eight seconds to recharge after use. The ring reaches half at four seconds and becomes available at zero seconds remaining.

Loot table

Related terms: drop rate, weighted random, rarity, pity timer

A list of possible rewards with a weight for each. The game rolls a random number and picks the item whose slice it lands in. A bigger weight means a bigger slice.

Tables are often nested: roll the rarity first, then an item of that rarity. Pure randomness produces long unlucky streaks, so many games add a pity timer that raises the odds after every miss until the rare item is guaranteed.

The four weights divide the roll interval into 70%, 21%, 7% and 2%. The example roll of 0.54 lands in the common interval.

Frame data

Related terms: startup, active, recovery, frame advantage

The timing of an attack, counted in frames. Startup is the wind-up before it can hit. Active is while the hitbox is out. Recovery is the time afterwards when the attacker cannot act.

Short startup makes a move hard to react to. Long recovery makes it punishable if it misses. Fighting game players study these numbers as tables, and designers balance the game by tuning them.

At 60 frames per second, the example takes 5 frames to start up, can make contact for 3 active frames and takes 12 more frames to recover.

Narrative

How choices, world state and context shape the story a player experiences.

Branching dialogue

Related terms: choices, dialogue graph, reconvergence, story flags

A conversation whose next lines depend on player choices or conditions. Asking for help might lead to an offer, a refusal or a question about an earlier favor. Branches can rejoin a shared scene, so every choice does not require a separate story all the way to the ending.

Rejoining does not have to erase consequences: quest facts can remember the choice and change a later reply. Inkle’s ink language supports this pattern with choices and gather points, used to author branching narrative in 80 Days.

Accepting or declining the dockside request rejoins the same ferry departure. The saved choice changes the reply after the shared scene.

Quest facts

Related terms: story flags, narrative state, conditions, events

Named values that record what has happened in the story. Rescuing a prisoner might set rescued = 1; a conversation can check that value to unlock a new reply. Facts can also count progress, such as three clues found, rather than only storing true or false.

A fact stores information; the quest, dialogue or script that reads it decides what happens next. The Witcher’s REDkit exposes a facts database shared by these systems. Save the relevant facts through serialization so returning to the game does not undo remembered choices.

Activating the third beacon writes a saved count. A conversation and a later quest can both read the same fact.

Contextual dialogue

Related terms: barks, response rules, rule matching, narrative state

Speech selected to fit the current situation and remembered history. A companion who sees ammunition can call attention to it; a character who has already delivered a warning can avoid repeating it immediately. Short spontaneous lines are often called barks, though contextual systems can also start longer conversations.

Authored rules describe when each line is suitable. The system checks facts, selects an eligible response and tracks any history needed for later choices. Valve’s rule database supports reactive dialogue in games including Left 4 Dead 2. This selects relevant speech; branching dialogue describes how a conversation proceeds through choices.

The clear pier makes one line eligible. A recent warning excludes the repeated line.

Procedural generation

Worlds, textures, shapes and motion computed from rules and math instead of made by hand.

Procedural generation

Also called: PCG

Related terms: seed, roguelike

Content built by an algorithm instead of by hand: levels, terrain, loot, whole planets. The generator combines random numbers, noise and hand-written rules.

The random numbers start from a seed. The same seed always produces the same result, so a huge world can be stored, or shared with a friend, as one number.

One generator makes all three islands. The two runs with seed 1234 produce the same coast and foliage, while seed 9876 changes both.

Pseudo-random numbers

Also called: pseudorandom numbers

Related terms: PRNG, RNG, seed, hash function

A computer cannot roll dice. It uses a formula that turns one number into the next, giving a sequence that only looks random. The starting number is the seed. The same seed always gives the same sequence.

That is a feature. It makes replays, daily challenges, shareable worlds and reproducible bugs possible. A hash function is the version with no memory: feed it a coordinate and get a random-looking value back. Noise is built on hashes.

Each row shows the first six draws, mapped to integers from 0 to 99. The same seed restarts the same sequence.

Shuffle bag

Related terms: sampling without replacement, controlled randomness, loot table

Put a chosen set of outcomes into a bag, shuffle it and draw each item once before refilling. Unlike independent random rolls, this controls how often each outcome appears within a complete bag. Repeated copies can give some outcomes more weight.

A bag does not automatically prevent every streak: the last item of one bag can match the first of the next, and duplicate items can sit together. Extra rules can prevent those repeats. Left 4 Dead shuffles boss events such as Tank, Witch and Nothing, and separately forbids consecutive repeats. Use this when distribution matters alongside surprise.

Each bag holds one circle, square and diamond. The circle happens to appear at the end of one bag and the start of the next.

Noise

Related terms: Perlin noise, simplex noise, octaves, fBm

Random values that change smoothly from one point to the next. Plain random numbers look like TV static. Noise looks like clouds or hills, because neighbors are similar.

It drives terrain, clouds, fire, wobble and camera shake. Adding several layers at rising frequency, called octaves, gives large shapes with fine detail on top.

RandomNoiseAs terrain
Click the picture or choose New variation for a new seed.

Fractal noise

Related terms: octaves, fBm, lacunarity, persistence

Several layers of noise added together. Each layer, called an octave, has finer detail and less strength than the one before. The first octave gives the mountains. The next ones give hills, then rocks, then pebbles.

Lacunarity is how much finer each octave gets, usually 2 times. Persistence is how much weaker, usually half. The result looks natural because real terrain and clouds have detail at every scale too.

1 octave3 octaves6 octaves
Click the picture or choose New variation for a new seed.

Domain warping

Related terms: distortion, turbulence

Bending the input of a noise function with more noise. Instead of asking for the noise at a point, you first push the point sideways by an amount that is itself noise.

Plain fractal noise looks like fog. Warped noise swirls and folds like marble, smoke or flowing lava. It costs a few extra noise lookups.

value = noise(p + strength * noise(p))

Fractal noiseWarped

Voronoi

Also called: Voronoi diagram

Related terms: cellular noise, Worley noise

Scatter some points, then give every pixel to its nearest point. The result is a pattern of cells, one per point. It looks like cracked mud, scales, stone paving or soap foam.

Using the distance to the nearest point as a brightness gives cellular noise, common in water caustics and organic textures. In world generation the cells become regions, biomes or countries.

CellsDistance to nearest

Procedural texture

Related terms: procedural material, shader graph, Substance

A texture computed by a formula instead of loaded from an image. The shader takes the UV or the position and calculates the color on the spot.

It has no fixed resolution, uses no texture memory, never repeats unless you want it to, and can be changed with a few parameters. The price is GPU time on every pixel. Tools such as Substance Designer build materials this way and then bake them to images.

CheckerWoodMarble
Each one is a short formula. No image is stored.

Procedural mesh

Related terms: procedural geometry, runtime mesh, mesh generation

A mesh built by code instead of in a modeling tool. The code works out each vertex position, lists which vertices form triangles, and fills in normals and UVs.

Terrain from a height map, roads along a spline, buildings from rules, voxel worlds and sword trails are made this way. The mesh can be rebuilt while the game runs.

A grid of 81 vertices uses the same 128 triangles in both views. A seeded height field changes the vertex heights.

Marching cubes

Related terms: marching squares, isosurface, metaballs

Turns a field of values into a mesh. Space is divided into small cubes. Each corner is tested: inside the shape or outside? The pattern of the eight answers picks, from a table of 256 cases, which triangles go in that cube.

It produces smooth voxel terrain that can be dug into, blobby metaballs and liquid surfaces. The 2D version, shown here, is marching squares.

The 2D version, marching squares, extracts a contour from a grid of samples. Each crossing is interpolated between samples with opposite signs.

CSG

Also called: constructive solid geometry

Related terms: boolean operations, brushes, smooth union

Building shapes by combining simple solids. Union merges two. Subtract carves one out of the other. Intersect keeps only the overlap. Level editors use it to cut rooms and doorways out of blocks.

With signed distance fields each operation is one line. A smooth union blends the two shapes where they meet, like clay.

union = min(a, b) subtract = max(a, -b)

The blue volume crosses the violet solid. Union keeps both, subtraction removes the blue volume from the violet solid, and intersection keeps only the shared volume.

Ray marching

Related terms: sphere tracing, Shadertoy

Drawing a scene by walking along a ray in steps until it hits something. There are no triangles. The scene is a signed distance field, and the distance value says how far the ray can safely jump without passing through a surface.

The whole renderer fits in one fragment shader, run once per pixel. Games use it for clouds, fog and volumetric light. Demos use it to draw entire worlds with no meshes at all.

Each dashed circle is the safe distance at that step. The ray stops within one unit of the blue surface.

Cellular automata

Related terms: cave generation, Game of Life, smoothing

A grid where every cell updates from a simple rule about its neighbors, all cells at once, step after step. Simple local rules add up to large organic shapes.

The classic use is caves. Fill the grid at random with about 45% wall. Then repeat: look at each cell and the eight around it. If five or more of those nine are wall, the cell becomes wall. Otherwise it becomes floor. After a few steps the static has turned into caverns.

Random fill2 steps5 steps
Click the picture or choose New variation for a new seed.

Dungeon generation

Related terms: BSP, binary space partitioning, rooms and corridors, random walk

A classic recipe uses binary space partitioning. Take the whole map as one rectangle and split it in two. Split each half again, and repeat. Put a room inside every final piece. Then join sibling pieces with corridors, working back up the tree.

Rooms can never overlap and every room is reachable. Other recipes: a random walk that digs as it wanders, cellular automata for caves, or hand-made rooms stitched together at random.

Seven dashed splits make eight partitions. Each gets one room, and corridors join sibling partitions as the generator works back up the tree.

Level generation from graphs

Related terms: room graph, topology, progression constraints, dungeon generation

Describe a level as rooms and connections before deciding their exact shapes or positions. Nodes can specify roles such as entrance, shop or combat room. Connections describe which rooms must link together. This lets designers control branching and progression while varying the physical layout.

In Dead Cells, a biome concept graph guides the arrangement of handmade rooms. Room choices must fit requirements such as their purpose and entrances. The graph describes relationships; the placement stage must still produce a valid layout. This expands dungeon generation beyond simply joining random rooms, giving different biomes their own structure.

Both layouts connect the entrance to the hall. The hall leads to the exit and branches to the shop.

Wave function collapse

Also called: WFC

Related terms: constraint solving, tile rules

An algorithm that fills a grid with tiles so that every tile fits its neighbors. The rules come from a list of which edges may touch, or are learned from a small example.

Every cell starts able to be any tile. Pick the cell with the fewest options left and choose one at random. Then remove every option in the neighboring cells that no longer fits, and repeat. Small tile sets grow into coherent towns, pipes and dungeons. Sometimes it paints itself into a corner and has to back up.

The numbers count possible tiles. Choosing a corner bend in a cell with two options requires compatible pipe edges in its neighbors.

L-system

Also called: Lindenmayer system

Related terms: grammar, turtle graphics, procedural plants

A way to grow shapes by rewriting text. Start with a short string and replace each letter by a rule, again and again. Then read the result as drawing commands: F is go forward, + and - are turn, [ and ] are start and end a branch.

One short rule grows into a tree, a fern or a bolt of lightning. Games use it for plants and for road networks.

F becomes F[+F]F[-F]F

Starting from F, each rewrite replaces every F with F[+F]F[−F]F. The drawing turns 23° at each plus or minus sign.

Scattering

Related terms: Poisson disk sampling, blue noise, foliage placement, density map

Placing many objects by rule instead of by hand: trees, rocks, grass, loot. Purely random positions clump together and leave bare patches. Poisson disk sampling also picks random spots but rejects any that are too close to an existing one. The result is irregular but evenly spread, like a real forest.

A density map then thins the points: fewer trees on steep slopes, none under water.

Both plots have 20 trees and exclude the pond. The dashed circle marks the minimum spacing between trunks in the Poisson disk sample.

Procedural animation

Related terms: secondary motion, spring, look-at, procedural walk

Motion computed by code while the game runs, instead of played back from keyframes. Simple cases: a pickup that bobs on a sine wave, a head that turns to look at the player, an antenna on a spring that lags and wobbles.

Complex cases: a creature that places each foot with IK on any terrain, or a tail where each segment chases the one in front. It adapts to situations nobody animated, and is often layered on top of normal clips.

The pickup follows a four-second sine wave. The chain follows a moving head, keeping a fixed distance between successive segments.

2D and UI

Flat images, layers, and the interface drawn on top of the game.

Tilemap

Related terms: tile, tileset

A 2D level built from a grid of small reusable images called tiles. The level is stored as a grid of numbers. Each number is an index into a tileset, an atlas of all the tiles.

A large level then costs very little memory, and editing it is like painting on graph paper.

Each of the 35 cells stores an index into the three-tile tileset. Both blue outlines mark the same cell, whose index selects water.

Autotiling

Related terms: terrain tiles, neighbor rules, bitmask, tilemap

Choosing a tile variant from the tiles around it. Paint a patch of terrain and rules select the matching edges, corners and center pieces, so grass can meet dirt without placing every border by hand.

Rules can inspect four neighbors or include diagonals. A tileset must supply the combinations the rules need. Autotiling chooses the appearance of a tilemap; it does not by itself design a playable level.

The occupied cells are the same in both views. The border rule checks adjacent and diagonal cells to choose the straight edges and inside and outside corners.

Pixel-perfect rendering

Related terms: pixel art, integer scaling, pixel snapping, nearest filtering

Drawing pixel art so source pixels line up consistently with the output pixel grid. Whole-number scaling keeps each source pixel the same size, and nearest filtering keeps edges crisp.

Camera position, sprite placement and render resolution also matter. Fractional scaling can give pixels uneven widths; subpixel camera movement can make edges shimmer. A common setup renders to a fixed small target and scales that image by an integer.

The two grids show the same sprite with nearest filtering. At 3× each source pixel covers three output pixels per axis. At 2.5× the widths alternate between three and two pixels.

Pivot

Related terms: origin, rotation point, transform, center of mass

The reference point used to place, rotate or scale an object or sprite. A door rotates around its hinge; a character sprite often uses a point near its feet so different animation frames stay grounded.

Changing the pivot can change where the artwork sits relative to the object. Keep pivots consistent across a sprite animation. The pivot is not necessarily the physics center of mass.

Further reading
Godot Engine: Sprite2D
The two door leaves turn through 54°. The mounted leaf turns about its hinge, and the detached leaf turns about its center. Dashed outlines mark their starting positions.

Texture bleeding

Related terms: atlas padding, edge extrusion, seams, texture filtering

Unwanted colors appearing along texture or sprite edges when sampling reaches neighboring image data. In a texture atlas, filtering or small mip levels can mix pixels from adjacent sprites.

Padding and extruding edge pixels around each packed image give the sampler room to blend the correct colors. Use enough padding for the intended mip levels and check UVs and filtering. Clamping the whole atlas does not protect the edges of each sprite inside it.

The highlighted footprint uses the same sample point in both atlases. The filter blends the two nearby texels. Copying the orange edge into the extra column keeps both texels orange.

Parallax scrolling

Background layers that move at different speeds when the camera scrolls. Far layers move slowly and near layers move fast, the way distant hills seem to crawl past a car window.

It is a cheap way to suggest depth in a 2D game. Each layer's offset is the camera position times a factor below 1.

The ridge, hills and fence scroll through the same 410-unit width in 24, 12 and 5 seconds respectively. Each arrow shows the relative speed of its layer.

Sorting order

Also called: draw order, z-order

Related terms: sorting layer, Y-sort, painter's algorithm

2D sprites are drawn one after another, and later ones cover earlier ones. This is the painter's algorithm. Sorting layers and order numbers fix the sequence: background, characters, effects, UI.

In top-down games, Y-sorting draws sprites that are lower on the screen later. A character can then walk behind a tree and in front of it with no extra work.

Compare the character’s feet with the base of the tree. Sprites with a lower ground point on the screen are drawn later, so the overlap reverses when the character passes the tree.

9-slice

Also called: 9-patch, nine-slice scaling

Related terms: sliced sprite

A way to resize UI panels and buttons without distorting their borders. The image is cut into a 3 by 3 grid. The four corners never scale. The edges stretch along one direction. The center stretches in both.

One small image then serves every box size in the game.

The four corner pieces stay 25 × 25 units. The edge strips stretch in one direction and the center stretches in both.

HUD

Also called: heads-up display

Related terms: UI, overlay, diegetic UI

The layer of information drawn on top of the game view: health, ammo, minimap, objectives. It is drawn last, in screen coordinates, so it does not move with the 3D camera.

Diegetic UI puts the same information inside the world instead, like an ammo counter on the gun itself.

Health, the minimap, reticle, item slots and ammo are composited over the game view at positions measured from the screen.

UI focus and navigation

Related terms: focus order, focus neighbor, keyboard navigation, controller navigation, accessibility

Focus identifies the interface control currently selected for keyboard or controller interaction. Pressing Confirm activates that control; pressing a direction or Tab moves focus to another. A visible outline or highlight tells the player where their next action will go.

Choose an initial focused control and sensible neighbors for each direction. Tab navigation can follow a separate next-and-previous order. When a dialog closes, return focus to a useful place instead of leaving it on a hidden button. This lets menus work for players who cannot or prefer not to use a mouse.

The double outline marks keyboard or controller focus. From Play, Right moves focus to Settings and Down moves it to Load.

Anchors

Related terms: UI scaling, canvas scaler, responsive UI, safe area, automatic layout

UI has to fit many screen shapes. Each element is anchored to a corner, an edge or the center of its parent, and keeps its distance from that anchor. A health bar anchored top-left stays top-left on a phone and on an ultrawide monitor.

UI scaling also grows or shrinks the whole interface with resolution. The safe area keeps it clear of notches and rounded corners.

The health bar and minimap keep their offsets from the top corners of the dashed safe area. The reticle stays centered inside it.

Automatic UI layout

Related terms: layout container, flow layout, minimum size, padding, anchors, localization

Arranging interface elements using layout rules instead of individually assigned positions. A parent can place its children in a row, column or grid, sharing available space while respecting minimum sizes and padding. A flow layout can wrap items onto another line when the container becomes too narrow.

This helps menus adapt to longer translations, larger text and different screen sizes. Anchors describe an element’s relationship to its parent’s bounds; automatic layout also coordinates siblings with one another. Choose rules that preserve reading order and usable controls, rather than simply shrinking everything until it fits.

All three controls keep the same width and height. The narrower container fits only two per row, so Options moves to the next line.

Accessibility options

Related terms: subtitles, colorblind mode, remapping, assists

Settings that let more people play. Common ones: subtitles with adjustable size and background, colorblind-safe palettes, full control remapping, toggle instead of hold, reduced camera shake, aim assist and slower game speed.

They are cheap when planned early. That means UI that scales, input that goes through an action map, and no information carried by color or sound alone.

The settings illustration shows subtitles, toggle actions and reduced camera shake. The game views show how larger text and a solid backdrop make the same subtitle easier to read.

Screen reader semantics

Related terms: accessible name, role, state, accessibility tree, UI focus

Meaningful information exposed to assistive software alongside the visual interface. A control has a name describing its purpose, a role describing what kind of control it is, and relevant state such as checked, disabled or its current value. A screen reader can announce that information when the player reaches it.

An icon alone does not supply all this meaning. Label custom controls, expose their actual state, and update it when the interface changes. Standard controls often provide part of this automatically. Combine semantics with usable navigation; a correctly labeled button still needs to be reachable.

The focused control exposes the name Subtitles, the checkbox role and its checked state. A screen reader can announce those fields when the player reaches it.

Audio

Sound as data, and how it is placed and mixed.

Audio sample

Related terms: sample rate, bit depth, waveform, PCM, streaming

Digital sound is a long list of numbers: the air pressure measured many times per second. Each number is a sample. The sample rate is how many are taken per second, usually 44,100 or 48,000. Bit depth is how precise each one is.

Short effects are loaded into memory whole. Music is long, so it is stored compressed and streamed from disk a piece at a time.

Further reading
Godot: AudioStreamWAV
At 48,000 samples per second, measurements are about 20.8 µs apart. The outlined dots mark the measured amplitudes. The filled dots and signed integers show an illustrative 4-bit encoding.

Audio latency

Related terms: buffer size, output latency, network latency

The delay between requesting a sound and hearing it. Audio is usually mixed in blocks, then queued for the operating system and output device. Calling play does not mean the first sample reaches the speakers immediately, even when the game renders smoothly.

Smaller buffers can reduce delay but demand more frequent processing and increase the risk of audible dropouts if deadlines are missed. Rhythm games need to account for audible playback timing, not just a track’s requested start time. Display and input delays also affect perceived synchronization, so audio latency is only one part of that timing problem.

Further reading
Godot documentation
In this 14 ms example, the request waits 3 ms for mixing to start, mixing takes 1.5 ms, and the device queues the result for another 9.5 ms.

Pitch

Related terms: frequency, octave, playback rate, pitch shifting, audio sample

How high or low a sound is perceived. For a simple tone, higher frequency means higher pitch. Doubling the frequency raises it by one octave.

Changing sample playback speed also changes pitch and duration: twice as fast is an octave higher and half as long. Pitch-shifting effects can change pitch separately from duration. Small variations help repeated footsteps or impacts sound less identical.

Further reading
Godot: Audio effects
The 400 Hz trace completes twice as many cycles as the 200 Hz trace in 10 ms, so its period is half as long and the pitch is one octave higher.

Audio parameters

Related terms: RTPC (real-time parameter control), automation, adaptive music

Values sent from gameplay to an audio system to change a sound while it plays. A parameter might represent engine speed, distance, health or danger. A mapping curve converts that value into properties such as pitch, volume or a blend between sound layers.

For an illustrative engine sound, rising RPM could raise pitch while crossfading into a stronger recording. Smooth abrupt value changes when they would create distracting jumps. Wwise calls its mapping mechanism real-time parameter control; its Project Adventure tutorial maps Distance_to_Player to pitch. A parameter supplies a value, while an audio event typically requests an action.

The same 4,200 RPM reading drives the dial and the dashed guides. This example curve maps engine speed to roughly 1.15× playback speed.

Audio clipping

Also called: clipping

Related terms: headroom, gain, limiter, distortion, audio mixer

Distortion caused when a signal exceeds a stage's allowed level and its peaks are cut off. Several individually quiet sounds can add together into a mix that is too loud.

Leave headroom, control loud sources and check the master output. A limiter can restrain peaks, but it does not replace a balanced mix. Floating-point mixers may allow internal levels above the output limit; the signal still needs to fit when it reaches the final output.

Further reading
Godot: Audio effects
Both outputs are limited to the range −1 to +1. The dashed trace on the right shows the input before clipping. The red output flattens wherever the input exceeds either limit.

Spatial audio

Also called: 3D sound

Related terms: listener, attenuation, panning, HRTF, reverb

Sounds placed at positions in the world and heard from a listener, usually the camera. The engine sets the volume from the distance and the left and right balance from the direction.

Extras add realism: occlusion muffles a sound behind a wall, the Doppler effect shifts the pitch of fast movers, and HRTF filtering gives a convincing sense of above and behind on headphones.

Further reading
Godot: Audio streams
The dashed circle bounds the full-volume region in this example. Outside it, distance attenuates both channels. The source’s bearing gives the right channel more gain.

Sound propagation

Related terms: sound portals, occlusion, spatial audio, reverb

How sound travels through a level before reaching the listener. Walls, doorways and connected rooms can change its loudness, filtering and apparent direction. A nearby source behind a wall may be heard mainly through an open doorway instead of along the shortest straight line.

Games often approximate this using rooms and sound portals, connections that let sound pass between spaces. HITMAN’s Paris audio update describes room-to-room 3D propagation and broken windows becoming sound gates. Propagation complements positional audio; it accounts for the environment between source and listener.

Example: HITMAN World of Assassination
IO Interactive
The wall blocks the direct route between source and listener. The highlighted route passes through the open portal, which changes the direction from which the listener hears the sound.

Audio mixer

Related terms: bus, channel, ducking, snapshot

Every sound is routed through a tree of buses. Each bus has its own volume and effects and feeds the one above it, ending at the master output.

This is what makes separate music and effects sliders possible. It also lets the game treat groups at once: muffle everything underwater, or duck the music automatically while a character speaks.

Footsteps and ambience share the effects bus. Dialogue and the theme have separate buses with their own gain controls. All three feed the master output.

Audio ducking

Related terms: sidechain compression, gain envelope, audio mixer

Temporarily lowering one sound or group so another remains clear. Dialogue can duck the music, or an important accessibility cue can reduce competing effects. The background usually returns smoothly when the priority sound finishes, preserving the scene’s energy without masking useful information.

Ducking describes the result, not one mandatory technique. A game can animate bus volume from dialogue events, or use a compressor whose sidechain listens to the voice bus. Attack controls how quickly reduction begins; release controls recovery. Choose enough reduction for clarity without making every short syllable produce distracting volume pumping.

Further reading
Godot documentation
Dialogue plays from 1 to 3 seconds. The music gain drops to 0.32 during speech and returns smoothly to full gain after it ends.

Reverb

Also called: reverberation

Related terms: decay time, wet/dry mix, audio mixer

The lingering sound of many reflections arriving after the direct sound. A clap in a large hall has a long tail; a soft furnished room absorbs more energy and sounds drier.

Games approximate this with audio effects and room or zone settings. Decay time shapes how long the tail lasts; the wet/dry mix blends the effect with the original sound. Use transitions between spaces so a cave does not sound like the open field outside.

Further reading
Godot: Audio effects
Both spaces receive the same direct sound at the same time. The upper response keeps its reflections audible longer, while the lower response models faster absorption.

Polyphony

Related terms: voice count, concurrent sounds, voice limit, voice stealing

The number of sound voices that can play at the same time. A voice is a playback instance: ten overlapping footstep sounds can use ten voices even if they all read the same audio file.

Set limits for repeated effects and for the mix as a whole to control cost and clutter. At the limit, the audio system may reject a new sound, stop an existing one through voice stealing, or keep an inaudible virtual voice.

At the violet marker, rain and two instances of one footstep sample overlap. The count is three active voices.

Voice stealing

Related terms: voice priority, virtualization, polyphony

Stopping an existing sound to make room for another when a voice or event-instance limit is reached. A policy might replace the oldest, quietest, farthest or lowest-priority sound.

Choose the policy for the sound: a fresh impact can replace an old one, while important dialogue needs protection. Virtualization is related but different: it can keep playback time moving silently so a voice can become audible again later.

All three slots are occupied just before three seconds. The oldest impact ends when the new one arrives and that slot is reused. The second impact and dialogue keep playing.

Adaptive music

Also called: dynamic music

Related terms: stems, layering, FMOD, Wwise

Music that reacts to what is happening. With layering, a track is split into stems such as pads, bass, drums and brass, which fade in and out with the intensity of the scene.

With re-sequencing, the music jumps between sections at bar lines, so a change of mood lands on the beat. Audio middleware such as FMOD and Wwise exists largely to author this.

Pads and bass continue from exploration into combat. Drums fade in at bar 5 and brass enters at bar 6 while the other stems keep their place.

Accessible audio cues

Related terms: earcons, navigation cues, screen reader semantics, audio ducking

Distinct sounds that communicate useful gameplay information without requiring the player to see it. A cue might identify a climbable ledge, confirm a hit or warn of an incoming attack. Consistent meanings and distinguishable rhythms or timbres help players learn what each cue represents.

The Last of Us Part II offers traversal and combat cues, separate cue volume control and a glossary where players can listen to them. These complement spoken interface narration. Keep important cues audible in the mix, and provide visual or haptic alternatives for players who cannot hear them; audio alone does not meet every accessibility need.

Example: The Last of Us Part II
Naughty Dog accessibility overview
These illustrative cues use two rising tones for a ledge, a short burst for a confirmed hit and three evenly spaced pulses for danger.

Networking

Keeping several machines in agreement about one game.

Client-server

Related terms: peer-to-peer, P2P, dedicated server, host, authority

In a client-server game, one machine runs the real simulation and has authority: its version of events is the truth. Clients send their inputs and receive the results. Cheating is harder, because a client cannot simply claim it hit someone.

In peer-to-peer, the players' machines talk directly to each other with no central referee. It needs no servers, but it is harder to keep in sync and to secure.

Blue arrows carry inputs to the authoritative server and violet arrows carry state back to the clients. In the peer-to-peer arrangement, all three machines exchange data directly.

Latency

Related terms: ping, lag, round trip, jitter, packet loss

The time data takes to travel between machines. Ping is the round trip in milliseconds: out to the server and back. Whatever the server decides, the player sees it one ping after they acted.

Jitter is latency that keeps changing. Packet loss is messages that never arrive. Most networking code in a game exists to hide these three things.

The 52 ms round trip includes 24 ms in each direction and 4 ms on the server. A later packet ends before it reaches the server.

Tick rate

Also called: simulation tick frequency

Related terms: update rate, send rate, snapshot

How many times per second the server advances its simulation. At 20 ticks per second, each step is 50 milliseconds; at 60 ticks, about 16.7 milliseconds. A snapshot is a transmitted state update. Its send rate can be lower than the simulation tick rate.

A higher tick rate can reduce simulation delay and improve hit timing, at a higher CPU cost. Sending snapshots more often also costs bandwidth. The tick rate is separate from each player's frame rate. Clients fill the gaps with interpolation.

Both rows cover 250 ms, counting ticks from the start up to the end of the interval. The dots mark simulation steps. The diamonds show a separate example snapshot send schedule of 10 updates per second.

Client-side prediction

Related terms: server reconciliation, rubber banding

The client applies the player's own inputs straight away instead of waiting for the server to confirm them. Controls feel instant even with high latency.

The server still computes the real result. When its answer arrives, the client compares. If they differ, the client corrects its position and replays the inputs sent since. That is reconciliation. A large visible correction is rubber banding.

The client moves immediately. The server later confirms position 1 after the second input. Reapplying the third and fourth inputs from that position brings the corrected client to position 3.

Entity interpolation

Related terms: extrapolation, dead reckoning, lag compensation

Other players' positions arrive only a few times per second. Drawn as received, they would teleport. So the client shows everyone else slightly in the past and lerps between the two most recent snapshots.

Extrapolation guesses ahead when a snapshot is late. Since every player sees the others in the past, the server uses lag compensation: when you shoot, it rewinds the world to what you saw at that moment before checking the hit.

At client time 350 ms the render time is 250 ms. The violet cart is halfway between the snapshots at 200 and 300 ms.

Rollback netcode

Related terms: GGPO, delay-based netcode, determinism

Used by fighting games, where every frame counts. Each machine runs the game immediately with its own inputs and a guess for the opponent's, usually "same as last frame". When the real input arrives and differs, the game rewinds to that frame, applies it, and re-simulates up to the present, all within one frame.

It requires a deterministic simulation: the same inputs must give exactly the same result on every machine. The older alternative, delay-based netcode, waits for both inputs and adds input lag.

Frame 4 initially uses a guessed right input. A late left input restores the saved state after frame 3, then runs frame 4 and updates the guesses for frames 5 and 6.

UDP and TCP

Related terms: transport, reliable, unreliable, packet

The two ways to send data over the internet. TCP guarantees that everything arrives, in order. When one packet is lost, everything behind it waits for the resend, which the player feels as a freeze.

UDP makes no promises. Packets can arrive late, out of order or not at all, but nothing ever waits. Fast games use UDP, because an old position update is worthless anyway, and add their own reliability only for messages that must arrive.

Numbers mark parts of the TCP byte stream and individual UDP datagrams. The TCP application receives the contiguous bytes for 3 and 4 after retransmission. UDP delivers datagram 4 with a gap at 3.

Replication

Related terms: RPC, remote procedure call, state sync, ownership

Keeping copies of game objects in sync across machines. The server marks which objects and values replicate. When a value changes, it is sent to the clients, which update their copies.

An RPC is the other tool: one machine asks another to run a function. The client tells the server "I fired". The server tells every client "play the explosion". Use state for things that last, RPCs for one-off events.

One client sends the fire request. After the server applies the result, it sends the updated health value of 60 to both clients.

Interest management

Related terms: network relevancy, area of interest, replication

Choosing which objects and updates each connected player needs to receive. A server might send nearby characters, teammates or visible enemies while leaving out distant or hidden objects. Different clients receive different subsets of the same world.

This saves bandwidth and processing, and can keep hidden information out of a client's memory. When an object becomes relevant, the client must receive enough current state to show it correctly, even if earlier events were missed. VALORANT's Fog of War uses network relevancy to restrict enemy information; its visibility checks also allow for movement and network delay.

The server’s map contains both crates and the central beacon. Each client receives its nearby crate and the shared beacon.

Lockstep

Also called: deterministic lockstep

Related terms: input sync, desync

Instead of sending where every unit is, each machine sends only its player's commands. All machines then run the exact same simulation from the same inputs. A turn runs only once everyone's input for it has arrived.

A thousand units cost no more bandwidth than one, which is why strategy games use it. It needs perfect determinism. The smallest difference between machines grows into a desync.

Both machines wait for the commands for turn 5. They apply the same left and right moves to the same starting state, so both reach the same result.

Performance

Where time and memory go, and the usual ways to get them back.

Profiling

Related terms: profiler, bottleneck, CPU bound, GPU bound

Measuring where the frame time goes before trying to make anything faster. A profiler records how long each system and function takes on every frame.

It shows whether the game is CPU bound (game logic, physics, too many draw calls) or GPU bound (too many pixels, heavy shaders). Speeding up anything other than the bottleneck changes nothing.

The illustrative profiles total 15.5 and 21 ms. Scripts grow from 3 to 8 ms in the heavy frame. The dashed line marks the 16.7 ms budget for 60 FPS.

Garbage collection

Also called: GC

Related terms: allocation, hitch

In languages such as C# and JavaScript, memory that is no longer used is reclaimed automatically by a garbage collector. When it runs, the game may freeze for several milliseconds. The player feels a hitch.

The fix is to create less garbage during play: reuse objects with an object pool and avoid making temporary objects every frame.

In this example, allocations raise heap usage between collections. At 2, 4 and 6 seconds, each collection reclaims memory and coincides with a longer frame.

VRAM

Also called: video memory

Related terms: GPU memory, memory budget

The memory on the graphics card. It holds everything the GPU needs in order to draw: textures, which usually take the biggest share, meshes, render targets and shadow maps.

When a game needs more than there is, data gets shuffled in and out and the result is heavy stutter or textures that stay blurry. Texture quality settings are mostly VRAM settings.

The example graphics card has 8 GiB. Textures occupy 4 GiB, other graphics resources occupy 3 GiB, and 1 GiB remains free.

Texture compression

Related terms: BC, DXT, ASTC, ETC, block compression

Textures stay compressed in VRAM, in formats the GPU reads directly. The image is cut into blocks of 4 by 4 pixels. Each block is stored as two colors plus a tiny number per pixel saying how to blend them.

The result is 4 to 8 times smaller with a small loss of quality. PC and consoles use the BC formats. Phones use ASTC or ETC. PNG and JPEG are different: they must be fully unpacked first, so they save disk space, not VRAM.

An RGBA8 block takes 64 bytes. Opaque BC1 stores two RGB565 colors and sixteen 2-bit indices in 8 bytes. The decoded block uses the two stored colors and two mixtures.

Instancing

Also called: GPU instancing, instanced rendering

Drawing many copies of the same mesh in one draw call. The mesh is sent once, together with a list of per-copy data: a transform, perhaps a color. The GPU repeats the mesh for every entry.

A forest of 10,000 trees becomes one call instead of 10,000. It works whenever the copies share a mesh and a material: grass, crowds, debris, bullets.

Further reading
Unity: GPU instancing
The transform list changes each tree’s position, rotation and scale. One instanced draw uses that list with the same mesh and material for all nine trees.

Occlusion culling

Related terms: occluder, PVS, portals, Hi-Z

Skipping objects that are hidden behind other objects. Frustum culling removes what is outside the view. Occlusion culling removes what is inside the view but covered: the rooms behind a wall, the city behind the nearest building.

Some engines work out ahead of time what can be seen from each area. Others test bounding boxes against the depth buffer every frame. The test itself costs time, so it only pays off when a lot is hidden.

The wall fully covers the two crates drawn with dashed outlines. The near crate and the crate at the edge of the occluded region can still be drawn.

Shader compilation stutter

Related terms: shader cache, PSO, pipeline state, shader variants, warm-up

A shader must be compiled for the player's exact GPU and driver before it is first used. If that happens during play, the game freezes for a moment the first time a new effect or material appears.

The fixes: compile everything on a loading screen or at first launch, keep the results in a cache, and cut down the number of shader variants. It is mostly a PC problem. Consoles have fixed hardware, so shaders ship precompiled.

The amber segments show compilation added the first time each shader is used. The regular frame work stays within the dashed 16.7 ms budget.

Shader variants and stripping

Related terms: shader keywords, permutations, build-time stripping

A shader can compile into different versions for different feature combinations, such as normal mapping on or off. Each version is a variant. Three independent on/off features already allow eight combinations; more switches can multiply build time, storage and memory use quickly.

Stripping removes variants the game does not need before they reach the build. Keep combinations that runtime changes or downloaded content may require, even if no starting scene uses them. Stripping reduces the work to compile and store shaders; warming up the remaining variants addresses a different problem, compilation stutter during play.

Three independent switches produce eight combinations. This example build keeps four required variants and strips four unused ones.

Multithreading

Related terms: main thread, render thread, job system, worker thread, race condition

A CPU has several cores. A game that uses only one wastes most of the machine. Engines split the work: a main thread runs game logic, a render thread prepares draw calls, and a job system chops big tasks such as physics, animation and culling into small jobs spread over worker threads.

The hard part is shared data. Two threads touching the same data at once cause a race condition: a bug that appears rarely and vanishes when you look for it. That is why most gameplay code stays on the main thread.

At 5 ms the main thread dispatches physics, animation and visibility jobs. After they complete, the main thread joins them and hands the frame to the render thread.

Loading

Related terms: async loading, asset bundle, loading screen, hitch

Getting assets from disk into memory: read, unpack, hand to the GPU. Loading everything up front means long loading screens. Loading in the middle of play on the main thread means a freeze.

Async loading does the work on background threads over several frames while the game keeps running. Assets are grouped into bundles that load and unload together. See level streaming.

Both loads use a 50 ms interval from request to readiness. The main thread stalls in the upper timeline. In the lower timeline it continues producing frames while the load progresses separately.

Cache misses

Related terms: CPU cache, data-oriented design, memory layout

Reading memory is a hidden cost in game code. The CPU keeps recently used memory in a small, very fast cache. Data sitting next to what was just read is almost free. Data somewhere else is a cache miss, roughly a hundred times slower.

Looping over thousands of objects scattered around memory is a chain of misses. Data-oriented design stores the same kind of data together in tight arrays and walks it in order. This is the performance argument for ECS.

Assume an empty cache that can hold all eight lines. The scattered reads touch eight different lines, so all eight miss. The packed reads touch two lines, producing two misses and six hits.

Debugging

Finding out what happened, isolating the cause and checking the fix.

Debugger

Related terms: breakpoint, watch, step into, step over, call stack

A tool that lets you inspect a running program. Pause execution, examine variables and the call stack, and step through code to see where behavior diverges from what you expected.

Use a breakpoint near the suspicious code, then check the actual values. Stepping into a function follows its body; stepping over runs the call without entering it. Pausing can change timing, which matters for networking and threaded bugs.

Execution pauses before the branch at line 23. Grounded is true and jumpPressed is false, so canJump is false.

Breakpoint

Related terms: conditional breakpoint, watchpoint, debugger

A marker that asks a debugger to pause when execution reaches a chosen location. It lets you inspect the state immediately before the marked code runs.

A conditional breakpoint pauses only when an expression is true, such as health < 0. That is useful for a function called hundreds of times when only one unusual call matters.

The breakpoint is on line 15. Its separate condition is health below zero. Health of 4 or 0 lets execution continue, while −2 pauses before the line runs.

Stack trace

Also called: stack traceback, backtrace

Related terms: call stack, exception, debugger

A list of the active function calls at a particular moment, often captured when an error occurs. It shows how execution reached the failing code, with file names and line numbers when that information is available.

If takeDamage fails, its caller might be onCollision, called from update. Read the trace to find the relevant call in your code. It describes the active chain, not a complete history of everything the game did.

Further reading
GNU Project: Backtrace
Read the active chain back from takeDamage to onCollision and update. The top frame points to the line accessing the missing state.

Assertion

Also called: assert

Related terms: invariant, precondition, logging

A check that a condition you expect to be true really is true. For example, assert(maxHealth > 0) makes an invalid setup visible near its cause, before later code divides by maxHealth.

A failed assertion may stop execution, log an error or break into a debugger, depending on the setup. Some builds disable assertions, so do not put required work inside them or rely on them to validate untrusted input.

Maximum health of 100 passes the assertion and allows the health fraction to be calculated. Zero fails the assertion before division.

Minimal reproduction

Also called: minimal repro, MRE

Related terms: reproduction steps, isolation, bug report

The smallest practical example that still shows a bug, together with reliable steps to trigger it. It might be one scene with a moving platform and a character instead of an entire level.

Remove unrelated assets and systems while checking that the failure remains. Record relevant settings, build information and inputs. A smaller case makes the cause easier to isolate and gives regression testing a focused scenario to preserve.

In both views, the platform moves right and leaves the rider at its previous horizontal position. The isolated scene preserves the same falling behavior.

Logging

Related terms: log level, console, diagnostic output, debugger

Recording messages while the game runs so you can inspect what happened afterward. Useful messages include the time, system, object identifier and values that explain a decision.

Levels such as debug, info, warning and error help filter the output. Log state changes and failures with enough context to connect events. Printing every frame can flood the log and affect performance, hiding the useful evidence.

Further reading
Godot: Logging
The log links E-17’s spawn, choice of target T-04, and pathfinding failure. The entity identifier connects the records across systems.

Deterministic replay

Related terms: record and replay, determinism, recovery, regression testing

Reproducing a simulation by starting from the same state and feeding it the same recorded inputs. The result must match, not merely look similar. This lets developers investigate failures, compare changes or recover an earlier game state.

Player commands alone may be insufficient. Timing, random-number state, external responses and execution order must also be controlled or recorded where they affect results. The code and game data must be compatible with the recording. League of Legends' Chronobreak uses deterministic server replay to restore an earlier match state after an incident, rather than restarting the whole match.

Both runs start with seed 42 and apply the same moves. Positions, remaining pickups, and scores match at each step. The second completed move is a possible recovery point.

Production

How a game gets planned, built, tested and shipped.

Greybox

Also called: blockout, whitebox, blockmesh

A level built from plain boxes and simple shapes, with no art. Designers use it to test layout, scale, sightlines, timing and difficulty while a change still costs minutes instead of days.

Only once the level plays well do artists replace the boxes with final models. Making the art first and then finding out the layout is not fun is the expensive mistake this prevents.

Both views use the same house, roof, path and boundary geometry. The left uses plain forms for testing the layout. The right adds the finished building surfaces and features.

Prototype

Related terms: proof of concept, experiment, greybox, vertical slice

A small experiment built to answer a question before committing to the full game. It might test whether movement feels good, whether a puzzle is understandable, or whether a technical approach can handle the required load.

Use the cheapest form that answers the question: paper, plain shapes or a small playable build. Some prototypes are discarded; others evolve. A vertical slice instead demonstrates a representative piece at the intended production quality.

This prototype asks whether a jump clears the gap. The landing answers the question and informs whether to keep, change, or discard the idea.

Vertical slice

Related terms: prototype, proof of concept, demo

A small, representative piece of a game brought to the intended final quality across gameplay, art, audio and UI. It shows how those layers work together and gives the team evidence about the production effort.

A finished encounter or short level can expose pipeline problems before the whole game is built. A prototype answers a narrower question with less finish. A slice can be shown to publishers, but it is also a practical test of how the team will produce the game.

The bridge encounter contains working gameplay, final art, a sound cue and a health bar. One complete encounter lets the team test how all four areas fit together.

Milestones

Related terms: pre-production, alpha, beta, gold, release candidate

The checkpoints of a project. Pre-production: prototypes, and deciding what the game is. Production: building it. Alpha: every feature is in, still rough. Beta: all content is in, and only bug fixing and polish remain.

Gold is the version approved to ship. The name comes from the gold master disc sent to the factory. After launch come patches and extra content. Studios define these stages a little differently, but the order is always the same.

An example sequence moves from experiments and production through alpha and beta to the gold build approved for release.

Version control

Also called: source control, revision control, VCS

Related terms: Git, Perforce, repository, commit

A system that records changes to project files over time. It lets a team inspect earlier versions, compare edits and recover known states. Code, scenes and source assets can all belong in version control.

Work is recorded in commits or submitted revisions, and parallel changes can be combined. Git and Perforce are examples. Large binary assets may also need locking because their edits are difficult to merge.

Each revision preserves a project state. Inspecting the earlier movement revision shows the jump and audio settings as they were then.

Repository

Also called: repo

Related terms: clone, remote, push, pull, version control

The collection of versioned project files and the history that tracks them. In Git, a local repository contains history on your machine; a remote repository is another copy you can exchange changes with.

Cloning creates a local copy of a Git repository. Pulling brings in remote changes; pushing sends local commits out. Teams also decide which generated files to ignore and how to store large assets.

Both copies contain files and recorded history. Push sends local commits to the remote. Pull brings remote changes to the local copy.

Commit

Related terms: snapshot, revision, staging, commit message, repository

A recorded project revision with a message explaining the change. In Git, a commit identifies a snapshot and its parent commit or commits. It records selected changes, not every unsaved edit in an editor.

Keep related edits together so a revision is understandable and can be checked or reverted. A local commit is not shared until it is pushed. A clear message explains the purpose, such as “Fix jumping after respawn”.

The jump code and its test are staged and recorded together with a message. The unrelated shop scene remains a working edit. Pushing shares the local commit.

Branch

Related terms: merge, main, feature branch, commit

A separate line of development. A team can work on a new movement system while the main line receives bug fixes. In Git, the branch name points to a commit and moves forward as new commits are made.

A merge combines lines of development. If their edits cannot be combined automatically, a merge conflict needs a decision. Short, focused branches generally leave less diverging work to reconcile.

Movement work branches from commit B while main advances to C. The merge combines C with E and becomes the new tip of main.

Merge conflict

Related terms: merge, conflict markers, resolution, branch

A situation where version control cannot safely combine changes automatically. Two branches might edit the same lines differently, or one might delete a file the other changed.

Inspect both intentions, choose or combine the result, then check it in the game. Removing conflict markers is only the text-editing step. Binary assets may need manual rework or choosing one version; asset locking can reduce that kind of overlap.

Both edits change the same speed setting. The resolver keeps 6, then checks that the 7.2-unit jump lands in the target interval from 7 to 8.

Asset locking

Also called: file locking

Related terms: exclusive checkout, binary asset, version control

Reserving an asset for one editor at a time in a version-control workflow. It is useful for files whose contents cannot be meaningfully merged, such as some binary scenes, models and layered art files.

Acquire the lock, make the change, submit it and release the lock so someone else can continue. Enforcement depends on the tool and configuration. Locking coordinates edits; it does not replace recorded history or communication.

Editor A holds the lock while editing revision 17. After A submits revision 18 and releases the lock, editor B can reserve the asset.

Build

Related terms: packaging, platform, port, continuous integration, nightly build

A packaged, runnable version of the game made from the current project. Code is compiled, assets are converted for the target platform, and everything is bundled. Each platform needs its own.

Studios automate it. A server makes a fresh build on every change or every night and runs tests, so a broken game is noticed within hours. A port is the work of adapting a game to a platform it was not made for.

The build process takes code, scenes and audio and produces distinct runnable packages for PC, console and mobile.

Certification

Also called: cert

Related terms: submission, lotcheck, platform requirements

Before a game can be sold on a console, the platform holder tests it against a long list of technical rules. No crashes. Correct handling of a controller unplugging, a user signing out, the console going to sleep. Correct button icons and wording.

Failing means fixing and resubmitting, which can take days or weeks, so schedules leave room for it. Patches go through it too. Mobile stores run a lighter review.

In this example, controller disconnection fails one of the review checks. The team fixes the handling, retests it and submits the build again.

Localization

Also called: l10n

Related terms: translation, string table, internationalization

Adapting a game for other languages and regions. Text is never written into the code. The code refers to a key, and a string table maps each key to the text in every language.

It is more than translation. German runs long. Japanese and Arabic need their own fonts, and Arabic reads right to left. Plurals, dates and numbers follow different rules. UI built with flexible layouts from the start avoids most of the pain.

The same key displays different text in English, German and Japanese. The German label exceeds the fixed width and fits when the button grows with its contents.

Playtesting

Related terms: user testing, QA, regression testing, telemetry, heat map

Watching people play to learn where they get lost, bored or stuck, and what they understand without help. Set a question for the session, observe, then ask about the player's experience without leading the answer.

Quality assurance also tests correctness and reliability. Playtesting emphasizes the player experience. Telemetry such as deaths, retries and route choices can reveal patterns across sessions, while observation helps explain why those patterns happen.

Six of the twelve example deaths cluster around the crossing. That concentration gives the team a place to observe what players see and do there.

Quality assurance

Also called: QA

Related terms: bug report, test case, regression testing, minimal reproduction

The practices used to find defects, prevent them and check that a game meets its requirements. Testing is a major part: try expected actions, awkward edge cases and supported hardware, then record what actually happens.

A useful bug report includes the build, setup, steps, expected result and actual result. Playtesting focuses on the player experience; QA also checks correctness and reliability. Recheck fixes and use regression testing to watch for side effects.

Testing at 150% text size exposes a clipped Resume button. The report records the build, steps, expected result and observed result. A retest confirms the button is visible after the fix.

Regression testing

Related terms: regression, automated testing, test suite, QA

Rerunning checks after a change to catch behavior that used to work but now fails. A fix for jumping might accidentally break moving platforms, loading a saved game or a different character ability.

Keep a focused check for the original bug and checks for important neighboring behavior. Some run automatically; others need a person. A passing set reduces uncertainty about the cases it covers, rather than proving the entire game has no bugs.

After the jump fix, respawn jumping passes and moving platforms fail. Loading a saved game passes in both builds.

Often confused

Terms that sound alike or get swapped, side by side.