The words you need to know

A software framework that provides the core systems a game needs: rendering, physics, input handling, audio, and scripting. Building these from scratch for every game would take years. An engine packages them so developers can focus on the game itself. The major engines are Unity (widely used, C#), Unreal Engine (AAA and film, C++/Blueprints), and Godot (open source, GDScript/C#). Each has a different philosophy, community, and licensing model. The right choice depends on the type of game, the team's skills, and the target platform.

An open-source game engine developed by the Godot community, free to use with no royalties. Organised around a scene-and-node architecture: everything in a game is a scene made of nodes. Primarily scripted in GDScript (a Python-like language designed for Godot) or C#. Excellent for 2D games; 3D capabilities are strong but historically less mature than Unity or Unreal. Gained significant popularity after Unity's 2023 pricing controversy caused a large portion of the indie game development community to migrate.

In 2D game development, a canvas is the rendering surface on which 2D elements are drawn. In Godot, CanvasItem is the base class for all 2D objects: sprites, labels, and shapes. The canvas has a coordinate system (origin at top-left, x increasing right, y increasing down in most implementations) and a transform (position, rotation, scale) that determines where items appear. "Canvas layer" in Godot allows you to place UI elements or background layers at different depths, so HUD elements always render in front of the game world.

A software application that combines a code editor, debugger, and project management tools. Game engines typically have their own built-in editor (Godot's editor, Unity's editor) which is the primary workspace for building the game. Scripting is often done in an external IDE: VS Code, JetBrains Rider, or Godot's built-in script editor. The game engine editor handles the visual assembly of scenes; the IDE handles writing and debugging code. The two communicate so that errors show up in the right place.

Godot's built-in scripting language, designed specifically for game development. Syntactically similar to Python: indentation-based, dynamically typed (though static typing is available), readable without much ceremony. Scripts attach to nodes and define their behaviour. GDScript runs inside Godot's runtime and is optimised for game use: it is fast enough for most purposes and integrates tightly with the engine. For performance-critical code, Godot also supports C# and GDNative (C/C++ bindings).

In Godot, a scene is a reusable, self-contained collection of nodes saved as a file. A player character is a scene. A level is a scene. A single bullet is a scene. Scenes can contain other scenes (instances). This composability means you can build complex games from simple, testable pieces. In other engines, the equivalent concept goes by different names: Unity uses prefabs for reusable objects and scenes for levels.

The fundamental building block in Godot. Every element in a scene is a node: a sprite, a collision shape, a camera, a script, a sound player. Nodes are organised in a tree hierarchy (the scene tree). Each node has a type that determines its properties and behaviour: Sprite2D displays an image, CollisionShape2D defines a collision area, CharacterBody2D handles physics. Nodes inherit from each other: most game objects combine multiple node types attached as children.

The hierarchical organisation of all active nodes in a running Godot game. The root node is at the top; every other node is a descendant. Parent nodes affect children: if you move a parent, all children move with it. If you hide a parent, all children are hidden. The scene tree is the runtime equivalent of the scene files on disk. Scripts can traverse and modify the scene tree, which is how most game logic works: finding nodes, changing their properties, adding or removing nodes dynamically.

The core cycle that every game runs continuously: process input, update game state, render the frame, repeat. Each iteration is a frame. At 60 frames per second, this cycle runs 60 times per second. Everything in a game (movement, physics, AI, animations) is driven by updates that happen within each iteration of the loop. In Godot, the _process(delta) function runs every frame; _physics_process(delta) runs at a fixed rate for physics calculations.

The time elapsed since the last frame, in seconds. Critically important: if you move an object 5 pixels per frame and the game runs at 30fps, the object moves 150 pixels per second. At 60fps, it moves 300 pixels per second. Multiply movement by delta time instead, and the object moves at the same real-world speed regardless of frame rate. All movement and time-dependent calculations in a game should use delta time. In Godot, delta is passed as an argument to _process() and _physics_process().

The number of frames rendered per second. 60fps is the standard for smooth gameplay on modern hardware; 30fps is acceptable for many game types; 120fps or higher is increasingly common on PC and newer consoles. Frame rate is separate from update rate: physics may update at a fixed 60Hz regardless of render frame rate. Low frame rate causes stuttering. Inconsistent frame rate (frame rate drops) is often more disruptive than a stable lower frame rate.

Godot's built-in event system for communication between nodes without tight coupling. A node emits a signal when something happens (body_entered, pressed, animation_finished). Other nodes connect to that signal and run code when it fires. This is the correct way to make nodes communicate in Godot: it avoids nodes needing direct references to each other, making code cleaner and scenes more reusable. In other programming contexts, signals are equivalent to events or the observer pattern.

A 2D image used to represent a game object: a character, an enemy, a coin, a tile. Sprites are typically PNG files with transparency. A sprite sheet (or texture atlas) packs multiple sprites into a single image file for efficiency: the game references specific regions of the sheet rather than loading dozens of separate files. In Godot, Sprite2D is the node for displaying a single texture; AnimatedSprite2D cycles through frames for animation.

An image applied to a surface in a game. In 2D, textures are the images displayed on sprites. In 3D, textures are wrapped around meshes to give them colour and detail. A texture can represent colour (diffuse map), surface roughness, reflectivity, or normal direction. Texture resolution (512x512, 1024x1024, 4096x4096) affects visual quality and memory usage. Compressing textures reduces memory at some visual cost. Most game assets are textures.

A small programme that runs on the GPU to determine how pixels are rendered. Vertex shaders transform the positions of geometry. Fragment shaders (pixel shaders) determine the final colour of each pixel. Shaders are written in specialised languages (GLSL, HLSL, Godot's shader language). Most visual effects in modern games are shaders: water ripples, glowing outlines, screen distortions, cel shading, bloom. The GPU runs shader code in parallel across millions of pixels simultaneously, which is why graphics cards are measured in shader processors.

A grid of tiles used to construct game environments efficiently. Each cell in the grid displays one tile from a tile set (a texture atlas organised into individual tiles). A level designed as a tilemap uses far less memory than a single large image and can be edited procedurally or by hand in a tile editor. Tilemaps are the dominant approach for 2D platformers, top-down RPGs, and strategy games. Godot's TileMap node handles both the visual display and can attach physics and navigation data to individual tile types.

A 3D object defined by vertices (points in space), edges (lines connecting them), and faces (polygons filling the space between edges). The geometry of every 3D object in a game is a mesh. A simple cube has 8 vertices, 12 edges, and 6 faces. A detailed character model has thousands to millions. Meshes are created in 3D modelling software (Blender, Maya) and imported into the engine. The level of detail in a mesh directly affects rendering cost: more polygons means more GPU work.

A rendering technique that simulates the path of light rays from the camera into the scene, calculating accurate reflections, shadows, and global illumination by tracing each ray as it bounces off surfaces. Produces photorealistic lighting but is computationally expensive. Real-time ray tracing in games became practical with NVIDIA's RTX cards (2018), which have dedicated hardware for the ray calculations. Most games use a hybrid approach: rasterisation for primary rendering, ray tracing for specific effects like reflections and shadows.

A texture that encodes surface orientation information (normals) per pixel, making a flat surface appear to have depth and detail when lit. Baked from a high-polygon model onto a low-polygon model: the normal map stores what the high-detail lighting would look like, so the low-poly model renders with the appearance of far more geometric detail. The RGB channels of a normal map store the x, y, and z components of the surface normal direction, which is why they appear purple-blue in texture editors.

The process of determining when two objects in a game are touching or overlapping. Without collision detection, characters walk through walls, projectiles pass through enemies, and nothing interacts physically. Collision detection computes whether the collision shapes (hitboxes) of two objects overlap each position update. Broad phase detection (e.g. bounding box checks) quickly eliminates most pairs; narrow phase detection precisely calculates if the remaining candidates actually intersect. Getting this right and efficient is one of the central problems of game physics.

Terms from action and fighting games. A hitbox is the area around an attack that can deal damage: the region a punch or bullet "occupies" when checking for hits. A hurtbox is the area around a character that can receive damage. They are intentionally different: hitboxes are often smaller than the visual animation (so attacks feel fair), and hurtboxes are tuned to match the character's visible body. Good hitbox design is invisible: players feel hits are accurate without consciously noticing the underlying geometry.

A physics-simulated object that responds to forces, gravity, and collisions according to the laws of physics. When you drop a rigidbody, it falls. When it hits something, it bounces or slides based on its mass, friction, and bounciness properties. In Godot, RigidBody2D and RigidBody3D are fully physics-simulated. CharacterBody2D/3D is for player characters, which need physics-like behaviour but direct programmer control rather than full simulation: you want to decide when the player can jump, not have the physics engine decide for you.

The simplified geometric shape used for physics and collision calculations, separate from the visual representation. Using the exact polygon of a character sprite for collision would be computationally expensive and often produces awkward results. Instead, a simple shape (rectangle, circle, capsule) approximates the character's body for collision purposes. Players never see collision shapes directly, but they determine whether the character can fit through a gap, stands on a ledge correctly, or gets stuck on environment geometry.

Projecting an invisible ray from a point in a direction and detecting what it hits first. Used for: line-of-sight checks (can the enemy see the player?), shooting (what does this bullet hit?), surface detection (is there ground below the character?), mouse picking (what object is the cursor over?). Raycasting is computationally cheap and extremely versatile. In Godot, the physics engine provides raycasting through PhysicsDirectSpaceState. Many games cast dozens of rays per frame for various purposes without noticeable performance cost.

The fundamental repeating cycle of actions that defines the game experience. In a farming game: plant, tend, harvest, sell, buy better tools, repeat. In a shooter: explore, encounter enemies, fight, loot, upgrade, repeat. The core loop is what players spend most of their time doing. A compelling core loop is intrinsically rewarding: the actions themselves feel good, not just the rewards. A weak core loop cannot be saved by good writing or graphics. Most game design work is refining the core loop until it feels right.

Creating game content algorithmically rather than by hand. A procedurally generated dungeon is different every time you play. Terrain, quests, items, and dialogue can all be generated procedurally. The advantages: infinite variety, reduced content creation cost, high replayability. The disadvantages: procedural content can feel incoherent, lack authorial intent, or produce occasionally absurd results. Most games use a mix: handcrafted structure with procedural variation within it. Minecraft's world generation is the most widely experienced example.

Roguelike: a genre defined by procedurally generated levels, permadeath (dying means starting over), and turn-based gameplay. Named after the 1980 game Rogue. Classic examples: NetHack, DCSS. Roguelite: a game with roguelike elements (typically permadeath and procedural generation) but with persistent progression between runs: you unlock new items, abilities, or characters that carry forward. Hades, Slay the Spire, Dead Cells. The roguelite framework is one of the most successful game design innovations of the 2010s.

A subgenre of action-adventure games defined by a large, interconnected map where access to new areas is unlocked by acquiring new abilities rather than progressing linearly. Named after Metroid and Castlevania: Symphony of the Night, which defined the template. The map appears explorable but is gate-kept by ability requirements: you can see the door you cannot open yet. As you acquire abilities, previously inaccessible areas open up, which rewards revisiting earlier parts of the map. Hollow Knight is the most celebrated recent example.

A written document describing what a game is: its concept, mechanics, story, art direction, sound, and scope. Used to communicate the vision across a team and to track decisions as development progresses. GDDs range from a single page (indie jam projects) to hundreds of pages (large studio productions). A living GDD updates as the game evolves; a fixed GDD becomes out of date. Many experienced game designers argue that the GDD matters less than the prototype: building is faster than writing about building.

A playable, polished section of a game that represents the final quality of the product across all disciplines: art, audio, gameplay, and code. Not a prototype (which tests ideas roughly) but a demonstration of what the finished game will actually look and play like. Usually a single level or a brief self-contained sequence. Studios use vertical slices to pitch to publishers, to align teams on the target quality bar, and to test whether the game concept actually works when fully realised.

Behaviour and scenarios that arise from the interaction of simple game systems, not explicitly designed by the developers. In physics-heavy games, stacking crates in unexpected ways to reach a ledge. In strategy games, alliances and betrayals between AI factions producing political drama. In sandbox games, players building structures far beyond the game's intended uses. Emergence is considered a mark of excellent game design: a small number of well-designed systems generating a large number of unpredicted experiences. It cannot be fully planned, only made likely by thoughtful system design.

The code and techniques that handle synchronisation between multiple players in an online game. Bad netcode produces lag, rubber-banding, and inconsistent hit detection. Good netcode is invisible: the game feels responsive even over a network connection that introduces delay. Netcode quality is often cited as the defining technical characteristic of fighting games and competitive shooters, where the difference between a 100ms and 150ms response time changes outcomes. Rollback netcode is the current gold standard for fighting games.

A server that is the single source of truth for game state in a multiplayer game. Clients send inputs to the server; the server calculates what happened and sends the results back. Clients cannot cheat by modifying their local game state because the server does not trust what clients report about the world, only what they report about their inputs. The trade-off: every action requires a round trip to the server, introducing latency. Most competitive multiplayer games use authoritative servers to prevent cheating at the cost of some responsiveness.

A technique where the client immediately applies the player's input locally, without waiting for server confirmation, to make the game feel responsive. The client predicts the outcome of its own actions and shows them instantly. When the server's authoritative update arrives, the client reconciles its prediction with the server's result. If the prediction was correct (usually), nothing visible happens. If it was wrong, the game corrects, which can produce a visible snap or rubber-band. Most modern online games use this to hide the latency of the authoritative server model.

How often a game server updates and broadcasts the game state, in updates per second. A 64-tick server updates 64 times per second; a 128-tick server updates 128 times. Higher tick rates produce more accurate and responsive gameplay but require more server resources and bandwidth. Counter-Strike professional play historically demanded 128-tick servers for the accuracy required at high levels. Most casual online games run at lower tick rates because the difference is imperceptible to non-competitive players. Tick rate is separate from client frame rate.

A designation for games produced by large studios with large budgets: Call of Duty, FIFA, Grand Theft Auto. No formal definition, but AAA implies a budget of tens to hundreds of millions of pounds, teams of hundreds to thousands of people, and global marketing campaigns. AAA games dominate sales charts but are expensive to produce and commercially risky. The indie segment (one to fifty developers, self-funded or small investment) has grown dramatically and now produces many of the most critically acclaimed and culturally significant games.

A distribution model in which players can purchase and play a game before it is officially complete. The developer continues to update and finish the game while players provide feedback and funding. Steam popularised it from 2013. Early Access works well when the game is genuinely playable and the developer communicates clearly. It fails when the game is released too early, development stalls, or the finished version never arrives. Player trust in Early Access as a concept has been eroded by high-profile abandonments.

A timed event in which participants create a game from scratch within a short period, typically 48 to 72 hours, around a given theme or constraint. Ludum Dare and Global Game Jam are the largest. Game jams are used for experimentation, learning, portfolio building, and fun. The constraint of a short deadline forces creative decisions and scope discipline that normal development often lacks. Many successful commercial games started as game jam entries: Superhot, Papers Please, and Celeste all have jam origins.

Additional content sold separately after a game's release: new levels, characters, story chapters, cosmetics. DLC as a model is neutral: it can fund continued development that extends a game's life, or it can be used to sell content that should have been in the base game. The critical question is whether the base game feels complete without it. "Day one DLC" (content sold on launch day that was clearly developed as part of the original game) is widely criticised. Expansion-scale DLC that adds significant new content at a reasonable price is generally well received.