animation
Clip playback on a node's animation component — starting, holding, seeking — and tweens, short clips generated from a table of steps and addressed by the handle they hand back.
assets
Asset definitions by reference: a project-relative file path, file#entry for one entry inside it, or #id for a block the scene declares. A script gets the definition table, not the parsed object the owning plugin builds from it.
audio
Sound playback: a file plays under an integer handle, with volume, pitch and loop options, and the sound component gives a node a sound of its own. With no output device every call still works and nothing is heard.
debugger
Breakpoints, the pause a stopped script sits in, and the ways out of it. The same machinery the editor's Debugger dock and the Debug Adapter Protocol server drive, so an outside editor and the built-in one see one debugger.
engine
The running app itself: the clock a frame reads, the command line it was started with, the directory it may write to, and the way out.
fs
Files on disk, project-relative unless the path is absolute, so a script cannot wander the filesystem by accident. This is the disk itself: a packed build's contents are reached through assets and scene.source.
gamend
The Gamend backend: a session, its REST API, and a realtime socket carrying topics and server hooks. Every call returns an id to await, and each result also reaches the handler method of the node it was given (ongamendevent unless on_event names another) as a map tagged with a kind.
geometry3d
Mesh operations that stand outside the simulation: hulls, convex decomposition, voxelisation, cutting and boolean intersection. A mesh is an asset's name or a table of points and indices.
http
HTTP calls, off the frame: the reply arrives on a later tick as a map with status, headers and body, or with error, both to the node's onresponse method and to whoever awaits the returned id. Options are method, headers, body and a timeout in seconds, which falls back to the project's [net] httptimeout.
input
One frame of input: the keyboard, mouse, touch screen and gamepads as they stand now, plus the edges — what went down or came up this frame. Nothing feeds it in a headless run, where every query answers neutrally rather than failing.
json
JSON text to and from script values, for talking to anything outside the engine. Unlike TOML it has null, so nil survives a round trip.
log
The three levels a script writes at, and the buffer behind them. Scripted lines go through the engine's own tracing stream, so they land beside engine ones.
math
Deterministic float maths, backed by pure-Rust libm: the same inputs give the same bits on every platform. A script uses these rather than the language's own float methods, which reach for the platform's libm and drift between machines.
node
What every node has: its name and path, its transform in local and world space, its children, its components and its script. Each operation takes the node as its first argument, so scripts normally call them as methods on a node value (this.node.position()).
physics
What spans both physics worlds at once: pausing, sleeping and clearing. Bodies and colliders live in physics2d and physics3d.
physics2d
The 2D rigid-body world: bodies and colliders on nodes, their velocities, and overlap queries. physics holds what spans both worlds.
physics3d
The 3D rigid-body world: bodies and colliders on nodes, their velocities, and overlap queries. physics holds what spans both worlds.
render
What a frame is made of: the shape, sprite, mesh or emitter a node draws, the 2D and 3D cameras, the OS window, and the backdrop and debug lines drawn around the scene.
replay
Record what a running game is fed and play it back. A recording holds each tick's input, network arrivals and events, not the world they produced, so a session is small and replays by re-running the game against the same input. The editor's Session dock drives these, and so does balaur run --record.
rng
The engine's one deterministic PCG32 stream: the same seed draws the same numbers on every platform, and a replay reproduces every draw a recorded session made.
scene
The node tree: its root, lookup by path, spawning and instancing. Also the component and preset vocabulary an editor builds its palette from.
script
Loading other scripts, inspecting what they declare, and calling into them without a failure taking the frame down.
skeleton
Bones under a rig node: the rest pose a rig returns to, and the tree order a skin numbers its joints in. A bone is any node carrying bone2d or bone3d; there is no skeleton component.
task
Waiting inside an async handler: init and event handlers may await, update is deliberately synchronous.
toml
TOML text to and from script tables: the format scene files, asset definitions and component properties are all written in.
ui
Immediate-mode UI, redrawn from a script's draw_ui every frame: panels, layout containers and the design system's widget shapes. HUD elements that live in the scene tree are the widget component instead.
websocket
A long-lived connection carrying text or binary frames. Its events are a stream, not a result: each one reaches the connecting node's handler method (onwebsocketevent unless on_event names another) as a map { socket, kind, .. } with kind open, message (with text), binary (with bytes), closed or error, and nothing awaits a socket id.