Glossary

A quick reference to the vocabulary used across these docs. Each term links to the page that covers it in full.

Building blocks

Device — a physical input or output on the playfield (a switch, coil, light, and so on), declared with a device block and referred to by name in your rules. See Devices.

Driven device — a device whose output Cade manages directly with built-in behavior (for example a drop target with its own reset), declared with a device subtype. See Driven Devices.

Variable — a named value the table tracks during play (a counter, flag, or total), declared with a variable block. See Variables.

Scope — how long a variable’s value lives and when it resets: ball, player, session, or global. The scope decides what survives a player switch, a new ball, or game end. See Variables and Syncing Outputs to Variable State.

Events and logic

Event — something that happened — a switch hit, a timer firing, a signal completing. Rules react to events by name.

Event handler — an event_handler block that reacts to a named event and runs actions (score points, set variables, start a mode, emit another event). It reacts; it does not detect patterns. See Signals vs Event Handlers.

Signal — a signal block that detects a pattern in hardware activity (a switch sequence, a timing window, a combo) and emits a named completion event when the pattern is met. See Signals vs Event Handlers.

Event flow — a flow block that orchestrates relationships between events over time (a sequence, a parallel set, a timed window) and emits a completion event when the pattern is met. See Event Flow.

Aggregation — a block that watches many hits and reacts to their shape over time — a burst of rapid hits, a sustained rate, or several devices hit at once. See Event Aggregation.

Cascade — the tree of effects a single event sets off: the root event, the handlers it triggered, the points they scored, and any events they emitted in turn. The console’s cascade viewer shows it live. See Cascade Viewer.

Device control — a device_control block that declaratively enables or disables devices and scoring (for example killing the flippers on tilt), with automatic rollback. See Game-Passive Modes & Device Control.

Scoring

Score rule — a score block that awards points when its when condition fires, optionally updating variables at the same time. See Scoring.

Modifier — a scoring rule that multiplies or adjusts other scoring (for example a playfield multiplier) rather than awarding a flat value. See Scoring.

Scoring safety mode — a fallback that keeps a game playable by awarding safe default points if a scoring rule can’t be resolved, instead of stalling. See Scoring Safety Mode.

Modes and structure

Mode — a chunk of gameplay that can be active or inactive (multiball, a hurry-up, attract). A mode always lives inside a module, which guards its rules so they only run while the mode is active. See Organizing Modes into Modules.

Module — a container that owns a mode’s variables, handlers, and scoring, keeping them grouped and scoped together. See Organizing Modes into Modules.

Fragment — a reusable bundle of scoring values you define once and reference from multiple score "event" rules to avoid repetition. See Fragments.

Assembly — a parameterized, reusable bundle of devices and rules you instantiate with use, passing different names and values each time (for example one assembly per rollover lane). See Reusing Config with Assemblies for the refactor workflow, or the Table Configuration reference.

Audio

Audio clip — a recorded sound file (.wav/.ogg) declared with audio_clip and triggered from devices or scoring. See Audio & Sound.

Synth patch — a sound generated in real time from oscillators, envelopes, and filters (no audio file), declared with a synth block and fired by a top-level route carrying a source "synth". See Synthesis.

Expressions

Expression — a formula evaluated against live game state, used in conditions, point values, and elsewhere (for example 5000 + var.ramp_count * 1000). See Writing Expressions.

Runtime binding — a value (such as a synth’s pitch) that can be a literal, an event property (from:event.<field>), or an expression, resolved when the event fires. See Runtime Bindings.

Noise generator — Cade’s deterministic source of randomness, behind functions like uniform() and dice_roll(); seed it and a game replays identically. See Noise Generator.

Noise context — a configured, named noise source you can reference for reproducible randomness. See Noise Context.

Configuration and tooling

Table config — the .cade file(s) that describe one table: its devices, events, variables, scoring, modes, fragments, and assemblies. See Table Configuration.

Runtime config — the machine-level cade.conf that sets the hardware platform, web server, and logging — separate from the table itself. See Runtime Configuration.

Platform / driver — the layer Cade uses to talk to hardware: FAST controllers, a Visual Pinball X bridge, or the built-in virtual driver for testing. Selected in the runtime config. See Platform and Drivers.

Pragma — a directive that tunes how strictly Cade validates your config (for example how reserved names are treated). See Pragma.

Reserved keyword — an identifier Cade reserves for its own vocabulary; using one for your own name can warn or error depending on the pragma mode. See Reserved Keyword Validation.

Scenario — a test that feeds events into the engine and checks the resulting score and state, run with cade scenario run. See Testing & Scenarios.

Console — the interactive TUI for debugging a live table: evaluate expressions, trigger events, inspect state, and watch cascades. See Console.