Glossary
The words of the docs: KitHost, module, ABI, slot, view, hook, passport…
Glossary #
The words of the GripForge docs, in plain English. grip-forge docs glossary, MCP gripforge_docs { topic: "glossary" }.
| Word | Meaning |
|---|---|
| ABI | The binary contract between the player and a presentation module: gripforge:present@1 (grip-forge docs abi, or the MCP tool gripforge_docs with topic abi). Version 1, extended only by appended variants (v1.1, v1.2). |
| Adapter | The implementation of a kit for one target (web, rust, godot, unity, unreal). Its status: native (runs), files (emits engine files), recipe (a checklist), planned (nothing yet). |
| API reference | The generated documentation of a kit: config, hooks, events, views, services, verbs, slots, collections, mod points, module, targets, changelog, examples (guide kit-api; gripforge kit api <id>). |
| Archetype | A reusable entity template of game.engine (kind, components, model slot) that scenes place as instances. |
| Bare player | The Bevy player without any game or kit code: renderer, generic layers, module host (gripforge docs player). |
| Board (planche) | The before/after capture comparison of the player: 0 = identical, under 5 = good. |
| Capability | A contract a kit provides or requires (combat.health, game.engine@^1). Any kit providing it satisfies a requirement. Also the name of the service object another kit reads. |
| Caps | Bits the host announces to modules (Init::host.caps): what it draws beyond the baseline (WGSL materials, post passes, web UI…). |
| Claim | A module saying "I draw this entity / this part": the generic layer then leaves it alone. |
| Collection | A list of documents a kit owns in the project data (missions, boons, rooms), with a schema. |
| Command trace | The text form of the commands a module sends, one per line (meshes and textures as size + digest, floats to 4 decimals), written by the SDK harness and compared in tests (tests/<name>.trace). |
| Compiled presenter | The old presenters compiled into the player (player/src/kits, features builtin-presenters / legacy), removed: every kit is drawn by its module. |
| Config | The settings of a kit in a project (installed[].config), validated by its configSchema. |
| Event | A message a kit emits on the bus when something happened (combat.died), with a payload schema. Others listen to it; scripts react to it. |
| Fingerprint | A hash of the sources of a package or module; it names the files so a cache never mixes versions. |
| Fragment | A piece of web UI (React components or HTML templates) mounted by ui.webui over the game. |
| FrameIn / FrameOut | The input of a module each frame (what changed in what it declared) and its answer (the list of commands), postcard bytes. |
| game.engine | The kit every game is built on: scenes, content, scripts, hooks, mods, saves (gripforge docs game-engine). |
| Generic layer | What the player draws for every game without a module: entities and their bound models, camera, ground, lights. |
| Harness | The SDK test runner (sdk/src/harness.rs): replays snapshots through a module exactly as a host would and checks its command trace, without a GPU. |
| Hook | A decision of a kit a game or a mod may intercept before it applies (damage, purchase, spawn): change mutable fields or cancel. |
| InputTracker | The part of a host that turns successive snapshots into the deltas each module declared (FrameIn); every host has one (a port for a non-Bevy host). |
| Kit host (Rust) | The Rust mirror of the TypeScript KitHost, same kits and same contract, used natively and for parity tests. |
| Kit | A brick of gameplay or presentation (combat.core, world.rooms): manifest, runtime, README, API notes. |
| KitHost | The runtime that runs the kits of a game: TypeScript in the page (web), Rust (gripforge-kithost) natively. It makes a snapshot each frame. |
| Library | The workspace store of assets (models, textures, sounds, VFX) of the GripForge site; slots bind its items. |
| Live settings | Values of a kit's <capability>.settings service a game or a reaction may change while the game runs (engine.moddable.settings). |
| Manifest | The declaration of a kit (manifest.ts): id, version, capabilities, config schema, events, hooks, slots… Its hash locks the version. |
| Mod points | What a kit lets mods change (engine.moddable): config keys, collections, live settings, registries. |
| Mod | A gripforge.mod/1 JSON document applied over a project before the kits mount: config, collections, hooks, scripts. Data only, never code. |
| Module (presentation module) | The drawing of one kit, in plain Rust compiled to .wasm, run by the module host. It reads its needs and answers commands. |
| Module host | The part of the player that runs modules and applies their commands, by family (mesh, material, node, scene, fx, ui, skeleton, camera/post/audio). |
| naga | The shader translator the hosts use to validate WGSL and turn it into GLSL ES 3.0 (WebGL2), HLSL, SPIR-V or MSL. |
| Needs | What a module declares it reads: components, events, data, views of services, settings, shared keys, commands it may send. |
| Parity fixture | A list of operations played on the TypeScript and on the Rust kit host to prove they behave the same (gripforge-kithost/parity/*.json). |
| Passport (mesh passport) | What an asset says about itself: real size, orientation, skeleton, colliders, clips, plus sections kits own (lod for render.lod). Made by the studios, carried by the game in the asset_passports collection of asset.meta; kits read it instead of guessing from the file. |
| Port | An interface a kit runtime gets from its host instead of importing an engine: physics, assets (ctx.physics, ctx.assets), so the same kit code runs headless. |
| postcard | The compact binary encoding (a Rust serde format) of every ABI payload; field order is encoding order. |
| Preset | A genre template: the kits, configs, data and control scheme a new game of that genre starts with. |
| Registry | A collection of things "by type" (enemy types, weapons) where a document may extends another. |
| Role (of a kit) | How a kit plugs into game.engine: world (builds a scene's ground), layer (dresses a scene), content (vocabulary: components, verbs, collections), actor (places actors), view (shows content), flow (game life cycle, saves), service (a pure service). |
| Scene | A place of a game in game.engine: its world kit document, its layers, its instances and its data; a game moves between scenes. |
| Share | State computed by a module and published to other modules (out.share). Never a copy of a kit view. |
| Slot | A named place where a kit draws a Library item (player_model, ground_texture), bound by the project. |
| Snapshot | What the KitHost sends the player each frame: entities, views, vars, new events. |
| Start pack | What game.engine hands an agent when a project starts: the content order, where custom code goes, what to fill next. |
| StdMaterial | The baseline material of the ABI (glTF metallic-roughness or unlit) every host must reproduce. |
| Tap | One interception of a hook (a hooks document): { hook, match?, if?, set?, add?, mul?, cancel? }. |
| Trigger DSL / script | Rules { when: <condition>, then: [<actions>] } of game.engine that react to events and state; kits add verbs to it. |
| ui.webui | The kit that carries every HUD and menu of the web player as DOM. |
| Var | A GameState path a kit publishes (player.health), readable by the HUD and scripts. |
| Verb | An action or condition of the script language a kit provides (give_item, has_item). |
| View | (1) A web interface of a kit, declared in its manifest (webViews). (2) A method of a service a module polls (world.atmosphere.sky). |
| wasmtime / AOT / .cwasm / wasmi / Pulley | Native WebAssembly runtimes: wasmtime compiles modules ahead of time (AOT) into .cwasm files; wasmi and Pulley interpret them where compiling is not allowed (iOS). Planned for the native hosts. |
| WebGL2 fallback | Every web player package holds WebGPU and WebGL2 and switches by itself; mandatory. |
| WGSL dialect | The subset of WGSL a module may send: plain functions, no imports, no bindings, no compute. |