GamingGaming GlossaryPart 1 of 8
How Games Get Made Glossary
50 terms from the Gaming book's How Games Get Made part, each defined in a line and linked to the chapter that explains it.
- Account: the publisher's identity for a person (
accounts), the thing a login, linked platform, wallet or ban attaches to, across all of the publisher's games (The Games Business). - Accumulator: the elapsed time a fixed-step loop has yet to simulate; each frame adds the clamped frame time and the simulation consumes it in fixed
dtsteps (Building Your Own Engine). - Actor, component: Unreal's object that can be placed in a level, and the units of behavior (with or without a transform) it is composed from (The Engine Landscape).
- Advance, recoupment: publisher funding paid before release, usually in milestone tranches, and earned back (with any agreed markup) from the game's revenue before the developer is paid a royalty; the split usually shifts toward the developer once it is recouped (The Games Business).
- Archetype, chunk (ECS): entities with the same set of components share an archetype, stored in fixed-size chunks (16 KiB in Unity) that hold one dense array per component type plus the entity IDs; not the same as a content chunk in patching (Building Your Own Engine).
- Audio mixer, mixer buffer: the engine thread that mixes every playing sound into blocks ahead of the audio device under a hard real-time deadline; a missed block is an audible dropout, so nothing on that thread waits on a lock, allocates or touches the disk (Building Your Own Engine).
- Broadphase, narrowphase: the two collision stages of a physics step: a cheap bounding-volume pass that finds pairs of bodies that might touch, then exact contact points, normals and depths for those pairs (Building Your Own Engine).
- Build: the parts produced for one platform from one source revision (executable, shaders, cooked content, a manifest and symbols), recorded as a
buildsrow that crashes, matches and tickets name (Production Pipelines & Builds). - Build farm, build graph: a pool of machines running a build described as nodes with dependencies, such as Epic's BuildGraph scheduled by Horde, so independent steps run in parallel (Production Pipelines & Builds).
- Build verification system (BVS): Riot's automated test run on every new League build, about 5,500 cases in about 18 minutes, reporting within about an hour of check-in (Production Pipelines & Builds).
- Certification (cert): the platform holder's test of a game or patch against its requirements before it can ship on a console; Microsoft publishes the Xbox Requirements (XRs), while Sony's (commonly called the TRC) and Nintendo's (its submission check is Lotcheck) are under NDA (Production Pipelines & Builds).
- Cloud streaming: running the game in a data center and streaming video to the player's device, which removes the install but adds input latency and its own licensing per service (The Games Business).
- Compliance QA, pre-cert: running a platform holder's requirement test cases in-house against a build before submitting it to certification (Production Pipelines & Builds).
- Cooking: converting content from the engine's internal format to a platform-specific one (compressed textures, compiled shaders, editor-only fields stripped), cached by a hash of every input that can change the output (Production Pipelines & Builds).
- Determinism: the simulation producing the same result from the same inputs; broken by wall clocks, floating point differences, iteration order, threads, uninitialized memory and unseeded randomness (Building Your Own Engine; the netcode that depends on it is in Lockstep, Rollback & Determinism).
- Developer, publisher, platform holder: the studio that builds a game, the company that funds, markets and distributes it, and the company that runs the hardware or store and sets certification, fees and identity (The Games Business).
- Engine: the part of a game that isn't the game: the loop, renderer, physics, audio, networking, asset pipeline and editor, and the largest dependency a studio takes on (The Engine Landscape).
- Entity component system (ECS): a design where an entity is only an ID, components are plain data and systems are functions over every entity with a given set of components; Unity's Entities package (part of DOTS), Unreal's MassEntity and Bevy are examples (Building Your Own Engine).
- Fixed timestep: advancing the simulation in equal
dtsteps whatever the frame rate, so results don't depend on hardware; a variabledttaken from the last frame makes physics differ between machines (Building Your Own Engine). - Frame budget: the milliseconds a frame may take at a target rate (16.67 ms at 60 frames a second, 7.8125 ms for a 128-tick server), divided among subsystems with an owner for each (Building Your Own Engine).
- Glyph budget, font fallback: the set of characters a game's font atlases must hold within each platform's memory, and the ordered fallback fonts searched for characters one font lacks (Production Pipelines & Builds).
- Job system, work stealing: work split into small jobs with declared reads, writes and dependencies, run by a pool of about one worker thread per core, where an idle worker takes jobs from another's queue (Building Your Own Engine).
- Live service: an operating model rather than a price, in which the game keeps changing after launch through patches, seasons, events and configuration, for years (The Games Business).
- Localization (l10n), LQA: adapting a game's text, assets and voice per language, as a pipeline step that gathers keyed strings into tables and compiles them per culture; linguistic QA is the pass where fluent testers play a localized build and log errors against the build and the string key (Production Pipelines & Builds).
- Locking (exclusive checkout): checking out a binary asset so nobody else can change it until it's checked back in, because textures and levels can't be merged; built into Perforce, weaker in Git LFS (Production Pipelines & Builds).
- Lotcheck, TRC, XRs: the names of Nintendo's submission check, Sony's requirement list and Microsoft's published Xbox Requirements; the first two are under NDA (Production Pipelines & Builds).
- Mainline, release branch: where development happens, and the branch cut from it for each patch, after which only that patch's fixes (and no new content past the content lock) go in; fixes land in the oldest branch that needs them and merge forward (Production Pipelines & Builds).
- Middleware: a licensed library for one engine subsystem (audio such as Wwise or FMOD, physics such as Havok, Jolt or PhysX, video such as Bink, vegetation such as SpeedTree), linked into the engine and usually licensed per title (The Engine Landscape).
- Milestone: a contracted deliverable (first playable, vertical slice, alpha, beta, gold master) whose acceptance releases a payment; each one is a recorded build (The Games Business).
- Mini game: a web-technology game hosted inside another app, such as WeChat, under that app's own platform rules (The Games Business).
- Minidump, symbolication: a crash capture of each thread's stack, registers and selected memory, turned into functions and line numbers with the exact build's symbols, then grouped by faulting stack; minidumps are personal data (Production Pipelines & Builds).
- Minimum guarantee, timed exclusive: an advance against a game's future sales on one store or service, paid in return for selling there only for a contracted window (The Games Business).
- Performance budget: a per-platform, per-subsystem limit (frame time, memory, load time, install and patch size) measured on reference hardware, which fails the build when exceeded (Production Pipelines & Builds).
- Platform developer program: the agreement-gated route to building for a console (ID@Xbox, PlayStation Partners, the Nintendo Developer Portal), whose requirements are under NDA except Microsoft's (Production Pipelines & Builds).
- Player profile: an account inside one game (
player_profiles), with a name, progression and settings; matches, reports and item instances hang off it (The Games Business). - Playtest: a session where players play a build to show whether they understand and enjoy it; the playtest build is a recorded build with its telemetry tagged (Production Pipelines & Builds).
- Porting, porting house: taking a game to a platform it wasn't built for (SDK, certification, input, performance, saves, achievements), often contracted to a specialist studio or co-development partner (Production Pipelines & Builds).
- Pseudo-localization: a fake locale made from the source text (accents, padding, CJK characters) run through automated tests so missing strings, overflow and missing glyphs show before translation (Production Pipelines & Builds).
- Render interpolation: drawing a blend of the previous and current simulated states by the accumulator's leftover fraction (alpha), so motion is smooth and always one step behind the newest state; teleports snap instead (Building Your Own Engine).
- Royalty statement: a periodic report of sales by store, region and SKU, the deductions, the split in force and the unrecouped balance, which reconciles to each store's payouts (The Games Business).
- Royalty (Unreal): 5% of a product's lifetime gross revenue above $1 million, or 3.5% for a game that launches on the Epic Games Store no later than elsewhere, as of October 2026 (The Engine Landscape).
- Runtime Fee: Unity's per-install fee, announced in September 2023, narrowed weeks later and cancelled in September 2024 without ever being charged (The Engine Landscape).
- Spiral of death: a simulation that can't keep up with the steps it's asked to take, so each slow frame demands more steps and makes the next one slower; prevented by clamping frame time (Building Your Own Engine).
- Sub-stepping: splitting one physics step into smaller steps, which steadies a simulation more than adding solver iterations (Building Your Own Engine).
- Sunset: the end of an online game, when servers shut down or move to a reduced mode and purchases and data must be honored, refunded, exported or deleted; the plan is written before launch (The Games Business; the law in When the Servers Shut Down, the runbook in End of Service).
- Symbols, symbol store: debug information from the same compile as the executable (PDBs, dSYMs, ELF or Breakpad symbols), matched to it by a build ID, kept in a store and never shipped (Production Pipelines & Builds).
- Unified clock: one source of game time that every system reads, recorded for replay; League consolidated 8 clock instances into one and kept a capped variable frame time rather than a fixed step (Building Your Own Engine).
- UObject: Unreal's base class, providing garbage collection, reflection through
UCLASSandUPROPERTYmarkup, serialization, editor integration and network replication (The Engine Landscape). - Virtual voice: a playing sound that isn't mixed; only its position and audibility are tracked until it becomes audible again, so a scene can hold more sounds than the voice limit (Building Your Own Engine).
- Work for hire: a work whose commissioning party is legally its author and copyright owner, so the studio that built it keeps no rights in it (The Games Business).