◆ Phonon

Rotary knob centered at 0 (center pan). Drag vertically to adjust (100 px of travel = full range). Double-click the knob to reset it to center. Range is −1 (full L) to +1 (full R). Pan is applied per-channel inside the StuderConsole using equal-power cosine/sine panning.

Vertical fader with a custom mixing-desk-style cap handle. The fader is bidirectionally linked to the track's GainModule — moving it in the mixer, changing the Volume knob in the module's Params panel, or CV-modulating the gain all stay in sync.

dB scale with log-taper: the fader uses a Yamaha/Harrison-style piecewise curve so 0 dB (unity) sits at ˜75% travel, with fine control around unity and aggressive attenuation near the bottom. Positions at key breakpoints: bottom → −∞ (true silence, snap zone); 5% travel → −60 dB; 25% → −30; 50% → −12; 75% → 0 (unity); 100% → +12 dB.

Double-click the fader to snap to unity (0 dB). The numeric readout below the fader shows dB (“+3.2 dB”, “−6.0 dB”, “−∞”). The underlying storage is still linear gain, so CV routing, save files, and automation lanes all continue to work unchanged — the dB display and log curve are UI-only.

The master fader uses the same dB convention and taper.

Page tabs: Mixer (1), Audio Analysis (2), Master Audio (3), Video Analysis (4), Master Video (5).

Action buttons: Record (bounce), Metronome toggle, Open Visuals.

DJ button (pinned to bottom): Enter/exit DJ Performance Mode.

All buttons are 42px with custom-drawn icons. A separator divides page tabs from action buttons.

The left portion of the drawer shows a live OpenGL preview of the visual graph output. The preview respects the video's native aspect ratio with letterboxing/pillarboxing.

Below the preview: 8 custom-drawn buttons — Open Window, Beginning, Prev Bar, Prev Frame, Play/Pause, Next Frame, Next Bar, and Slice. Play syncs with spacebar. Slice creates an undo point and splits video/audio regions at the playhead.

24px stereo VU meter with green→yellow→red gradient, peak hold indicators, clip indicator, and dB tick marks. Fed from the master peak values.

Scrolling waterfall display with log frequency scale and a Wikipedia-style color LUT. Uses WriteableBitmap circular buffer. Pink noise compensation for balanced frequency representation.

Lissajous L/R stereo phase scope with blue-cyan color scheme, persistence/decay, and phase correlation meter. Auto-gain scaling for consistent display.

48-band log-frequency bar display with peak hold and frequency labels.

ITU-R BS.1770 loudness metering with K-weighting filter (high shelf + highpass RLB). Displays Momentary (400ms, white needle), Short-term (3s, colored bar), and Integrated (running average since play, resets on play start) LUFS values. True Peak L/R readouts in dBTP with color coding (green/yellow/red). Platform target markers on the meter bar: Spotify/YouTube (−14 LUFS), Apple Music (−16), CD (−9). Scrolling history bar graph at the bottom with platform target lines.

4-band parametric equalizer — low shelf (80 Hz), two peak bands (500 Hz, 3 kHz), high shelf (10 kHz). RBJ biquad filter implementation, stereo processing. Visual display shows live spectrum background with frequency response curve overlay and 4 colored draggable handles (red, gold, green, blue). Double-click a handle to reset it to default frequency and 0 dB gain. Auto-bypasses when all bands are flat.

Brick wall limiter with three large rotary knobs: Threshold (orange, −24 to 0 dB), Ceiling (gold, −6 to 0 dB), Release (blue, 10–500 ms). Gain reduction meter at the bottom with color-coded fill (green → orange → red). Double-click any knob to reset to default.

Mid-side stereo width control with large rotary knob. 0% = mono (side channel zeroed), 100% = normal stereo (unity), 200% = extra wide (side channel doubled). Per-sample smoothing prevents clicks. Stereo field visualization bar and L/R labels. Double-click to reset to 100%.

Tape-style soft-clipping waveshaper (tanh). Variable drive (1× at 0%, 4× at 100%) with automatic gain compensation and dry/wet blend. DC blocker prevents offset buildup. Live transfer curve visualization updates as you adjust the knob. Double-click to reset to OFF.

RGB + luminance distribution display from BGRA frame data with overlapping filled curves.

Chrominance distribution on a circular plot. Angle = hue, distance from center = saturation. RGB→YCbCr (BT.601) conversion. Includes SMPTE color bar target boxes (R, MG, B, CY, G, YL), skin tone reference line, quarter-radius graticule circles, and crosshairs. Pixels are color-coded by hue position for intuitive reading. Phosphor persistence decay.

Luminance waveform display — each column of the source frame maps to a vertical brightness plot. IRE grid lines at 0/25/50/75/100%. Click to toggle between Luma mode (single white waveform) and RGB Parade mode (three side-by-side R/G/B waveforms). Phosphor persistence with 60% decay.

Full 9-stage GPU color pipeline applied via the ScreenNode shader: input levels → brightness → contrast → gamma → color balance (luminance-weighted shadows/midtones/highlights) → temperature → tint → saturation → output levels. 18 parameters serialized to the project file.

Controls: SlimSlider widgets for levels/tone, ColorWheelControl (circular HSV ring with draggable point) for shadow/mid/highlight RGB offsets. Double-click any control to reset.

Vinyl A (spinning platter) — DJ Mixer (center, with embedded visuals preview) — Vinyl B (spinning platter) — DJ Control Panel (right side). The mixer is 1.6× wider than the vinyl spinners and contains a 16:9 visuals preview between the control columns.

LOAD A re-opens a project file as the main project. LOAD B loads a second .phonon file in the background, so the current deck keeps playing without interruption. Video decoders warm up when the deck starts playing, and Deck B runs on its own audio thread.

3-band EQ per deck (HI/MID/LOW mini knobs) — Volume faders (vertical, per deck) — Crossfader (horizontal, equal-power curve, A/B color gradient) — Play/Pause buttons (per deck) — SYNC (copies BPM from Deck A to Deck B) — LOAD buttons (per deck, opens file picker) — BPM display (per deck).

When a track is loaded, Phonon renders the entire song offline into a stereo buffer on a background thread. The buffer becomes available for scratching progressively as it renders.

During scratch, playback reads from that pre-rendered buffer at a variable rate set by the vinyl rotation speed. Forward rotation = forward playback (pitch up with speed), reverse = reverse playback. The vinyl position smoothly interpolates toward the target to eliminate clicks.

Right-click on the performance lane → "Add Performance Zone" → enter a name in the dialog. Zones are created at the clicked position (snapped to grid) with a default duration of 4 bars and auto-rotating colors.

Right-click an existing zone for: Rename, Change Color (8 presets), Enable/Disable Loop (shown as dashed border), Delete.

Gold drag handles on left and right edges for resizing. Click body to select (gold outline) and drag to move. Minimum duration: 1 bar.

PZ SYNC A→B / B→A — sync zone position between decks (bar-level matching with fallback). PZ LOOP (toggle, default ON) — loop within the active performance zone.

MUTE (toggle) — zero deck gain while active. AUTO MUTE — schedules a one-beat silence starting at the next beat boundary. Beat-quantized timing with sample-counted duration (immune to PZ loop resets).

PZ CUE NEXT — cue the next zone (blinks when pending). PZ NEXT BAR — transition at next bar boundary (blinks when pending). PZ NEXT NOW — immediate jump.

AUTO FADE — crossfader fades toward the target deck over remaining zone duration or 4 bars (blinks during fade). Cancel by touching crossfader or pressing again.

RAMP BPM — linear BPM ramp from current to root over 4 bars (sample-counted). ROOT BPM — instantly set deck BPM to root (region tempo override or project BPM). Cancels any ramp.

Source → 3-Band DJ EQ (kill EQ, 250/2500 Hz crossover, 0=kill, 0.5=unity, 1=+6dB) → LP/HP Sweep Filters (resonant biquad, exponential freq mapping, Q=1.2) → Grain Delay (beat-synced, 16 simultaneous Hann-windowed grains, feedback loop) → Plate Reverb (8 comb filters, 4 allpass diffusers, 12ms pre-delay, smoothed send) → Volume × Crossfader → Mute → Output.

DJ EQ: On the mixer. RBJ biquad with complementary mid extraction (mid = input − low − high). Sweep Filters: LP sweeps 20kHz→60Hz, HP sweeps 20Hz→16kHz. Auto-bypass when fully open. Grain Delay: Scales from quarter-note echoes (low) to 32nd-note granular wash (high) with pitch randomization and occasional octave shifts. 3-second capture buffer. Plate Reverb: Per-comb damping, stereo spread via offset buffer lengths, smoothed send amount with always-running tail (no pop on on/off). All knobs double-click to reset to default (LP=1, HP=0, Grain=0, Reverb=0, EQ=0.5).

The top info bar splits into two deck panels in DJ mode, matching the normal position display style (Consolas monospace, rounded border shell, vertical dividers). Each panel shows: Deck letter (A blue, B orange) | BAR (bar.beat.sub) | BPM with base BPM in parentheses when synced to a different tempo (e.g. "125.0 (120)") | ZONE name | TIME (min:sec.tenths). Base BPM = region tempo override if set, otherwise project root BPM.

Disabled in DJ mode — use per-deck Play/Pause buttons or double-click the vinyl platters.

Click the DJ button, press Ctrl+P, or press Escape. The arrangement view restores to single-timeline mode, Deck B stops, and the drawer returns to normal tabbed layout.

Nodes are rounded boxes with input ports (left) and output ports (right). Cables are bezier curves between ports. Right-click the canvas to add nodes. Click+drag ports to create cables. Click+drag node headers to move them. Left-click drag empty background or middle-mouse drag anywhere to pan. Every Blocks module starts with a MIDI In node (gate/pitch/velocity/trigger outputs) and an Audio Out node (L/R inputs). These cannot be deleted.

Inline parameter sliders — drag horizontally to adjust values displayed on the node. Custom header colors — right-click → 🎨 Header Color with 12 preset colors or reset to category default. Custom labels — right-click → ✏ Set Label to add an italic annotation below the node name. Both persist with the project file.

SubBlocks is a node that contains an entire nested patching canvas. Add via right-click → ⬡ SubBlocks. The node has 7 input and 7 output ports: Audio L/R, Gate, Pitch, Velocity, Trigger, CV In/Out. Inside the sub-canvas, an ⬡ Input bridge node provides incoming signals and an ⬡ Output bridge node collects outgoing signals. Double-click a SubBlocks node to open its canvas in a child window. SubBlocks can be nested recursively. Deep copy/paste via right-click menu duplicates the entire sub-graph including all internal nodes and cables.

MIDI In — receives note events from the track. Outputs: Gate, Pitch (MIDI note number), Velocity, Trigger (1-sample pulse on note-on). Legato note stack with retrigger support.

Audio Out — final stereo output. Inputs: Left, Right.

CV In — reads a value from the Meadow CV bus system. Params: Bus (0–63).

Audio Bus In — reads audio from a shared audio bus. Tracks can route their output to buses 1–12; this node reads from them. One buffer latency. Outputs: Left, Right. Params: Bus (1–12).

SubBlock Input / Output — I/O ports for SubBlocks patches. 7 ports each side.

Visual Send — sends any signal to the Blocks→Visual bridge bus (64 channels). See Blocks→Visual Bridge.

Oscillator — anti-aliased oscillator with PolyBLEP. Continuous waveshape morphing (0=Saw, 1=Sine, 2=Triangle, 3=Pulse with variable pulse width). FM input for frequency modulation.

ADSR Osc — oscillator with built-in ADSR envelope. Accepts Gate, Pitch, Velocity directly from MIDI In. Stereo output.

Unison — multiple detuned oscillators mixed with stereo spread. Built-in ADSR envelope.

Noise — white noise generator.

Sample — WAV sample player with per-note triggering, pitch CV, and sample rate reduction.

Script — user-written Glyph code executing per-sample. 8 inputs, 8 outputs. Port names defined by the script. Double-click to open the code editor.

FM Operator — single sine-wave FM operator with configurable ratio and feedback. Chain several to build classic DX-style FM patches.

Karplus-Strong — plucked-string physical model. Short delay line + lowpass feedback. Trigger input excites the string; pitch input sets the delay length.

Waveguide — bidirectional delay-line physical model with configurable L/R reflection coefficients and damping. Blank slate for tuned tube/string sounds.

Tube — Waveguide with built-in breath noise + envelope. Three modes: Flute, Clarinet (negative reflection → square-wave timbre), Brass (tanh nonlinearity for embouchure).

LFO — low-frequency oscillator (Sine, Triangle, Saw, Square, S&H). Free or tempo-synced rate.

Constant — outputs a fixed value. Useful for setting frequencies, bias voltages, etc.

CV Trig→Pitch — outputs a fixed MIDI pitch when triggered by CV. Configurable gate duration.

Clock — generates trigger and gate pulses at a configurable rate (Hz). Adjustable pulse width.

Step Sequencer — step sequencer with configurable pattern.

CV Sequencer — CV-driven step sequencer.

Is Playing — outputs 1 when transport is playing, 0 when stopped. No inputs.

Beat — outputs trigger and gate pulses synced to musical divisions (whole, half, quarter, 8th, 16th, 32nd, 64th notes). Adjustable gate width. Syncs to the transport clock.

CV Noise — random CV signal generator. Speed controls how often a new random target is picked. Smooth controls interpolation between targets. Outputs −1 to +1.

Rand CV — outputs a random value in a configurable range on each trigger rising edge. Holds value until next trigger.

Rand Pitch — outputs a random MIDI pitch (integer) in a configurable note range on each trigger. Holds value until next trigger.

Rand Hz — outputs a random frequency (Hz) on each trigger. Logarithmic distribution for perceptually even spread across octaves. Configurable range (default 20–20000 Hz).

Chord Builder — builds 4-voice chords from a root note. 14 chord types (maj/min/7/9/sus2/sus4/dim/aug…) × 9 scales, or Direct chord-type selection. Inversions, Change trigger output for arpeggiation.

Euclidean — Euclidean rhythm generator. Distributes N pulses evenly across M steps. Params: Pulses, Steps, Rotation. Triggers fire on the active steps.

Turing Machine — 16-bit shift register after the Music Thing module. Length 2–16, Probability for bit flips. Outputs: Pitch (quantized), CV (0–1), Trigger, Gate. Preset defaults for a usable starting pattern.

Pattern Recorder — beat-synced CV capture and playback. Records up to 1.5M samples of incoming CV. Params: Rate, Reverse, One-Shot. Monitor-through when not recording.

Envelope — ADSR envelope generator. Gate input triggers Attack/Decay/Sustain; gate release triggers Release. Direct retrigger from NoteOn events.

Complex Envelope — multi-point envelope with configurable curve types. Gate and trigger inputs. Looping support.

Harmonic Quantizer — quantizes pitch to the current harmonic progression from the GlassEngine/Song Structure system.

Add — A + B. Subtract — A − B. Multiply — A × B (B defaults to 1). Divide — A / B (safe; returns 0 if B ≈ 0).

Min / Max — outputs smaller / larger of A and B.

Abs / Negate — absolute value / sign flip of input.

Clamp — constrains input to a Min/Max range.

Map Range — remaps input from one range to another. Params: In Min, In Max, Out Min, Out Max.

Math (Legacy) — dropdown-based operator node. Kept for backward compatibility with existing patches.

Trig: Sin, Cos, Tan, Asin, Acos, Atan2 — all measured in turns (0–1 = one full cycle) rather than radians, so they compose neatly with LFO / phase inputs.

Exp / Log — natural exponential / logarithm (guards x ≤ 0 → 1e-9).

Pow — A to the B power. Signed-negative-base handling for bipolar curves.

Sqrt — square root of |input|.

All comparator nodes output 1.0 for true, 0.0 for false. Logic inputs treat ≥ 0.5 as true.

Equal — A ≈ B (configurable tolerance). Not Equal — A ≉ B.

Greater — A > B. Less — A < B.

Greater/Eq — A ≥ B. Less/Eq — A ≤ B.

And — both true. Or — either true. Not — inverts.

XOR — one or the other, not both. XNOR — both same.

NAND — not both. NOR — neither.

Audio→Trig — fires a CV trigger pulse when audio amplitude crosses a threshold. Rising edge detection. Configurable gate duration (1–200ms).

Amp→CV — envelope follower. Converts audio amplitude to a 0–1 CV signal with separate attack/release smoothing. Gain parameter for scaling quiet signals.

Pitch→CV — maps MIDI pitch (0–127) to 0–1 CV. Configurable low/high note range for the mapping.

Uni→Bi — converts unipolar (0 to 1) to bipolar (−1 to +1). Formula: out = in × 2 − 1.

Bi→Uni — converts bipolar (−1 to +1) to unipolar (0 to 1). Formula: out = (in + 1) × 0.5.

CV→Hz — maps 0–1 CV to frequency using exponential/logarithmic scaling. Configurable range (default 20–20000 Hz). Equal CV distances = equal musical intervals.

Hz→Pitch — converts frequency in Hz to MIDI note number. Standard formula: 69 + 12 × log₂(hz / 440). Fractional output for microtonal precision.

Delay — audio delay line with time (up to 2s) and feedback controls.

Waveshaper — nonlinear waveshaping with multiple curve modes (Tanh, Fold, Clip, etc.).

Phaser — 4-stage all-pass filter chain with feedback. LFO sweeps center frequencies (200–4000 Hz). Stereo phase offset for width. Params: Rate, Depth, Feedback, Mix, Stereo.

Chorus — modulated delay line with sub-sample interpolation. Center delay (1–30ms) with LFO modulation. Stereo offset for width. Params: Rate, Depth, Mix, Delay ms, Stereo.

Ring Mod — multiplies audio by an internal oscillator for metallic/bell tones. CV-controllable frequency. Shape crossfades sine→square carrier. Params: Freq, Mix, Shape.

Flanger — short modulated delay (0.1–5ms) with feedback for comb filter sweeps. Negative feedback allowed for hollow sound. Stereo. Params: Rate, Depth, Feedback (−0.95 to +0.95), Mix, Delay ms, Stereo.

Grain Stretch — granular time-freeze effect. When Gate CV ≥ 0.5, captures audio and loops it with two overlapping grains. Mix input controls wet/dry. Params: Grain ms (10–200), Scatter (randomize grain position), Pitch (playback speed 0.25–4×).

Filter — resonant state-variable filter (Lowpass, Bandpass, Highpass). Stereo. L/Mono input mirrors to R if R is not connected. Cutoff and resonance inputs.

High Pass — dedicated high-pass filter.

Ladder — Moog-style 4-pole ladder filter with tanh saturation. Self-resonates at high Q.

Prism — SEM-style filter that morphs continuously Lowpass → Notch → Highpass via a Shape knob.

Formant — 3-band formant filter for vocal-tract simulation. Params: Q (1–40), Gender (−1 male → +1 female).

Comb — comb filter (feedback delay with pitched coloration). Frequency-tuned.

Allpass — all-pass filter for phase shifting without amplitude change. Useful for building reverbs and phasers from primitives.

Biquad — general-purpose RBJ biquad. Modes: Peak, Notch, LowShelf, HighShelf. Params: Freq (Hz), Q, Gain (for Peak/Shelf). Coefficient caching to avoid recompute on every sample.

CV Gate — passes signal through only when it exceeds a threshold. Modes: Zero (output 0 below threshold) or Hold (hold last above-threshold value).

If-Else — conditional signal routing. If Cond ≥ 0.5, outputs A; otherwise outputs B.

Prob Gate — probabilistic gate. Outputs the input gate with a configurable pass-through probability.

Trig Chance — randomly passes or blocks trigger pulses. On each rising edge, rolls against a Chance parameter (0–1). 1.0 = always pass, 0.0 = always block.

Gate Length — holds the gate open for a fixed duration after a trigger (ms).

Gate Delay — delays incoming gates by a configurable amount, in milliseconds or beats.

Swing — applies per-division swing timing to triggers. Auto-detects incoming interval; ±0.5 swing amount.

Ratchet — subdivides each incoming gate into N rapid subdivisions. Useful for trap hats and drill'n'bass patterns.

T Flip-Flop — toggles output state on each rising edge of input.

SR Flip-Flop — Set/Reset flip-flop. Reset-dominant (S+R simultaneous → R wins).

Counter — counts trigger rising edges. Max parameter wraps. Outputs: Count (current value), Overflow (trigger on wrap).

MIDI In — (also listed under I/O; lives in the MIDI menu for discoverability.) Gate/Pitch/Velocity/Trigger outputs from the track's MIDI input.

MIDI CC — receives a live MIDI CC value. Params: CC number, Smoothing (one-pole), Initial value. Outputs: Value (0–1), Bipolar (−1 to +1), Trigger (on value change). MIDI Learn: right-click → “🎚 Learn CC” and move a knob on your controller to bind. Amber outline while armed. Values arrive via LiveMidiDispatcher — zero-latency, no track-chain stamping.

CC → Bipolar — convenience wrapper: converts an incoming CC (0–127) directly to −1..+1 bipolar CV.

CC → Pitch — maps a CC to a MIDI pitch (with optional scale snap). Params: Min note, Max note, Snap.

CC → Hz — maps a CC to a frequency using exponential/logarithmic scaling. Params: Low Hz, High Hz.

VCA — voltage-controlled amplifier. Multiplies audio by a CV signal. Volume parameter.

Mixer — 4-channel stereo mixer with per-channel gain and pan, plus master gain.

Splitter — 1 input, 8 outputs (all identical passthrough).

Selector — 8 inputs + Select CV → 1 output. Crossfade or hard-cut between inputs.

Crossfader — A/B crossfade with Curve knob blending between Linear and Equal-Power crossfade shapes.

S+H — sample and hold. Samples the input value on the rising edge of the trigger signal. Output holds until next trigger.

Slew Limiter — limits how fast a signal can change. Single Rate parameter (seconds). Low rate = slow glide, high rate = nearly instant. Exponential smoothing.

Lag — like slew limiter but with separate Rise and Fall times. Fast rise + slow fall = percussive follower. Slow rise + fast fall = swell in, snap off.

Attenuverter — scale, invert, and offset a signal. Amount (−1 to +1): negative inverts, zero silences, positive passes. Offset added after scaling.

Quantize — snaps input values to a grid of N evenly-spaced steps.

SR Reducer — sample-rate reducer. Holds input value at a configurable output rate (Hz) — aliasing and grit below audio-rate.

Bit Crush — quantizes signal to 2^Bits levels over [−1, +1]. Fractional bit depths allowed for fine-grained grit.

Delta — outputs the per-sample change in input. First derivative, useful for edge detection and envelope analysis.

Integrator — leaky integrator with optional reset input. dt-scaled, so the time constant is sample-rate independent.

Peak — peak detector with VU-style decay. Reset input clears held peak.

RMS — windowed RMS (loudness) over a configurable window in milliseconds.

SubBlocks — nested patching canvas. 7 I/O ports each side. Orange header color. See SubBlocks above.

Glyph uses strict typing and mandatory semicolons for code clarity. All variables persist their values between audio samples — this is how oscillator phases accumulate and filter states are maintained. Variables reset on note-on events or when the script is recompiled.

Scripts have 8 input ports and 8 output ports. Port names are defined by the script itself: writing in("Pitch") creates an input port called "Pitch" on the node. Writing out("Left", sample) creates an output port called "Left". Unused ports remain with default names and carry zero signal.

A Volume knob on every Script node attenuates all outputs (default 0.5) to prevent accidental clipping while developing.

Source code passes through four stages: Lexer (text → tokens) → Parser (tokens → AST, recursive descent) → Compiler (AST → bytecode with constant pooling and jump patching) → VM (stack-based execution with 256-element float stack, zero allocation per sample). The entire pipeline runs when you click Compile or press Ctrl+Enter. Errors display with line and column numbers.

float — 32-bit floating point. The primary type for audio signals, frequencies, gains, and most values. This is the workhorse of Glyph.

int — 32-bit integer. Use for counters, MIDI note numbers, array indices, and bitwise operations.

bool — true/false. Use for gates, flags, and conditional logic. Internally represented as float (1.0 = true, 0.0 = false).

buffer[N] — fixed-size float array of N elements. Use for delay lines, wavetables, and sample storage. Declared with a size: buffer[2048] delay;. See Buffers.

All variables must be declared with a type. Variables persist their values between samples — this is essential for audio DSP where you need state (oscillator phases, filter memories, counters).

float phase = 0.0;       // oscillator phase
int counter = 0;          // sample counter
bool triggered = false;   // flag
buffer[4096] delayLine;   // 4096-sample delay buffer

Variables declared without an initializer start at zero. Variables reset to zero on note-on events and when the script is recompiled, but buffer contents are preserved across resets (delay lines keep their audio data).

Use in("name") to read a value from an input port. The string becomes the port label on the node. Each unique port name creates one input port, up to 8 total.

float pitch = in("Pitch");       // MIDI note number
float gate = in("Gate");         // 0 or 1
float velocity = in("Velocity"); // 0 to 1
float cutoff = in("Cutoff");     // custom modulation input

If nothing is connected to a port, it reads the port's default value (typically 0).

Use out("name", value) to write a value to an output port. The string becomes the port label. Each unique port name creates one output port, up to 8 total. This is a statement, not an expression — it must end with a semicolon and cannot be used inside an expression.

out("Left", sample);             // stereo audio left
out("Right", sample);            // stereo audio right
out("Trigger", trigger);         // CV trigger pulse
out("Envelope", envValue);       // modulation output

All outputs are clamped to ±10 and multiplied by the node's Volume knob before reaching the connected cable.

+ add, - subtract, * multiply, / divide, % modulo. Division by zero returns 0 (no crashes in the audio thread).

== equal, != not equal, < less than, > greater than, <= less or equal, >= greater or equal. All return 1.0 (true) or 0.0 (false).

&& AND, || OR, ! NOT. Values above 0.5 are considered true.

& AND, | OR, ^ XOR, ~ NOT, << shift left, >> shift right. Operands are truncated to int before the operation.

= assign, += add-assign, -= subtract-assign, *= multiply-assign, /= divide-assign.

phase += freq * dt;    // equivalent to: phase = phase + freq * dt;

condition ? valueIfTrue : valueIfFalse

float vol = gate > 0.5 ? 1.0 : 0.0;

(float)x, (int)x, (bool)x. Float-to-int truncates. Bool clamps to 0 or 1.

int index = (int)phase;          // truncate to integer
float normalized = (float)count; // int to float

Standard if/else with braces required. Supports else if chaining.

if (gate > 0.5) {
    env += (1.0 - env) * dt * 10.0;
} else {
    env -= env * dt * 5.0;
}

if (mode == 0) {
    // sine
} else if (mode == 1) {
    // saw
} else {
    // pulse
}

Use for iterating over buffers or running fixed-count operations. A safety limit of 4096 iterations per sample prevents infinite loops from locking the audio thread. If your loop exceeds this, execution silently stops for that sample.

int i = 0;
while (i < 64) {
    delayLine[i] = delayLine[i] * 0.99;
    i += 1;
}

Performance note: every instruction inside a while loop runs 48,000 times per second per iteration. A loop over 1024 samples means ~49 million operations per second for that loop alone. Keep loop bodies lean.

sin(x) cos(x) tan(x) atan2(y, x)

Arguments are in radians. For a full cycle sine oscillator: sin(phase * 6.283185) where phase goes 0→1.

abs(x) absolute value, floor(x) round down, ceil(x) round up, round(x) round to nearest.

min(a, b) max(a, b) clamp(x, lo, hi)

float safe = clamp(value, -1.0, 1.0);   // prevent clipping
float louder = max(left, right);         // peak of stereo pair

pow(x, y) x raised to power y, sqrt(x) square root (clamped to ≥0), log(x) natural logarithm (returns −100 for ≤0), exp(x) e^x (clamped to prevent overflow).

lerp(a, b, t) — linear interpolation from a to b. When t=0 returns a, t=1 returns b. Essential for crossfading, parameter smoothing, and mixing.

smoothstep(lo, hi, x) — smooth Hermite interpolation. Returns 0 when x≤lo, 1 when x≥hi, and a smooth S-curve between. Useful for soft thresholds and transitions.

mtof(note) — MIDI note number to frequency in Hz. Middle C (note 60) = 261.6 Hz. A4 (note 69) = 440 Hz. Supports fractional notes for microtuning.

ftom(freq) — frequency in Hz to MIDI note number. The inverse of mtof.

tanh(x) — hyperbolic tangent. The workhorse of soft clipping and saturation. Gently compresses values toward ±1. Drive into it for warm distortion: tanh(signal * 3.0).

wrap(x, lo, hi) — wraps value into range (like modulo, but works cleanly with floats). Essential for oscillator phases: wrap(phase, 0.0, 1.0).

fold(x, lo, hi) — folds value at boundaries (bounces back instead of wrapping). Creates triangle-like shapes from ramp signals and interesting waveshaping effects.

rand() — white noise sample, uniformly distributed from −1 to +1. Returns a new random value every sample.

rand_range(a, b) — random float uniformly distributed between a and b. Useful for randomized timing, pitch variation, and generative patterns.

These variables are injected by the runtime before each sample executes. They cannot be assigned to.

dt — time per sample in seconds (1/sampleRate). At 48kHz, dt ≈ 0.0000208. This is the fundamental unit of time in Glyph. Multiply frequency by dt to get phase increment: phase += freq * dt;

sr — sample rate in Hz (typically 48000). Use for calculating buffer sizes or converting between seconds and samples.

beat — current beat position from the transport clock.

bpm — current tempo in beats per minute.

note — last received MIDI note number (0–127). Persists until the next note-on.

velocity — last received MIDI velocity (0–1). Persists until the next note-on.

Buffers are fixed-size float arrays. Declare with a size in brackets:

buffer[4096] delay;        // 4096 samples ≈ 85ms at 48kHz
buffer[48000] longDelay;   // 1 second at 48kHz

Buffer contents are preserved across variable resets (note-on, recompile). This means delay lines keep their audio data between notes. Use length(buf) to get the buffer size.

Use array syntax to read and write:

// Write to buffer
delay[writePos] = inputSample;

// Read from buffer
float delayed = delay[readPos];

// Index wrapping is automatic — negative indices and
// indices beyond the buffer size wrap around.
// delay[-1] reads the last element.
// delay[length(delay) + 5] wraps to index 5.

buffer[24000] delay;  // 500ms delay at 48kHz
float input = in("Audio");
float feedback = in("Feedback");
float time = in("Time");

// Calculate delay in samples
int delaySamples = (int)(time * sr);

// Read delayed signal (auto-wrapping)
float delayed = delay[writeIdx - delaySamples];

// Write input + feedback
delay[writeIdx] = input + delayed * feedback;
writeIdx += 1;
if (writeIdx >= length(delay)) {
    writeIdx = 0;
}

out("Left", input + delayed * 0.5);
out("Right", input + delayed * 0.5);

The simplest possible instrument. Wire Gate and Pitch from MIDI In.

float pitch = in("Pitch");
float gate = in("Gate");

float freq = mtof(pitch);
phase += freq * dt;
if (phase >= 1.0) {
    phase -= 1.0;
}

float sample = sin(phase * 6.283185) * gate;
out("Left", sample);
out("Right", sample);

Raw saw wave with a simple attack/release envelope and velocity sensitivity.

float pitch = in("Pitch");
float gate = in("Gate");
float vel = in("Velocity");

float freq = mtof(pitch);
phase += freq * dt;
if (phase >= 1.0) {
    phase -= 1.0;
}
float saw = phase * 2.0 - 1.0;

// Smooth envelope
if (gate > 0.5) {
    env += (1.0 - env) * dt * 20.0;
} else {
    env -= env * dt * 5.0;
}
if (env < 0.0001) { env = 0.0; }

float sample = saw * env * vel;
out("Left", sample);
out("Right", sample);

Pass audio through and apply adjustable distortion. Tanh gives warm saturation.

float inputL = in("Left");
float inputR = in("Right");
float drive = in("Drive");

// Default drive if nothing connected
if (drive < 0.01) { drive = 1.0; }

// Scale drive: 1 = clean, 10 = heavy distortion
float scale = 1.0 + drive * 9.0;

out("Left", tanh(inputL * scale));
out("Right", tanh(inputR * scale));

Passes gate signals through with a random probability. Wire between MIDI In and a synth for stochastic rhythms. Outputs a trigger on accepted gates.

float gateIn = in("Gate");
float pitchIn = in("Pitch");
float prob = in("Probability");

if (prob < 0.01) { prob = 0.5; }

// Detect rising edge
float trigger = 0.0;
if (gateIn > 0.5 && prevGate < 0.5) {
    // Roll the dice
    if (rand_range(0.0, 1.0) < prob) {
        active = 1.0;
        trigger = 1.0;
    } else {
        active = 0.0;
    }
}
if (gateIn < 0.5) {
    active = 0.0;
}
prevGate = gateIn;

out("Gate", gateIn * active);
out("Pitch", pitchIn);
out("Trigger", trigger);

[script] Raindrops — self-generating ambient texture. Random pitched drops from a pentatonic scale with fast exponential decay, random stereo pan, and variable density. No input needed — creates sound on its own. Outputs stereo audio plus CV trigger and envelope signals for driving other modules.

[script] Soft Pad — warm detuned stereo pad from three sine oscillators with ±0.3% detune and smooth attack/release envelope. Wire Gate, Pitch, Velocity from MIDI In.

[script] Acid Bass — squelchy 303-style monosynth. Saw oscillator through a resonant one-pole filter with envelope-driven cutoff sweep. External Cutoff and Resonance inputs for modulation.

[script] Bit Crusher — lo-fi audio effect. Stereo pass-through with adjustable bit depth reduction and sample rate decimation. Inputs for Bits (1–16) and Rate.

[script] Ring Mod — ring modulator effect. Multiplies stereo input by a sine carrier oscillator. Adjustable carrier frequency and dry/wet mix.

Glyph supports single-line comments (// comment) and multi-line comments (/* comment */). Preset scripts are heavily commented — read them to learn patterns for oscillators, envelopes, filters, effects, and generative algorithms.

Add a GlyphVis Script node via right-click → Generator in the Visual Graph Editor. Double-click the node (or right-click → ◆ Edit Script) to open the shader editor. Write your visual code, press Ctrl+Enter to compile. The script is transpiled from Glyph syntax to GLSL and compiled as a GPU fragment shader. It renders at full frame rate into the visual graph's texture pipeline.

GlyphVis nodes have a texture input (for compositing with upstream nodes), a texture output (for downstream effects), and two float inputs (Audio and CV) for receiving signals from the audio engine. Script presets are available via right-click → ◆ Script Presets.

Every GlyphVis script has three pre-declared variables: uv (vec2, pixel coordinates 0→1), color (vec3, output RGB), and alpha (float, output opacity). The shader wraps your code inside void main() and assembles the final output as fragColor = vec4(color, alpha). You just write the math that fills color.

GlyphVis scripts compile to native GLSL and run on the GPU at full speed — there is no interpreter overhead. The transpiler adds helper functions (noise, fbm, hsv2rgb, etc.) to the shader header automatically. Disconnected GlyphVis nodes are automatically skipped during rendering — only nodes in the dependency chain leading to the Screen node are processed.

GlyphVis uses native GLSL types directly — no translation needed: float, int, bool, vec2, vec3, vec4. Swizzling works natively: color.rg, p.xy, v.xyzw. Constructor functions work: vec2(0.5, 0.3), vec3(1.0).

Same strict syntax as audio Glyph — semicolons required, braces for blocks. Comments use // single-line and /* */ multi-line.

All GLSL operators work natively: arithmetic (+ - * / %), comparison (== != < > <= >=), logical (&& || !), ternary (? :). GLSL vector operations work on component types: vec3(1,0,0) * 0.5, p * scale, color += vec3(0.1).

GlyphVis transpiles your code to GLSL and injects helper functions into the shader header. If you use any of these names as variable names, the shader will silently fail to compile (black screen, no error in the script editor). Avoid these as variable names:

GLSL ES reserved words: active, attribute, buffer, centroid, coherent, common, filter, flat, image, input, output, partition, patch, precise, resource, restrict, sample, shared, smooth, subroutine, varying, volatile — and many others. If your shader is black, a reserved variable name is the first thing to check.

GlyphVis helper functions (injected by the transpiler — don't shadow these with variables): audio, bass, mids, treble, audio_in, cv_in, noise, fbm, rand, hsv2rgb, rgb2hsv.

Pre-declared in main(): uv, color, alpha — these are already declared. Don't redeclare them with float or vec3.

Safe practice: Use descriptive variable names like cellActive instead of active, audioLevel instead of audio, noiseVal instead of noise.

Every GlyphVis shader has access to the audio analyzer's output:

bass() — low frequency energy (kick drums, sub bass). Returns a small float — multiply by 20–50 for visible effect.
mids() — midrange energy (vocals, synths, melody).
treble() — high frequency energy (hi-hats, cymbals, sibilance).
audio(index) — raw 256-bin FFT spectrum. Index 0 = deepest bass, 255 = highest treble.

// Make a circle pulse with the kick drum
float kick = bass() * 30.0;
float d = length(uv - 0.5);
float ring = smoothstep(0.3 + kick * 0.05, 0.28 + kick * 0.05, d);
color = vec3(ring);

GlyphVis nodes have two float input ports: Audio and CV. Wire source nodes (Audio Bus, CV Bus, Blocks In) to these ports, then read them in the script:

audio_in() — reads the Audio float input port.
cv_in() — reads the CV float input port.

// Wire an Audio Bus (bus 0 = bass) to the Audio port
float kick = audio_in() * 30.0;

// Wire a CV Bus (LFO) to the CV port
float lfo = cv_in() * 5.0;

// Use both to drive visuals
color = hsv2rgb(vec3(lfo * 0.1 + time, 0.8, kick));

A dedicated 64-channel bridge bus connects the Blocks audio patching system directly to the Visual Graph. Any signal in a Blocks patch — an oscillator's output, an envelope's shape, an LFO's value, a Glyph script's custom modulation — can be sent to the visual system.

The bus is thread-safe: the audio thread writes per-sample values at 48kHz, the render thread reads smoothed per-frame values at 60fps. One-pole smoothing prevents jitter.

In the Blocks editor, add a Visual Send node (Utility category). Wire any signal to its input and set the bus number (0–63). The signal passes through to the output so Visual Send can be inserted mid-chain without breaking the audio path.

Blocks patch:
  Oscillator → Filter → Visual Send (Bus 0) → Audio Out
                                ↓
                    (Bus 0 carries the filtered signal
                     to the visual system)

In the Visual Graph, add a Blocks In node (Source category). Set it to the same bus number. Wire its float output to a GlyphVis node's Audio or CV input. The signal from your Blocks patch is now driving your GPU shader.

Visual Graph:
  Blocks In (Bus 0) → GlyphVis "Audio" input
                              ↓
                    audio_in() in the shader reads
                    the filtered oscillator signal

Send an envelope follower on bus 0 to make visuals pulse with the kick. Send an LFO on bus 1 to smoothly rotate a kaleidoscope effect. Send a step sequencer output on bus 2 to drive color changes per beat. Send the raw oscillator output on bus 3 to visualize the actual waveform. With 64 buses, you can make the interaction between audio and visuals as intricate as the music itself.

All standard GLSL functions work natively — no transpilation needed: sin, cos, tan, asin, acos, atan, abs, floor, ceil, round, fract, mod, min, max, clamp, mix, step, smoothstep, pow, sqrt, log, exp, length, distance, dot, cross, normalize, reflect, refract, sign, radians, degrees.

The transpiler automatically includes these helper functions in every shader:

noise(vec2 p) — 2D value noise. Returns 0–1. Use for organic textures.
fbm(vec2 p) — fractal Brownian motion (5 octaves of noise). Richer, more detailed noise.
hsv2rgb(vec3 c) — convert HSV (hue 0–1, saturation 0–1, value 0–1) to RGB. Essential for colorful procedural visuals.
rgb2hsv(vec3 c) — convert RGB back to HSV for color manipulation.
rand(vec2 co) — pseudo-random hash from 2D coordinates. Deterministic per pixel.
audio(int index) — raw FFT bin (0–255).
bass(), mids(), treble() — frequency band energy.
audio_in(), cv_in() — float input port values.

Use param("Name", min, max, default) to create inline sliders on the GlyphVis node. The function returns the current slider value. Each unique param name creates one slider.

float speed = param("Speed", 0.1, 5.0, 1.0);
float glow = param("Glow", 0.0, 2.0, 0.8);
float count = param("Ring Count", 2.0, 20.0, 8.0);

Params compile to GLSL uniforms and are set per-frame. They persist with the project. Slider values are preserved across recompiles if the param name matches.

Feeds video frames into the visual graph as a texture. Receives frames from the video track or a loaded video file.

Reads audio analysis data and outputs it as a float. Bus 0 = bass, 1 = mids, 2 = highs, 3 = RMS (overall loudness), 4–63 = raw spectrum bins. Params: Bus (0–63), Gain (0.1–50), Smooth (0.01–1.0).

Reads a CV bus value from the audio engine's CV system (LFOs, envelopes, sequencers). The per-sample CV values are averaged to a single per-frame float. Params: Bus (0–63), Gain (0.1–10), Offset (−1 to +1), Smooth (0.01–1.0).

Reads from the Blocks→Visual bridge bus. Receives signals sent by Visual Send nodes in Blocks patches. 64 independent channels. Params: Bus (0–63), Gain (0.1–50).

One texture input, 8 texture outputs (all identical). Fan out a single visual source to multiple downstream nodes.

8 texture inputs + Select float input → 1 texture output. CV selects which input passes through. Crossfade or hard-cut mode. 0.0 = Input 1, 1.0 = Input 8.

Low-frequency oscillator. Outputs a cycling float value. Waveforms: Sine, Triangle, Saw, Square, Sample & Hold. Beat sync toggle uses the transport BPM (rate becomes beats-per-cycle). Params: Rate (0.01–20), Amplitude (0–1), Offset (−1 to +1), Wave (0–4), Sync (Free/Beat).

Random float output with smoothing. Three modes: White (stepped random at speed rate), Smooth (interpolated random walk), Drift (multi-frequency sinusoidal wander for organic slow movement). Params: Speed (0.01–50), Smooth (0–0.999), Amplitude (0–1), Offset (−1 to +1), Mode (White/Smooth/Drift).

// Simplest possible GlyphVis script
color = vec3(uv.x, uv.y, 0.5);
alpha = 1.0;

float radius = param("Radius", 0.1, 0.5, 0.3);
vec2 center = vec2(0.5 + sin(time) * 0.2, 0.5 + cos(time * 0.7) * 0.2);
float d = distance(uv, center);
float circle = smoothstep(radius, radius - 0.01, d);
color = hsv2rgb(vec3(time * 0.1, 0.8, circle));
alpha = 1.0;

// Vertical bars driven by the FFT spectrum
float barCount = param("Bars", 8.0, 64.0, 32.0);
float barIdx = floor(uv.x * barCount);
int specIdx = int(barIdx * 256.0 / barCount);
float amp = audio(specIdx) * 30.0;

float barHeight = clamp(amp, 0.0, 1.0);
float bar = step(1.0 - barHeight, uv.y);
float hue = barIdx / barCount;
color = hsv2rgb(vec3(hue + time * 0.05, 0.8, bar * 0.9));
alpha = 1.0;

// Sample the upstream texture and apply a color effect
// Wire another node's output to this node's texture input
float amount = param("Warp", 0.0, 0.1, 0.02);
vec2 warpedUV = uv + vec2(noise(uv * 5.0 + time), noise(uv * 5.0 + time + 100.0)) * amount;
vec3 source = tex(0, warpedUV).rgb;
color = mix(source, source.gbr, 0.3);  // subtle color shift
alpha = 1.0;

// Wire a Blocks In node (reading an envelope on bus 0) to Audio input
float envelope = audio_in() * 20.0;

vec2 p = uv - 0.5;
float d = length(p);
float glow = exp(-d * (3.0 + envelope * 2.0));
color = hsv2rgb(vec3(time * 0.1, 0.6, glow * (0.5 + envelope)));
alpha = 1.0;

[script] Confetti — procedural falling rectangular particles with per-particle hue, flutter rotation, and size variation. Params: Density, Speed, Flutter, Size.

[script] Audio Rings — concentric rings where each ring maps to a frequency band. Inner rings = bass, outer = treble. Audio drives radius wobble and brightness. Params: Reactivity (1–100), Rings, Thickness, Hue Shift.

[script] Neon Grid — retro synthwave perspective grid scrolling toward camera. Magenta grid lines, cyan audio-reactive horizon glow. The iconic Phonon visual. Params: Scroll speed, Glow, Line Width.

[script] Liquid Warp — organic flowing color field from layered fbm noise cross-modulating itself. Params: Complexity, Speed, Saturation, Contrast.

[script] Star Field — parallax star layers with twinkle and depth. Multiple scroll speeds create the illusion of flying through space. Params: Speed, Density, Brightness, Layers.

[script] Pulse Tunnel — demonstrates the audio_in() and cv_in() bridge. The LFO (via CV port) physically rotates the tunnel and morphs it between circular and polygonal. Bass (via Audio port) drives ring intensity. Includes full setup instructions in the code comments. Params: Depth, Color Speed, Audio Scale, CV Amount.

uv — pixel coordinates, 0→1 in both axes.
time — elapsed time in seconds (maps to uTime uniform).
beat — current beat position from the transport.
bpm — current tempo.
resolution — viewport size in pixels (vec2). Use for aspect correction: vec2 p = (uv - 0.5) * vec2(resolution.x / resolution.y, 1.0).
mouse — mouse position (vec2, 0–1).

A GlyphSDF script must define exactly one entry point:

float sdf(vec3 p)

p is a point in the shape's local space. The return value is the signed distance from p to your surface: negative inside, positive outside, zero on the surface. Helper functions, global variables, and const globals are all allowed.

That's the whole interface. Everything else — marching the rays, shading, spinning, zooming, compositing — is supplied by the node.

The audio texture is 512×2, single channel (.r):

Spectrum row: texture(uAudioTex, vec2(bin, 0.25)).r — bin in 0–1 runs from bass (0) to treble (1). Values are FFT magnitudes; multiply up and clamp for visible effect.
Waveform row: texture(uAudioTex, vec2(phase, 0.75)).r — the raw time-domain window.

The Spectral Urchin preset shows the idiomatic pattern: derive bin from a direction or position, so different parts of the shape ride different frequencies.

Declare helpers and globals in the ordinary way:

float wob(vec3 p) { ... }          // helper function ✓
const float TAU = 6.28318;         // const global ✓
vec3 gOffset = vec3(0.0);          // mutable global ✓ (persists per-pixel only)

Stick to float, int, bool, vec2/3/4, and mat2/3/4 for top-level declarations. Global arrays, structs, and #define macros are not namespaced when the shape is composed into a shared shader — they work in a lone node but can collide if two scripts using the same names meet inside one Blend. If you need them, give them names unlikely to collide.

length(p) - r                                          // sphere
length(max(abs(p) - b, 0.0))                           // box (b = half-extents)
length(vec2(length(p.xz) - R, p.y)) - r                // torus
(abs(p.x) + abs(p.y) + abs(p.z) - s) * 0.57735         // octahedron
p.y - h                                                // floor plane
length(p - clamp(p, a, b)) - r                         // capsule from a to b

min(a, b)          // union
max(a, b)          // intersection
max(a, -b)         // subtraction: carve b out of a
abs(d) - t         // onion: turn a solid into a shell of thickness t
d - r              // rounding: inflate with soft corners

Smooth union (the "weld" — the single most useful operator in the language):

float weld(float a, float b, float k) {
    float h = clamp(0.5 + 0.5 * (b - a) / k, 0.0, 1.0);
    return mix(b, a, h) - k * h * (1.0 - h);
}

k is the gooeyness. See the Metaball Trio preset.

p = abs(p);                                  // mirror symmetry across all axes
q = mod(p.xz + s * 0.5, s) - s * 0.5;        // infinite repetition, cell size s
vec2 cell = floor((p.xz + s * 0.5) / s);     // which cell (hash it for variety)
p.xz = mat2(c, -s, s, c) * p.xz;             // rotate around Y

Per-cell hash for varying repeated elements:

float h = fract(sin(dot(cell, vec2(127.1, 311.7))) * 43758.5453);

See Endless Columns for repetition + hashing, Nested Shells for onioning and cutaways.

At composition time, every top-level function and global your script declares is renamed into a slot namespace via #define/#undef pairs. Two GlyphSDF nodes can both define weld and ball and meet in one Blend without conflict. This is why the reserved-name and top-level-declaration rules exist: the renamer recognizes ordinary function and scalar/vector/matrix declarations, and leaves exotic ones alone.