Glossary

Every term of art this section uses, pinned. The vocabulary is the code's own — these are the words the docstrings, the design records and the tutorial all share. Each entry links to the page that develops it.

arrangement — the client-side layer that places elements in time, groups them recursively and renders them: clausters.form. Pure and transport-agnostic; the server knows nothing of it. Its DAW-style view is the multitrack editor. Called the arrangement (or the arrangement model when naming the layer as such) — never "the model" bare, which reads as the node tree or a def.

automation / automation lane — a break-point curve placed on the timeline that drives controls: clausters.seq.Automation. Stored as an Env; rendered as a control vector read onto a control bus. (Automation)

base level — the zoom at which a nested group is summarized (one labeled rectangle) or resolved (lanes of its own): Editor.expand / collapse. The same structure, seen coarser or finer — a view state, not data. (The editor)

beats — the arrangement's unit of time: musical, tempo-relative. Everything in clausters.form — onsets, durations, placements, extent — is in beats. Compare timeline samples. (Overview)

bounce — evaluating a generator offline into a generated element: a pattern run on a throwaway clock into a timeline of events (at flatten time), or a whole piece rendered to audio (Bouncing). A bounce is a change of state.

bus (internal) — a private audio/control bus a logical group declares (buses=["mix"]); members wire to it by naming it in their controls. Each graph instance allocates its own. The reserved name OUT is the hardware output. (The logical side)

change of state — evaluating a generator into a generated element: a pattern bounced to events, a piece rendered to a file. The compositional act rendering performs — it turns something you can only produce into something you can manipulate. (Elements)

clip — the editor's graphic unit: a placed rectangle spanning [offset, offset + dur] on the shared axis — its length is its duration. Draws the body (or layered bodies) its element calls for: a take, a piano-roll, a curve. (The editor)

concrete (group kind) — see group: a group whose members relate in time (a section, a lane), as opposed to a logical one, whose members relate by processing. It is the default kind, and the one the multitrack draws as lanes of clips. (Grouping)

control bus — a server bus carrying control-rate values. What an automation renders onto: a small internal synth reads the control vector onto the bus, and targets follow it (via /n_map, or by reading the bus directly). (Automation)

control vector — an automation curve discretized into a server control buffer (/b_gen "env", the same envelope math EnvGen plays — what is drawn is what is heard). (Automation)

cursor — the static transport line: where a located, stopped transport sits, and where the next play starts. Set by locate or a ruler click. Compare playhead. (Editing)

dirty — Editor.dirty: the arrangement changed since the last render. An edit never interrupts what is sounding; the next transport action re-reads the composition. (Editing)

duration — an element's own length in beats (Element.duration), optional. Distinct from a placement's dur, which overrides and trims it. (Elements)

edit-back — the GUI-to-data direction of the loop: the window's gestures ("clip" move/resize, "points" curve edits, "wire" rewiring, "locate") applied onto the arrangement by Editor.apply / Editor.poll. (Editing)

element — the arrangement's unit: any bounded thing that produces a unit of meaning and can be decomposed or combined — in one of the two modes, generated or generator, carrying an optional onset and duration, delegating its playing to the object it wraps. (Elements)

Env — the client's envelope object (levels, segment times, per-segment shapes): the stored form of an automation curve, round-tripped to and from break-points by env_to_points / points_to_env — the picture, the data and the server buffer all read the same object. (Automation)

event / clip (element) — the Event primitive: parameters grouped into one action, internally simultaneous. Wraps clausters.seq.Event. (Elements)

extent — the composition's length in beats, read from the arrangement (the end of its last placed element): Editor.extent(). Not a constant — move a clip past the end and the piece is longer. (The editor)

five primitives — the five element kinds, each a thin adornment over an object the client already has, with their conceptual names: Event (event/clip), Sequence (List), Buffer (Buffer), Track (Set), Generator (Function). (Elements)

flatten — the tree-walk that accumulates nested placement offsets into absolute beats, producing a flat timeline of playable items; contained patterns are bounced in the same pass. clausters.form.flatten / to_timeline — also available as pure inspection. (Grouping)

follow — Editor.follow: re-render on every applied edit (the live editor). Off, an edit marks dirty and waits for the next transport action. (Editing)

generated / generator — the two modes of an element, the axis the layer turns on. Generated: the rendered thing — random-access data you can edit, slice, read backwards (a buffer, a timeline of events). Generator: the algorithm that renders it — forward-only, it can just be evaluated (a pattern, a def). Between them, the change of state. (Elements)

group — the arrangement's one new structure: a composite element placing members recursively by offset. Two kinds: concrete (the members relate in time — a section, a lane) and logical (the members relate by processing — wired through buses, rendered as a GraphDef). (Grouping, The logical side)

GraphDef — the server's named configuration of member nodes wired by buses, sent with /d_graph and instanced with /graph_new. What a logical group renders to: Group.to_graphdef() maps one onto it, 1:1. (The logical side)

handle (member) — the stable object Group.add returns (also Group.handles), identifying one placement across edits — what move and remove take, and what the editor holds per clip. Group.members reads the placements as (offset, dur, element) triples. (Grouping)

instrument — the def named to play a Buffer element (its buf control takes the buffer number). A buffer is data: without an instrument it is structure only — it draws and contributes extent, but emits no event. (Elements)

lane — one track row of the multitrack window. The root group's members are the lanes; a lane's members are its clips. (The editor)

locate — seek: put the transport at a beat. Stopped, it moves the cursor; playing, it re-renders from there. A click on a lane's ruler or empty space is the same locate. (Editing)

logical (group kind) — see group: a group whose members relate by processing — wired to each other through buses — rather than in time. It does not flatten; it renders to a GraphDef, and it draws as a patch. (The logical side)

multitrack editor — the arrangement's DAW-style view and driver: clausters.gui.Editor plus the track/clip/graph widgets. Draws the tree, applies edits back onto it, owns the transport, and is the only converter between beats and timeline samples. (The editor)

onset — where an element starts, in beats, relative to its context; optional. Usually supplied by a placement rather than the element itself. (Elements)

patch / patcher — the view of a logical group: member boxes, bus nodes, one wire per (member, control) ↔ bus connection. Deliberately undirected — the data knows the connection; the direction is the server's analysis. (The logical side)

piano-roll — the clip body an element of events draws: one bar per note, high pitches up. A pattern's roll is bounced to be drawn — a generator lane shows the notes it is about to play. (The editor)

placement — one member's position in a group: an offset (beats, relative to the group) and an optional dur. An element's concrete place comes from its placement, not from itself. (Grouping)

placement length (trim) — a placement's dur overrides the element's own duration and trims what plays: events past the end are dropped, a final event is shortened — on a copy; the element is never rewritten. The DAW rule: a clip's length is what you hear of it. (Grouping)

playhead (sweeping) — the moving transport line, anchored to the engine's sample clock so it tracks the audio (Editor.anchor). Also the clausters.seq.Playhead object itself: what a render returns. Compare cursor. (Rendering, Editing)

poll — Editor.poll(): drain the window's pending events into the arrangement (apply each), returning whether the composition changed. One call, no loop; never from the clock thread. (Editing)

quant — the one musical grid, in beats: the editor converts it once and hands it to the lanes as their drag grid, and snaps edit-backs to it — so the grid a clip is dropped on is the grid the arrangement re-schedules on. (The editor)

render / rendering — the change of state to sound, Element.render. What it does depends on the group kind. For a concrete group (a relation in time): flatten to a timeline and play it through a Playhead — and every render re-reads the tree. For a logical group (a relation of processing): translate to a GraphDef, send it, instance it. RT or NRT purely by destination. (Rendering)

rerender — Editor.rerender(): re-schedule the (edited) composition from the playhead's position, reusing the destination and clock the last render remembered — stop, re-flatten, play. Honest semantics: re-schedule from here, not a sample-exact splice; a synth already sounding keeps sounding. (Editing)

RT / NRT — real-time (a live server, timetagged bundles) versus non-real-time (an offline score, Session.nrt + render). The same client code and the same flattening either way — which is why a bounce is sample-identical to what you heard. (Bouncing)

take — an audio clip: a Buffer element's recorded/bounced content, drawn from the server buffer itself (fetched and decimated host-side). (Setup, The editor)

temporal character — what a single element's onset/duration presence makes it: segment (both), punctual (onset only), relative (duration only), abstract (neither — pure context). (Elements)

temporal relation — what a group's members' placements make the group: successive (they tile contiguously), simultaneous (they start and end together — one thing on the timeline, drawn as one layered clip), mixed (anything else). Derived, never declared. (Grouping)

timeline samples — the view's unit: one unit per audio sample, so a take sits 1:1 on the axis. Clips, rulers and edit-backs speak it; the editor converts (one beat = sample_rate / tempo units) and nothing else does. (The editor)

unit bridge — the single conversion between beats and timeline samples, owned entirely by the editor (units_per_beat, beats_to_units, units_to_beats), through the core's own time arithmetic. (The editor)

wire — one (member, control) ↔ bus connection of a patch. Rewiring on screen rewrites the member Generator's controls; the next render sends the graph as drawn. (The logical side)