Sound Editor

The Sound Editor is a visual node-graph tool for a table’s entire audio system. One canvas covers four layers of sound: sources (sample clips, synth voices, music, playlists), synth patches (the DSP inside a synth voice — oscillators, envelopes, filters, modulation), mix/bus routing (channel strips, buses, effects, panning, ducking, down to the device output), and trigger rules (event-driven decisions that pick and fire sounds). You can also hear your work: a synth patch auditions live through the browser.

See Node Editor Basics for the shared canvas gestures. Which graph is on the canvas — the top “Sources” scope, a synth’s patch, a clip-selection graph, or the mix graph — is shown by the breadcrumb in the top-left toolbar.

The audio rail

The live-audio panels live in a right-side rail rather than crammed into the toolbar: audition transport, output meters and oscilloscope, the clip-selection panel, the mix/bus strip, and the selected-node parameter preview. The rail reserves canvas width (the graph shrinks to make room) instead of floating over the nodes, so nothing hides beneath it. The top-left toolbar keeps the light chrome — breadcrumb, the find-nodes filter, the add-node palette, and the status line.

The node palette

The Add node palette is scoped to where you are — it offers only the node kinds that belong on the current canvas rather than every category at once. Which scope you’re in — the top Sources graph, a synth patch, the mix graph, or a clip-selection graph — decides what you can add. A Show unavailable expander reveals the kinds that scope knows about but can’t add directly, each greyed with its reason (for example Music, which redirects you to a playlist or layer).

By scope:

Sources ✦ (the top graph) — Audio Clip (sample playback), Synth (a voice that encapsulates a DSP patch you drill into), Playlist (an ordered/shuffled set with crossfade), Music Layer (a base track with conditional overlays).
Synth DSP ∿ (inside a patch) — Oscillator (waveform generator; its amp doubles as FM depth), Filter (biquad low/high-pass with modulatable cutoff), Envelope (ADSR control value), a signal Mixer (picks its inputs and target when you add it), and Delay (an echo with time and feedback; adding one asks which signal it taps, since a delay can’t exist unwired). The Output entry enables only while the patch lacks one — adding it asks which signal feeds it — and the Amp VCA stays managed for you.
Mix / Bus ▤ (the mix graph) — Channel and Bus add directly. Effect (reverb/compressor/EQ/mod) enables once a strip exists: adding one opens a small form to pick the strip and effect type, and Delete removes a selected effect from its strip. The remaining inserts — Pan, Duck (sidechain), Spatializer, Limiter, Device Out (the terminal sink to the audio device) — are added in context and stay greyed in the palette.
Triggers ⌁ (a clip-selection graph) — Selection plus the decision kinds Condition (gate on a var/expression), Probability (weighted sampler), Anti-Repeat (no-repeat / cooldown), and Selector (pick from a pool and fire). Event references are authored in the Rules and 3D editors, not here.

Ports are rate-typed and color-coded — signal (audio-rate PCM), control (control-rate CV), trigger (sparse events), gain (a scalar), and bus (named routing). A wire only completes between compatible classes (plus the one control↔gain “modulation” cross). When a connection is refused the wire snaps back and the status line tells you why — a transient warning (for example “rejected connection — … is not rate-compatible with …”, or cade’s own reason for an illegal modulation) that clears after a few seconds. Refusals are no longer silent.

Opening a synth patch

A Synth source node encapsulates a DSP patch. Double-click it to drill into the patch scope; the canvas repaints to the oscillators/envelopes/filters and the breadcrumb extends (e.g. Sources › bassSynth). Press Escape, double-click empty canvas, or click an earlier breadcrumb crumb to drill back out. Inside a patch you can add/connect/delete/rename nodes and edit their params inline — envelope times are scrubbable millisecond fields (drag, wheel, or type a plain number like 120), matching the freq and gain controls. A wire onto a param slot becomes a modulate edge (for example an envelope onto carrier.freq).

The smallest patch that makes a sound is one oscillator wired to the output — no envelope required. cade fills in a default amplitude gate so the voice still plays and releases cleanly. When you do add an envelope, the first one is auto-named amp (later ones become env, env_2, …), so you never have to remember the magic name. The amp → output gain wire is drawn as a muted, translucent “documentary” wire: cade binds the amplitude VCA by the reserved amp name, not by that edge, so it’s there to show the amp is the voice level, not as a connection you manage.

Auditioning a patch

The Audition transport lets you hear a synth patch play through your speakers. The engine renders the same bit-accurate sound the real machine uses and streams it to the browser, so the preview is the true patch, not a re-synthesis.

▶ Play / ■ Stop — start and immediately silence the patch.
Audition mode — One-shot plays a clip of the set Length, Loop re-triggers that clip on a cycle (so you hear the envelope repeat), and Continuous holds a sustained tone until you press Stop.
Note buttons — a small keyboard (A3, C4, E4, G4, A4; A3 by default) sets the audition pitch so you can demonstrate the patch across notes.
Status line — reports readiness (ready — bit-accurate synth via cade), auditioning…, done, stopped, or an error. If the patch can’t play yet it tells you exactly what’s missing — “Add an oscillator and an output to audition this synth.” An amp envelope is not required: an oscillator wired to an output is enough to audition.

By default Play auditions a bundled demo patch; once you’ve drilled into a live synth, Play auditions that patch. Audition is a user gesture (it starts the audio engine on first Play, satisfying browser autoplay rules). In a headless environment or an engine build without audio, the transport is disabled and reads “audition unavailable” — it never errors.

Playing it from a MIDI keyboard

With a MIDI keyboard attached, tick MIDI input in the audition rail and pick your device — the browser asks permission the first time. Keys then play the patch you’re drilled into, polyphonically and with velocity, and drilling into a different synth takes effect on the very next key press. The sustain pedal and pitch bend behave as you’d expect.

Knobs map by ear, not by number: select a node, click Learn CC, then move a controller — the first knob you move claims that node’s parameter and drives it on every sounding voice from then on. Capture writes the values you’ve dialled in back into the patch as one undoable edit, and Clear forgets all mappings. In a browser without MIDI support the block simply doesn’t appear.

Audition and MIDI preferences also live in the app-wide settings, and changing them there applies to an already-open editor immediately.

Meters, scope, and parameter preview

Two visualizers help you read a patch — don’t confuse them:

Output meters — a live oscilloscope of the waveform plus stereo L/R level meters with peak-hold and live dB readouts. It only moves while audition is playing; idle it reads “press Play to audition.”
Parameter preview — a static inspection panel that follows the selected DSP node and draws its shape from its numbers with no sound: an ADSR curve for an envelope, a frequency-response curve (with cutoff marker) for a filter, or a single-cycle waveform for an oscillator. Select an oscillator, filter, or envelope to populate it.

Clip selection and triggers

The Clip selection panel has a scope dropdown listing selection scopes as owner · name (clip count); picking one loads that decision graph — event sources, conditions, probability, anti-repeat, and selectors — onto the canvas so you can see how a sound is chosen and fired for an event.

With Follow 3D selection on (an Options-menu toggle, on by default), picking a sound-bound device in the Object Editor surfaces that device’s selection graph on the Triggers canvas. The same happens when you open the Sound editor from the object editor’s right-click Open in editor ▸ Sound editor deep-link — it lands focused on the device you came from.

Selecting an Audio Clip or Synth source node and pressing Delete takes it off the route — the trailing Selector node goes with it once the last source is removed, and the change lands as one undoable entry in Edit History. The decision-chain nodes behave differently depending on what they represent: Condition, Probability, and Anti-Repeat are attribute-shaped, so deleting one just clears the field(s) behind it, while Event and Selector are derived from the route itself and refuse — the status line names the node and says why rather than leaving Delete looking like a dead key. The removal edits the live engine’s in-memory config, so it does not survive a reload of the bundled default table (only a live/persisted table); making a route removal durable across a default-table reload still means editing the .cade source, as was done to drop the flipper and pop-bumper demo routes.

Mix and bus routing

The Mix / bus panel shows the routing as a read-only row of strip chips — one per channel or bus (buses prefixed “⇢”, effect counts shown like “(2 fx)”) — with a status such as “3 strips · 1 flagged route(s).” A flagged route is the engine pointing out a routing concern worth inspecting. The single top-level mix graph loads directly onto the canvas; the chip list is a summary, and the routing itself is the graph you edit on the canvas.

Live vs. sample

The editor draws on two data sources that can be live independently — the catalog behind the palette, and the synth patches you drill into. When live, edits round-trip through the engine and a rejected edit reverts with an explanation — and they persist across a reload and sync live to other open windows on the same table. In sample mode the palette and a faithful sample catalog are available but editing is optimistic, and audition, selection, and mix editing all need the live engine.