Gaming Glossary

Games borrow words from engine programming, networking, finance, consumer law and moderation, and vendors name the same thing differently: one platform's entitlement is another's license, ownership or item grant, and one engine's chunk is another's archive. Each entry here is one line and a link to where the volume explains it, or to the chapter that owns the idea when several touch it. The volume's own names (account, player profile, entitlement, item instance, wallet, match, penalty) are the ones in The Core Data Model.

How Games Get Made#

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 dt steps (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).
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).
Build: the parts produced for one platform from one source revision (executable, shaders, cooked content, a manifest and symbols), recorded as a builds row 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, while Sony's and Nintendo's are under NDA (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 dt steps whatever the frame rate, so results don't depend on hardware; a variable dt taken 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).
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).
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).
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).
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).
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).
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).
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 (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).
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).
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 UCLASS and UPROPERTY markup, serialization, editor integration and network replication (The Engine Landscape).

Clients and Delivery#

Background patching: a launcher downloading and installing patches while it's open, so the game is ready when the player is; the Riot Client added it as an opt-in in May 2023 (Game Clients & Launchers).
Binary delta, delta patch: a new file encoded as copy and insert instructions against one known old version (bsdiff, Courgette, zstd --patch-from); smallest for that version, but a release needs a patch per supported old version (Patching & Content Delivery).
Boot set: the plugins a client loads before it's usable; League's Affinity mechanism for choosing it broke in 2018, so every plugin loaded at bootstrap, which is why the boot set needs an owner and a CI gate (Game Clients & Launchers).
Bundle: a CDN object grouping many chunks so a download needs few requests; League's data is over 300,000 chunks in fewer than 5,000 bundles, over 85% shared with the previous version (Patching & Content Delivery).
CEF (Chromium Embedded Framework): a BSD-licensed project for embedding Chromium in other applications, the League client's front end since it left Adobe AIR (Game Clients & Launchers).
Channel, staged exposure: a live or test channel per platform and region that points at one signed release at a time, and moving a release to a share of players or a region at a time while watching failures and crashes (Patching & Content Delivery).
Chunk (content), content-defined chunking: a variable-size piece of a file, cut where a rolling hash meets a condition and named by its hash, so an insertion shifts only nearby chunks and identical chunks deduplicate; FastCDC is the algorithm League's patcher builds on (Patching & Content Delivery).
Front-end client: the out-of-game client a player uses between matches, for sign-in, patching, the store, social features, queues and launching the game process (Game Clients & Launchers).
Game Client API, LCU: Riot's supported, read-only local HTTPS interface in the running game at 127.0.0.1:2999 (including the Live Client Data API), against the League Client API between CEF and the client's C++ services, which Riot doesn't support for third parties (Game Clients & Launchers).
Go-live switch: flipping the new manifest, the new minimum version and the new server builds at one instant, after preloads have put most bytes on disk, for a game where everyone moves together (Patching & Content Delivery).
Host process: the long-lived client process that owns local services and canonical state (session, social, patching, game launch), so the UI can be closed during a match and rebuilt (Game Clients & Launchers).
Launcher: a program that installs, patches and launches games, with news and a store page, such as Steam, the Epic Games Launcher, the EA app and the Riot Client (Game Clients & Launchers).
Loopback API: a client's local service interface bound to 127.0.0.1 on a port chosen at startup, requiring a per-session secret and rejecting browser origins it doesn't own (Game Clients & Launchers).
Manifest: the list of every file and chunk in a release by content hash, which launchers and patchers read; League's is about 8 MB, signed, and the client loads nothing unsigned (Patching & Content Delivery; the build's own manifest is in Production Pipelines & Builds).
Minimum supported version: the oldest build allowed to sign in or queue for a game and platform, checked at startup and before queueing with an "update required" screen (Patching & Content Delivery).
Network protocol version: a deliberate version carried on every connection and bumped when the wire format changes, not on every build, so servers and matchmaking can decide compatibility (Patching & Content Delivery).
Plugin (client): an independently owned and versioned unit of a client, front end (UI in CEF) or back end (C++ services); a League client build is a JSON list of plugins whose semver dependencies must resolve (Game Clients & Launchers).
RADS: League's binary-delta patcher for eight years; its 2019 chunked replacement downloaded 22% more on patch 9.9 but cut average update time from over 8 minutes to under 40 seconds and failures from 2.2% to 0.3% (Patching & Content Delivery).
Rollback (release): pointing a channel at the previous manifest, recorded as a new release with a higher sequence number so clients that refuse older manifests still accept it; not rollback netcode (Patching & Content Delivery).
Rollback attack, freeze attack: serving an older release to reinstall a vulnerable version, or the same old metadata forever, two of the updater attacks The Update Framework (TUF) lists; defended by signed manifests, monotonic release numbers and short expiry (Patching & Content Delivery).
SteamPipe, depot: Steam's content system, which splits files into roughly 1 MB chunks, patches with binary deltas and publishes each depot build with a 64-bit manifest ID to branches (Patching & Content Delivery).
Streaming install, launch set: Xbox's way of letting a title start once the data it needs to run is installed, with the rest installing in the background (Patching & Content Delivery).

Multiplayer#

Agones: an open-source library for hosting, running and scaling dedicated game servers on Kubernetes, with GameServer and Fleet resources and an SDK the server calls (Game Servers & Hosting).
Allocation: handing a forming match a server that is already Ready and returning its address and port; idempotent (keyed by the match ID), atomic and placed by latency (Game Servers & Hosting).
Authoritative server: a server that runs the real simulation; clients send inputs and receive state, and when they disagree the server wins (Netcode Fundamentals).
Backfill: matching players into a match that already exists, such as one a player left, through a ticket that describes the open slots (Matchmaking & Ranked).
Block: a one-directional edge that needs no consent and overrides the rest of the social graph: it removes a friendship, hides presence both ways and stops whispers, invites and voice, enforced by every service (Parties, Presence, Chat & Voice).
Client-side prediction: the client running the same movement code as the server on its own inputs and showing the result at once, instead of waiting a round trip (Netcode Fundamentals).
Dedicated server, listen server: a server with no local players, against one where a player's machine hosts the match, has zero latency to the authority and ends the match when it leaves (Netcode Fundamentals).
Desync, first divergence: machines whose simulations no longer match, found by comparing state checksums per frame or turn; hierarchical state logs are diffed to find the first divergence, because everything after it is noise (Lockstep, Rollback & Determinism).
Deterministic lockstep: every machine running the whole simulation in turns from identical commands, a turn executing only when every player's commands have arrived, at the speed of the slowest connection (Lockstep, Rollback & Determinism).
Drain: telling a server to finish its match and shut itself down rather than killing it; scale-down and updates never touch an Allocated server (Game Servers & Hosting).
Elo, K-factor: one rating per player, moved after each game by K times the difference between the actual and expected score; FIDE uses K of 40, 20 or 10 by experience and rating (Matchmaking & Ranked).
Entity interpolation: drawing other players a little in the past, between the two server states that bracket the render time; the interpolation delay is the floor on how old every enemy on screen is, and extrapolation covers only a briefly late packet (Netcode Fundamentals).
Fan-out (presence): telling every online friend allowed to see it when a player's presence changes; its cost is concurrency times change rate times recipients, cut by coalescing changes (Parties, Presence, Chat & Voice).
Fleet, ready buffer: a set of identical servers (one build, one location) kept warm for allocation, and the number held Ready at all times so matches don't wait for a server to start (Game Servers & Hosting).
Frame delay: a small input delay in a rollback game that reduces the number and length of rollbacks; GGPO's guidance is that more than one frame is noticeable in fighting games (Lockstep, Rollback & Determinism).
Friendship: a mutual, consented edge stored once per pair and hung off the account, so one friends list covers a publisher's games (Parties, Presence, Chat & Voice).
Game server lifecycle: the states every orchestrator models: starting, Ready (in the pool), Reserved, Allocated (must not be deleted), Shutdown, and Unhealthy after missed health pings (Game Servers & Hosting).
Games per core: the capacity unit of a game server host at a tick rate; VALORANT targeted three 128-tick games per core, 2.34 ms each, with 10% of the frame reserved for the host (Game Servers & Hosting).
GGPO: the MIT-licensed SDK that pioneered rollback networking in peer-to-peer games in 2009, built on save, load and advance callbacks the game implements (Lockstep, Rollback & Determinism).
Glicko-2: a rating with a rating deviation (RD) and a volatility, updated per rating period; the deviation shrinks as evidence arrives and grows while a player is inactive (Matchmaking & Ranked).
Head-of-line blocking: a lost packet holding up everything behind it until it's retransmitted, as in TCP; the reason real-time games run over UDP and build only the reliability they need (Netcode Fundamentals).
Input recording, keyframe: a replay stored as the starting state or seed plus every input, tied to the exact build, with periodic state snapshots so playback can seek (Lockstep, Rollback & Determinism).
Interest management, relevancy: deciding which entities each client receives and how often; it saves bandwidth and server CPU, and what a client is never sent a wallhack can't show (Netcode Fundamentals).
Iris, Replication Graph: Unreal's opt-in replication system (Experimental in the 5.8 docs), and the earlier system of persistent nodes and grid cells built because Fortnite's 100 players and about 50,000 replicated actors outgrew per-actor checks (Netcode Fundamentals).
Lag compensation, rewind: the server reconstructing hitboxes as the shooter saw them, judging the shot there and applying the result in the present, so a target can die after reaching cover on their own screen (Netcode Fundamentals).
Match quality score: a proposed match's predicted closeness plus penalties for ping, party mismatch and role fit, accepted when it clears a threshold that falls as tickets age (Matchmaking & Ranked).
Matchmaking rating (MMR): the hidden rating a game uses to make fair matches, kept separate from the visible rank and never shown to the player (Matchmaking & Ranked).
Message classes: unreliable latest-wins state that is never retransmitted, reliable ordered events on their own channel, and inputs made reliable by repeating every unacknowledged one in each packet (Netcode Fundamentals).
Mock game server: a lightweight fake that provisions, runs for a match length and reports a result without any gameplay, used to load test the platform at launch scale (Game Servers & Hosting).
Open Match: Google's open-source matchmaking framework, whose parts (frontend, ticket pool, director, match function, evaluator, assignment) name what every matchmaker has (Matchmaking & Ranked).
OpenSkill, Weng-Lin: a Bayesian rating method with closed-form updates for any number of teams, and the open-source libraries that implement it (Matchmaking & Ranked).
Party: players who queue and play together as one ticket, with a leader and the states open, queued, in_match and disbanded; any change while queued cancels the ticket (Parties, Presence, Chat & Voice).
Party MMR: the one number a party matches on, such as an average, a mean weighted toward the highest-rated member, or an average plus a party bonus (Matchmaking & Ranked).
Peeker's advantage: the extra time a player moving around a corner has to react over the player holding the angle, from round trip and buffering; Riot measured about 141 ms in VALORANT and cut it to about 71 ms (Netcode Fundamentals).
Placement (ranked): setting a new or returning player's rank from every prior signal, on the low end of where the system thinks they belong, then letting it converge (Matchmaking & Ranked).
Placement (server): choosing the location that hosts a match from client-measured latency (ping beacons), minimizing the worst player's ping and capping the spread (Game Servers & Hosting).
Prediction window: how far rollback may run ahead on predicted inputs (8 frames in GGPO) before it stalls; one rendered frame must be able to resimulate all of it (Lockstep, Rollback & Determinism).
Presence, rich presence: whether a friend is online, derived from live sessions and held in memory, and the small, typed, localized detail of what they're doing (Parties, Presence, Chat & Voice).
Queue, ticket: a pool of waiting requests plus the rules for matching them, and a request from one player or a whole party that can only match within its queue; a ticket moves from searching to proposed to assigned, or ends cancelled or expired (Matchmaking & Ranked; states in The Ticket Model).
Rank, LP, RR: the visible tier and division a player sees, with points (League Points, VALORANT's Rank Rating) to the next, moving in predictable steps toward MMR (Matchmaking & Ranked).
Reconciliation: the client taking the server's state as of the last input it processed (by move number), dropping acknowledged inputs, replaying the rest and correcting smoothly if the result differs (Netcode Fundamentals).
Relay: a server that forwards packets between players or to game servers without running the game, solving NAT traversal and hiding IP addresses, as Steam Datagram Relay does (Netcode Fundamentals).
Rewind cap: the limit on how far back the server will rewind for hit registration, set from the latency distribution, with each client's claimed time checked against its measured ping (Netcode Fundamentals).
Riot Direct: Riot's own network of routers in major internet hubs, peering directly with ISPs so player traffic avoids lowest-cost routing (Game Servers & Hosting).
Role queue: a queue where each team needs one of each role and players list the roles they'll play; the scarce role sets everyone's wait (Matchmaking & Ranked).
Rollback netcode: applying local input at once, predicting remote input, and when a real input differs, loading the saved state and resimulating to the present within one frame (Lockstep, Rollback & Determinism).
Server Network Recording, Delta Checker: League's complete record of a match's inputs, settings and configuration, replayable on its deterministic server, and the testing tool from recorded inputs that the determinism work began with (Lockstep, Rollback & Determinism).
Smurf: an experienced player on a new account, who stomps lower-skill matches while the rating catches up; most alternate accounts are made to play with friends of a different rank (Matchmaking & Ranked).
Snapshot, delta compression: state sent as everything relevant to a client, or as the differences from the last snapshot the client acknowledged (Netcode Fundamentals).
State synchronization: inputs up and state down, with the server simulating and clients predicting their own character; tolerant of imperfect determinism (Lockstep, Rollback & Determinism).
Tick rate: how many times a second the server simulates and sends updates; higher ticks mean fresher state and less buffering for linearly more CPU, so a tick rate is also a hosting budget (Netcode Fundamentals).
TrueSkill, TrueSkill 2: Microsoft's Gaussian team rating updated by message passing on a factor graph, and its successor that adds experience, squads, kills and quitting as evidence (Matchmaking & Ranked).
Voice token, voice channel: a short-lived credential your server signs for the voice vendor, naming the action, user, channel and expiry, and the channels it opens: positional (3D) per match, non-positional (2D) for teams and parties (Parties, Presence, Chat & Voice).
WebTransport: HTTP/3 over QUIC in the browser, with unreliable datagrams for state and reliable streams for the rest (Netcode Fundamentals).
Widening, expansion: relaxing a ticket's constraints on a schedule as it ages (FlexMatch calls the steps expansions), skill before latency, with a cap on how far it goes (Matchmaking & Ranked).
XMPP: an XML protocol for messaging and presence with rosters, which Riot's chat is built on and extends (Parties, Presence, Chat & Voice).

Backend and Live Services#

Account merge: folding two accounts into one; the player chooses which profile survives per game, ownership is unioned by revoking and regranting entitlements and moving balances as merge ledger transactions (never by editing rows), penalties carry over, and every service applies its step idempotently within a reversal window (Accounts, Identity & Cross-Platform).
Account status: active, locked (takeover suspected or recovery in progress) or closed (including an account retired by a merge, which names the survivor); a ban is a penalty, never a status (Accounts, Identity & Cross-Platform).
Anonymous login, recoverable login: a device or custom ID login that asks nothing but can't be recovered if the device is lost, and the email or platform login a player is prompted to add at the first purchase or real progress (Accounts, Identity & Cross-Platform).
Clawback: the one algorithm for refunds, voids and chargebacks: find the grant by its store transaction, reverse it, apply a published rule for currency already spent, and record the decision, never locking the account (Inventories, Entitlements & Economies).
Config version: an immutable published snapshot of a game's remote config; a change or a rollback publishes a new version, and clients and telemetry report the version they run (Live Operations).
Cross-play, cross-progression, cross-purchase: players on different platforms in one match, the same profile and rank everywhere, and something bought on one platform usable on another, which store agreements constrain more than technology (Accounts, Identity & Cross-Platform).
Entitlement: a never-deleted record that an account has the right to an item, with its source, a unique source_ref, validity and revocation; the source of truth every other view of ownership defers to (Inventories, Entitlements & Economies).
Environment (versioned): one immutably versioned specification of the client build, server build, service images and config overrides deployed and rolled back together as a set per shard (Game Backend Architecture; the release-side record, a release set, is in Live Operations).
Epic Online Services (EOS): Epic's free cross-platform services, split into Game Services that sign in with any identity provider and Epic Account Services (friends, presence, overlay) that need an Epic account (Accounts, Identity & Cross-Platform).
Event envelope: the fields every telemetry event carries whatever its type, so any event can be joined to its account, match, build and config (Telemetry & Analytics).
Game result (exactly once): the result a game server reports at match end, ingested once per match from the assigned server only; a second submission is a duplicate or a conflict, never applied twice (Game Backend Architecture).
Global and regional services: accounts, entitlements, wallets and catalog with one logical home, against parties, matchmaking, match history and game servers that live per shard and fail alone (Game Backend Architecture).
Heatmap: a count of events per cell of a map, from server-sampled positions keyed by map version and normalized by time spent in each cell (Telemetry & Analytics).
Hot path, cold path: the stream that feeds live operations within minutes (concurrency, crash spikes, frame-time alarms) and the scheduled warehouse build of everything else, both from one event stream (Telemetry & Analytics).
Hotfix: a smaller client or server build shipped between patches; a server-only hotfix needs no download (Live Operations).
Inventory: what a player can use in one game, the account's live entitlements plus the profile's live item instances, read from a cache and written in transactions that check ownership, quantity and capacity (Inventories, Entitlements & Economies).
Item definition, item instance: the catalog entry for what an item is (items), and one copy held by a player profile with its own state, such as rolled stats or a trade history; items are rights, stackable counts or unique copies (Inventories, Entitlements & Economies).
Kill switch: a flag that disables content or a system without a build (a character, a mode, a store item, a crafting recipe), failing safe for players already using it (Live Operations).
Linking, relink cooldown: attaching a platform identity to an account after proving both sides with fresh credentials, refusing silent moves, and waiting out a cooldown before an unlinked identity can join a different account (Accounts, Identity & Cross-Platform).
Live operations: the discipline of changing a running game safely and on schedule: patches, hotfixes, server-side data, config, events, experiments and incidents (Live Operations).
Login queue: admission control with a user interface at the edge of the account service: a capacity per scope, a ceiling on the queue, honest positions, priority classes and reclaimed idle slots (Game Backend Architecture).
Micropatch, server-side override: a server-only fix shipped as data the game server loads, replacing the original by key; TFT's fixed a broken burn effect in about an hour, and it must be merged back before the next patch (Live Operations).
Paid currency, earned currency: units bought with real money and units granted by play, kept in separate ledger accounts even when the client shows one balance, because refunds, accounting and consumer law treat them differently (Inventories, Entitlements & Economies).
Patch cadence (train): a fixed release schedule kept as data that tools read; League's 2026 schedule has 24 patches, mostly two weeks apart, and out-of-band fixes ride faster paths between trains (Live Operations).
Platform identity: an account another company issued (a Steam ID, a PSN account, an Xbox user, an Epic, Apple, Google or Nintendo sign-in), verified server to server and linked to your account by its stable ID, never a name (Accounts, Identity & Cross-Platform).
Platform scope: where an entitlement may be used: portable across platforms, only on the platform where it was bought, or bounded in time (Accounts, Identity & Cross-Platform).
Release set: one record per patch, hotfix or override naming the client builds, server build, service versions, config version and content version released together; not Patching's per-build release manifest (Live Operations).
Remote config: tuning a game without a deploy through versioned key-value parameters, schema-checked, audited, defaulted in the client and applied to game servers at match start (Live Operations).
Sample by match: keeping a deterministic fraction of matches (by hashing the match ID) in full rather than sampling events, so a kept match's paths and per-match questions stay answerable (Telemetry & Analytics).
Seasons and events (dated content): passes, limited-time modes and store rotations shipped dark and activated by a valid_during range, with a start rule (one global instant or local midnight) and a minimum client build (Live Operations).
Server-recorded fact: a match result, purchase, grant or penalty written by the server or backend; client events are claims, used for behavior and diagnostics only (Telemetry & Analytics).
Shard, platform: one regional deployment of the platform with its game servers, the platform being the backend services around the game server (parties, matchmaking, provisioning, results, store) (Game Backend Architecture).
Sources and sinks: the faucets that create currency and items (rewards, drops, purchases, compensation) and the drains that remove them (store spends, crafting, repair, fees), measured exactly from the ledger (Inventories, Entitlements & Economies).
Spend order: the versioned rule for whether a spend uses paid or earned units first when a player holds both, recorded on each spend because finance, refunds and regulators ask; paid spends are also attributed to purchases first in, first out, so each purchase's unspent remainder is a query (Inventories, Entitlements & Economies).
Stable ID (PUUID, Riot ID): the platform's or publisher's permanent player identifier that records key on, against a display name such as a Riot ID (a game name and tag line) that can change (Accounts, Identity & Cross-Platform).
Trade hold, escrow: the wait before a new copy can be traded (Valve recommends at least 72 hours after purchase), and locking items in an open trade so they can't be spent or traded twice (Inventories, Entitlements & Economies).
Version skew: client builds, server builds, services, config and content at different versions at once; managed with exact client-server matches, N and N-1 service support, expand and contract migrations and a minimum client version (Live Operations).
Voided match, abandoned match: a match undone after the fact (a confirmed cheater, a server fault), marked voided with a reason so consumers reverse their effects, and a match whose server died without reporting, closed by a timeout job (Game Backend Architecture).
Wallet, currency ledger: an account's balance of one virtual currency, kept as a double-entry ledger whose transactions sum to zero across player, issued and consumed accounts, so the balance is the sum of its entries (Inventories, Entitlements & Economies).

Fair Play and Safety#

Aimbot, triggerbot: a cheat that aims or fires for the player using enemy positions and synthetic input; it sends valid inputs, so server authority can't stop it and detection has to (Anti-Cheat).
Auto-mute: blocking a zero-tolerance chat message before it's sent and muting the sender, as League's 2023 system does; filtering before delivery fails closed (Player Behavior & Moderation).
Botting: software simulating game input, usually unattended, to level accounts for sale or farm currency; Vanguard took League from over a million bot hours a day to under 5,000 (Anti-Cheat).
Cheat case: signals per account accumulated into one case with a score and a model version, so automated action happens only at high confidence and the middle band goes to human review (Anti-Cheat).
Client integrity: client-side protection that makes the game hard to read or modify (encrypted code, randomized anti-debug checks that react late, encrypted values, an obfuscated protocol); it raises cheat costs and decays as cheats adapt (Anti-Cheat).
Delayed enforcement (ban wave): collecting signature detections and enforcing later, so cheat sellers learn which check fired as late as possible, while immediate harm in a ranked match is stopped at once (Anti-Cheat).
Disruptive behavior, harmful conduct: conduct that doesn't match the norms a player and community set, and the subset that causes significant emotional, mental or physical harm, per the Disruption and Harms in Online Gaming Framework (Player Behavior & Moderation).
Easy Anti-Cheat, BattlEye, VAC: Epic's prevention-first anti-cheat with free and paid tiers, a kernel-based protection system with backend-controlled scanning, and Valve's signature-based system that never bans on reports alone (Anti-Cheat).
Hardware ban: a ban on a hard-to-change device identifier, such as the TPM, so a banned player can't just make a new account; stored hashed, with an end date and an appeal path for secondhand and shared machines (Anti-Cheat).
In-game support SDK: a help center and ticket or messaging inside the game, filled with context the game already knows; on consoles it can hand off to a phone by QR code (Player Support).
In-match report: a report filed when the behavior happens, naming the match, channel and category, with the server attaching evidence from its own records and weighing the reporter's credibility (Player Behavior & Moderation).
Intentional feeding, AFK: losing on purpose by walking into the enemy, and going idle or leaving; detected from match telemetry by the game team, with frequency-based penalties for leaving (Player Behavior & Moderation).
Kernel anti-cheat: an anti-cheat driver running with the operating system's privilege, often loaded at boot, so user-mode cheats can't outrank it; it risks stability and abuse, and Proton doesn't support it on Linux and Steam Deck (Anti-Cheat; its risks are in The Risks of Kernel Drivers).
Penalty ladder: escalating responses per behavior that restrict the abused feature first (chat, queue, ranked) before the account, with zero-tolerance violations skipping straight to a permanent ban (Player Behavior & Moderation).
Prevalence, time to action: the share of matches with a cheater by mode and region, and the matches from first detection to enforcement; Riot reported League dropping from 45+ games to under 10 after Vanguard (Anti-Cheat).
Prevention, detection, deterrence: the three tenets of Riot's anti-cheat, with prevention preferred because it stops cheating before players meet the cheater (Anti-Cheat).
Proactive detection: scanning content before anyone reports it; Xbox scanned 14.8 billion items in 2025 and found far more violations than players reported (Player Behavior & Moderation).
Reform: the goal of most penalties, since most disruptive players are only sometimes disruptive; consequences work when they're specific, prompt and proportionate, with strikes that expire (Player Behavior & Moderation).
Request a Human: a button that hands a bot-answered support ticket to a person, which brought Riot's bot satisfaction up to match agents; denials stay with people (Player Support).
Scripting: third-party programs that attach to the game client to read its state and automate precise actions; as many as 1 in 15 League games had a scripter or botter before Vanguard (Anti-Cheat).
Shadow mode: running a moderation vendor against a labeled sample of your own reports, without acting, before it's allowed to decide anything (Player Behavior & Moderation).
Support operation: a named, idempotent action support takes on an account (grant, restore, reverse a takeover), capped by value and approved by a second person above a threshold; there is no operation for changing sign-in details or ending a ban (Player Support).
Vanguard: Riot's anti-cheat, a user-mode client plus a kernel driver loaded at boot that sends nothing back, using TPM 2.0 as a hard-to-fake hardware identifier (Anti-Cheat).
Voice evaluation: moderating voice by recording on a short fuse and evaluating on report (VALORANT keeps recordings 24 hours, 7 days if reported) or by analyzing live channels and surfacing events with clips (ToxMod) (Player Behavior & Moderation).
Wallhack, ESP, map hack: cheats that show enemies, items or state the player shouldn't see, read from client memory; defeated by withholding hidden state (Anti-Cheat).
Withholding hidden state (Fog of War): the server not sending enemy positions until a client needs to display them; VALORANT does it with a precomputed potentially visible set at under 2% of server frame time (Anti-Cheat).

Money#

appAccountToken, purchase token: the UUID set at purchase that Apple returns in the transaction to tie it to your account, and Google's globally unique key for a purchase, which must be acknowledged within three days or it's refunded (Stores, Fees & Payments).
Battle pass: a time-limited reward track with a free lane and a premium lane bought for the season; progress is the sum of awards keyed by the server event that earned them, rewards are entitlements granted on reaching a tier, and upgrading mid-season grants every earlier premium tier at once (Monetization Models).
Chargeback: a payment reversed by the cardholder's bank, possibly months later; virtual goods invite friendly fraud, and a chargeback revokes what it paid for without locking the account (Stores, Fees & Payments).
Dark pattern: a purchase-flow design that tricks players into charges; the FTC's 2023 order bars Epic from charging through dark patterns or without express consent (Monetization Models).
Deferred revenue: virtual currency bookings recorded as owed and recognized over time; Roblox recognizes durable items over the estimated life of a paying user, 27 months as of December 31, 2025 (Monetization Models; the ledger facts it needs are in Inventories, Entitlements & Economies).
DLC, expansion, season pass: added content that depends on the base game, and a pre-purchase of DLC not yet made, granted by a job that walks pass holders as each piece ships (Monetization Models).
Durable, consumable: an item owned for good (a skin, a character), and one used up (a boost, a currency pack), refundable only until consumed (Monetization Models).
Edition: a bundle of entitlements (base license, a cosmetic pack, early access), each sellable alone, never a flag on the account (Monetization Models).
Fee schedule: store rates kept as data per store, program, region and transaction kind, with validity ranges and sources, because court orders and programs keep changing them (Stores, Fees & Payments).
Free-to-play: no price to start, with revenue from a minority who buy items, currency and passes; where the ownership and economy systems become mandatory (Monetization Models).
Gross bookings, net to developer: the sum of purchase prices before tax, and what remains after the store's fee (Monetization Models).
In-App Purchase (IAP): Apple's billing for in-app digital goods, required for in-game currencies; 30% standard, 15% in the Small Business Program, and 26% in the EU from 1 October 2026 (Stores, Fees & Payments).
Link-out (steering): sending a player from the app to buy on the web; allowed in the US App Store since 1 May 2025 with its commission still in court, and in the EU at 15% on sales within 7 days of the link tap (Stores, Fees & Payments).
Net Receipts: Microsoft's fee base: customer payments minus taxes collected, refunds and chargebacks, and amounts owed to Microsoft; 12% for PC games and 30% for Xbox console games (Stores, Fees & Payments).
Offer, offer price: a sellable bundle of items with its rules and audience, priced by dated rows per store and market, one live price each, so a price change is a new row with a reason (Monetization Models).
Personalized shop: a shop that shows each player different items chosen by a recommender (Riot's Your Shop uses collaborative filtering), with eligibility filters after scoring and the same price for the same item (Monetization Models).
Premium: paying once up front for a license the player owns for as long as the account exists, plus optional DLC (Monetization Models).
Receipt validation: verifying a purchase with the store's server before granting anything; the store transaction moves from pending to verified, granted and acknowledged, or to rejected or reversed (Stores, Fees & Payments).
Regional pricing: prices per store, currency or region with validity ranges, conversion method and cooldowns; Steam offers exchange-rate, purchasing-power and multi-variable conversion (Stores, Fees & Payments).
Rewarded ad: an ad the player chooses to watch for an in-game reward, granted only on the ad network's server-side verification callback, never on the client's word (Monetization Models).
Seller (merchant of record): the party that takes the payment and owns refunds, chargebacks and usually tax; the store on a closed platform, you on your own web store (Stores, Fees & Payments).
Steam Wallet transaction: Steam's microtransaction flow, InitTxn with your order ID, player authorization, FinalizeTxn to grant, and GetReport at least daily to reconcile refunds and chargebacks (Stores, Fees & Payments).
Store fee: the store's share of a sale, from 12% (Epic after the first $1 million, Microsoft PC games) to 30% (Steam under $10 million, Xbox console, Apple IAP), as of October 2026 (Stores, Fees & Payments).
Subscription: a monthly fee for a library or online play from the platform, or a benefit for a period inside one game; either way an entitlement with a validity range, not a flag (Monetization Models).
Virtual currency: a balance bought in packs and spent on items, smoothing regional prices and enabling small purchases while hiding the real price, which is where regulators step in (Monetization Models).
Web store: selling directly outside platform billing for margin and the customer relationship, while taking on tax, fraud, chargebacks, identity and link-attribution tokens (Stores, Fees & Payments).

The Rules#

Accessibility settings: settings per account with device overrides, seeded from the platform's caption, contrast and narration settings, reachable before the first cinematic, and never reset by live config (Accessibility).
Action remapping: binding physical inputs to actions through a table the player edits, with hold, toggle and repeat as properties of the binding and every prompt reading the current binding (Accessibility).
Age band: an account's age as a band (under_13, 13_15, 16_17, adult, unknown) rather than a birth date, derived from its age signals (the lowest wins) and cached on the account, never set directly; unknown gets the youngest band's defaults (Accounts, Identity & Cross-Platform; the rules it drives are in Ratings, Age & Children).
Age signals: platform APIs that pass a player's age band to the game under state app-store laws: Apple's Declared Age Range API and Google's Play Age Signals API; each answer is stored as an append-only signal the account's band is derived from (Ratings, Age & Children).
Assists: separate settings (game speed, timing windows, skipping events, aim help) rather than difficulty presets, with a per-mode policy and the assist state recorded on the match participant (Accessibility).
Build features check: a CI join between the features a build declares (paid random items, time-limited offers, chat) and what the live ratings say, so a new feature triggers a re-rating before release (Ratings, Age & Children).
Consolidated rate: the effective chance of a top-tier item once pity is counted; a 1% base rate with a guarantee on the 50th draw gives 39.50 expected draws, a 2.53% rate (Loot Boxes & Consumer Law).
COPPA: the US rule for online services directed to children under 13 or with actual knowledge of one; in games it reaches display names usable as contact information, voice audio and persistent identifiers (Ratings, Age & Children).
CPC principles: the EU consumer authorities' March 2025 principles on purchased virtual currency: real-money prices, no obscured costs or forced bundles, pre-contractual information, withdrawal rights, fair terms and care for minors (Loot Boxes & Consumer Law).
CVAA: the US law requiring advanced communications services, a category in-game text and voice chat can fall into, to be accessible where achievable (Accessibility).
Drop table: the possible outcomes of a random draw and their weights, versioned with integer weights, immutable once published, and the single source for both the server's roll and the disclosed odds (Loot Boxes & Consumer Law; each roll is an item_rolls row in Inventories, Entitlements & Economies).
ESRB: the North American rating board (E, E10+, T, M, AO), whose Interactive Elements such as In-Game Purchases (Includes Random Items) label a game without changing its age rating (Ratings, Age & Children).
IARC: the International Age Rating Coalition's system, where one questionnaire issues each participating authority's rating for digital storefronts; the answers are stored with the build they described (Ratings, Age & Children).
Integer weights: odds stored as whole-number weights over a fixed total (10,000 makes each unit 0.01%), so displayed probabilities are exact and sum to 100.00 (Loot Boxes & Consumer Law).
Loot box, paid random item: a purchase whose contents the buyer doesn't know in advance (gacha, card packs, prize wheels), including ones bought with currency bought for money (Loot Boxes & Consumer Law).
Odds audit: a daily test of observed outcomes against the disclosed base and consolidated rates per live table version, with the results kept as the answer to anyone who asks (Loot Boxes & Consumer Law).
Odds disclosure: publishing the chance of each item before purchase, required by Apple, Google Play and China, and in the FTC's HoYoverse order together with multi-tiered currency exchange rates (Loot Boxes & Consumer Law).
PEGI: the European rating system (3, 7, 12, 16, 18) whose interactive risk descriptors now change the age: paid random items are PEGI 16 by default for games submitted from June 2026, and existing games were re-rated from October 2026 (Ratings, Age & Children).
Pity: a guarantee of a top-tier result after a number of draws without one (soft pity raises the rate before it); counters are derived from openings and stored on each one (Loot Boxes & Consumer Law).
Play-by-appointment: rewards for returning, such as daily quests and login streaks; PEGI 7 from June 2026, and PEGI 12 when players lose content or progress for not returning (Ratings, Age & Children).
Right of withdrawal: the EU's 14-day cancellation right; lost for digital content only with express consent, and treated by the CPC principles as still covering unused purchased currency (Loot Boxes & Consumer Law).
Screen narration: UI read by the platform screen reader or a speech synthesizer in the order name, role, value, position, which needs an accessibility tree under the UI (Accessibility).
Significant change: under Utah's app-store law, a material change such as new monetization features or an altered age rating, which needs a parent's approval before a child sees it (Ratings, Age & Children).
Spending limit: a per-account cap on real-money purchases per day, week or month, set by default, the player, a parent or support, and checked against pending and completed purchases before one starts; child accounts start at zero (Loot Boxes & Consumer Law).
Subtitles, captions: text for speech, and text for all audio including sound effects and who is speaking; at most 40 characters a line and two lines on screen, on before the first sound (Accessibility).
Support for internal operations: COPPA's exception allowing persistent identifiers without consent for keeping a service working, security and anti-cheat, never for profiling or behavioral ads (Ratings, Age & Children).
Xbox Accessibility Guidelines (XAGs): Microsoft's numbered best practices for game accessibility (101 text, 102 contrast, 104 subtitles, 106 narration, 107 input), with testable numbers but no compliance role (Accessibility).

Running the Platform#

Active (player): an account that sent at least one event from a named list of gameplay events on a day, so background pings and failed logins don't count (Game Metrics).
ARPDAU, ARPU, ARPPU: net revenue per daily active player, per monthly active player in a calendar month, and per paying player in a period; computed on gross bookings instead, the name says so ("ARPU on gross bookings"); vendors differ, with GameAnalytics counting in-app purchases only and Unity including ad revenue (Game Metrics).
Asset provenance: a record at import of whether shipped content was made by people, AI or both, with which tool and any performer replica consent, used to answer store surveys (AI in Games).
Behavior tree: NPC decisions as a hierarchy of selectors and sequences over tasks, with a Blackboard holding its data and decorators that observe conditions and abort branches (AI in Games).
Bot participant: a match slot filled by a bot: a match_participants row with a bot_key and no profile, so ratings, reports and metrics leave it out (AI in Games).
Calibration: whether matches predicted at, say, 60/40 are won by the favorite about 60% of the time, checked against the prediction stored on the match when it was made (Game Metrics).
Competitive ruling: a sanction on a person, roster or organization under a tournament's rules, provisional until final, linked to a penalty only when an account is also restricted (Esports & Spectating).
Concurrent users (CCU), peak CCU: players connected at one instant, and the highest count in a period, from fixed-interval samples with "connected" defined per tier (Game Metrics).
Conversion (payer conversion): the share of active players who made a purchase in a named window, daily (over DAU) or monthly (over MAU); GameAnalytics reports it per day, and a monthly figure is a different number (Game Metrics).
Crash rate: crashes per 1,000 sessions, and the share of daily actives who crashed; Google Play's bad behavior threshold is 1.09% of daily actives (Game Metrics).
DAU, MAU, stickiness: distinct active accounts on a day, across the 30 days ending on a day (rolling) or a calendar month, and their ratio (Game Metrics).
Digital replica consent: a performer's scoped, separate consent to a voice or likeness replica (which game, which characters, real-time or pre-generated), checked before generation, with every generated line counted (AI in Games).
Game AI, generative AI: deterministic NPC decision and movement code a designer tunes, against model-produced text, speech and art with their own latency, cost and safety problems; generative output is at most a request to the game AI layer (AI in Games).
Ghosting: relaying a live spectator feed, which shows both teams, to a player; prevented by a server-side delay past the time the information would help (Esports & Spectating).
LTV (realized, predicted): net revenue per cohort member to day N, which can be audited, and a forecast to a horizon labeled with its model version (Game Metrics).
Match intervention: a pause, resume, restore, remake or side swap in a competitive match, recorded as a ruling with the official and the reason (Esports & Spectating).
Navigation mesh: a simplified polygon map of where agents can walk, divided into tiles that rebuild locally, with area costs and a separate local avoidance step for crowds (AI in Games).
Observer: production staff driving the broadcast cameras from a spectator client connected live to the game server; Riot said in 2022 that its esports matches normally run with up to 20 observers (Esports & Spectating).
Official data feed: sequenced match events from the authoritative server for broadcasters, teams and licensed partners, corrected by new events and tiered by latency; GRID is Riot's sole distributor (Esports & Spectating).
Pre-generated, live-generated content: Steam's content survey categories for AI-made content that ships with a game and content an AI makes while the game runs, the latter needing a description of its guardrails (AI in Games).
Project Chronobreak: League's esports tool that lets officials rewind a live game to a chosen moment by replaying its Server Network Recording, typically restoring the 40-minute mark in under three minutes (Esports & Spectating).
Queue time: from ticket creation to a match, reported as p50, p90 and p99 per queue, region and skill band; FlexMatch separates time to a potential match from time to successful placement (Game Metrics).
Retention (D1, D7, D30): the share of an install cohort active exactly N days after its first gameplay day; an unbounded variant counts day N or later (Game Metrics).
Sample ratio mismatch (SRM): an observed split of players across experiment variants far from the configured one, often caused by a treatment that crashes or breaks logging; a bug alarm before any result is read (Game Metrics).
Server tick health: the share of server frames that finish within the tick budget, per build and player count; VALORANT reported 99.3% or more since patch 5.07 (Game Metrics).
Spectator delay, spectator relay: the server-side buffer that releases a public spectator stream only after what it shows is stale, and the relay tier that holds keyframes and deltas and fans the stream out without exposing the game server (Esports & Spectating).
StateTree: Unreal's hierarchical state machine that combines behavior tree selectors with states and transitions (AI in Games).
Stomp rate: the share of completed matches decided by a margin above a game-specific threshold (VALORANT's is a win by 8 or more rounds), read beside queue time (Game Metrics; VALORANT's smurf figures are in Matchmaking & Ranked).
Tournament server: a server local to the players with fixed performance settings on a protected network, trading density for predictability, with pauses and every admin command logged (Esports & Spectating).
Utility AI: scoring every option from considerations normalized between 0 and 1 and picking the highest, for characters with many competing needs (AI in Games).

References#

Reference

Glenn Fiedler: Fix Your Timestep!, fixed steps, the accumulator, the spiral of death and render interpolation
GGPO: Developer Guide, rollback networking, determinism requirements and the sync test
Mark E. Glickman: Example of the Glicko-2 system, rating, deviation and volatility
The Update Framework: Security, the attacks a software updater must resist
CPC Network: Key principles on in-game virtual currencies (PDF), the EU's 2025 principles on purchased virtual currency
PEGI: Expanded age rating criteria, interactive risks that change the age rating from June 2026
Microsoft: Xbox Accessibility Guidelines, the numbered guidelines for game accessibility

How Games Get Made#

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 dt steps (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).

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).

Build: the parts produced for one platform from one source revision (executable, shaders, cooked content, a manifest and symbols), recorded as a builds row 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, while Sony's and Nintendo's are under NDA (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 dt steps whatever the frame rate, so results don't depend on hardware; a variable dt taken 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).

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).

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).

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).

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).

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).

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).

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 (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).

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).

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 UCLASS and UPROPERTY markup, serialization, editor integration and network replication (The Engine Landscape).

Clients and Delivery#

Background patching: a launcher downloading and installing patches while it's open, so the game is ready when the player is; the Riot Client added it as an opt-in in May 2023 (Game Clients & Launchers).

Binary delta, delta patch: a new file encoded as copy and insert instructions against one known old version (bsdiff, Courgette, zstd --patch-from); smallest for that version, but a release needs a patch per supported old version (Patching & Content Delivery).

Boot set: the plugins a client loads before it's usable; League's Affinity mechanism for choosing it broke in 2018, so every plugin loaded at bootstrap, which is why the boot set needs an owner and a CI gate (Game Clients & Launchers).

Bundle: a CDN object grouping many chunks so a download needs few requests; League's data is over 300,000 chunks in fewer than 5,000 bundles, over 85% shared with the previous version (Patching & Content Delivery).

CEF (Chromium Embedded Framework): a BSD-licensed project for embedding Chromium in other applications, the League client's front end since it left Adobe AIR (Game Clients & Launchers).

Channel, staged exposure: a live or test channel per platform and region that points at one signed release at a time, and moving a release to a share of players or a region at a time while watching failures and crashes (Patching & Content Delivery).

Chunk (content), content-defined chunking: a variable-size piece of a file, cut where a rolling hash meets a condition and named by its hash, so an insertion shifts only nearby chunks and identical chunks deduplicate; FastCDC is the algorithm League's patcher builds on (Patching & Content Delivery).

Front-end client: the out-of-game client a player uses between matches, for sign-in, patching, the store, social features, queues and launching the game process (Game Clients & Launchers).

Game Client API, LCU: Riot's supported, read-only local HTTPS interface in the running game at 127.0.0.1:2999 (including the Live Client Data API), against the League Client API between CEF and the client's C++ services, which Riot doesn't support for third parties (Game Clients & Launchers).

Go-live switch: flipping the new manifest, the new minimum version and the new server builds at one instant, after preloads have put most bytes on disk, for a game where everyone moves together (Patching & Content Delivery).

Host process: the long-lived client process that owns local services and canonical state (session, social, patching, game launch), so the UI can be closed during a match and rebuilt (Game Clients & Launchers).

Launcher: a program that installs, patches and launches games, with news and a store page, such as Steam, the Epic Games Launcher, the EA app and the Riot Client (Game Clients & Launchers).

Loopback API: a client's local service interface bound to 127.0.0.1 on a port chosen at startup, requiring a per-session secret and rejecting browser origins it doesn't own (Game Clients & Launchers).

Manifest: the list of every file and chunk in a release by content hash, which launchers and patchers read; League's is about 8 MB, signed, and the client loads nothing unsigned (Patching & Content Delivery; the build's own manifest is in Production Pipelines & Builds).

Minimum supported version: the oldest build allowed to sign in or queue for a game and platform, checked at startup and before queueing with an "update required" screen (Patching & Content Delivery).

Network protocol version: a deliberate version carried on every connection and bumped when the wire format changes, not on every build, so servers and matchmaking can decide compatibility (Patching & Content Delivery).

Plugin (client): an independently owned and versioned unit of a client, front end (UI in CEF) or back end (C++ services); a League client build is a JSON list of plugins whose semver dependencies must resolve (Game Clients & Launchers).

RADS: League's binary-delta patcher for eight years; its 2019 chunked replacement downloaded 22% more on patch 9.9 but cut average update time from over 8 minutes to under 40 seconds and failures from 2.2% to 0.3% (Patching & Content Delivery).

Rollback (release): pointing a channel at the previous manifest, recorded as a new release with a higher sequence number so clients that refuse older manifests still accept it; not rollback netcode (Patching & Content Delivery).

Rollback attack, freeze attack: serving an older release to reinstall a vulnerable version, or the same old metadata forever, two of the updater attacks The Update Framework (TUF) lists; defended by signed manifests, monotonic release numbers and short expiry (Patching & Content Delivery).

SteamPipe, depot: Steam's content system, which splits files into roughly 1 MB chunks, patches with binary deltas and publishes each depot build with a 64-bit manifest ID to branches (Patching & Content Delivery).

Streaming install, launch set: Xbox's way of letting a title start once the data it needs to run is installed, with the rest installing in the background (Patching & Content Delivery).

Multiplayer#

Agones: an open-source library for hosting, running and scaling dedicated game servers on Kubernetes, with GameServer and Fleet resources and an SDK the server calls (Game Servers & Hosting).

Allocation: handing a forming match a server that is already Ready and returning its address and port; idempotent (keyed by the match ID), atomic and placed by latency (Game Servers & Hosting).

Authoritative server: a server that runs the real simulation; clients send inputs and receive state, and when they disagree the server wins (Netcode Fundamentals).

Backfill: matching players into a match that already exists, such as one a player left, through a ticket that describes the open slots (Matchmaking & Ranked).

Block: a one-directional edge that needs no consent and overrides the rest of the social graph: it removes a friendship, hides presence both ways and stops whispers, invites and voice, enforced by every service (Parties, Presence, Chat & Voice).

Client-side prediction: the client running the same movement code as the server on its own inputs and showing the result at once, instead of waiting a round trip (Netcode Fundamentals).

Dedicated server, listen server: a server with no local players, against one where a player's machine hosts the match, has zero latency to the authority and ends the match when it leaves (Netcode Fundamentals).

Desync, first divergence: machines whose simulations no longer match, found by comparing state checksums per frame or turn; hierarchical state logs are diffed to find the first divergence, because everything after it is noise (Lockstep, Rollback & Determinism).

Deterministic lockstep: every machine running the whole simulation in turns from identical commands, a turn executing only when every player's commands have arrived, at the speed of the slowest connection (Lockstep, Rollback & Determinism).

Drain: telling a server to finish its match and shut itself down rather than killing it; scale-down and updates never touch an Allocated server (Game Servers & Hosting).

Elo, K-factor: one rating per player, moved after each game by K times the difference between the actual and expected score; FIDE uses K of 40, 20 or 10 by experience and rating (Matchmaking & Ranked).

Entity interpolation: drawing other players a little in the past, between the two server states that bracket the render time; the interpolation delay is the floor on how old every enemy on screen is, and extrapolation covers only a briefly late packet (Netcode Fundamentals).

Fan-out (presence): telling every online friend allowed to see it when a player's presence changes; its cost is concurrency times change rate times recipients, cut by coalescing changes (Parties, Presence, Chat & Voice).

Fleet, ready buffer: a set of identical servers (one build, one location) kept warm for allocation, and the number held Ready at all times so matches don't wait for a server to start (Game Servers & Hosting).

Frame delay: a small input delay in a rollback game that reduces the number and length of rollbacks; GGPO's guidance is that more than one frame is noticeable in fighting games (Lockstep, Rollback & Determinism).

Friendship: a mutual, consented edge stored once per pair and hung off the account, so one friends list covers a publisher's games (Parties, Presence, Chat & Voice).

Game server lifecycle: the states every orchestrator models: starting, Ready (in the pool), Reserved, Allocated (must not be deleted), Shutdown, and Unhealthy after missed health pings (Game Servers & Hosting).

Games per core: the capacity unit of a game server host at a tick rate; VALORANT targeted three 128-tick games per core, 2.34 ms each, with 10% of the frame reserved for the host (Game Servers & Hosting).

GGPO: the MIT-licensed SDK that pioneered rollback networking in peer-to-peer games in 2009, built on save, load and advance callbacks the game implements (Lockstep, Rollback & Determinism).

Glicko-2: a rating with a rating deviation (RD) and a volatility, updated per rating period; the deviation shrinks as evidence arrives and grows while a player is inactive (Matchmaking & Ranked).

Head-of-line blocking: a lost packet holding up everything behind it until it's retransmitted, as in TCP; the reason real-time games run over UDP and build only the reliability they need (Netcode Fundamentals).

Input recording, keyframe: a replay stored as the starting state or seed plus every input, tied to the exact build, with periodic state snapshots so playback can seek (Lockstep, Rollback & Determinism).

Interest management, relevancy: deciding which entities each client receives and how often; it saves bandwidth and server CPU, and what a client is never sent a wallhack can't show (Netcode Fundamentals).

Iris, Replication Graph: Unreal's opt-in replication system (Experimental in the 5.8 docs), and the earlier system of persistent nodes and grid cells built because Fortnite's 100 players and about 50,000 replicated actors outgrew per-actor checks (Netcode Fundamentals).

Lag compensation, rewind: the server reconstructing hitboxes as the shooter saw them, judging the shot there and applying the result in the present, so a target can die after reaching cover on their own screen (Netcode Fundamentals).

Match quality score: a proposed match's predicted closeness plus penalties for ping, party mismatch and role fit, accepted when it clears a threshold that falls as tickets age (Matchmaking & Ranked).

Matchmaking rating (MMR): the hidden rating a game uses to make fair matches, kept separate from the visible rank and never shown to the player (Matchmaking & Ranked).

Message classes: unreliable latest-wins state that is never retransmitted, reliable ordered events on their own channel, and inputs made reliable by repeating every unacknowledged one in each packet (Netcode Fundamentals).

Mock game server: a lightweight fake that provisions, runs for a match length and reports a result without any gameplay, used to load test the platform at launch scale (Game Servers & Hosting).

Open Match: Google's open-source matchmaking framework, whose parts (frontend, ticket pool, director, match function, evaluator, assignment) name what every matchmaker has (Matchmaking & Ranked).

OpenSkill, Weng-Lin: a Bayesian rating method with closed-form updates for any number of teams, and the open-source libraries that implement it (Matchmaking & Ranked).

Party: players who queue and play together as one ticket, with a leader and the states open, queued, in_match and disbanded; any change while queued cancels the ticket (Parties, Presence, Chat & Voice).

Party MMR: the one number a party matches on, such as an average, a mean weighted toward the highest-rated member, or an average plus a party bonus (Matchmaking & Ranked).

Peeker's advantage: the extra time a player moving around a corner has to react over the player holding the angle, from round trip and buffering; Riot measured about 141 ms in VALORANT and cut it to about 71 ms (Netcode Fundamentals).

Placement (ranked): setting a new or returning player's rank from every prior signal, on the low end of where the system thinks they belong, then letting it converge (Matchmaking & Ranked).

Placement (server): choosing the location that hosts a match from client-measured latency (ping beacons), minimizing the worst player's ping and capping the spread (Game Servers & Hosting).

Prediction window: how far rollback may run ahead on predicted inputs (8 frames in GGPO) before it stalls; one rendered frame must be able to resimulate all of it (Lockstep, Rollback & Determinism).

Presence, rich presence: whether a friend is online, derived from live sessions and held in memory, and the small, typed, localized detail of what they're doing (Parties, Presence, Chat & Voice).

Queue, ticket: a pool of waiting requests plus the rules for matching them, and a request from one player or a whole party that can only match within its queue; a ticket moves from searching to proposed to assigned, or ends cancelled or expired (Matchmaking & Ranked; states in The Ticket Model).

Rank, LP, RR: the visible tier and division a player sees, with points (League Points, VALORANT's Rank Rating) to the next, moving in predictable steps toward MMR (Matchmaking & Ranked).

Reconciliation: the client taking the server's state as of the last input it processed (by move number), dropping acknowledged inputs, replaying the rest and correcting smoothly if the result differs (Netcode Fundamentals).

Relay: a server that forwards packets between players or to game servers without running the game, solving NAT traversal and hiding IP addresses, as Steam Datagram Relay does (Netcode Fundamentals).

Rewind cap: the limit on how far back the server will rewind for hit registration, set from the latency distribution, with each client's claimed time checked against its measured ping (Netcode Fundamentals).

Riot Direct: Riot's own network of routers in major internet hubs, peering directly with ISPs so player traffic avoids lowest-cost routing (Game Servers & Hosting).

Role queue: a queue where each team needs one of each role and players list the roles they'll play; the scarce role sets everyone's wait (Matchmaking & Ranked).

Rollback netcode: applying local input at once, predicting remote input, and when a real input differs, loading the saved state and resimulating to the present within one frame (Lockstep, Rollback & Determinism).

Server Network Recording, Delta Checker: League's complete record of a match's inputs, settings and configuration, replayable on its deterministic server, and the testing tool from recorded inputs that the determinism work began with (Lockstep, Rollback & Determinism).

Smurf: an experienced player on a new account, who stomps lower-skill matches while the rating catches up; most alternate accounts are made to play with friends of a different rank (Matchmaking & Ranked).

Snapshot, delta compression: state sent as everything relevant to a client, or as the differences from the last snapshot the client acknowledged (Netcode Fundamentals).

State synchronization: inputs up and state down, with the server simulating and clients predicting their own character; tolerant of imperfect determinism (Lockstep, Rollback & Determinism).

Tick rate: how many times a second the server simulates and sends updates; higher ticks mean fresher state and less buffering for linearly more CPU, so a tick rate is also a hosting budget (Netcode Fundamentals).

TrueSkill, TrueSkill 2: Microsoft's Gaussian team rating updated by message passing on a factor graph, and its successor that adds experience, squads, kills and quitting as evidence (Matchmaking & Ranked).

Voice token, voice channel: a short-lived credential your server signs for the voice vendor, naming the action, user, channel and expiry, and the channels it opens: positional (3D) per match, non-positional (2D) for teams and parties (Parties, Presence, Chat & Voice).

WebTransport: HTTP/3 over QUIC in the browser, with unreliable datagrams for state and reliable streams for the rest (Netcode Fundamentals).

Widening, expansion: relaxing a ticket's constraints on a schedule as it ages (FlexMatch calls the steps expansions), skill before latency, with a cap on how far it goes (Matchmaking & Ranked).

XMPP: an XML protocol for messaging and presence with rosters, which Riot's chat is built on and extends (Parties, Presence, Chat & Voice).

Backend and Live Services#

Account merge: folding two accounts into one; the player chooses which profile survives per game, ownership is unioned by revoking and regranting entitlements and moving balances as merge ledger transactions (never by editing rows), penalties carry over, and every service applies its step idempotently within a reversal window (Accounts, Identity & Cross-Platform).

Account status: active, locked (takeover suspected or recovery in progress) or closed (including an account retired by a merge, which names the survivor); a ban is a penalty, never a status (Accounts, Identity & Cross-Platform).

Anonymous login, recoverable login: a device or custom ID login that asks nothing but can't be recovered if the device is lost, and the email or platform login a player is prompted to add at the first purchase or real progress (Accounts, Identity & Cross-Platform).

Clawback: the one algorithm for refunds, voids and chargebacks: find the grant by its store transaction, reverse it, apply a published rule for currency already spent, and record the decision, never locking the account (Inventories, Entitlements & Economies).

Config version: an immutable published snapshot of a game's remote config; a change or a rollback publishes a new version, and clients and telemetry report the version they run (Live Operations).

Cross-play, cross-progression, cross-purchase: players on different platforms in one match, the same profile and rank everywhere, and something bought on one platform usable on another, which store agreements constrain more than technology (Accounts, Identity & Cross-Platform).

Entitlement: a never-deleted record that an account has the right to an item, with its source, a unique source_ref, validity and revocation; the source of truth every other view of ownership defers to (Inventories, Entitlements & Economies).

Environment (versioned): one immutably versioned specification of the client build, server build, service images and config overrides deployed and rolled back together as a set per shard (Game Backend Architecture; the release-side record, a release set, is in Live Operations).

Epic Online Services (EOS): Epic's free cross-platform services, split into Game Services that sign in with any identity provider and Epic Account Services (friends, presence, overlay) that need an Epic account (Accounts, Identity & Cross-Platform).

Event envelope: the fields every telemetry event carries whatever its type, so any event can be joined to its account, match, build and config (Telemetry & Analytics).

Game result (exactly once): the result a game server reports at match end, ingested once per match from the assigned server only; a second submission is a duplicate or a conflict, never applied twice (Game Backend Architecture).

Global and regional services: accounts, entitlements, wallets and catalog with one logical home, against parties, matchmaking, match history and game servers that live per shard and fail alone (Game Backend Architecture).

Heatmap: a count of events per cell of a map, from server-sampled positions keyed by map version and normalized by time spent in each cell (Telemetry & Analytics).

Hot path, cold path: the stream that feeds live operations within minutes (concurrency, crash spikes, frame-time alarms) and the scheduled warehouse build of everything else, both from one event stream (Telemetry & Analytics).

Hotfix: a smaller client or server build shipped between patches; a server-only hotfix needs no download (Live Operations).

Inventory: what a player can use in one game, the account's live entitlements plus the profile's live item instances, read from a cache and written in transactions that check ownership, quantity and capacity (Inventories, Entitlements & Economies).

Item definition, item instance: the catalog entry for what an item is (items), and one copy held by a player profile with its own state, such as rolled stats or a trade history; items are rights, stackable counts or unique copies (Inventories, Entitlements & Economies).

Kill switch: a flag that disables content or a system without a build (a character, a mode, a store item, a crafting recipe), failing safe for players already using it (Live Operations).

Linking, relink cooldown: attaching a platform identity to an account after proving both sides with fresh credentials, refusing silent moves, and waiting out a cooldown before an unlinked identity can join a different account (Accounts, Identity & Cross-Platform).

Live operations: the discipline of changing a running game safely and on schedule: patches, hotfixes, server-side data, config, events, experiments and incidents (Live Operations).

Login queue: admission control with a user interface at the edge of the account service: a capacity per scope, a ceiling on the queue, honest positions, priority classes and reclaimed idle slots (Game Backend Architecture).

Micropatch, server-side override: a server-only fix shipped as data the game server loads, replacing the original by key; TFT's fixed a broken burn effect in about an hour, and it must be merged back before the next patch (Live Operations).

Paid currency, earned currency: units bought with real money and units granted by play, kept in separate ledger accounts even when the client shows one balance, because refunds, accounting and consumer law treat them differently (Inventories, Entitlements & Economies).

Patch cadence (train): a fixed release schedule kept as data that tools read; League's 2026 schedule has 24 patches, mostly two weeks apart, and out-of-band fixes ride faster paths between trains (Live Operations).

Platform identity: an account another company issued (a Steam ID, a PSN account, an Xbox user, an Epic, Apple, Google or Nintendo sign-in), verified server to server and linked to your account by its stable ID, never a name (Accounts, Identity & Cross-Platform).

Platform scope: where an entitlement may be used: portable across platforms, only on the platform where it was bought, or bounded in time (Accounts, Identity & Cross-Platform).

Release set: one record per patch, hotfix or override naming the client builds, server build, service versions, config version and content version released together; not Patching's per-build release manifest (Live Operations).

Remote config: tuning a game without a deploy through versioned key-value parameters, schema-checked, audited, defaulted in the client and applied to game servers at match start (Live Operations).

Sample by match: keeping a deterministic fraction of matches (by hashing the match ID) in full rather than sampling events, so a kept match's paths and per-match questions stay answerable (Telemetry & Analytics).

Seasons and events (dated content): passes, limited-time modes and store rotations shipped dark and activated by a valid_during range, with a start rule (one global instant or local midnight) and a minimum client build (Live Operations).

Server-recorded fact: a match result, purchase, grant or penalty written by the server or backend; client events are claims, used for behavior and diagnostics only (Telemetry & Analytics).

Shard, platform: one regional deployment of the platform with its game servers, the platform being the backend services around the game server (parties, matchmaking, provisioning, results, store) (Game Backend Architecture).

Sources and sinks: the faucets that create currency and items (rewards, drops, purchases, compensation) and the drains that remove them (store spends, crafting, repair, fees), measured exactly from the ledger (Inventories, Entitlements & Economies).

Spend order: the versioned rule for whether a spend uses paid or earned units first when a player holds both, recorded on each spend because finance, refunds and regulators ask; paid spends are also attributed to purchases first in, first out, so each purchase's unspent remainder is a query (Inventories, Entitlements & Economies).

Stable ID (PUUID, Riot ID): the platform's or publisher's permanent player identifier that records key on, against a display name such as a Riot ID (a game name and tag line) that can change (Accounts, Identity & Cross-Platform).

Trade hold, escrow: the wait before a new copy can be traded (Valve recommends at least 72 hours after purchase), and locking items in an open trade so they can't be spent or traded twice (Inventories, Entitlements & Economies).

Version skew: client builds, server builds, services, config and content at different versions at once; managed with exact client-server matches, N and N-1 service support, expand and contract migrations and a minimum client version (Live Operations).

Voided match, abandoned match: a match undone after the fact (a confirmed cheater, a server fault), marked voided with a reason so consumers reverse their effects, and a match whose server died without reporting, closed by a timeout job (Game Backend Architecture).

Wallet, currency ledger: an account's balance of one virtual currency, kept as a double-entry ledger whose transactions sum to zero across player, issued and consumed accounts, so the balance is the sum of its entries (Inventories, Entitlements & Economies).

Fair Play and Safety#

Aimbot, triggerbot: a cheat that aims or fires for the player using enemy positions and synthetic input; it sends valid inputs, so server authority can't stop it and detection has to (Anti-Cheat).

Auto-mute: blocking a zero-tolerance chat message before it's sent and muting the sender, as League's 2023 system does; filtering before delivery fails closed (Player Behavior & Moderation).

Botting: software simulating game input, usually unattended, to level accounts for sale or farm currency; Vanguard took League from over a million bot hours a day to under 5,000 (Anti-Cheat).

Cheat case: signals per account accumulated into one case with a score and a model version, so automated action happens only at high confidence and the middle band goes to human review (Anti-Cheat).

Client integrity: client-side protection that makes the game hard to read or modify (encrypted code, randomized anti-debug checks that react late, encrypted values, an obfuscated protocol); it raises cheat costs and decays as cheats adapt (Anti-Cheat).

Delayed enforcement (ban wave): collecting signature detections and enforcing later, so cheat sellers learn which check fired as late as possible, while immediate harm in a ranked match is stopped at once (Anti-Cheat).

Disruptive behavior, harmful conduct: conduct that doesn't match the norms a player and community set, and the subset that causes significant emotional, mental or physical harm, per the Disruption and Harms in Online Gaming Framework (Player Behavior & Moderation).

Easy Anti-Cheat, BattlEye, VAC: Epic's prevention-first anti-cheat with free and paid tiers, a kernel-based protection system with backend-controlled scanning, and Valve's signature-based system that never bans on reports alone (Anti-Cheat).

Hardware ban: a ban on a hard-to-change device identifier, such as the TPM, so a banned player can't just make a new account; stored hashed, with an end date and an appeal path for secondhand and shared machines (Anti-Cheat).

In-game support SDK: a help center and ticket or messaging inside the game, filled with context the game already knows; on consoles it can hand off to a phone by QR code (Player Support).

In-match report: a report filed when the behavior happens, naming the match, channel and category, with the server attaching evidence from its own records and weighing the reporter's credibility (Player Behavior & Moderation).

Intentional feeding, AFK: losing on purpose by walking into the enemy, and going idle or leaving; detected from match telemetry by the game team, with frequency-based penalties for leaving (Player Behavior & Moderation).

Kernel anti-cheat: an anti-cheat driver running with the operating system's privilege, often loaded at boot, so user-mode cheats can't outrank it; it risks stability and abuse, and Proton doesn't support it on Linux and Steam Deck (Anti-Cheat; its risks are in The Risks of Kernel Drivers).

Penalty ladder: escalating responses per behavior that restrict the abused feature first (chat, queue, ranked) before the account, with zero-tolerance violations skipping straight to a permanent ban (Player Behavior & Moderation).

Prevalence, time to action: the share of matches with a cheater by mode and region, and the matches from first detection to enforcement; Riot reported League dropping from 45+ games to under 10 after Vanguard (Anti-Cheat).

Prevention, detection, deterrence: the three tenets of Riot's anti-cheat, with prevention preferred because it stops cheating before players meet the cheater (Anti-Cheat).

Proactive detection: scanning content before anyone reports it; Xbox scanned 14.8 billion items in 2025 and found far more violations than players reported (Player Behavior & Moderation).

Reform: the goal of most penalties, since most disruptive players are only sometimes disruptive; consequences work when they're specific, prompt and proportionate, with strikes that expire (Player Behavior & Moderation).

Request a Human: a button that hands a bot-answered support ticket to a person, which brought Riot's bot satisfaction up to match agents; denials stay with people (Player Support).

Scripting: third-party programs that attach to the game client to read its state and automate precise actions; as many as 1 in 15 League games had a scripter or botter before Vanguard (Anti-Cheat).

Shadow mode: running a moderation vendor against a labeled sample of your own reports, without acting, before it's allowed to decide anything (Player Behavior & Moderation).

Support operation: a named, idempotent action support takes on an account (grant, restore, reverse a takeover), capped by value and approved by a second person above a threshold; there is no operation for changing sign-in details or ending a ban (Player Support).

Vanguard: Riot's anti-cheat, a user-mode client plus a kernel driver loaded at boot that sends nothing back, using TPM 2.0 as a hard-to-fake hardware identifier (Anti-Cheat).

Voice evaluation: moderating voice by recording on a short fuse and evaluating on report (VALORANT keeps recordings 24 hours, 7 days if reported) or by analyzing live channels and surfacing events with clips (ToxMod) (Player Behavior & Moderation).

Wallhack, ESP, map hack: cheats that show enemies, items or state the player shouldn't see, read from client memory; defeated by withholding hidden state (Anti-Cheat).

Withholding hidden state (Fog of War): the server not sending enemy positions until a client needs to display them; VALORANT does it with a precomputed potentially visible set at under 2% of server frame time (Anti-Cheat).

Money#

appAccountToken, purchase token: the UUID set at purchase that Apple returns in the transaction to tie it to your account, and Google's globally unique key for a purchase, which must be acknowledged within three days or it's refunded (Stores, Fees & Payments).

Battle pass: a time-limited reward track with a free lane and a premium lane bought for the season; progress is the sum of awards keyed by the server event that earned them, rewards are entitlements granted on reaching a tier, and upgrading mid-season grants every earlier premium tier at once (Monetization Models).

Chargeback: a payment reversed by the cardholder's bank, possibly months later; virtual goods invite friendly fraud, and a chargeback revokes what it paid for without locking the account (Stores, Fees & Payments).

Dark pattern: a purchase-flow design that tricks players into charges; the FTC's 2023 order bars Epic from charging through dark patterns or without express consent (Monetization Models).

Deferred revenue: virtual currency bookings recorded as owed and recognized over time; Roblox recognizes durable items over the estimated life of a paying user, 27 months as of December 31, 2025 (Monetization Models; the ledger facts it needs are in Inventories, Entitlements & Economies).

DLC, expansion, season pass: added content that depends on the base game, and a pre-purchase of DLC not yet made, granted by a job that walks pass holders as each piece ships (Monetization Models).

Durable, consumable: an item owned for good (a skin, a character), and one used up (a boost, a currency pack), refundable only until consumed (Monetization Models).

Edition: a bundle of entitlements (base license, a cosmetic pack, early access), each sellable alone, never a flag on the account (Monetization Models).

Fee schedule: store rates kept as data per store, program, region and transaction kind, with validity ranges and sources, because court orders and programs keep changing them (Stores, Fees & Payments).

Free-to-play: no price to start, with revenue from a minority who buy items, currency and passes; where the ownership and economy systems become mandatory (Monetization Models).

Gross bookings, net to developer: the sum of purchase prices before tax, and what remains after the store's fee (Monetization Models).

In-App Purchase (IAP): Apple's billing for in-app digital goods, required for in-game currencies; 30% standard, 15% in the Small Business Program, and 26% in the EU from 1 October 2026 (Stores, Fees & Payments).

Link-out (steering): sending a player from the app to buy on the web; allowed in the US App Store since 1 May 2025 with its commission still in court, and in the EU at 15% on sales within 7 days of the link tap (Stores, Fees & Payments).

Net Receipts: Microsoft's fee base: customer payments minus taxes collected, refunds and chargebacks, and amounts owed to Microsoft; 12% for PC games and 30% for Xbox console games (Stores, Fees & Payments).

Offer, offer price: a sellable bundle of items with its rules and audience, priced by dated rows per store and market, one live price each, so a price change is a new row with a reason (Monetization Models).

Personalized shop: a shop that shows each player different items chosen by a recommender (Riot's Your Shop uses collaborative filtering), with eligibility filters after scoring and the same price for the same item (Monetization Models).

Premium: paying once up front for a license the player owns for as long as the account exists, plus optional DLC (Monetization Models).

Receipt validation: verifying a purchase with the store's server before granting anything; the store transaction moves from pending to verified, granted and acknowledged, or to rejected or reversed (Stores, Fees & Payments).

Regional pricing: prices per store, currency or region with validity ranges, conversion method and cooldowns; Steam offers exchange-rate, purchasing-power and multi-variable conversion (Stores, Fees & Payments).

Rewarded ad: an ad the player chooses to watch for an in-game reward, granted only on the ad network's server-side verification callback, never on the client's word (Monetization Models).

Seller (merchant of record): the party that takes the payment and owns refunds, chargebacks and usually tax; the store on a closed platform, you on your own web store (Stores, Fees & Payments).

Steam Wallet transaction: Steam's microtransaction flow, InitTxn with your order ID, player authorization, FinalizeTxn to grant, and GetReport at least daily to reconcile refunds and chargebacks (Stores, Fees & Payments).

Store fee: the store's share of a sale, from 12% (Epic after the first $1 million, Microsoft PC games) to 30% (Steam under $10 million, Xbox console, Apple IAP), as of October 2026 (Stores, Fees & Payments).

Subscription: a monthly fee for a library or online play from the platform, or a benefit for a period inside one game; either way an entitlement with a validity range, not a flag (Monetization Models).

Virtual currency: a balance bought in packs and spent on items, smoothing regional prices and enabling small purchases while hiding the real price, which is where regulators step in (Monetization Models).

Web store: selling directly outside platform billing for margin and the customer relationship, while taking on tax, fraud, chargebacks, identity and link-attribution tokens (Stores, Fees & Payments).

The Rules#

Accessibility settings: settings per account with device overrides, seeded from the platform's caption, contrast and narration settings, reachable before the first cinematic, and never reset by live config (Accessibility).

Action remapping: binding physical inputs to actions through a table the player edits, with hold, toggle and repeat as properties of the binding and every prompt reading the current binding (Accessibility).

Age band: an account's age as a band (under_13, 13_15, 16_17, adult, unknown) rather than a birth date, derived from its age signals (the lowest wins) and cached on the account, never set directly; unknown gets the youngest band's defaults (Accounts, Identity & Cross-Platform; the rules it drives are in Ratings, Age & Children).

Age signals: platform APIs that pass a player's age band to the game under state app-store laws: Apple's Declared Age Range API and Google's Play Age Signals API; each answer is stored as an append-only signal the account's band is derived from (Ratings, Age & Children).

Assists: separate settings (game speed, timing windows, skipping events, aim help) rather than difficulty presets, with a per-mode policy and the assist state recorded on the match participant (Accessibility).

Build features check: a CI join between the features a build declares (paid random items, time-limited offers, chat) and what the live ratings say, so a new feature triggers a re-rating before release (Ratings, Age & Children).

Consolidated rate: the effective chance of a top-tier item once pity is counted; a 1% base rate with a guarantee on the 50th draw gives 39.50 expected draws, a 2.53% rate (Loot Boxes & Consumer Law).

COPPA: the US rule for online services directed to children under 13 or with actual knowledge of one; in games it reaches display names usable as contact information, voice audio and persistent identifiers (Ratings, Age & Children).

CPC principles: the EU consumer authorities' March 2025 principles on purchased virtual currency: real-money prices, no obscured costs or forced bundles, pre-contractual information, withdrawal rights, fair terms and care for minors (Loot Boxes & Consumer Law).

CVAA: the US law requiring advanced communications services, a category in-game text and voice chat can fall into, to be accessible where achievable (Accessibility).

Drop table: the possible outcomes of a random draw and their weights, versioned with integer weights, immutable once published, and the single source for both the server's roll and the disclosed odds (Loot Boxes & Consumer Law; each roll is an item_rolls row in Inventories, Entitlements & Economies).

ESRB: the North American rating board (E, E10+, T, M, AO), whose Interactive Elements such as In-Game Purchases (Includes Random Items) label a game without changing its age rating (Ratings, Age & Children).

IARC: the International Age Rating Coalition's system, where one questionnaire issues each participating authority's rating for digital storefronts; the answers are stored with the build they described (Ratings, Age & Children).

Integer weights: odds stored as whole-number weights over a fixed total (10,000 makes each unit 0.01%), so displayed probabilities are exact and sum to 100.00 (Loot Boxes & Consumer Law).

Loot box, paid random item: a purchase whose contents the buyer doesn't know in advance (gacha, card packs, prize wheels), including ones bought with currency bought for money (Loot Boxes & Consumer Law).

Odds audit: a daily test of observed outcomes against the disclosed base and consolidated rates per live table version, with the results kept as the answer to anyone who asks (Loot Boxes & Consumer Law).

Odds disclosure: publishing the chance of each item before purchase, required by Apple, Google Play and China, and in the FTC's HoYoverse order together with multi-tiered currency exchange rates (Loot Boxes & Consumer Law).

PEGI: the European rating system (3, 7, 12, 16, 18) whose interactive risk descriptors now change the age: paid random items are PEGI 16 by default for games submitted from June 2026, and existing games were re-rated from October 2026 (Ratings, Age & Children).

Pity: a guarantee of a top-tier result after a number of draws without one (soft pity raises the rate before it); counters are derived from openings and stored on each one (Loot Boxes & Consumer Law).

Play-by-appointment: rewards for returning, such as daily quests and login streaks; PEGI 7 from June 2026, and PEGI 12 when players lose content or progress for not returning (Ratings, Age & Children).

Right of withdrawal: the EU's 14-day cancellation right; lost for digital content only with express consent, and treated by the CPC principles as still covering unused purchased currency (Loot Boxes & Consumer Law).

Screen narration: UI read by the platform screen reader or a speech synthesizer in the order name, role, value, position, which needs an accessibility tree under the UI (Accessibility).

Significant change: under Utah's app-store law, a material change such as new monetization features or an altered age rating, which needs a parent's approval before a child sees it (Ratings, Age & Children).

Spending limit: a per-account cap on real-money purchases per day, week or month, set by default, the player, a parent or support, and checked against pending and completed purchases before one starts; child accounts start at zero (Loot Boxes & Consumer Law).

Subtitles, captions: text for speech, and text for all audio including sound effects and who is speaking; at most 40 characters a line and two lines on screen, on before the first sound (Accessibility).

Support for internal operations: COPPA's exception allowing persistent identifiers without consent for keeping a service working, security and anti-cheat, never for profiling or behavioral ads (Ratings, Age & Children).

Xbox Accessibility Guidelines (XAGs): Microsoft's numbered best practices for game accessibility (101 text, 102 contrast, 104 subtitles, 106 narration, 107 input), with testable numbers but no compliance role (Accessibility).

Running the Platform#

Active (player): an account that sent at least one event from a named list of gameplay events on a day, so background pings and failed logins don't count (Game Metrics).

ARPDAU, ARPU, ARPPU: net revenue per daily active player, per monthly active player in a calendar month, and per paying player in a period; computed on gross bookings instead, the name says so ("ARPU on gross bookings"); vendors differ, with GameAnalytics counting in-app purchases only and Unity including ad revenue (Game Metrics).

Asset provenance: a record at import of whether shipped content was made by people, AI or both, with which tool and any performer replica consent, used to answer store surveys (AI in Games).

Behavior tree: NPC decisions as a hierarchy of selectors and sequences over tasks, with a Blackboard holding its data and decorators that observe conditions and abort branches (AI in Games).

Bot participant: a match slot filled by a bot: a match_participants row with a bot_key and no profile, so ratings, reports and metrics leave it out (AI in Games).

Calibration: whether matches predicted at, say, 60/40 are won by the favorite about 60% of the time, checked against the prediction stored on the match when it was made (Game Metrics).

Competitive ruling: a sanction on a person, roster or organization under a tournament's rules, provisional until final, linked to a penalty only when an account is also restricted (Esports & Spectating).

Concurrent users (CCU), peak CCU: players connected at one instant, and the highest count in a period, from fixed-interval samples with "connected" defined per tier (Game Metrics).

Conversion (payer conversion): the share of active players who made a purchase in a named window, daily (over DAU) or monthly (over MAU); GameAnalytics reports it per day, and a monthly figure is a different number (Game Metrics).

Crash rate: crashes per 1,000 sessions, and the share of daily actives who crashed; Google Play's bad behavior threshold is 1.09% of daily actives (Game Metrics).

DAU, MAU, stickiness: distinct active accounts on a day, across the 30 days ending on a day (rolling) or a calendar month, and their ratio (Game Metrics).

Digital replica consent: a performer's scoped, separate consent to a voice or likeness replica (which game, which characters, real-time or pre-generated), checked before generation, with every generated line counted (AI in Games).

Game AI, generative AI: deterministic NPC decision and movement code a designer tunes, against model-produced text, speech and art with their own latency, cost and safety problems; generative output is at most a request to the game AI layer (AI in Games).

Ghosting: relaying a live spectator feed, which shows both teams, to a player; prevented by a server-side delay past the time the information would help (Esports & Spectating).

LTV (realized, predicted): net revenue per cohort member to day N, which can be audited, and a forecast to a horizon labeled with its model version (Game Metrics).

Match intervention: a pause, resume, restore, remake or side swap in a competitive match, recorded as a ruling with the official and the reason (Esports & Spectating).

Navigation mesh: a simplified polygon map of where agents can walk, divided into tiles that rebuild locally, with area costs and a separate local avoidance step for crowds (AI in Games).

Observer: production staff driving the broadcast cameras from a spectator client connected live to the game server; Riot said in 2022 that its esports matches normally run with up to 20 observers (Esports & Spectating).

Official data feed: sequenced match events from the authoritative server for broadcasters, teams and licensed partners, corrected by new events and tiered by latency; GRID is Riot's sole distributor (Esports & Spectating).

Pre-generated, live-generated content: Steam's content survey categories for AI-made content that ships with a game and content an AI makes while the game runs, the latter needing a description of its guardrails (AI in Games).

Project Chronobreak: League's esports tool that lets officials rewind a live game to a chosen moment by replaying its Server Network Recording, typically restoring the 40-minute mark in under three minutes (Esports & Spectating).

Queue time: from ticket creation to a match, reported as p50, p90 and p99 per queue, region and skill band; FlexMatch separates time to a potential match from time to successful placement (Game Metrics).

Retention (D1, D7, D30): the share of an install cohort active exactly N days after its first gameplay day; an unbounded variant counts day N or later (Game Metrics).

Sample ratio mismatch (SRM): an observed split of players across experiment variants far from the configured one, often caused by a treatment that crashes or breaks logging; a bug alarm before any result is read (Game Metrics).

Server tick health: the share of server frames that finish within the tick budget, per build and player count; VALORANT reported 99.3% or more since patch 5.07 (Game Metrics).

Spectator delay, spectator relay: the server-side buffer that releases a public spectator stream only after what it shows is stale, and the relay tier that holds keyframes and deltas and fans the stream out without exposing the game server (Esports & Spectating).

StateTree: Unreal's hierarchical state machine that combines behavior tree selectors with states and transitions (AI in Games).

Stomp rate: the share of completed matches decided by a margin above a game-specific threshold (VALORANT's is a win by 8 or more rounds), read beside queue time (Game Metrics; VALORANT's smurf figures are in Matchmaking & Ranked).

Tournament server: a server local to the players with fixed performance settings on a protected network, trading density for predictability, with pauses and every admin command logged (Esports & Spectating).

Utility AI: scoring every option from considerations normalized between 0 and 1 and picking the highest, for characters with many competing needs (AI in Games).