◆ Phonon
Digital Instrument Environment
Phonon is a modular digital instrument environment for composing, performing, and experimenting with sound and vision. It combines a hierarchical module system, a chord-aware harmonic engine, a timeline-based arrangement view with full parameter automation, audio track support, hardware-accelerated video playback with real-time shader effects, performance zones with a dedicated DJ mode for live audiovisual sets, and a library of over 390 synthesizers, drum machines, samplers, effects, and generative tools — all running through a signal path modeled after vintage analog mixing hardware.
Phonon's arrangement, mixing, and recording workflows are substantially those of a modern DAW — timeline, tracks, regions, MIDI and audio capture, a full signal-path mixer, parameter automation. What makes it different is what sits on top: any CV can be routed to any knob on any module. Crayon turns the whole arrangement into a drawing surface, where a line becomes notes in key, a beat, or an effect shaped by hand. Audio or CV signals can drive a real-time visual engine that layers HD video with GPU shader effects. A DJ-inspired performance mode lets you play the whole environment — music and visuals together — as a live instrument, moving nonlinearly between musical and visual states. As far as we know, no other software combines all of this in one place.
Phonon rewards exploration. Its arrangement, mixing, and recording workflows will feel familiar to any DAW user, while the harmonic engine, CV routing, visual engine, and DJ mode open up territory no other tool reaches. It is genuinely powerful, and it does things nothing else can.
01 Getting Started
When Phonon launches, you'll see a splash screen with six options:
★ Tutorial: Opens an empty project and starts the built-in tutorial, which walks you through making a track a step at a time. See Tutorial.
✦ Starter Patch: Opens a four-track project: a kit (Analog Kick II, Hi-Hat Synth and two snares, glued together with Magic Glue), a pad (Nimbus feeding the Namib wave terrain synth, ducking out of the kick's way), a Roundwound Bass, and a piano part (Pianist playing the Felt Grand). Hit play and hear music immediately. It is an ordinary project — open it, change it, and save it somewhere of your own.
📄 New Project: Opens an empty project.
📂 Open Project: Load an existing .phonon file.
🔀 DJ Mode: Go straight into DJ Performance Mode.
✕ Exit: Close Phonon.
Links to documentation, a getting-started video, and the Discord community are at the bottom of the splash screen.
After the splash screen, you'll see the main window divided into two areas: the hierarchy tree on the left and the arrangement view filling the rest. The hierarchy shows every module in your project as a tree. The arrangement shows a timeline where you place regions to control when tracks play.
The hierarchy starts with three permanent sections:
🎹 Harmonic Engine — chord progressions
♪ Melodic Engine — the phrase library the generators draw from
📁 Control — CV sequencers, LFOs
────────────────────
📁 Master — your tracks and modules
└ 📁 Pluck
├ ♫ Harmonic Follower — arp up, octave 3
├ ✦ Preset Machine — Metallic Pluck preset
└ 🔉 Gain
└ 📁 Pad
├ ♫ Harmonic Follower — chord sustained
├ ◫ Oh Bee Osc — dual "SAM" style oscillators
├ ◈ SAM Filter — low cutoff, warm resonance
└ 🔉 Gain
└ 📁 Drums
├ 🏠 FOTF Generator — deep house
├ ◉ Analog Kick II
├ 🎩 Hi-Hat Synth
├ 🪘 CombiSnare
└ 🔉 Gain
────────────────────
🎛 Tuber Console ON
└ ▣ Freebaby — bus compressor
Tutorial
The tutorial walks you through building a track from an empty project, one step at a time. Each step is a short instruction with a recording of the action beside it, so if the words leave any doubt you can watch the gesture instead. Click the picture, or the ⤢ button above it, to see it at full size.
Open it from ★ Tutorial on the splash screen, from the ❖ Tutorial button at the bottom of the hierarchy pane, or from the Command Palette (Ctrl+T).
It runs beside the app rather than over it, and it does not wait for you — read a step, do it in your own time, then press NEXT. Arrow keys move between steps too. Close it whenever you want the screen back; it reopens on the step you were on.
To make sound: right-click Master → Add Track, then right-click the new track → Add Module and choose a synthesizer. The track automatically includes a Gain module at the end for volume and pan control. Press Space to play.
Save your project (Ctrl+S) before importing audio files or
loading samples. Saving creates the project directory, and audio you import afterward is copied
into the project's /samples/ folder — keeping the project self-contained and portable.
If you import before the first save, those files are referenced from their original locations and
can go missing when the project moves.
02 Core Concepts
Module Chains
Modules within a track are processed in series — audio flows from top to bottom. A typical chain: Generator → Synthesizer → Effect → Effect → Gain. The generator produces notes (an arpeggiator, harmonic follower, or sequencer), the synthesizer (or drum machine or sample player) turns them into sound, effects modify it (reverb, filter, delay), and the Gain module controls final volume and pan.
Tracks
Tracks live under Master and are summed together for the final output. Each track is an independent signal chain. Tracks can be muted, soloed, and routed to audio buses. New modules are automatically inserted before the trailing Gain module.
Harmonic Awareness
Phonon's distinguishing feature is its harmonic engine. The Harmonic Engine defines chord progressions organized into banks, sections, and forms. Harmonic Follower modules placed in tracks read the current chord and generate MIDI notes accordingly — arpeggios, pads, bass lines, melodies — all harmonically coherent without manual note programming.
Control Rack
The Control section at the top of the hierarchy holds modulation sources — LFOs, envelope loopers, CV sequencers, and utility modules — that live outside any track. They write to the project's CV buses, and any knob or slider on any module can read from a bus to be modulated. This is how one LFO can sweep a filter, pulse a gain, and animate a visual all at once. See CV Bus System.
Visual Graph
Alongside the audio engine, Phonon runs a real-time visual node graph: a patchable chain of generator and effect nodes that renders audio-reactive visuals and layers them over hardware-accelerated video with GPU shader effects. Audio bands, CV buses, and Blocks signals can all drive the visuals, so the picture moves with the music. See Visuals & Video.
DJ Mode
DJ Performance Mode turns whole Phonon projects into a live instrument. Two decks — each a complete project with its own tracks, effects, video, and visuals — play side by side with a crossfader, per-deck EQ and effects, vinyl scratching, and beat-synced performance zones for jumping around a song. See DJ Performance Mode. (DJ mode is currently in beta — see the note in that section.)
03 Interface
Hierarchy Tree
Module tips. Some entries in the Add Module menu carry a short tip beside the name — usually what to pair the module with, e.g. "try layering it with a Session Snare". It is separate from the module's description, and a module with nothing useful to add gets none.
Search. The box above the tree filters tracks and modules by name as you type. Matches force their branch open and highlight, so a module buried inside a collapsed track still surfaces. Escape clears the filter.
The left panel shows the module hierarchy as a tree. Right-click nodes to access context menus, or use the … button on a track's row for the same menu. Double-click any module to open its dedicated editor window. Drag nodes to reorder them within their parent.
Master: Add Track, Add Audio Bus
Track: Add Module, Add Generator, Send to Bus, Mute, Solo, Rename, Delete
Module: Mute, Rename, Delete
Control: Add Control Module (CV/utility only)
Tuber Console: Add Bus Effect (dynamics, filters, reverb, modulation, stereo, distortion, utility), Open Mixer
Structure / Harmonic Engine / Song Structure: No context menu (permanent fixtures)
A module claimed by a Drum Rack pad — or by any module that manages its own children — is folded out of the hierarchy tree; the rack presents it in its own panel instead. It is hidden, never silenced: it keeps processing, automating and taking CV, and its editor window still opens.
Once anything in the project is managing children, a ▦ MANAGED toggle appears in the hierarchy panel to show or hide them in the tree.
Strategies
◇ Strategies at the bottom of the hierarchy pane draws a card from a deck of 106 creative prompts — one line each, to read when you are stuck. "Mute the loudest thing. Don't replace it." "Start the loop somewhere other than the downbeat."
The deck is dealt rather than rolled: it shuffles, deals to the end, then reshuffles, so you will see every card before you see any of them twice. Draw another whenever you like. The window is small and stays on top, so you can leave it open beside the arrangement and work with the card in view.
Arrangement View
The right side of the main window is the arrangement timeline. From top to bottom:
Ruler — bar numbers along the top, with the chord the Harmonic Engine will play written under each one — root and quality both, so a half-diminished or a quartal voicing reads as itself rather than as its root. A name appears only where the chord changes, so what you see is where the harmony moves.
LOOP — thin lane at the top. Drag to create a loop region.
SONG — global song structure lane. Place colored section markers (Verse, Chorus, Bridge, etc.) with optional tempo and time signature overrides.
Track lanes — one per track under Master. Module/MIDI tracks play continuously by default — regions control MIDI note output and variation, not track silence (right-click a region and turn off Auto MIDI Flow Outside Regions to make that track's generators obey its regions instead). To silence a track over a span, automate the Gain module's Mute parameter (see Automation Lanes). Audio tracks play where regions contain samples; effects always process.
Automation sub-lanes — thin lanes below any track that has automation. Show the automation curve, editable points, and a mode label ([R] Read, [T] Touch, [—] Off). See Automation Lanes.
Audio track lanes — tracks with WAV regions display waveforms directly in the lane. Drag-and-drop WAV files onto the arrangement to create audio tracks. See Audio Tracks.
🎛 TUBER — gold-tinted lane at the bottom. Place regions here to trigger bus effects.
A 140px column on the left of the arrangement shows track headers (visible by default, toggle with H). Each header contains:
Track type icon: Geometric shapes identify track types at a glance — ● red circle (audio track), ■ blue square (MIDI/normal track), ▲ green triangle (bus), ✕ orange X (Tuber console).
Track name: Truncated to fit the header width.
M / S / A buttons: Mute, Solo and Audition. Mute glows red, Solo gold, and changes are reflected in both the header and the hierarchy tree. A is audition: on an audio track it passes the live input through so you can hear what you are about to record; on a MIDI or instrument track it arms Live MIDI so the track's instrument plays from your keyboard.
Selection checkbox: Beside the A button, and mirrored with the hierarchy's selection. Unlike clicking in the hierarchy it lets you tick several tracks at once, which is what RECORD TO SELECTED records.
AUTOMATION button: Shows or hides that track's automation lanes, with the lane count on it. See Automation Lanes.
Hovering any of these shows what it does.
Gain slider: A handle-less horizontal bar in the widened header (see below). Click and drag to adjust the track's gain in real time. Its value appears only under the pointer, which keeps the header uncluttered. For normal tracks the slider controls the track's Gain module (linear, unity at centre); for the Tuber console it controls the master fader. The slider displays the gain in dB, turns orange above unity, and stays in bidirectional sync with the Mixer tab in the drawer — changes in either place update the other.
Level meter: Thin horizontal bar at the bottom of each header showing the track's peak output level. Green → yellow → red color coding. Peak levels are computed per track, with a smooth decay.
When headers are hidden (H), the arrangement shifts left and floating track labels appear instead. Headers expand vertically with the Z zoom toggle.
Widening the header. Drag the header column's right edge — a blue grab stripe appears as you approach it — to reveal a second column of controls: the gain fader, REC, BUS, COLOR, COUNT (count-in length), and on audio tracks INPUT (which input channel this track records from). Whether headers are shown, how wide they are, and whether tracks are expanded are all saved with the project.
Selecting one or more regions opens the Inspector Panel — a 240px sidebar on the right showing editable properties for the selected region(s). The sidebar auto-hides when nothing is selected.
MIDI region controls: Mute (three-state for mixed selections), Transpose (±24 semitones), Velocity Mod (−100% to +100%), and Quantize grid (Off, 1/4, 1/8, 1/8 triplet, 1/8 dotted, 1/16, 1/16 triplet, 1/32). All transforms are non-destructive — the piano roll always shows the original notes, and the transforms are applied at playback time.
Audio region controls: Mute, Loop toggle, Reverse toggle, a read-only Time Stretch ratio (shown as e.g. 1.25×, or "various" across a mixed selection), a Remove Retiming button, and Quantize grid. The stretch method is chosen automatically.
Mixed selection: When both MIDI and audio regions are selected, only Mute is shown (applies to both types).
All sidebar changes are undoable and refresh the arrangement display in real time.
Click a region to select it. Shift+click to add/remove from multi-selection. Ctrl+A selects all regions across all tracks. Escape clears the selection. Selected regions show a blue highlight border.
Ctrl+C copies all selected regions (MIDI and audio) to the clipboard, preserving lane relationships. Ctrl+V pastes at the playhead position with deep-copied data (independent from the source). Delete / Backspace removes all selected regions.
All clipboard operations use compound undo — paste and delete of multiple regions undo as a single action.
Track color: Right-click a track in the hierarchy → 🎨 Track Color. 12 preset colors (Red, Orange, Gold, Green, Teal, Blue, Purple, Pink, Slate, Brown, Mint) or None. Tints the track lane background in the arrangement and adds a colored dot (●) in the hierarchy tree next to the track name.
Region color (track default): Right-click a track → 🎨 Region Color. Sets the default color for all regions on that track (MIDI and audio), in place of the standard fill.
Region color (per-region): Right-click any individual region → 🎨 Color. Overrides the track default for that specific region. Color priority: per-region override → track region color → global default.
All colors serialize with the project.
Follow playhead: When enabled (Settings → "Follow playhead during playback"), the arrangement view automatically scrolls to keep the playhead visible during playback. Scrolling manually during playback breaks the follow — pressing play again resets it. On by default.
Auto-extend: The arrangement canvas automatically grows as you add or extend regions. There is always at least 16 bars of empty space beyond your furthest content. Audio regions are included in the length calculation.
Crayon
The CRAYON button, right of DO, turns the arrangement into a drawing surface. Track lanes grow to twice their height, your regions dim to a backdrop, and what you draw on a track plays on that track.
While it is on, the region tools give way to a MODE dropdown, three nib sizes and an eraser. There are nine modes — Melodic, Bassline, Beats, Resample, Pitch Shift, Phaser, Bit Crush, Reverb and Delay. Each has its own colour and its own layer, and you draw and rub out only the layer you are holding — the other eight stay on screen, ghosted, so you can see what you are drawing against.
The eraser is a toggle beside the nibs rather than a fourth nib, so turning it off puts you back on the size you were using. Rubbing through the middle of a line splits it and leaves the ends.
A line stays on the track it started on. Drag past the edge of a lane and the mark pins to that edge rather than continuing into the neighbour.
Melodic spans three octaves of lead range up the height of the track; Bassline is the same idea in the bass register. Where the playhead passes through your colour, that height sounds — snapped to the Harmonic Engine's chord tones, so the notes land in key, and quantized to the nearest sixteenth.
Both are polyphonic. Every height you have coloured at a given moment triggers together, so a chord is a stack of small nib marks. A monophonic instrument will take the notes it can and drop the rest.
A bigger nib draws a wider band and plays harder, so nib size is both how much you cover and how firmly it sounds.
A line held across several sixteenths is one note held. Where it crosses into the next chord tone, one note ends and another begins — which is what makes a drawn curve come out as a melody.
The height of the track is eleven rows, one per part of the kit, laid out like a drum stave: kick at the floor, then sidestick, snare and clap, the toms ascending, the hats, and the cymbals on top. Draw on a row and that part plays, on the nearest sixteenth.
A held stroke is a roll. Where a pitched crayon holds one note across the sixteenths it covers, Beats hits again on every one of them — so the length of a mark is how long the ratchet runs. A short mark is a single hit however it falls across the grid.
The nibs are the three weights — a ghost note, a normal hit and an accent. All three land on one part, so a heavy hand never spills onto the row next door; the mark is drawn fainter or more solid to show which weight you used.
Beats plays a kit rather than a tune, so it does not answer to the Harmonic Engine. The parts it names are the Drum Rack's, and a track drawn on with Beats needs a kit under it to hear anything.
The rest colour what the track is already playing. Height is the amount, and the effect sits after the track's chain and before its fader. Where you have not drawn, the track passes through untouched.
Resample — keeps a bar of the track, chops it into eighths and replays them from
the height you drew. Above the middle it plays forward, below it plays backward.
Bit Crush — height is how far down, from a clean sixteen bits to a coarse three.
Phaser — height moves the notches up the spectrum, so the sweep is yours to draw
rather than a rate to set.
Reverb — height takes the room from small to large. Tails ring out past the end of
a mark.
Pitch Shift — an octave either way, snapped to the chord tones underneath, so a
drawn slide stays in the harmony. The middle is unison.
Delay — an eighth-note ping-pong; height is the feedback, so the higher you draw
the longer it trails.
Faint guides appear on the track for the crayon in your hand — octave lines for the pitched crayons, named rows for Beats, the eighth-note chops for Resample, the unison line for Pitch Shift.
Marks are kept in beats and in fractions of the track's height, so zooming, resizing lanes, copying a track or reopening the project all leave them exactly where you drew them. Drawing and rubbing out are undoable.
Drawing on a track gives it what it needs to sound — you do not add anything by hand. Turn CRAYON off and the arrangement comes back as it was, with everything you drew still playing.
Transport & Position Display
The top info bar shows the Phonon logo on the left, a centered position panel (BPM controls and beat position), and status text with zoom controls on the right. Transport controls (play/stop/record, metronome, visuals) live in the Preview Drawer button column. The status text is fixed-width (200px, right-aligned) so it doesn't shift the centered display.
BAR — large bold display showing bar.beat.subdivision (e.g., "3.2.1"). Updates on every playhead movement including arrow keys and micro-nudge.
BPM — shows the current tempo to one decimal place. Click to open a modal input dialog with a numeric spinner (0.1 increment, 20–400 range) and a 🥁 Tap Tempo button. Tap repeatedly to detect BPM from your tapping rhythm (averages the last 2–8 tap intervals, resets after 2 seconds of inactivity). The detected BPM fills the input field in real time. Press Enter or click Set to confirm.
CHORD — gold text showing the current chord from the Harmonic Engine (e.g., "Am7"). Shows "—" when no chord is active.
TIME — elapsed time in minutes:seconds.tenths (e.g., "1:23.4"). Correctly accounts for tempo changes throughout the song by walking through all global region tempo overrides.
SIG — the time signature at the playhead, following any overrides placed on the global track.
OUT — master output level, left and right, with a peak-hold tick. It latches CLIP once a peak has clipped and keeps showing it, so a clip that happened while you were looking elsewhere is still there when you look back. Click to reset.
LOAD — how much of its processing budget the audio engine is using. Past 100% it cannot keep up and you will hear dropouts — check this first if the sound starts breaking up.
Mixer
The mixer is the default tab in the bottom drawer. Switch to it with the 🎚 Mixer tab button at the top of the drawer's column, or press 2 from anywhere in the app (the drawer pops open if collapsed). Each track gets a channel strip with: name, bus routing indicator, Mute / Solo buttons, a rotary Pan knob, a vertical volume fader, and stereo level meters flanking the fader. The master strip sits on the right. Meters show green below −6 dB, yellow approaching 0 dB, and red when clipping. The Tuber Console can be switched to Clean mode from the mixer's top bar.
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 uses equal-power cosine/sine panning.
Vertical fader with a custom mixing-desk-style cap handle. The fader is bidirectionally linked to the track's Gain module — 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 console-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”, “−∞”). CV routing, save files and automation lanes all use the underlying linear gain value; the dB display and log curve are for the interface only.
The master fader uses the same dB convention and taper.
Right-click in the global (SONG) track → 🏁 Set End of Song Here to place a red dashed marker line with "🏁 END" label. When the playhead reaches this marker, playback stops on its own — as do stem bounce and recording. A loop brace overrides it, so looping keeps circling past the marker. Right-click again to move or remove it. The marker is serialized with loop zones in the project file.
Preview Drawer
The bottom panel of the main window is the Preview Drawer — a tabbed interface combining audio/video analysis, master processing, and DJ performance controls. A vertical button column on the left provides tab navigation and action buttons.
Page tabs: Info (1), Mixer (2), Audio Analysis (3), Master Audio (4), Video Analysis (5), Master Video (6), Control Rack (7).
Bounce and the metronome are on the BOUNCE and METRO buttons in the top toolbar.
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 default drawer view. With a module window focused it shows that module's name and the description that normally hides in its footer. Hovering a UI surface — a region, a track, the transport, the loop brace — replaces that with an explanation of what the surface does and which modifier keys apply to it.
Knob help: hovering any knob, slider, dropdown or switch on a module panel explains that specific control — what it does to the sound and when you'd reach for it — including the hand-drawn flagship panels. Text is resolved most-specific-first: the module's own entry for that control, then a shared vocabulary of common control names (Cutoff, Resonance, Attack, Drive, Detune and so on), so every control says something useful. Move off the control and the panel reverts to the module's description.
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.
Audio Analysis Tab
Scrolling waterfall with frequency gridlines and Hz labels down the left edge. The vertical axis is a square law, not a true logarithm: the lows get more room than a linear scale would give them but far less than a log one, so everything below about 340 Hz sits in the bottom eighth of the display. Resolution is 43 Hz per bin, which resolves individual partials comfortably above 1 kHz and not at all down in the bass — some of the banding you see on a low note is the analyser, not the sound.
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.
Master Audio Tab
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.
Signal chain: Audio → Master EQ → Stereo Width → Saturation → Master Limiter → Peak Metering → Analyzer.
Video Analysis Tab
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.
Master Video Tab
Full 9-stage GPU colour pipeline, applied in this order: 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.
Rotary Knobs
Every knob in the app is the same knob. Drag vertically to adjust. Double-click to reset to the default value, captured when the module was created. The hand-drawn flagship panels paint their knobs rather than assembling them from standard controls, but they answer the same gestures and carry the same markings.
A knob tells you three things without being touched, and each one has its own colour so you can read them at a glance in a panel full of controls.
| Marking | What it means |
|---|---|
| Gold star in the middle | Start here. The stars mark the handful of controls that most change the sound of this module — turn one and you will hear it. The flagship and component-modeled synths carry them, a few to a panel. |
| Blue arc around the rim | An automation lane is driving this parameter. The arc shows where the lane is taking it right now. See Automation Lanes. |
| Violet ring around the rim | A CV bus is modulating this parameter. The ring shows the modulated value as it moves. See CV Bus System. |
When something else is driving a knob, the pointer stays where you left it and the arc or ring shows where the value is being taken. Your setting stays visible and stays yours, so you can always get back to it.
Both can be present at once: automation moves the setting, and CV sweeps around wherever automation has taken it.
Assigning modulation
Right-click any knob to assign a CV bus, choose the depth, or clear an existing assignment. Or drag a cable from a Control Rack module's OUTPUT jack and drop it on the knob, which assigns the bus with no dialog — see Control Rack.
Not every knob accepts one. A control backed by a fixed value has nothing for CV to sweep, and says so rather than appearing to work.
04 Controls
Keyboard Shortcuts
| Key | Action |
|---|---|
| Space | Play / Pause. Works from any window — module editors, mixer, bank, etc. All child windows automatically forward transport keys to the main window. With a loop active, playback starts at the loop start. |
| Enter | Stop and return playhead to the beginning of the song. Works from any window. Not intercepted when a text field has focus. |
| X | Switch to the Mixer drawer tab (opens drawer if collapsed). Same as pressing 2. |
| Ctrl+S | Save project. Works from any window. First save prompts for location and creates a project directory. |
| Ctrl+O | Open a project file. |
| Ctrl+N | New project (with confirmation dialog). |
| Ctrl+Z | Undo — reverses exactly one operation. Works from any window. See History Panel. |
| Ctrl+Y or Ctrl+Shift+Z | Redo — re-applies the next operation. Works from any window. |
| Ctrl+Shift+S | Save As — writes the project to a new location. |
| Ctrl+H | Show / hide the History Panel on the right edge of the window. |
| Ctrl+Shift+H | Show / hide the Tonnetz on the right edge of the window. Open by default. |
| Ctrl+T | Command Palette — type to search every command in the app. See below. |
| Ctrl+K | Musical Typing — play the computer keyboard as a MIDI keyboard. See below. |
| Ctrl+Shift+B | Arm stem bounce — starts recording per-track stems. |
| Ctrl+P | Enter / exit DJ Performance Mode. |
| 1 | Switch to Info drawer tab (opens drawer if collapsed). |
| 2 | Switch to Mixer drawer tab. |
| 3 | Switch to Audio Analysis drawer tab. |
| 4 | Switch to Master Audio drawer tab. |
| 5 | Switch to Video Analysis drawer tab. |
| 6 | Switch to Master Video drawer tab. |
| 7 | Switch to Control Rack drawer tab. |
| ← | Move playhead by one bar. |
| → | Move playhead by one bar. |
| Escape | Cancel a bank drag, or clear the region selection. It does not leave DJ Performance Mode — use the DJ button or Ctrl+P. |
| Ctrl+← / → | Move playhead by one beat. |
| Ctrl+Shift+← / → | Move playhead by a 16th note. |
| R | Record on the selected track. On an audio track, arms audio recording from the input device. On a MIDI / instrument track, arms MIDI capture and auto-starts playback. Count-in length is set with the COUNT button in the widened track header (0, 1, 2 or 4 bars). Press R again to stop. See MIDI Recording. |
| Shift+< / > | Micro-nudge playhead by 1/128th note. |
| Ctrl+A | Select all regions (MIDI and audio) across all tracks. Selected regions show a blue highlight and can be dragged together. |
| Ctrl+E | Extract to new project — select tracks to clone into a fresh project. |
| Ctrl+C | Copy selected regions (MIDI and audio) to clipboard. |
| Ctrl+V | Paste clipboard at playhead position (deep copy). |
| Delete / Back | Delete all selected regions. |
| Z | Toggle track zoom — switches between 72px (default) and 36px track height. Zoomed view shows stereo waveform channels stacked. |
| H | Toggle track headers — 140px column with type icons, M/S buttons, and level meters. |
| B | Open / focus the Pattern Bank window (MIDI and Audio banks). |
| V | Open the Visualizer (real-time audio-reactive visuals + node graph). |
Ctrl+T opens a search box over every command in Phonon. Type a few letters of what you want — the match does not have to be contiguous — and each result shows its own keyboard shortcut, so the palette doubles as the way you learn them.
A command that cannot run right now is dimmed rather than hidden, with the reason beside it.
Ctrl+K turns the computer keyboard into a MIDI keyboard for the selected track's instrument — Z…/ are the white keys and S…; the black ones, with the gaps positioned as they are on a piano.
Notes are pushed into the track itself, not just auditioned, so an armed track records what you type. There is a panic control for when something hangs.
Piano Roll
These apply inside the piano roll window, to the selected notes.
| Key | Action |
|---|---|
| ↑ / ↓ | Move the selection by one semitone. |
| Shift+↑ / ↓ | Move the selection by an octave. |
| ← / → | Nudge the selection by one grid step. |
| Alt+← / → | Fine nudge by a 64th note. |
| Ctrl+← / → | Extend or retract the end of the selected notes by a 16th, down to a 64th minimum. |
| Delete | Delete the selected notes. |
| Ctrl+A / C / V | Select all, copy, paste. |
| Ctrl+Z / Y | Undo / redo — the same history as the arrangement. |
| Ctrl + scroll | Zoom horizontally, anchored at the pointer. The grid subdivides as you go in. |
| Shift + scroll | Scroll horizontally. Plain scroll moves vertically. |
A held arrow key is one undo entry for the whole run, not one per press — and so is a drag across the note inspector's Probability or Velocity bar.
Mouse Controls
| Action | Location | Result |
|---|---|---|
| Left click | Empty space below tracks | Move playhead and clear selection |
| Left click | Empty space on a track | Clear selection (does not move playhead — prevents accidental playhead moves when missing a region edge) |
| Left click | Ruler | Move playhead to that position |
| Left click + drag | Ruler | Scrub playhead continuously. Pauses playback on drag start. |
| Left click + drag | Region body | Move region |
| Left click + drag | Region edge (±6px) | Resize region |
| Left click + drag | Loop track | Create or move loop region |
| Right click | Track lane (empty) | Create a new 1-bar region |
| Right click | Audio region | Context menu: slice, copy, paste, loop, mute, warp, detect pitch, reverse, normalize, pitch shift, time stretch, delete |
| Double click | Audio region | Open the Warp Editor (timing + pitch correction hub) |
| Right click | Region | Context menu: section type, variation, mute, delete |
| Right click | Global track (empty) | Create a new 1-bar song section, or set/remove end-of-song marker (🏁) |
| Right click | Global region | Set section type, tempo, time signature, variation |
| Right click | Loop track | Create or remove loop |
| Right click | Any slider/knob | MIDI Learn context menu |
| Ctrl + drag | Region body or edge | Turn snapping OFF — free positioning. Without it, drags snap to the nearest whole beat. |
| Drag | Left gold edge | Trim the start of the audio region. For looping regions, trims the loop content start while the region end stays fixed. |
| Drag | Right gold edge | Resize the audio content. For looping regions, changes the loop iteration size while the total loop duration stays fixed. |
| Drag | Loop end edge (outer right) | Extend or shorten the total loop duration. Minimum is one loop iteration. |
| Shift + drag | Left or right gold edge | Non-destructive retime (varispeed — pitch changes with speed). Can be applied from either end. |
| Ctrl+Shift + drag | Left or right gold edge | Non-destructive retime with free positioning (no beat snap). |
| Drag edge, then press Shift | Any gold edge | Seamlessly switches from resize mode to retime mode mid-drag. |
| Drag file | Video track | Drop .mov/.mp4/.avi/.mkv/.webm files to create a video region. Ghost preview shows duration. |
| Drag file | MIDI track | Drop a .mid / .midi file to import it as a region at the drop point. Several files lay end to end. A file written at a different tempo is reported, not applied — the notes land on the project's own grid. |
| Left click + drag | Video region body | Move the video clip on the timeline (beat-snapped). |
| Drag | Video region gold edge | Resize/trim the video clip. Left edge adjusts video start offset; right edge capped at video duration. |
| Right click | Video region | Context menu: slice at playhead, copy, duplicate, delete, help. |
| Right click | Video track (empty) | Paste video region at playhead (if clipboard has one), help. |
| Drag | Module in hierarchy | Move module between tracks (drop onto another track's container) |
| Scroll wheel | Arrangement | Scroll horizontally (left/right) — the default |
| Shift + scroll | Arrangement | Scroll vertically (up/down) |
| Ctrl + scroll | Arrangement | Zoom in/out (toward cursor) |
| Double click | Hierarchy tree node | Open module editor window |
| Right click | Hierarchy tree node | Context menu (actions depend on node type) |
| Left drag | Hierarchy tree node | Reorder within the same parent |
05 Song Structure
Harmonic Engine
The Harmonic Engine is the harmonic brain of your project. It defines chord progressions organized into Banks, each containing Sections (groups of chords) and a Form (the order sections play in). The engine advances through chords based on the clock position.
The Wheel is the circle of fifths, and the selected section's chords are drawn on it as a path — near is related, across is far, so a progression's shape is something you can see. Click a spoke to retune the selected chord's root.
The Form is the strip of chips below it. Drag them to reorder the sections that play, click one to change which section that slot plays, × removes a slot and + appends one.
Preset… applies one of 22 curated progressions to the active bank. Generate Song fills the Verse, Chorus and Bridge banks at once with related progressions in the chosen mood.
Bank — a complete harmonic setup (e.g., "Verse", "Chorus"). Multiple banks allow different progressions for different song sections.
Section — a group of chord changes within a bank (e.g., Section A: Cm → G♯ → F♯).
Form — the order sections play: [0, 0, 1, 0] means A, A, B, A.
Chord Entry — root note + chord type + duration in measures.
Mood Generator — select a mood from the dropdown and click Generate to create a theory-aware progression. 16 moods: Dark, Melancholy, Ambient, Hopeful, Tense, Uneasy, Awe-Inspiring, Glorious, Frightful, Spooky, Unsettling, Uplifting, Jubilant, Celebratory, Jazzy, Blues. Each mood uses appropriate scales (Lydian, Harmonic Minor, Mixolydian, Phrygian, etc.), diatonic chord qualities, and characteristic root movement patterns. Each click generates a unique progression.
Each kind of section on the SONG lane plays its own bank, so a Verse and a Chorus can run different progressions across one timeline. The Song Structure panel sets which: a row per section type, with ◂ ▸ to choose its bank. Verse, Chorus and Bridge start on banks 0, 1 and 2. A section pointed at a bank you have not made falls back to bank 0.
The Harmonic Engine does not produce sound — it only manages harmonic state. Harmonic Follower modules read the current chord and generate MIDI notes.
Tonnetz
A live picture of the harmony, on the right edge of the window. Press Ctrl+Shift+H to show or hide it; it is open when you start. The chord's name sits at the top, the key beneath it, and the lattice below.
Every dot is a note. The three directions between neighbouring dots are a major third across, a fifth down-and-right, and a minor third down-and-left — so a chord becomes the shape you get by joining its notes up, and that shape says what the chord is:
Major triads point down. Minor triads point up. Two notes side by side with the third below between them, or one note above two. A seventh is two triangles sharing an edge. A row of three is an augmented chord, and stacked fourths draw as a straight run.
Chords with notes in common share those dots. That is what the lattice is for: relative major and minor sit on either side of one edge, and a progression that keeps two notes and moves one is a small tumble, while a distant chord is a jump across the panel.
The seven notes of the key stay lit under everything else. It is the landmark to watch: when the music modulates, the patch moves.
The last five chords fade behind the current one, so you can see the path the progression has just taken as well as where it is now.
The lattice wraps — the same note appears in more than one place — so a chord is drawn wherever it sits closest to home. In a given key a chord is always drawn in the same place, which is what makes the shapes worth learning.
The pill at the top of the panel switches between ✺ TONNETZ and ♫ MIDI. The MIDI view is a keyboard standing on the right edge with all 128 notes down it, and every track’s notes streaming away to the left as the song plays — the rightmost pixel is now, the left edge a couple of bars ago.
Each track has its own colour, so two parts on the same note read as two lines rather than one thick one, and a note’s length on screen is its length in the music. The keys light blue on the chord tones in force, so you can see the harmony the parts are playing over at the same time as the parts.
The lattice is what opens; the MIDI view has nothing to show until the transport is running.
Harmonic Follower
A Harmonic Follower reads the current chord from the Harmonic Engine and generates MIDI note events. Multiple followers in different tracks can interpret the same progression differently — one playing arpeggios, another playing pads, another playing a bass line.
Each follower has a mode that determines how it voices the current chord: chord pads, arpeggios (up/down/random), bass notes, melodic patterns, and more. Modes can be overridden per song section (Verse, Chorus, etc.) so the same follower plays differently in different parts of the song.
Interpolate Chord Changes: When enabled, on the last beat before a chord change, the follower plays only pivot tones — notes that belong to both the current and upcoming chord. For example, going from Cm (C-Eb-G) to Ab (Ab-C-Eb), it plays only C and Eb. This creates smooth Philip Glass-style transitions where the harmony is already halfway to the new chord before it arrives. If no common tones exist, normal playback continues.
Humanize: Multi-layered dynamics model: phrase arcs (velocity rises and falls over 16-beat cycles), metric accent (downbeats louder), breathing (5.5-second sinusoidal swell), melodic contour (higher notes slightly emphasized), chord voice weighting (top note emphasized, inner voices recessed), repetition drift, and micro-jitter.
A follower's panel shows what it is doing while the track plays: the chord it is reading, which keys are held down at this instant, and an eight-beat trace of the shape it has been playing.
The trace is drawn from the notes the engine actually emitted, not from the pattern it intends to play, so it cannot drift from what you are hearing.
Melodic Engine
A permanent fixture in the structure rack, and the Harmonic Engine's sibling: where that one decides the chords, this one composes a four-bar melodic line. Double-click it in the hierarchy to open its panel, where the line is fully parameterised and auditioned in its own piano roll before it goes anywhere near the arrangement.
To use the line, right-click an empty MIDI lane and choose 🎼 Insert Melody — or 🎼 Insert Melodic Improv, which stamps a variation instead. Improv is always an operation performed on the line, never a free walk away from it, so a variation still sounds like the same tune.
Hookwright and Conceit build a line from rules — a rhythm cell, a motif hammered with one deliberate twist, a hole of silence, a spice note leaning on the harmony.
Quilt keeps a library of hand-written motifs and adds form: phrases placed into a named four-bar shape.
Scrapbook keeps the library and adds nothing else: 198 melodic micro-phrases drawn and laid end to end until four bars are full. It is the default — a stream of good fragments with no rule layer over the top.
Its phrase lengths are irregular and rarely line up with the bar, and the tiling runs continuously across all four bars rather than restarting each one, so the result does not settle into a loop.
The panel is grouped by what each control decides: THE ENGINE picks which of the four is composing, then THE LINE, THE CONCEIT, THE EXPECTATION, THE DELIVERY and THE IMPROV shape the material, how far it strays, and how a variation departs from it. Controls that only apply to one engine grey out when another is selected.
Global Track
The SONG lane in the arrangement defines song structure visually. Place colored regions representing Verse (blue), Chorus (red), Bridge (green), Intro (amber), Outro (purple), or Break (grey). Each global region can optionally override the tempo and time signature for that section.
Loop Track
The LOOP lane at the top of the arrangement defines a playback loop. Only one loop region can exist. When a loop is active, pressing Play starts at the loop start, and the playhead returns to the loop start when it reaches the end. A subtle green overlay highlights the looped area across all tracks.
The PUNCH IN lane sits directly beneath it and decides where a take starts and stops — see Punch In. While a take is running the loop brace goes dashed and stops wrapping, so a loop cannot cut a recording in half.
Markers
The MARKERS lane sits under SONG. Markers are named, coloured spans used purely for navigation — the map of the song rather than part of it. Right-click the lane to create one, drag to move or resize it, and pick a colour from the palette.
Ctrl+1…9 jumps the playhead to a marker. They are numbered left to right by position, not by the order you made them, so the numbering keeps matching the song as you rearrange it.
Regions
Regions on track lanes serve different purposes depending on track type. Module/MIDI tracks play continuously by default — regions control MIDI note output and drive pattern variation, but effects, generators, and drum sequencers run continuously. Reverb tails, delays, and other time-domain effects ring out naturally without needing special tail regions. Audio tracks only produce audio where regions contain sample data, but their effects chain always processes (so reverb/delay tails ring out after the region ends). Right-click empty space on a track to create a 1-bar region.
Name: Every region carries one. A MIDI region reads its track's name and how many notes it holds; an audio region reads its file. Right-click → Rename to give it your own, and clear the box to put the automatic name back. A region you have not named follows its track, so renaming the track renames them all.
Variation (1–8): Drives pattern variation in sequencer modules.
Mute: For MIDI regions, muting a region skips its note output but does not silence the track — other modules (drum sequencers, generators) continue playing. For audio regions, muted regions produce no audio.
🎹 Edit MIDI: Opens the piano roll for the region.
✂ Split at Playhead: Splits a MIDI region at the current playhead position. Notes spanning the split point are truncated correctly and offsets are adjusted for the second half.
Multi-selection: Press Ctrl+A to select all regions across all tracks. Selected regions show a blue highlight border. Drag any selected region to move all selected regions together — useful for adding breathing room at the start of a song. Press Escape to deselect.
🔁 Loop MIDI: Looping MIDI regions display dimmed note previews at each loop repetition, so you can see the full playback content at a glance. Dashed lines mark loop boundaries.
🎵 Shift: Right-click a MIDI region → Shift submenu to transpose by ±Octave, ±Fifth, or ±Fourth.
🎼 Follow Harmonic Engine: Re-voices a region's notes live against whatever chord is playing underneath, degree-mapped from the key it was written in. Non-destructive — the notes themselves never change — so a region keeps fitting the progression wherever you move, stretch or loop it. Following regions wear a gold border and a 🎼 mark.
🎨 Color: Overrides the track's default region colour for one region, from a 12-swatch palette.
Fades: Drag a region's top corners to fade it in or out — MIDI as well as audio, in beats either way. Right-click → Remove Fades clears both. On a MIDI region the fade rides the track's output, after the gain stage.
06 Modules
Phonon ships with over 390 modules — the building blocks of your instrument. Each module is a link in a track's chain: it receives audio and MIDI events, processes them, and passes them to the next module. Double-click any module in the hierarchy to open its dedicated editor window. Modules can be dragged between tracks in the hierarchy panel.
Five filters — Filter, Ladder, Brutalist, Screaming and SAM — carry an XY pad at the top of their FILTER column. Cutoff runs across it, resonance up it, and dragging the point moves both at once.
Behind the point is that filter's own response curve: the corner tracks cutoff, the peak grows with resonance, and the skirt visibly steepens when the SAM filter is switched to 4-pole. A dashed line marks where that particular filter starts to self-oscillate — 0.7 on the Screaming Filter, 1.0 on the Ladder — so "about to ring" looks the same wherever you are. Shift-drag for a fine adjust.
The Cutoff and Resonance sliders stay underneath it. The pad is for finding a sound; the sliders are for typing a value, and they are where a CV cable lands.
The Lowpass Gate deliberately has none — its cutoff comes from the vactrol responding to a gate, so there is no cutoff control to put on an axis.
Almost every instrument here derives its sound from formulae — a decay power law, a stiffness curve, a two-stage ratio. Eight do not. Felt Grand Piano, Archtop Guitar, Flatwound Guitar, Roundwound Bass, Tine Kalimba, Pedal Harp, Rosewood Marimba and Flemish Harpsichord were analysed off real recorded instruments: for every sampled pitch and playing strength, each partial's exact frequency and its amplitude at 21 log-spaced instants from the attack out to four seconds. Playing a note blends the four surrounding measurements and runs one oscillator per partial.
What that buys is everything nobody has a formula for. The two-stage decay a piano has — a fast strike settling into a long singing tail — is simply in the data, along with the beating between unison strings and the way the top of the spectrum drains while the low partials hold. None of it was modelled. It was recorded.
This is not a sample library. What ships is measurements — all eight instruments together come to about 620 KB, and only the harpsichord carries any recorded audio at all, for a reason given below. Partial frequencies are stored as ratios to each note's own fundamental, so a source instrument's inharmonicity is reproduced while its tuning is not — tuning stays a choice made at playback.
Each one then adds back what the analysis could not carry, and what that is differs by instrument. Heterodyne extraction keeps the partials and discards everything between them, so the noise around an attack is genuinely absent rather than doubled up. Felt gets Action (the hammer's knock and the thump of its momentum reaching the bridge) and Sympathy (the other two hundred strings, silent until the pedal lifts their dampers — apart from the top octaves, which have none at all). Archtop gets Pick, Body (its air and plate modes, knocked directly at every attack) and Ring — six resonators in standard tuning rather than a chromatic wash, because that is what a guitar actually has. Roundwound gets Pick and Weight, which is not a bass boost but a correction: a magnetic pickup sits where the fundamental barely moves the string, so across that whole dataset the first partial reads several decibels under the loudest partial in its note. Flatwound gets Pick, Ring and a Tone control, and pointedly no Body — a card below says why. Tine Kalimba gets Nail and Ring; Pedal Harp gets Pluck and Sympathy. Flemish Harpsichord gets Pluck, the quill catching and letting go. Rosewood Marimba gets Mallet — one control moving amount and hardness together, because that is what changing mallets actually does, and on an instrument whose sustain is three or four sine waves that wooden knock is most of what says a stick hit a piece of wood.
Rosewood is the one where the measurement proved something. A plain wooden bar is wildly inharmonic — its modes sit near 1 : 2.76 : 5.40 and it reads as a plank. A marimba maker cuts an arch out of the underside precisely to drag the second mode onto four times the fundamental and the third to around ten. Nothing told the analysis to expect that. Measured across the instrument, the fourth-harmonic mode landed between 4.004 and 4.026 and the tenth between 10.070 and 10.126 — under one percent of spread on both, because every bar was tuned to the same ratios on purpose. That constancy is also what lets ten sampled bars cover five octaves: unlike a piano's inharmonicity, which swings from note to note, these ratios are fixed by construction, so all that interpolates between neighbours is amplitude and decay.
A few details worth knowing, because they are the kind of thing a formula would smooth over. Archtop's data came from two recordings of the same take — the decay shape from a magnetic pickup, which hears very nearly the string alone, and the partial balance from a microphone, because a pickup reads its own fundamental light. Roundwound carries thirty-two partials where most carry twenty: twenty partials of a 41 Hz low E reaches only 830 Hz, underneath the growl entirely. And Pedal Harp's understrings tune themselves to the Harmonic Engine's current chord and retune when it changes, because a real harp's ringing strings are whatever its pedals are set to — a fixed set would clash the moment you changed key.
Tine Kalimba had to be split in two before it could be measured at all. A kalimba has no per-note partials in any useful sense: pluck one tine and all twenty-five ring, so most of what a microphone hears is not the note you played. A typical recording shows three peaks belonging to the plucked tine and twenty-one belonging to its neighbours. So the two are stored separately and treated oppositely — the tine's own modes (a bar clamped at one end, so they sit near 6.3 and 17.5 times its pitch rather than at whole-number multiples, which is why it rings rather than sings) transpose with the note, while the neighbours are fixed absolute frequencies that never do. Keeping them together would drag the whole sympathetic chord around under every note and stack a differently-detuned copy of it beneath every note of a chord. Split, it plays chromatically and still behaves.
Flemish Harpsichord is the one with no velocity, and that is the instrument. A plectrum plucks the string identically however hard you press — it is the limitation that got the harpsichord replaced by the piano — so there is exactly one measurement per pitch and the lattice shows a single row. What a player changes instead is registration, and both ranks were measured separately: 8′ at written pitch, 4′ an octave above and thinner, and the two coupled for the bright full sound people picture. Its inharmonicity is tiny, an order of magnitude under a piano's bass strings, because harpsichord strings are thin and slack by comparison — so the character is not in stretched partials at all. It is in the attack, and in how a note stops.
Which is why this one instrument ships a little recorded audio: eight real key releases, spread from F♯1 to C6, the damper landing and the jack dropping back onto the string. Heterodyne analysis keeps partials and throws away everything between them, so a noise like that cannot survive it — it had to be analysed the way a drum is, with the phase-critical thunk kept raw. On an instrument with one dynamic and no sustain pedal, nearly every expressive choice left is when to let go, and fast passagework is largely a rhythm of dampers landing.
One control in the family is invented rather than measured, and it is labelled. Storing partials as ratios is exactly what lets an instrument's inharmonicity survive while its tuning does not — but a neglected piano's whole charm is its tuning, so Felt's Honk hands it back as a choice. Each low partial gains a second oscillator a few cents off, which is literally what a mistuned unison is, and the amount is derived from the note itself rather than rolled fresh — so one note is always sour and its neighbour nearly true, every time you play them. That is the difference between a piano with a character and one with a wobble. It starts at zero, where the instrument is exactly as it was recorded.
Opening any of them shows the plate: that instrument's own measurements, partials running across and time running down, with a cursor travelling down as a note rings so you can watch the spectrum drain. Beneath it, the lattice marks every pitch and strength the instrument was measured at, lighting the four being blended for whatever you are playing.
The method has limits, and both of them turned into other methods. It suits instruments that are pitched and decay — struck and plucked things. It does not suit percussion, because for a cymbal or a snare the sound between the partials is the instrument. And it does not suit anything that never stops, because every partial here is stored as a decay and a note that holds has no decay to store. Those two gaps became the two other methods described below: the drums, and the reed.
An Epiphone SG strung with flatwounds, both pickups, knobs on ten, recorded straight into the desk. 120 MB of recordings shipping as 101 KB. It sits beside Archtop deliberately, because the two are the same architecture applied to instruments that are not remotely the same thing — and the difference is instructive.
Archtop's dataset had to be built from two simultaneous signals. A magnetic pickup sits near the bridge, where the fundamental barely moves the string, so it reads its own first partial several decibels under what a microphone in the room hears; the envelope shape came off the pickup and the partial balance off the mic. None of that applies here. A solid body has no top, no air and no acoustic sound to be light against — the pickup is not a lossy view of the instrument, it is the instrument. One direct take is the whole honest signal, and there is no Body control because there is no body.
Tone is the control that was genuinely missing. Every sample was played with the guitar's knobs wide open, so its tone circuit is simply absent from the data rather than merely unmeasured. It is modelled as the real thing: a capacitor working against the pickup's inductance, which means it peaks just under its corner before it falls. That bump is why a rolled-back electric sounds like a voice rather than a blanket over the amp. The resonance opens out as the knob does — turning the pot up takes the capacitor out of circuit — so at ten it is a no-op to the sample, which is exactly what the recording says it should be.
And the velocity ladder taught the project something it did not want to hear. A broadband look at the source recordings — loudness averaged over the first fraction of a second — said that half the sampled pitches were inverted: played harder, they came out quieter, with the range collapsing to two decibels high on the neck. A correction was designed to fix it. The heterodyne analysis disagreed, and the analysis was right: measured properly, all eighteen pitches climb cleanly across twelve to eighteen decibels.
The reason matters more than the result. A broadband window measures the recording — pick noise, inharmonic clank, every partial above the cap, and the decay length folded in by averaging. This instrument plays none of that. It sums exactly the partials in the dataset, so the sum of those partials is its output level, by construction. Up the neck, the difference between the two is most of the signal. The correction was built, found to be flattening real measured variation into an average, and taken back out. Measure the thing that gets played, not the thing it was made from.
Seven drums — Jazz Snare, Stick Shot, Cross Stick, Ride, Ride Bell, Crash and Hi-Hat — come off a real kit played by a real drummer, and ship as 0.86 MB. The recordings they were analysed from are 212 MB, and none of that audio is in the app.
The trick is refusing to treat a drum hit as one sound. It is two, and they want opposite handling.
The attack is phase. You identify a struck object almost entirely from its first few milliseconds, and every method that stores a spectrum instead of a waveform smears exactly that — a snare crack becomes a whoosh. So the attack is not modelled at all. It is kept, as raw audio, about forty milliseconds of it, which is cheap precisely because it is short.
The tail is statistics. Above a couple of kilohertz a cymbal has thousands of modes packed far tighter than anyone can hear apart — and that is the condition under which describing them as band energy over time is faithful rather than approximate. What does still need naming individually are the low modes, because a ride's ping is a discrete pitch and noise cannot stand in for it. So a tail is thirty-two band envelopes plus a handful of resolved partials.
That split is also why it pays. Cymbals were nearly three quarters of the original sample library purely because their tails run for ten or fourteen seconds — which is the exact case this compresses hardest. A kick, almost pure transient, would barely compress at all; kicks were never the problem.
Storing a description rather than a recording buys controls no sampler can offer. Decay genuinely stretches the ring instead of truncating it — a crash can fall for half as long or twice as long and still be that crash. Wash and Ring are separate because the noise and the modes were stored separately: pull Ring down and the ride keeps its spread while losing its pitch, pull Wash down and the ping stands alone. And Character leans the whole thing toward a second, vintage microphone from the same take — steeply low-cut and forward in the midrange — which is stored as a measured 32-band tilt weighing 128 bytes instead of a second copy of the kit.
Because that vintage position has no low end under it at all, it layers with a synthesised kick rather than fighting one: the sample brings a character no model here produces, the synth brings a floor the microphone never heard.
Velocity picks a measured hit, not a volume. A soft stroke is a different analysis of a differently-played note — quieter and duller, wires barely speaking — because that is how it was struck. Drums carry many strike strengths and few alternates; cymbals carry the reverse, several alternate takes at each strength, since a crash varies by where you hit it rather than how hard. A take never repeats twice running.
The hi-hat is deliberately one module holding four states rather than four modules. Closed has to land on an open hat and stop it dead, and separate modules could never choke each other — the pedal would simply not work.
A second kit on the same architecture, sharing every line of its player: 1.2 GB of recordings becoming 4.3 MB. It is deliberately not another jazz kit. A marching bass drum used as a kick, a cajon standing in for one, three snare articulations, and cymbals that include a cracked crash and a cracked splash sampled as first-class instruments rather than as defects. Almost nobody ships those.
Two microphones here are two models, not a tone knob. The jazz kit's second position measured as very nearly a filtered copy of its first, so it ships as a 32-band tilt weighing 128 bytes. These are not that. A kick's beater mic hears the click while its resonant-head mic hears the boom; a snare's top hears the batter head while its bottom hears the wires. Those are different transients, and no tilt turns one into the other — so each microphone is a full model and Mix balances them. Batter against wires is the most useful thing a two-mic snare has to offer.
Both fire from one strike, sharing the same noise offset. Voices are normally decorrelated so two hits do not phase against each other, but two microphones are hearing one drum — the same air in the same room. Independent noise would make the blend sound like two drums played at once rather than one drum heard twice, and would make Mix change the level as well as the balance.
The velocity ladders were thinned by level rather than by count, and it took three attempts. Nothing interpolates between layers, so the step between rungs is heard directly — as terracing when a part crescendos across it. The source ladders are wildly uneven: the marching kick spans 47 decibels across 22 layers, its first two steps eleven and ten decibels and its last twelve all under two. Densely sampled where it does not matter and coarse exactly where a kick lives. Keeping every Nth layer left a thirteen-decibel hole; evenly spaced targets snapped to distant rungs and made the broken splash worse than its own source. What ships walks the ladder and takes the furthest rung still inside the bound, which puts nearly every gap between five and six decibels.
A third kit on the same architecture: 603 MB of recordings becoming 9.1 MB across eight pieces — a 24-inch kick, a snare, a hi-hat, a ride, and four toms at 14, 15, 18 and 22 inches.
The toms are the reason it exists. Neither measured kit before this one has a tom at all, so four sizes on the General MIDI slots — 50, 48, 45 and 41, descending — are the one thing here not competing with something already shipped. Drop all four in and a generator's fill lands across them.
The snare carries two articulation axes at once, which nothing else in the app does. The note picks where the head was struck — 38 centre, 40 edge, 91 rimshot, 37 sidestick — and Sticks picks what struck it: stick, brush or mallet. They are independent, so a brushed part and a stick part are the same pattern with one control moved.
Sticks is a stepped control and not a knob that morphs, and the honest reason is that there is nothing in between to morph toward. Each position is a separate set of recordings with its own velocity ladder — the same arrangement as Breath stepping through measured dynamics on the woodwinds, rather than scaling a gain. Calling it continuous would promise a blend the recordings cannot supply. The snare and the four toms have it; the kick and both cymbals were recorded with one beater, and get no control at all rather than a dead one.
One consequence is worth knowing before it surprises you: brushes and mallets were recorded at the centre of the head only, so a brushed rimshot does not exist. Ask for one and you get the brush anyway, at its own velocity and alternate take. The part keeps its hit, where dropping the note would punch a hole in the middle of a phrase.
The hi-hat holds seven states rather than the usual four, because this library actually sampled the middle of the pedal's travel — and that is where a hat is played. Closed 42, tight 93, loose 94, quarter 92, open 46, pedal 44, foot splash 95. Tight, loose and quarter are the ones a four-state hat has to fake by reaching for closed or open. Quarter sits on 92 deliberately: that is the slot the jazz and Salvage hats call half-open, so a part written against either lands on the nearest thing here rather than on nothing.
The ride is one module holding three zones — 51 the bow you ride on, 53 the bell you punctuate with, 59 the edge you crash — for the same reason the hi-hat is one module. They are the same piece of metal, and three modules would ring three cymbals where a drummer has one.
Every piece here was recorded with two microphones, so Mix is live on all eight: close against overhead on seven, and top against bottom on the snare, which is batter head against wires.
Both methods above describe a note dying. One stores every partial's decay; the other stores a noisier one. A saxophone does neither, because the player keeps putting energy in — so the thing that has to be described is not how it fades but how it lives while it is held. That is a third method, and Cane Tenor was the first instrument on it, and Spruce Cello, Grenadilla Clarinet and Argent Flute followed: 46 real tenor sustains, 144 MB of recordings, shipping as 669 KB.
Of that, 647 KB is raw attacks and 22 KB is the entire measured instrument. The attack is kept for the same reason the drums keep theirs: for the first ten milliseconds breath sits only five decibels under the tone, and by two hundred it is twenty-six decibels under. That collapse is the articulation, and no method that stores a spectrum survives it. Past that point the spectrum genuinely stops moving — measured, a low note's first twelve harmonics hold to tenths of a decibel for seconds — so the sustain is one harmonic vector, held, rather than an envelope.
Blowing harder is not turning it up. A reed's source spectrum flattens under pressure: between the two measured dynamics the upper harmonics climb nine or ten decibels while the lower ones barely move. So a soft note is a different instrument from a loud one, not a quieter one — and the panel draws exactly this, with the soft take and the hard take as two outlines and the note you are playing filled in between them. Edge keeps walking along that same measured line past the hardest take, which is honest in a way a treble shelf is not: it is the direction the horn actually moves.
Two things fall out of the method that a sampler cannot offer. The recordings carry no vibrato, which sounds like a limitation and is the opposite — vibrato here is a control, including how late it arrives, instead of whatever the player felt on the day, baked in and unremovable. And because a driven oscillation is periodic by definition, its spectrum is exactly harmonic: measured across the whole set, every partial landed within about a cent of a whole-number multiple. So no frequencies are stored at all, only harmonic numbers. A struck string is the opposite and needs every ratio kept.
Wander is the control that decides whether it sounds alive or synthetic, and it is fussier than it looks. Three separate slow processes: the whole spectrum breathing together, a brightness tilt, and a per-harmonic zigzag. The zigzag is the dangerous one, and in a real horn it is very nearly frozen — give every harmonic its own fast independent movement instead and you have not built life, you have built a comb filter with moving notches, which sounds like a flanger draped across the instrument. That is not a hypothetical: it is what the first version did, and it was caught by ear before it was caught by any measurement.
One part of this instrument is not measured, and it is worth saying which. No sustained recording contains a note-to-note transition, so a slur cannot be played back — it has to be constructed. Rather than bending the old note to the new pitch, which would drag the body resonance along with it, the new pitch's own measured spectrum starts underneath a short fade. A saxophone's bore does not move when the fingers do.
Growl, extreme subtone, altissimo and wide bends stay with Lacquer Sax, the physical model, which now sits under Legacy. A model can be driven places a measurement cannot follow; on plain tone, the measurement wins.
A bow is the other kind of driven instrument: the player keeps feeding it, so like the saxophone it has no decay to store. Spruce Cello is the second instrument on that method — and it is where two things learned from a reed turned out to be facts about reeds rather than facts about driven instruments.
Both assumptions reversed on a bow. On the tenor, playing harder raises the upper harmonics against the fundamental; on the cello, measured, the fundamental climbs hardest — six decibels — and the extra energy goes in above the fourth harmonic rather than at the top. And a tongued saxophone entry stands proud of its own sustain, where a bowed one starts underneath it and grows in: rosin has to catch before the string will speak. Two tests written from the saxophone called a correct cello broken.
Vibrato is a control here for the same reason it is on the tenor. The recordings carry none, which sounds like a limitation and is the opposite — depth, rate and how late it arrives are yours, rather than whatever the player felt on the day being baked in past removing. Slide is the bow arriving on a new note by moving along the string rather than lifting off it.
Voicing is a mode, not a heuristic. Generators that stagger note onsets to humanise a chord — which is most of them — are indistinguishable, from inside the instrument, from a player deliberately moving between notes. So it is a switch: in Legato a note arriving alone continues the line and slurs into it, while notes arriving together are a chord and each get their own bow; in Poly every note is its own attack. The instrument cannot guess which you meant, so it asks once instead of guessing every note.
Two more instruments on the saxophone's method, sharing every line of its player. Grenadilla Clarinet is eleven pitches at three blown dynamics — one more than the saxophone shipped on — in 440 KB. Argent Flute is nine pitches at two, in 238 KB. Both come off the same free chamber-orchestra library.
The clarinet's second harmonic is missing, and that is the instrument. A clarinet is a closed pipe, so it radiates its odd harmonics strongly and its even ones barely at all. Measured here, its low A♯ sits at 233, 699, 932 and 1165 Hz — first, third, fourth, fifth, with the second simply absent. Nothing told the analysis to expect that; it came off the recording and survived every stage down to the oscillators, and it is most of why a clarinet is hollow and woody where a saxophone is brassy. ⚠ It also makes the instrument a trap for anything that estimates pitch by looking for a period, because the usual evidence for the fundamental is not there.
The flute was expected to fail and did not. It is the woodwind whose tone is supposed to be mostly breath, and this method keeps the partials and discards everything between them — so the honest prediction was that most of the instrument would be thrown away. Measured, 99.3 to 100 per cent of its energy sits ON the harmonics: the cleanest of any source in the line. The breath is in the attack, which is kept as raw audio anyway.
⚠⚠ A ROOM ON THE SOURCE IS A NEW FAILURE MODE, AND IT FLANGES. Both of these were recorded in a hall, and a hall combs the sound: as the pitch drifts a few cents, each harmonic slides along that comb and genuinely wobbles on its own. Measured faithfully and replayed, that becomes a moving comb filter built out of somebody else's room. It was heard by ear before any statistic caught it — the second time on this exact fault.
The rate was not the problem. The clarinet's wander was the SLOWEST of the three instruments; it was the DEPTH of the per-harmonic term, at 5.06 dB against the saxophone's 3.58, with nearly every harmonic moving at the player's cap. Part of that was a measurement fault worth fixing properly — harmonics down in the noise were reporting their noise as wander, because the measurement is in decibels and near the floor a couple of quantisation steps read as several decibels of movement. That is invisible on a close-mic'd 24-bit take and immediate on a 16-bit one in a hall. Wander is now measured only where it can be measured. The rest is the room, and the room is real, so the depth is scaled and the reason is written down rather than buried in a constant.
⚠ The risk grows with harmonic count, which is a thing a person heard before it was looked for: a comb needs teeth, and the bottom of the clarinet's range carries sixty-four harmonics against seven at the top.
Every note on this architecture is two things joined: 150 ms of raw recorded audio, then a synthesised steady tone. The raw attack is resampled to whatever pitch is being played — and the reference it was being resampled against was measured six hundred milliseconds into the take.
Players settle into a note. Once the analyser started tracking pitch frame by frame, that drift became real data rather than noise, and the consequence was that the first 150 ms played at the wrong speed and then snapped to correct at the handover. A step, heard as a glide into every note, and audible with the scoop control at zero because it had nothing to do with scoop. Measured across the range: 45 cents on the flute's low C, 25 on the clarinet, 13 on the cello, 5 on the saxophone — which is the order the fault was reported in, and why the saxophone was the one that sounded fine.
The fix uses a number the analysis already computed and threw away: the tracked pitch AT the handover instant, which was being kept for the splice's phase and not for its rate. Stored now, so the two sides of the join agree by construction. The flute went from 36 cents to 6, the saxophone from 24 to 15.
⚠ The cello did not move, and that is left open rather than papered over. A bowed attack is not a tongued one: for 150 ms the bow is still catching, so the pitch there is genuinely unsettled rather than merely offset, and a single instant at the handover is a poor anchor for it. Fixing it needs its own measurement of where a bowed note actually arrives — the same question that set the attack length in the first place. The test records what is true today so the eventual fix has a before.
⚠ And a note for whoever rebuilds these next: the build parameters were never written down. They were recovered by rebuilding and comparing file sizes — the cello came out 272 bytes larger than what shipped, which is exactly 68 layers times the four bytes of the new field, and the saxophone 184, which is 46 times four. That is proof of an exact match rather than a plausible guess, but it is not a method anyone should have to use twice.
Synthesizers — Flagship
10 modules
Synthesizers — Component-Modeled
10 modules
Synthesizers — Analog
14 modules
Synthesizers — Digital
18 modules
Synthesizers — Physical Modeling
42 modules
Synthesizers — Experimental
21 modules
Synthesizers — Physical Modeling (Legacy)
4 modules
Synthesizers — Textures
2 modules
Drum Synths
73 modules, 4 legacy
Drum Machines
6 modules
Samplers
5 modules
Effects — Filters
8 modules
Effects — Reverb & Delay
14 modules
Effects — Modulation & Dynamics
21 modules
Effects — Distortion, Character & Stereo
20 modules
Effects — Resonance
5 modules
Effects — Utility
11 modules
Remix & Bus Effects
18 modules
Generators & Sequencers
41 modules, 14 legacy
Rhythm Generators
26 modules, 9 legacy
Utility, CV & Control
27 modules
Blocks
1 module
VST Hosting
VST editor windows use native Win32 hosting for maximum plugin compatibility. Editor windows stay on top of the main Phonon window so they remain accessible while working in the arrangement. Windows auto-resize to match the plugin's reported editor dimensions.
07 Routing
CV Bus System
Phonon has 64 CV buses for control voltage modulation. Control modules (LFOs,
envelope loopers, sequencers, envelope followers) write to buses; audio modules read from them.
Any parameter displayed as a ModParam (the controls with
cv ◂ 3 ▸ depth underneath) can be modulated by a CV bus.
Set the bus number (0–63) and depth (−1 to +1) to modulate the parameter.
A bus value of "—" means no modulation. The final parameter value is:
base + bus[sample] × depth.
Any knob or slider on any module can be CV-modulated by right-clicking and selecting 📡 CV Modulate.... This opens a dialog where you set the CV bus number and depth. The binding is stored on the track and persists across saves — no need to open the module panel after loading.
Or drag a cable. Every module in the Control Rack (drawer tab 7) has an OUTPUT jack. Drag from it and a cable droops out behind the pointer; drop it on any modulatable knob or slider anywhere in the app and that bus is assigned directly, with no dialog. The cable is drawn on a layer above everything, so it can cross floating module windows on its way. Right-click a jack to see what it is currently driving, and to unassign.
Not every control can take one. A knob backed by a fixed value has no modulation input for CV to sweep — dropping a cable on one says so rather than appearing to work.
The hand-drawn flagship panels take cables too — Keyboardist, Fretwork, Kitwork and Swage. Their knobs are painted rather than assembled from standard controls, so aim at the knob face itself; the drop finds it the same way it finds an ordinary one, and the ring moves as the modulation arrives.
A control module added to the rack claims the lowest free run of buses wide enough for it, so two LFOs do not both land on bus 0. A module that needs several consecutive buses — Mother Rhythm takes four, Stochastic twelve — is placed as a block.
This happens only when a module is added. Loading a project always restores each module's saved bus, so opening an old session never rewires it.
The Complex Envelope Editor lets you draw arbitrary envelope shapes with multiple control points and 8 curve types: Linear, Exp In, Exp Out, Log In, Log Out, S-Curve, Hold (step), and Bezier (smootherstep). Click to add points, drag to move them (constrained between neighbors), right-click to delete. Press C to cycle curve types. Presets include ADSR, Attack-Release, Ramp Up/Down, Triangle, S-Curve Rise, and Flat.
Three modules use complex envelopes:
Complex Env Module (Utility) — sits in a track chain, triggers on MIDI NoteOn, writes the envelope shape to a CV bus immediately, so downstream modules see the value in the same buffer.
Env Looper (Control rack) — loops the envelope shape continuously on a CV bus. Rate syncs to BPM (beats) or runs free (Hz). Like an LFO with any waveshape you draw.
Cmplx Env Synth (Experimental) — wavetable synth with three built-in complex envelopes controlling morph position, filter cutoff, and amplitude. Self-documenting — the module panel includes full instructions.
Audio Buses
Right-click Master → Add Audio Bus to create a summing bus. Then right-click any track → Send to Bus to route that track's output to the bus instead of the master output. Audio buses appear in the hierarchy with a 🔊 icon and green text. Bus tracks can have their own effects (reverb sends, parallel compression, etc.).
Tuber Console
Phonon's summing path is modeled after vintage mixing hardware. Each channel passes through an input transformer (Beyer/Malotki iron saturation), an ECC83 valve stage (even-harmonic distortion), and an output transformer. Switch it to “Clean” mode from the top bar of the Mixer tab in the drawer to bypass the valve and transformer coloration. New projects default to Clean mode.
A gold 🎛 Tuber Console node sits below Master in the hierarchy, with a corresponding gold lane in the arrangement view.
Adding effects: Right-click the Tuber node → Add Bus Effect. Choose from Dynamics, Filters, Reverb, Modulation, Stereo, Distortion, or Utility.
Audio flow: Tracks → Tuber channel strips → Tuber summing bus → Bus effects chain → Master output.
Block Editor (Visual Patching)
The Block Editor provides a visual node-based patching environment. Create processing nodes, connect them with bezier cables, and build custom signal flows. The system supports 15+ node types, and always processes them in the correct order however you arrange them on screen. CV cables propagate per-sample. Block patches are saved and loaded with the project.
Automation Lanes
Any parameter in Phonon can be automated. Right-click any knob, slider, or integer slider in a module window and select ⤴ Add Automation Lane. A thin automation sub-lane appears below the track in the arrangement view, showing the parameter name and automation curve. Integer parameters (like Metal Noise, step counts, instrument types) are also supported — CV and automation values are rounded to the nearest integer automatically.
Parameters are uniquely identified by their column and control labels (e.g., "VOICE 1.LP Reso" vs "VOICE 2.LP Reso"), so identically-named controls on different voices or sections get independent automation lanes.
You can also build a lane the other way around, without opening a module window at all. Every track's automation stack ends in a row carrying SELECT…, EXPAND and + ADD NEW. + ADD NEW drops a blank lane onto the track, labelled "— no parameter". SELECT… opens a menu of every module on that track and every automatable parameter on each one; pick one to point the lane at it. A lane can be re-pointed later the same way, and any points already drawn are rescaled into the new parameter's range rather than thrown away. A track with no lanes at all still shows one empty row, purely so SELECT… is somewhere to be found.
Showing and hiding a track's lanes. Each track header has its own AUTOMATION button, which reveals or collapses that track's whole stack at once. Hovering a knob that already has a lane lights up the lane it belongs to, so it is obvious which row drives which control; if that track's lanes are hidden, the AUTOMATION button itself lights instead of the arrangement rearranging itself under your pointer.
EXPAND triples a lane's height. An expanded lane prints the exact value beside every point and reveals a second button row — COPY, PASTE and OPERATE — for working on a selection of nodes.
Read [R] — plays back recorded automation. The parameter value follows the automation curve during playback, and the slider in the module window moves in real time.
Touch [T] — records while you're touching. During playback, moving the slider (or a MIDI-learned knob) records automation points at the current beat position. When you stop moving, playback resumes from the existing curve. Touch mode punches over existing automation — it erases and replaces the region you're touching.
Off [—] — lane exists but is bypassed. The parameter is not affected.
Editing points: Left-click in an automation lane to add a new point. Drag points to move them (both beat position and value). Hold Ctrl to disable beat snapping for fine positioning. Right-click a point to delete it.
Curves. By default the value moves linearly from one point to the next, but every point except the first can carry its own shape. Right-click a point and choose Curve In — Linear, Smooth, Ease In or Ease Out, the last two at two strengths. The shape describes the segment arriving at that point, which is why the first point in a lane has none. What is drawn is sampled with the same function the audio engine reads, so the curve you see is the curve that plays.
Selecting nodes. The Automation Select tool in the toolbar drags a box over points. While it is active the pointer does one thing only — no regions move, no playhead jumps, and no new points are drawn, so you can start the box inside a lane rather than having to begin outside one. Shift-drag adds to the selection. A marquee selects within a single lane: if the box spans several, the lane with the most points inside it wins. Selected nodes show a ring. Delete removes all of them as one undo step, and OPERATE on an expanded lane applies an operation — randomize, smooth, straighten — to the selection.
Context menu: Right-click anywhere in an automation lane to switch modes, add or delete points, clear all points, or delete the lane entirely.
Anything that changes the piece is undoable: adding, moving, curving and deleting points, clearing a lane, deleting a lane. A drag is one undo step, not one per pixel.
Anything that changes how you are looking at the piece is not: showing or hiding a track's lanes, and EXPAND. An undo stack full of "collapse lane" buries the edits you actually want back. Both are remembered in the saved project regardless.
Automation data is saved with the project and restored on load. The value holds at the first point before it, and at the last point after it.
08 MIDI Control
MIDI Learn
Every knob and slider in Phonon supports MIDI Learn and automation. Right-click any control to see the context menu:
Select 🎛 MIDI Learn, then move a knob or fader on your MIDI controller. The parameter is now bound — the on-screen slider moves in real time as you turn the physical knob. To remove a binding, right-click the same control and select Remove MIDI Binding.
Select ⤴ Add Automation Lane to create an automation lane for that parameter in the arrangement view. See Automation Lanes for details on recording and editing automation.
MIDI Recording
Any non-audio track can be armed to capture MIDI notes from a connected keyboard. There are two ways to arm:
- Select the track in the hierarchy and press R. This arms and auto-starts playback. Press R again to stop.
- Right-click the track header and choose ⏺ Capture MIDI. This only arms the track — playback must be started separately. Multiple tracks can be armed at once this way.
Arming has an important side-effect: if the track doesn't already have a MIDI Region module in its chain, one is added automatically, so keys you play become audible through the track's instrument stack immediately. This means you can audition sounds while the transport is stopped and actually hear them before recording anything.
Notes played during recording are committed to a fresh MIDI region on the track at the beat position where recording began. Velocity and per-note MIDI CC data (mod wheel, pitch bend, sustain) are captured alongside notes. Transport stop, pause, or pressing R again finalizes the region and disarms the track — arming is a per-take action, not a sticky mode.
Everything that governs when a take starts and stops — the count-in, the punch region, recording repeated takes, and recording MIDI tracks alongside audio ones in a single pass — is described under Recording. A loop brace does not wrap during a take: it goes dashed and the transport plays straight through.
Live MIDI
Live MIDI lets you play a track's instrument stack in real time from a connected keyboard, independent of record arming. This is the "play alongside the song" workflow: arm a bass track's live MIDI, play along with the arrangement while it plays, no recording, no commit.
Right-click a non-audio track for two menu entries:
- 🎹 Live MIDI: On / Off — toggle the feature on the track.
- Configure Live MIDI Range… — opens a modal where you set the note range (lowest and highest MIDI note) and optionally a specific source device.
The note range lets you split a keyboard across multiple tracks. A common setup: bass track listens to C1–B2, pad track listens to C3–B4, lead track listens to C5 and up. Play the keyboard and each zone automatically routes to the right track. Notes outside a track's range simply don't trigger it.
The source-device filter is useful when you have multiple MIDI inputs connected. For example, leave most tracks on "(Any device)" so any keyboard plays them, but restrict a sound-design track to a specific pad controller so random keyboard input doesn't trigger it accidentally.
Live MIDI requires the transport to be playing. Stop it and incoming notes are suppressed, so start playback — even on an empty song — before you play.
Multiple Input Devices
Phonon's MIDI input layer is a hub — it holds multiple devices open simultaneously and aggregates their events. In practice this means you can have a keyboard and a controller connected at the same time: the keyboard drives notes (for recording and live play), and the controller drives CC bindings (via MIDI Learn) and zone triggers, all without conflict.
Settings holds one preferred device, opened automatically on startup. A second connected device can still send input, but there is no Settings control for choosing it.
Settings & Persistence
Open ⚙ Settings to select and connect your MIDI input device. Phonon
remembers your device and auto-reconnects on startup. The device preference is stored at
%AppData%/Meadow/midi_device.txt.
MIDI parameter bindings (knob/slider assignments) are saved as a .midi sidecar
file alongside your project. Zone triggers are saved as a .zones sidecar file.
Live MIDI settings (enabled state, note range, preferred device name) are persisted in the
project file alongside each track. All are restored when you reload the project. Bindings become active once you open the module's editor window.
09 Recording
Phonon records audio inputs and MIDI performances onto the timeline, one track or several at once, with a count-in, punch points, and as many takes as you care to play. Everything a take produces is written to disk as its own file — nothing you play is discarded, including the pass you abandoned halfway through.
Arming and Starting
Select a track and press R, or click REC in the widened track header. What that means depends on the track: on an audio track it opens the chosen input and writes samples; on a MIDI or instrument track it captures what you play into a new MIDI region. Press R again — or Space, or Enter — to stop. Arming is a per-take action, not a sticky mode.
Recording holds the transport. While a take is running, an active loop brace stops wrapping and goes dashed: the transport plays straight through, so a loop you left on from an hour ago cannot silently cut your take in half. The punch region is the one thing that decides where a take starts and stops.
Count-In
The COUNT button in the widened track header sets the count-in. Right-click it for 0, 1, 2 or 4 bars — the setting is global, not per-track, because a count-in is a property of how you like to play rather than of one track.
The playhead waits exactly where you left it — at the record point — while the count is beaten out, and only then does the lead-in run up to it. Recording begins on the beat you chose, not a bar earlier.
During the count the playhead is drawn in yellow and the transport shows the bars remaining. Press Space at any time during the count to cancel: the take is abandoned and the playhead stays where it was, rather than starting playback.
The metronome during recording is its own setting, separate from the main metronome toggle — clicking it on for a take does not leave the metronome running over everything else afterwards.
Punch In
The PUNCH IN lane sits directly under LOOP. Drag across it to create a white punch region, drag its body or either edge to move it, right-click it to remove it. One punch region exists at a time.
With a punch region set, recording starts at its left edge — after any count-in — and stops at its right edge. Without one, recording runs linearly from the playhead until you stop it. The punch region is saved with the project.
Multiple Takes
Right-click a punch region and enable Record multiple takes. The punch region then loops, and every pass through it is captured as a separate take rather than overdubbed onto the last. The brace shows ↻ TAKES while this is on.
When you stop, the most recent whole take is placed on the timeline — not the
fragment you were part-way through when you decided you had it. Every other take,
including that unfinished one, is written to disk and kept. The
bank opens automatically on a multi-take stop so you can hear
what you got: audio takes land in the project's /samples/ folder and MIDI
takes in /midi/, numbered take-1, take-2 and so on.
To swap a different take onto the timeline, drag it out of the bank.
Naming and Colour
Before a take begins, Phonon asks for a name prefix and a
colour. The prefix is prepended to every file the take writes, so
gtr_take-1.wav is findable in a folder that otherwise fills up with
timestamps. The colour is worn by the recorded regions on the timeline and by their
entries in the bank, so a take you can see is a take you can find.
The prompt is on by default, and the dialog says where to turn it off.
Inputs
Phonon opens every channel your interface offers, not just the first. The INPUT button in an audio track's widened header chooses which channel that track records from, so an eight-input interface can feed eight tracks from eight different sources.
A track saved against an interface you no longer have falls back to the first available input rather than recording silence. Configure the device itself, along with sample rate and buffer size, in Settings.
Recording Several Tracks at Once
Every track header has a selection checkbox beside the M / S / A buttons. It mirrors the hierarchy's selection, and unlike clicking in the hierarchy it lets you tick as many tracks as you like.
With one or more ticked, RECORD TO SELECTED — above COLLAPSE, red-bordered — records all of them in a single pass. Audio and MIDI tracks record together: they share one count-in, one punch region, and one transport, so a live take of a played part against a sung one lines up without any nudging afterwards. The button counts what it will actually take, reading "RECORD TO 3 TRACKS" when three are ticked.
Two tracks pointed at the same input simply both record it. Buses, the master and the video track are never included, however they are selected — none of them has an input or an instrument to record.
A MIDI-only pass needs no audio device at all, and is not blocked by the absence of one.
10 Stem Bounce
Press Ctrl+Shift+B to arm a stem bounce. Phonon resets
to beat 0, starts playback, and records each track's audio output to individual WAV files
in real time. Press Stop to finalize — stems are saved to a timestamped
Stems - date - time/ folder alongside your project. Each file is named
with the track number and name (e.g., 01 - Synth.wav).
This captures VST output, effects, and everything in the signal chain — perfect for importing stems into another DAW or sharing individual track recordings.
For live audiovisual performance — playing music and visuals together as an instrument — see DJ Performance Mode.
11 Audio Tracks
Phonon supports audio tracks alongside its module-based tracks. Create an audio track (right-click Master → Add Audio Track), then drag WAV files onto it in the arrangement view. Record directly from your audio input with the built-in recording system.
Drag & drop import: Drag any WAV file onto an existing audio track lane. A ghost preview shows the exact placement and duration before dropping. Drop position snaps to the nearest beat. Multi-file drop supported. Supports 16-bit, 24-bit, and 32-bit float WAV files.
Audio recording: Press R to arm recording on the selected track.
Audio is trimmed to the beat boundary and auto-saved to the project's /samples/
folder. The count-in, punch points, multiple takes, per-track input selection and recording
several tracks at once all live under Recording. Configure input and
output devices and the sample rate in Settings.
Region editing: Right-click for context menu: Slice at Playhead, Split at Playhead, Copy, Paste, Loop toggle, Mute, Delete, and Convert to Multi Sampler (with automatic transient detection).
Effects chain: Audio tracks can have child modules just like any other track. Add effects (reverb, delay, EQ, etc.) as children of the audio track and they process the audio output in series.
Portable projects: Audio files are copied into the project's /samples/
folder when saving, so the project is self-contained. All audio processing operations (pitch shift,
reverse, normalize, etc.) also save to the project directory.
Audio Region Tools
Right-click an audio region to access a comprehensive set of non-destructive and destructive
audio processing tools. Destructive operations save a new WAV file to the project's
/samples/ directory.
📊 Analyze BPM: Onset detection with histogram binning. Shows primary BPM, half-time and double-time alternatives, and onset count. Click "Set BPM" to apply the detected tempo to the project transport.
🔄 Change BPM: Non-destructively retime the region to match a new tempo. Enter original and target BPM — the playback rate and duration adjust based on the BPM ratio, equivalent to a shift-drag retime. Warp markers scale proportionally. No resampling, no new files. Fully undoable.
🎯 Quantize To: Non-destructive audio quantization using warp markers. Transient detection finds onsets, then warp markers snap each transient to the nearest grid position (16th, 8th, or quarter notes). The original audio is untouched — playback reads through the warp map. For retimed regions, markers are automatically scaled to match the current playback rate. Set to "Off" to remove quantization and clear warp markers.
⇄ Reverse: Non-destructive reverse toggle. Flips the playback direction without modifying the original audio data. Works with all other non-destructive operations — reverse a retimed, quantized, looping region and everything composes correctly.
📢 Normalize To: Normalize peak level to 0 dB, −3 dB, or −6 dB.
🎵 Pitch Shift: Granular overlap-add pitch shifting. Presets: ±1, ±5, ±7, ±12 semitones plus custom input. Level-matched to input peak.
⏱ Remove Time Stretch: Appears only on retimed regions. Resets playback rate to 1.0× and restores the original region duration.
〰 Warp...: Opens the warp editor for non-destructive, per-region time manipulation. Place markers on the waveform and drag to stretch or compress specific sections while preserving pitch. See Warp Editor for full details.
🎵 Detect Pitch...: YIN pitch detection across the region with chord suggestions. Reports up to 6 detected pitch classes and scores 180 chord templates from the Harmonic Engine vocabulary. See Pitch Detection.
The DO Menu
The gold DO button, between the tool palette and the transport, opens a panel of command tiles that act on the current region selection. Each tile greys out when it does not apply, so the panel itself tells you what the selection can do.
Split at the playhead · Duplicate · Combine (two or more MIDI regions on one track) · Split Into Bars · Mute / Unmute, which relabels itself for what you have selected and works on audio as well as MIDI · Reverse (audio, non-destructive) · Fade In / Fade Out, where applying one clears the other · No Fade · Quantize, which opens a grid picker with a dot on the grid you used last, and Off to put the notes back where you played them · Export, the same bounce dialog as the toolbar BOUNCE button.
Each tile is a single undo entry however many regions it touches.
Region Tool Palette
A row of tool buttons beside the transport readout changes what dragging a region does. One tool is active at a time. Every tool is also a command-palette action ("Region Tool: Normal / Stretch / Loop / Fade / Slice / Automation Select").
Normal — click to select, drag the body to move, drag an edge to trim.
Stretch — dragging either gold edge always retimes the region, the same as holding Shift in Normal mode but without holding anything.
Loop — dragging a non-looping region's right gold edge turns looping on and takes the loop length from the drag itself, unlike the right-click Loop toggle, which always adds one whole extra repeat.
Fade — click near a region's start or end and drag to set a fade. Works on MIDI regions as well as audio; on a MIDI region the fade rides the track's output, after the gain stage.
Slice — click an audio or MIDI region to cut it in two at the pointer.
Automation Select — a marquee for automation nodes. While it is active the pointer does nothing else in the arrangement: no regions move, no playhead jumps, and no points are drawn, so a selection box can start inside a lane. Shift-drag adds to the selection.
Snapping. Region drags snap to the nearest whole beat. Hold Ctrl to turn snapping off for free positioning — including while stretching, where it can be pressed mid-drag once you can see where the edge is going to land.
Non-Destructive Time Stretching
Audio regions can be retimed non-destructively by holding Shift and dragging either gold edge (left or right). The original WAV file is untouched — only the playback rate changes. Two playback modes are available:
Pitch Shift (Varispeed): Changes playback speed and pitch together, like speeding up or slowing down a record. Stretching a region to 2× its original length plays it at half speed, one octave lower. The region label shows ⏩ and the current rate (e.g., "⏩0.50×").
Granular (Pitch-preserving): Changes playback speed while maintaining the original pitch using real-time granular overlap-add synthesis. The region label shows ⏱ and the rate (e.g., "⏱0.50×"). Good for tempo-matching loops and samples.
Composability: Retiming composes correctly with all other non-destructive operations. Warp markers scale proportionally on retime. Looping uses the retimed duration as the loop iteration size. Slicing preserves the playback rate and calculates correct NaturalBeats for each half. Remove retiming (right-click menu or Inspector button) scales warp markers back and restores the original duration.
The right playback method is chosen automatically from the region's state — whether it carries warp markers, and whether pitch is being preserved.
Warp Editor
Double-click an audio region to open the warp editor. The editor is a central hub for both timing and pitch correction, controlled by the Edit Layer dropdown.
Warp markers allow per-region, non-destructive time manipulation — stretch or compress specific sections of audio while preserving pitch, without modifying the original file.
Visual waveform: The full waveform is displayed through the warp map — as you drag markers, the waveform visually stretches and compresses in real-time.
Click to add markers: Click anywhere on the waveform to place a warp marker. Flanking markers are automatically created at the nearest transient peaks when needed.
Drag to adjust: Drag any marker left or right to retime that section. Markers are constrained between their neighbors to prevent crossing.
Right-click to delete: Remove any marker except the start/end anchors.
16th note grid: Grid overlay with bar numbers and beat markers for precise alignment.
Switch to Pitch mode via the Edit Layer dropdown for per-segment pitch correction.
Async analysis: On first switch to Pitch mode, the audio is analyzed in the background. A progress bar tracks the analysis. A Cancel button aborts the analysis and closes the warp editor. For short clips (<10 seconds), analysis is nearly instant. Results are cached — switching back to Timing and returning to Pitch does not re-analyze.
Pitch buckets: The audio is divided into segments (buckets) at transient boundaries and pitch changes. Each bucket shows its detected pitch as a note name (e.g., A4, F#2) and a horizontal orange line at its current pitch offset. Dashed vertical lines mark bucket boundaries.
Drag pitch lines: Hover over an orange pitch line (N/S cursor appears) and drag vertically to adjust the pitch. Snaps to 0.5 semitone increments, ±12 semitone range. The semitone offset is displayed as a label (e.g., "+3.0st", "−1.5st").
Right-click context menu:
• ✂ Split Bucket Here — divides the bucket at the click position. Both halves inherit the pitch shift.
• ⟶ Merge with Next / ⟵ Merge with Previous — combines adjacent buckets.
• ↺ Reset Pitch — sets the bucket's pitch shift back to 0.
Pitch method: Buckets shift pitch granularly by default, which preserves timing. Varispeed shifts pitch by reading faster or slower instead, subtly changing timing within each bucket.
Timing and pitch corrections compose correctly: the warp map resolves timing first (beat → source sample position), then pitch bucket adjustments are applied at that position. Both are fully non-destructive — original samples are never modified.
Pitch buckets are stored in absolute sample space, so they survive retime, slice (buckets split at the cut point), copy/paste (deep copied), and serialization. All warp editor changes push a single undo action when Done is clicked.
Pitch Detection & Chord Suggestions
Right-click an audio region → 🎵 Detect Pitch... to analyze the harmonic content using the YIN algorithm (2048-sample chunks with parabolic interpolation).
The analyzer scans the region and builds a 12-bin pitch class histogram weighted by detection confidence. The top 6 pitch classes are reported. Then every chord template in the Harmonic Engine's 180-chord vocabulary is scored against the detected pitches. The top 8 chord suggestions are shown with percentage match scores — useful for identifying the key of a sample or finding compatible chords for the harmonic engine.
Advanced Pitch Editing
Right-click an audio region → Advanced Pitch… for a blob-based pitch editor. Where the Warp Editor's pitch layer offers a handful of per-bucket semitone offsets, this analyses the region into individual blobs — one per note, each carrying its own pitch curve — which you can drag, reshape and blend into each other.
Mono — full editing. Drag a blob to retune it, flatten or exaggerate the vibrato and drift inside it, and reshape the transition into the next blob.
Poly — read-only. Stacked blobs show what pitches are living inside a chord, with a chord reading along the top for context.
Corrections render through the same pitch engine as the rest of Phonon's non-destructive pitch tools, so the result matches what those produce.
Stereo Audio Support
Phonon natively handles stereo WAV files. When a stereo file is imported, left and right channels are stored separately. A mono file carries no overhead for a second channel it does not have. All audio operations — reverse, normalize, pitch shift, quantize, change BPM, slice, copy/paste, time stretch, and warping — process both channels independently. Playback renders L/R through all paths including normal, rate-changed, pitch-preserved, and warped.
Snippet Arranger
The Snippet Arranger is a specialized region type on audio tracks for drum programming and sample chopping. It provides a layered timeline view where you place short audio clips — the way breakbeats were traditionally chopped and rearranged. Right-click an audio track lane → Create Snippet Region to get started.
A snippet region contains 8 independent layers, each holding any number of placed audio clips (snippets). Drag WAV files up to 5 seconds long into the snippet arranger to place them on a layer. Each layer can be labeled (e.g. "Kick", "Snare", "Hat"), muted, and has its own gain control. During playback, all non-muted layers are mixed together — each snippet's sample data is read at the correct beat offset and summed into the track's audio output.
Placement: Snippets snap to 16th notes by default. Hold Ctrl to snap to 32nd notes. Hold Shift+Ctrl to move freely with no grid snap.
Right-click: Right-click a snippet to open a context menu with 💾 Save to Audio Bank... (saves the snippet's audio to the shared library) and 🗑 Delete.
📦 Bank button: Opens a file picker pointed at the audio bank folder. Select one or more WAV files to load them as snippets at beat 0.
Selection: Hold Shift and click to multi-select snippets. Copy and paste groups of selected snippets.
Duration: Drag the left or right edge of a snippet to trim its duration. Hold Ctrl and drag the left or right edge to time-stretch the snippet (changes playback rate without affecting pitch).
Velocity: Drag the top edge of a snippet to adjust its gain (0–2×). Per-snippet velocity gives you natural dynamics — accent a snare hit, ghost a kick.
Playback rate: Each snippet stores its own playback rate multiplier (1.0 = normal, 2.0 = double speed / pitch up, 0.5 = half speed / pitch down). Ctrl-drag the edges to set this.
Stereo support: Mono and stereo WAVs are both supported. Stereo snippets are mixed to their respective channels.
When a snippet region is created, a Snippet MIDI module is automatically added to the track's module chain. This module watches snippet positions during playback and emits MIDI note events, so snippets can also trigger downstream synths and effects.
Per-layer MIDI note: Each of the 8 layers has an assignable MIDI note (0–127, or −1 to disable). When a snippet's start position crosses the playhead, the module fires a NoteOn at the assigned pitch with the snippet's gain as velocity.
Per-layer decay: A decay multiplier (0.01–1.0) per layer scales the snippet duration for both audio envelope and NoteOff timing. At 1.0, the note sustains for the full snippet length. At lower values, the audio fades out early — the last 20% of the decay window is a linear fade to zero. This lets you create staccato hits from longer samples without editing each snippet individually.
Layer independence: MIDI note assignments and decay settings live on the Snippet Module (not on the region data), so they're shared across all snippet regions on the same track. Changing the kick layer's decay affects every snippet region on that track.
Break Editor
Right-click an audio region → Break… to convert it into a break region and open the Break editor — a second chop tool alongside the Snippet Arranger, built for breakbeat destruction rather than layered drum programming.
Three stacked panes: the Source bin at the top (drag a chop out of the waveform, click to audition it), the Timeline in the middle — 8 lanes, 1–8 bars, on a fixed 32nd-note grid — and the Slice inspector along the bottom.
A break opens with the one region you right-clicked, but the bin holds as many files as you add to it, which is what turns a chopper into a collage tool.
Reverse and Ratchet — each chop can play backwards and retrigger across its placed length.
Fit — Natural plays the chop at its own speed and cuts it off at the placed length; Stretch forces it to fill that length exactly, varispeed unless Preserve Pitch is set. The placed length is the stretch amount — there is no separate ratio.
Gain and pan, per slice, on top of per-lane mute and gain.
Every edit commits one undo entry onto the same stack as the arrangement — Ctrl+Z in the Break window and in the arrangement are the same history. Changing the break's bar count resizes the hosting region to hold a whole number of repeats.
Audio Region Display
Audio regions display their waveform overview with min/max aggregation. The waveform correctly reflects the current playback rate, reverse state, loop wrapping, and warp markers.
Patterns
The PATTERNS button opens a library of hand-written material — separate from the Pattern Bank, which browses files on disk. Nothing here is generated: every entry was written out by hand and kept because it played well.
230 eight-bar patterns across 46 families, from straight backbeats through to the veering end of breakcore. Each is a real arrangement rather than a one-bar loop repeated — several families are written as seven distinct bars and a fill, so nothing comes round twice.
40 phrases in 10 families — Hooks, Leads, Arpeggios, Basslines, Pads & Chords, Plucks & Stabs, Riffs, Ambient & Drift, Jazz Lines, Folk & Modal.
Align to Harmonic Engine transposes a phrase into the key and chord the engine is currently playing as it lands, so a phrase written in one key fits the song you are actually in.
Pattern Bank (MIDI & Audio)
The Pattern Bank is a persistent library of MIDI patterns and audio clips
stored in %APPDATA%/Phonon/Library/. Patterns and clips are saved as standard
files (MIDI Format 0 / 16-bit WAV) and are accessible across all projects.
Press B to open the bank window.
Save: Right-click any MIDI region → 💾 Save to Bank... — enter a name, saved as a standard MIDI file (480 PPQ, Format 0). Stored in Library/MidiBank/.
Browse: The bank window shows cards with name, date, BPM, note count, and a horizontal MIDI note preview strip. Newest files appear first.
Drag to arrange: Drag a card from the bank window onto any non-audio track lane. A ghost preview with note visualization appears during drag, snapping to the beat grid. Drop creates a new MIDI region with deep-cloned notes.
Delete: Click the ✕ button — confirmation dialog before deletion.
Save: Right-click any audio region → 💾 Save to Audio Bank... — saves just the region's slice (SampleOffset to duration), not the entire source file. 16-bit WAV. Stored in Library/AudioBank/. Also available from the snippet arranger: right-click a snippet → Save to Audio Bank.
Browse: The bank window has MIDI and Audio tabs. Audio cards show name, date, duration (seconds/ms), sample rate, mono/stereo, and a waveform peak preview strip.
Drag to arrange: Drag an audio card onto any track lane. Ghost preview with waveform visualization during drag. Drop creates an audio region at that position.
Load into Snippet Arranger: The snippet arranger has a 📦 Bank button that opens a file picker pointed at the audio bank folder. Select WAVs to load them as snippets.
Normal: Green-tinted region with waveform and filename label.
Muted: Dark grey fill with dimmed waveform, subdued border, and 🔇 prefix on the label.
Broken (missing file): Red-tinted region with diagonal hash lines, red border, and a ⚠ warning showing the missing filename.
Selected: Blue highlight border (Ctrl+A to select all). Drag any selected region to move all selected regions together.
Looping: Dashed lines at each loop boundary with ↻ markers. Loops update in real time as you resize the base content.
Gold edge markers: Both ends of the base audio content are marked with gold lines (#D0A840). For looping regions, the right gold edge marks the end of the first loop iteration, not the end of the total region. Three grabbable edges on looping regions: left gold (trim start), right gold (resize content), and loop end (extend/shorten total duration).
Stereo zoom: Press Z to double track height. Stereo regions show L and R channels stacked with a subtle divider line. The R channel uses a slightly different blue (#5090B0) for visual distinction. Mono regions get a taller single waveform.
MIDI and Audio are the shared libraries that follow you
between projects. Proj MIDI and Proj Audio point at the current
project's own midi/ and samples/ folders — where recorded takes land.
+ Add Folder… pins any folder on your computer into the bank as its own tab. Nothing is copied or moved; it is a live listing, remembered between sessions, removed again with the × on its tab. Large folders are listed in pages, so pointing the bank at a sample library with a thousand files in it does not stall.
Added folders live on the machine, not in the project — opening someone else's session does not add their drive letters to your bank, and moving a project between machines does not lose yours.
Audition — audio cards have a play/stop control, a progress indicator and a stop-all button, so you can hear a clip without placing it. Useful when a "sample" turns out to be a whole song.
Dragging out uses the operating system's own drag-and-drop, so it behaves like dragging any file: the arrangement shows its drop preview as you drag over it, and the same drag works into any other file-accepting target — the drum sequencer's sample slot, Explorer, another program entirely.
Bounce to Audio
Right-click any MIDI region → 🔊 Bounce to Audio to render a track's output to a stereo WAV file in real time. A modal dialog shows progress and provides a Cancel button — the main window is locked during bounce to prevent accidental changes.
The bounce captures the source track's audio output as it plays through the normal audio engine, including all effects in the track's chain. Other tracks are temporarily muted to prevent bleed. A 1-beat pre-roll lets synths and filters settle before capture begins.
When complete: the bounced stereo WAV is saved to the project's /samples/
folder, a new audio track is created with the audio placed at the original position, and the
source region is muted. The original region stays visible (dimmed) so you can unmute it to
go back to the live version.
📂 Show in Folder: Right-click any audio region → 📂 Show in Folder to open the containing folder in your file manager with the file selected. Works on Windows (Explorer), macOS (Finder), and Linux (xdg-open).
MIDI Editing
Double-click a MIDI region in the arrangement to open the Piano Roll editor. The piano roll provides a full-featured MIDI note editing experience.
Note editing: Click to place notes. Drag note body to move. Drag edges to resize. Right-click to delete. Notes snap to the selected grid (1/4, 1/8, 1/16, 1/32). Hold Ctrl for free (unsnapped) mode.
Multi-selection: Click to select a single note. Shift+click to add/remove from selection. Shift+drag on empty space for box select. Ctrl+A to select all. Delete removes all selected notes.
Arrow keys: ↑/↓ transpose selected notes by 1 semitone. ←/→ move by one grid step. Shift+←/→ for fine nudge (1/64th note).
Velocity editing: Ctrl+drag on a note body to adjust velocity vertically. Note color reflects velocity: blue (quiet) → red (loud). Multiple selected notes adjust by the same delta from their original values.
Multi-note resize: Select multiple notes, then drag the edge of any selected note to resize all of them by the same amount. Works for both left and right edges.
Copy/paste: Ctrl+C copies selected notes. Ctrl+V pastes at the playhead position (or after the last note if stopped). Relative positions are preserved.
Live sync: Changes to region length, loop settings, or notes from outside the piano roll are reflected immediately — no need to close and reopen the editor.
Harmonic highlighting: With the Harmonic Engine running, the grid shades the notes that fit the harmony, and it shades them bar by bar — a region spanning a progression shows each chord’s own tones under the stretch of the region that plays over it, rather than one set taken from wherever the playhead happens to be. Resize or move the region and the shading is re-cut to match. The ♫ Harmony button in the toolbar turns it on and off from inside the roll, and it defaults to chord tones. Press ♯ Refresh Key to pull the key again.
Named rows: The key gutter labels the drum-kit rows by name — Kick, Snare, CH, OH, Ride, LoTom — beside the note numbers, so a drum part reads as parts rather than as pitches.
Convert Loops to Regions: Right-click a looping MIDI region → 🔀 Convert Loops to Regions to expand each loop iteration into its own independent MIDI region, editable separately.
Per-note pitch bend: Each note can be bent into and out of, dialled in the note inspector along the bottom of the roll — see Pitch Bend. The shape is drawn beside the note, a semitone to a row, so a scoop visibly rises into the pitch it is written at.
Big Mode: Click 🔍 Big Mode in the toolbar for 5× taller notes at 2× horizontal zoom — room to place a note exactly, and to read the bend drawn beside it, on a part that is otherwise a sliver.
Variant generation: Right-click a MIDI region → 🧬 Generate Variant After... to create a new region placed after the source with melodic, rhythmic, or combined variation. Scale-aware (detects key from the notes). 4 melodic strategies, 6 rhythmic strategies. Undoable.
Click a key in the left-hand keyboard column to hear that note through the track's instrument and select every note at that pitch — the toolbar reports how many. On a drum map that is how you grab every hit on one lane at once. The MIDI note number lives here too, as a column down the gutter rather than repeated on every note block.
A panel along the bottom of the piano roll shows performance controls for the current selection: RATCHET, PROBABILITY, VELOCITY and MUTE. It reads "nothing selected" when nothing is, and "mixed" when the selected notes disagree.
Ratchet — eight blocks, 1–8. The note retriggers that many times across its own length.
Probability — drag the bar for the chance the note sounds on any given pass. It snaps to "always" near the top, and the fill only turns gold below 100%, so a roll full of certainties stays quiet and the conditional notes stand out.
Velocity — drag the bar for the whole selection. The reading is given twice: the MIDI number, and the dynamic marking it means (ppp–fff). The bar is filled in the note's own colour, the same one the note is drawn in above, so the panel and the roll always agree.
Mute — muted notes are skipped entirely rather than played quietly, and are drawn in flat grey instead of their velocity colour: "not in the music", not "played softly".
A drag across Probability or Velocity is one undo entry, however many values it passes through on the way.
The Zoop button opens a stride picker — off, or every 1, 2, 3, 4, 6 or 8 sixteenths. With a stride set, dragging across the roll lays a sixteenth-note every N steps out from where you started, on that pitch: a straight run at "every sixteenth", sparser patterns wider out. Zoop notes are always exactly a sixteenth long whatever the quantize grid says, and the whole gesture is one undo entry.
The drum sequencer has one too — the same gesture, in the place it came from. Its ⚡ Zoop button offers off, or every 2, 3, 4, 6 or 8 steps, and a drag lays a hit every N steps along that track.
The two differ in one way worth knowing. In the drum sequencer, "off" means paint every step — dragging along a lane fills it, which is what you usually want from a hi-hat. In the piano roll, dragging does not place a note at every position it passes, so the piano roll's picker has an extra setting the drum sequencer's does not need: every sixteenth, which is how you ask for the straight run that the drum grid gives you by default.
Zoom in far enough — Ctrl+scroll, or big mode — and the drawn grid subdivides to 32nds and then 64ths, so a zoomed-in view is never mostly empty space with nothing to place a note against. This is purely visual; it does not change what notes snap to.
Pitch Bend
A note can be bent into and out of. Bend in and the note starts off pitch and slides onto it — a scoop from below, or a fall onto the note from above. Bend out and it leaves as it releases. Both are dialled per note in the BEND tile of the note inspector, along the bottom of the piano roll.
IN and OUT — a depth in semitones, up to an octave either way. Negative comes from below, positive from above. Drag to set.
LEN — how much of the note each bend takes, as a percentage of its length. Either side may take the whole note.
When both sides ask for more of the note than there is, they split in ratio: two bends at 100% meet in the middle at half each, and 100% against 50% gives two thirds to one third. The tile shows what each side was granted beside what it asked for.
The bend is drawn alongside the note in the roll, a semitone to a row — the same vertical unit as the rest of the grid — so a two-semitone scoop reaches down exactly two rows and climbs from there.
Bending retunes a note that is already sounding, without restriking it, and each voice bends on its own — so one note of a held chord can slide while the others stay put.
Which instruments bend. The flagship and component-modelled synths retune a sounding voice: Cascadia, Mount Etna, Mesa Verde, Shinjuku, Namib, Big Sur, Mariana, the Flagship polysynth, Hamamatsu, Lexington 2600, Keio MS-20, Tomo, Vitriol, Baryon Bass, Consensus Supersaw and Remanence Pad. The measured and physically modelled instruments hold the pitch they were struck at, as the real things do — and the BEND tile says so plainly rather than taking a number that would not be heard. Layer a synth that bends onto the track and the control comes alive.
Bends save with the project and survive copy, paste and variant generation.
MIDI Output
The MIDI Out module sends MIDI to external hardware synths via Windows MIDI (winmm.dll). Supports channel remap, transpose, velocity scaling, MIDI clock, and transport messages. Place the module in a track's chain after whatever generates notes (MIDI Region, Piano Roll, sequencer, or arpeggiator) and configure the output device in Settings.
A few details worth knowing: clock pulses are timed by beat position rather than wallclock, so they stay locked to tempo through BPM changes and loop wraparound. Retrigger handling sends an implicit NoteOff before a new NoteOn on the same pitch, which is important for hardware synths that track gate state and would otherwise drop the retrigger. Transport stop silences all active notes plus sends All-Notes-Off as a safety net. The Panic button triggers the same cleanup on demand.
Pitch to MIDI
The Pitch → MIDI module uses the YIN algorithm to detect pitch from audio input and convert it to MIDI notes in real time. Features chord quantization (snaps to current Harmonic Engine chord), time quantize (quarter/eighth/sixteenth grid), and configurable smoothing. Sing a melody and it becomes MIDI notes.
Microtonal Tuning
Phonon supports full microtonal compatibility through a global TuningTable. Every synthesizer module references the tuning table instead of hardcoding 12-tone equal temperament. Change the tuning and every synth in the project retunes instantly. The tuning system is serialized with the project file.
Access via right-click Master → 🎵 Tuning submenu.
9 built-in presets: 12-TET (standard), Just Intonation (5-limit), Pythagorean (3-limit), 19-TET, 22-TET, 24-TET (quarter-tone), 31-TET (excellent just intonation approximation), 53-TET (Turkish music), and Bohlen-Pierce (13 equal divisions of the tritave — a non-octave-repeating scale).
Scala file import: Load any .scl file — the standard
microtonal tuning format with thousands of scales available online. Supports both
cents and ratio pitch definitions, and non-octave-repeating periods.
Reference pitch: Adjustable A4 reference (432 Hz, 440 Hz, etc.). The tuning table stores 128 frequency entries and is serialized with the project.
Combined with the Harmonic Engine, microtonal tuning creates chord progressions that use the actual interval relationships of the selected tuning — a major chord in 31-TET uses genuinely different intervals than in 12-TET.
The piano roll dynamically adapts to the active tuning system. It is not a 12-TET grid with microtonal notes crammed between the cracks — the grid itself restructures.
Grid rows = scale degrees. In 19-EDO you get 19 rows per octave. In 31-EDO, 31. Octave boundary lines appear at the correct period boundary for any tuning, including non-octave scales like Bohlen-Pierce.
Color-coded rows: Root notes are highlighted in blue and perfect-fifth equivalents (~702¢) get a subtle highlight. Seven degrees show as "white keys" and the rest as "black keys," giving visual orientation in unfamiliar tunings.
White-key scheme: For any non-12 tuning, a Keys dropdown appears in the piano-roll toolbar with two ways of choosing those seven white keys:
· Classic — the degrees nearest the familiar major-scale intervals (0, 200, 400, 500, 700, 900, 1100¢). A direct approximation of the 12-tone layout — handy for getting your bearings.
· Regular Diatonic — takes whichever degree is closest to a pure 3/2 fifth (~702¢) and stacks seven of them from F (F–C–G–D–A–E–B), revealing the tuning's own diatonic structure instead of approximating 12-TET. In a tuning like 22-EDO this lays out the true diatonic scale where direct approximation would distort it. The choice is saved with the project.
Tuning-aware labels: Root notes show degree and octave (e.g., 0:4 in
non-12 tunings, standard note names in 12-TET). Note labels on MIDI events update to match.
12 Visuals & Video
Phonon integrates a real-time visual engine and hardware-accelerated video playback into a unified system. Press the V key to open the Visualizer — a real-time audio-reactive visual display powered by OpenGL. The visualizer renders in a separate window that defaults to topmost (press T to toggle).
Visual Node Graph
The visual node graph provides a shader patching environment where you combine multiple visual generators and effects into complex compositions. Each node generates or transforms a visual signal. Connect nodes with cables to build effect chains — for example, feed a video clip through a Kaleidoscope node, a Color Map, and a Feedback node for endlessly evolving processed imagery.
Visual patches are saved and restored with the project.
Node Palette
191 nodes across 14 categories. Right-click the graph canvas to browse them by category.
Output
Where a patch ends — the screen, or a transition between scenes.
Source
Signals coming in: audio, CV, MIDI, the video track, another scene.
Generator
2D image generators — the usual place to start a patch.
Static Pattern
Fixed patterns, useful as masks and texture.
3D Shapes
Raymarched geometry. Feed one into a Render node to light it.
Shape Mods
Modify a 3D shape before it is rendered.
3D Transform
Bend, repeat and warp 3D space itself.
3D Texture
Surface treatments for 3D shapes.
Render
Turn 3D geometry into an image — each is a lit scene preset.
Transform
Move, warp and repeat a 2D image.
Blend
Combine two images.
Effect
Colour, grain, glitch and bloom treatments.
CV
Control-voltage sources and shapers for driving node parameters.
Utility
Plumbing — split a signal, choose between signals.
Video Track
Phonon includes a dedicated video track at the bottom of the arrangement view. Video playback is hardware-accelerated — via Windows Media Foundation (DXVA) on Windows and AVFoundation / VideoToolbox on macOS — and feeds directly into the visual node graph through the Video In node.
Adding clips: Drag .mov, .mp4, .avi,
.mkv, or .webm files from your file explorer onto the video track.
Clips appear as regions with filmstrip thumbnail previews. A loading dialog appears while
audio is extracted from the video file.
Moving clips: Click and drag a clip to reposition it on the timeline. Snaps to beat grid.
Resizing clips: Drag the gold handles on the left or right edge. Resizing adjusts the portion of video the region covers — the playback speed scales proportionally.
Minimum clip size: 1/16th note (0.25 beats).
Video regions are beat-locked — their size in beats never changes when BPM changes. A 1-bar video region is always 1 bar (4 beats), regardless of tempo.
When BPM changes, the video playback speed adjusts automatically to fill the same number of beats. At half the original BPM, the video plays at half speed. At double BPM, double speed. This happens per-frame with no artifacts.
Slicing a region divides its video portion proportionally — each slice plays exactly its share of the original video at whatever speed the current tempo demands.
Right-click a video region for:
✂ Slice at Playhead: Splits the region into two at the current playhead position. Both halves reference the same video file with correct video offsets and durations.
📋 Copy / Paste: Copy a region to the clipboard, then right-click empty space and paste at the playhead position. Audio data and thumbnails are preserved.
⎘ Duplicate: Creates an identical copy placed immediately after the original.
🔇 Mute Audio: Mutes the audio for an individual video region.
🗑 Delete: Removes the region from the timeline.
Video Audio Track
Below the video track, a dedicated Video Audio lane displays and controls the audio embedded in video files. Audio is extracted automatically when a video file is loaded using NAudio (via Media Foundation).
Waveform display: Each video region shows its extracted audio waveform — blue min/max rendering, clipped to region bounds. Muted regions appear dimmed with a 🔇 icon.
M (Mute) button: Mutes all video audio on the track.
Gain slider: 0–2× range (default 0.7). Drag to adjust. Unity gain is marked at center. Shows dB readout. Orange tint when gain exceeds unity.
Per-region mute: Right-click a waveform region → 🔇 Mute Audio / 🔊 Unmute Audio.
BPM-synchronized: Video audio playback speed matches the video — when tempo changes, audio stretches proportionally using linear interpolation for pitch-preserving playback.
Video Playback Engine
Video decoding stays a few seconds ahead of the playhead, pre-seeking upcoming clips and the loop point, so playback and looping stay seamless.
Video clips are beat-synced — they play in time with the transport. Scrubbing the playhead (even when stopped) updates the visual display in real time. When the playhead is outside any video region, the display goes black.
The visuals window preserves the video's aspect ratio regardless of window size — letterboxing (black bars left/right) or pillarboxing (top/bottom) is applied automatically.
When two video regions overlap on the timeline, Phonon automatically crossfades between them on the GPU. The blend is computed per frame on the GPU, so it costs nothing in playback performance.
The Video In node outputs to the visual node graph just like any generator node. This means you can route video through any combination of shader effects — Kaleidoscope, Color Map, Feedback, Distort, Edge Detect, and more. Effects process in real time at the video's native frame rate.
In DJ Performance Mode each deck carries its own visual graph, so crossfading between decks blends both the music and the video processing chain simultaneously.
Export & Bounce
Phonon supports three export modes, accessed via the Record button:
Arms the transport — press Play to begin capturing the master output to a WAV file. Press Stop or reach the End of Song marker to finalize. Audio is captured exactly as it sounds during playback, including all effects, VSTs, and video audio.
Renders the master output to WAV faster than real time — a 5-minute song can export in under a minute. The audio engine is stopped during bounce to prevent interference. Requires an End of Song marker (right-click a region → 🏁 Set End of Song Here).
⚠ VST instruments may be unstable during offline bounce.
Renders synchronized video + audio to an H.264 + AAC MP4 file using Media Foundation. A resolution picker lets you choose:
1280×720 (720p) · 1920×1080 (1080p) · 2560×1440 (1440p) · 3840×2160 (4K)
Frame rate options: 24, 30, or 60 fps.
The visual node graph is rendered offscreen at the target resolution — the visuals window opens automatically if needed, and rendering is independent of the window size. A progress bar with cancel button shows rendering status.
Requires an End of Song marker. Video output includes the full shader effects chain — whatever the visuals window shows during playback is what gets encoded.
13 DJ Performance Mode
DJ Performance Mode is in beta. Everything described here is expected to work, but the workflow is still being refined around how people actually perform with it — which controls, transitions and behaviours matter most in a live set. Expect this area to change, and send feedback if something is missing.
Phonon includes a full DJ performance system where each "song" is an entire Phonon project — synths, effects, video, visual shaders, and all. Click the DJ button (two circles icon, pinned to the bottom of the drawer column), or press Ctrl+P, to enter DJ mode. A confirmation dialog appears; clicking "Yes" activates performance mode.
Layout
In DJ mode, the arrangement view splits into two side-by-side timelines: Deck A (left, blue) and Deck B (right, orange). Each has its own playhead, scroll position, and ruler. The Preview Drawer switches to a centered DJ control layout.
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.
Dual Deck System
Each deck is a fully independent song state — its own tracks, clock, CV, video, and visual graph. Deck A is the currently loaded project. Deck B loads via the LOAD button in the background, with video decoders deferred until playback starts to eliminate loading stutter.
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. Deck B mixes in alongside Deck A once DJ mode is active, using the same pre-rendered buffer that makes scratching instant.
DJ Mixer
The center module provides full DJ mixing controls, all custom-drawn:
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 A→B and SYNC B→A (copy BPM between decks in either direction) — LOAD buttons (per deck, opens file picker) — BPM display (per deck).
Audio & Video Crossfade
The crossfader controls both audio mixing and video blending simultaneously. Audio uses an equal-power crossfader curve. Video crossfade GPU-blends between Deck A and Deck B video frames. When only one deck has video, it displays that deck's video regardless of crossfader position.
Vinyl Scratching
Click and drag the vinyl platters to scratch. The system uses an offline pre-rendered audio buffer for instant, artifact-free scratching:
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.
Recently viewed frames stay cached, so scrubbing back and forth during a scratch is instant. If a frame is not cached yet the last good one holds, rather than cutting to black.
Performance Zones
A dedicated Performance Track sits at the bottom of the arrangement view. It holds Performance Zones — named, colored regions that mark sections of your song for DJ navigation.
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.
DJ Control Panel
Separate module to the right of the decks. Two columns (Deck A blue, Deck B orange) with grouped buttons:
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.
DJ Effects Chain
Each deck has its own independent effects chain. The effects module sits to the right of the DJ control panel with 4 knobs per deck. The entire DJ drawer scrolls horizontally via vertical mouse wheel.
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).
DJ Info Bars
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.
DJ Mode Notes
Disabled in DJ mode — use per-deck Play/Pause buttons or double-click the vinyl platters.
Click the DJ button or press Ctrl+P — Escape does not leave DJ mode. The arrangement view restores to single-timeline mode, Deck B stops, and the drawer returns to normal tabbed layout.
14 Blocks
Blocks is Phonon's visual patching environment — a modular synthesizer canvas where you build instruments, effects, and signal processors from individual nodes connected by cables. Add a Blocks module via the top-level ⬡ Add Blocks item in the track right-click menu. The node library currently ships with 124 nodes across 13 categories (I/O, Source, CV Source, Modulator, Operator, Comparator, Converter, Effect, Filter, Gate, MIDI, Utility, SubBlocks).
Overview
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
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.
Node Reference
124 nodes across 13 categories. Each category has its own menu submenu and a distinct header color on the canvas.
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 — 4-pole transistor 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 with zero latency.
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. A Step input advances to the next connected input on every hit (Forward, Ping-Pong or Random) and takes over from Select while it is cabled.
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.
Right-click the Blocks canvas → ⬡ Full Patches to instantiate a complete starter graph atomically. 8 included presets: Plucked Strings (Karplus-Strong bell), DX Bass (FM Operator chain), Formant Pad (unison + formant filter), Acid Lead (ladder filter + envelope), Turing Sequence (generative CV pattern), Ratcheted Bass (gate-subdivision groove), Chord Progression (ChordBuilder + ADSR), Comb Drone (detuned comb filter harmony). Confirmation dialog before replacing an existing graph.
15 Glyph Scripting
Glyph is Phonon's built-in audio-rate scripting language. Write text code that executes at 48,000 samples per second inside the Blocks visual patching environment. Glyph scripts live inside Script nodes — add one via right-click → Source → Script, or choose a preset from the ⬡ Script Presets submenu. Double-click a Script node (or right-click → ⬡ Edit Script) to open the code editor. Press Ctrl+Enter to compile.
Overview
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.
Types & Variables
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).
I/O Ports
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. The Volume knob multiplies only the first two outputs — audio left and right by convention; control outputs such as Trigger and Envelope pass through unattenuated, so turning Volume down cannot weaken a trigger. Outputs reach the connected cable.
Operators
+ 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
Control Flow
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.
Built-in Functions
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.
Special Variables
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
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);
Examples
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 Presets
Right-click the Blocks canvas → ⬡ Script Presets to add pre-written Script nodes. Each spawns with the code loaded and the custom label set. Open the script editor to study the code and modify it — presets are designed as both useful instruments and teaching examples.
[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.
16 GlyphVis Shaders
GlyphVis is Phonon's visual shader scripting language — a companion to Glyph (audio scripting) that runs on the GPU. Write fragment shaders using familiar Glyph-style syntax and they render in real-time inside the Visual Graph. GlyphVis scripts can react to audio, read CV buses, receive signals directly from Blocks patches, and be composited with video through the visual node graph's blend and effect nodes.
Overview
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 texture inputs for compositing with upstream nodes — the
node grows another as you fill the last, up to eight, read as tex(0, uv) through
tex(7, uv) — a texture output for downstream effects, and five
float inputs (Audio1, Audio2, CV1, CV2, CV3) for 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.
Syntax & Types
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:
Injected helpers:
hash, noise, fbm, hsv2rgb,
rot2 — and the input accessors audio_in,
audio_in2, cv_in, cv_in2, cv_in3.
These are written into the shader header before your code, so a variable of the same name
shadows the function and the shader stops compiling.
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.
Audio Reactivity
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 five float input ports — Audio1, Audio2, CV1, CV2 and CV3. Wire source nodes (Audio Bus, CV Bus, Blocks In, MIDI Bus…) to them and read them in the script:
audio_in() — Audio1.
audio_in2() — Audio2.
cv_in() — CV1.
cv_in2() — CV2.
cv_in3() — CV3.
So a patch can take, say, bass on Audio1 and highs on Audio2 while three separate LFOs drive the CV ports, without any of them having to be merged first.
// 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));
Blocks→Visual Bridge
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.
Built-in Functions
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.
Parameters
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.
Source Nodes
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).
Turns a track's MIDI into CV: five outputs — Env, Gate, Vel, Pitch and Voices — so notes you play can drive the visuals directly. Auto Range learns the tessitura of what is actually being played and scales Pitch into it, rather than mapping the whole MIDI range and leaving a bassline crammed into the bottom of the output.
Fires on a specific note or note range — a hit for a visual event rather than a continuous signal. Its Step output counts hits rather than reporting a level, so it is immune to envelope and velocity edge cases; cable it into a Selector's Step input to rotate the visuals on every kick.
Brings another visual scene in as a texture, so scenes can be composed out of scenes.
Utility Nodes
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.
A Step input advances to the next connected input on every hit — Forward, Ping-Pong or Random — and takes over from Select whenever it is cabled, so a Note Trigger's Step output can rotate the visuals in time with the drums.
CV Nodes
CV nodes output float values that can be wired to any float input on other visual nodes (shader uniforms, selector CVs, etc.). They enable animation and modulation without audio input.
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), Range (Bipolar/Unipolar — Unipolar folds the output into 0…1 rather than −1…+1).
VLFO — an LFO for glacial rates, where the ordinary one bottoms out.
Audio In, Low Freq, Mid Freq, High Freq, Vocal Range — audio analysis as CV, either whole or split into bands.
Lowpass Filter, Highpass Filter, Bandpass Filter — smooth or sharpen a CV signal before it drives anything.
Math and Map — combine two CVs, or rescale one from one range into another.
Shape Probe — samples a 3D shape's distance field at a point and gives you the distance as CV, so geometry can drive the rest of the patch.
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).
Examples
// 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;
Visual Presets
Right-click the Visual Graph canvas → ◆ Script Presets to add pre-written GlyphVis shaders. Each spawns a compiled GlyphVisNode with inline param sliders. Open the script editor to study the code and customize.
[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).
16 GlyphSDF 3D Shapes
GlyphSDF is Phonon's user-scriptable 3D generator: you write one GLSL distance function, and the node wraps it in the house raymarcher — camera, tumble, lighting, four CV-modulatable knobs, a violet Warp input for 3D Transformer chains, and a gold Shape output that drops your scripted geometry straight into Blend 3D, Cloner, Shatter, Shape Sequencer, and every presentation renderer (Studio, Glass, Museum, Cosmos, …). This section is the complete reference for the scripting contract.
The Contract
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.
Design your shape centered on the origin at roughly unit scale (a bounding
radius of about 0.5–0.9 reads best). The preview camera sits at z = -2.5;
presentation renderers place their floors at about y = -1.3 and frame a subject
of that size. The Zoom knob rescales your shape without touching the script
(space is divided by Zoom and the returned distances are corrected automatically), so favor
readable numbers over exact framing.
The Environment Your Script Sees
These are in scope inside sdf and any helper:
| Name | Type | Meaning |
|---|---|---|
uTime | float | Seconds since playback started. The animation clock. |
uBass | float | Low-band energy follower, ~0–1. |
uMid | float | Mid-band energy follower, ~0–1. |
uHigh | float | High-band energy follower, ~0–1. |
uBeat | float | Beat impulse: spikes on detected beats, decays fast. |
uAudioTex | sampler2D | The shared 512×2 audio texture (see below). |
pU1 … pU4 | float | The node's P1–P4 sliders, 0–1. Each has a CV input port, so any LFO/envelope/probe in the graph can drive them. |
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.
P1–P4 — yours. They arrive as pU1–pU4 and mean
whatever your script says they mean. Comment the meanings at the top of the script —
future-you will thank you.
Hue — house shading tint. Preview only — when your shape is consumed through the Shape output, the consumer does the shading and Hue is ignored.
Zoom — rescales the shape (distance-corrected, always safe).
Spin — two-axis tumble applied outside your function. Your
sdf always sees unrotated local space — don't add your own tumble unless you
want both.
Step — march step damping, 0.3–1.0. The safety valve for imperfect distance fields — see Honest Distances.
Zoom, Spin, and Step travel with the shape through the gold Shape output; P1–P4 stay live and CV-modulatable inside any consumer, no matter how deeply the shape is nested.
Language Rules
Scripts are GLSL ES 3.00 fragments (ANGLE-translated on Windows). The usual GLSL toolbox
applies: length, dot, cross, mix,
clamp, smoothstep, min/max,
abs, mod, floor/fract,
sin/cos/atan, pow/exp,
swizzles, vec2/3/4, mat2/3/4, constant-bound for
loops with break.
Never name a function or global any of these:
init, map, main — the node
generates functions with these names around your script.
pal, domainWarp, domainDamp —
house functions that share the shader with your script in preview mode.
GLSL reserved words that are easy to reach for accidentally:
layout, sample, filter, input,
output, union, buffer, half.
Everything else is fair game — and thanks to namespacing (see Graph Integration) you don't have to worry about other scripts' names, only these.
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.
Keep loop bounds constant (for (int i = 0; i < 6; i++)
with an early break is fine; a loop bound computed from a uniform is not).
Avoid mutable arrays indexed by a variable — ANGLE compiles these to indexable temp registers, roughly 10× slower. Unroll or restructure.
Remember your sdf runs per pixel per march step — up to
~100 times per pixel. A texture() fetch or sin chain you'd never
notice once adds up fast. Hoist what you can into constants.
Distance-Field Craft
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.
Anything can move: positions by uTime, radii by uBass, weld
factors by pU1. The house pattern for audio-reactivity:
uBass/uMid/uHigh for smooth
breathing and swelling.
uBeat for accents (add it to a size or displacement).
uAudioTex when different regions of the shape should follow
different frequencies.
Honest Distances (or: Why Your Shape Has Holes)
The raymarcher trusts your return value: it steps forward exactly that far. If you ever return a distance larger than the true distance, rays overshoot thin features and you get holes, flicker, or a shape that comes apart while rotating.
Displacement (d += sin(...)), non-uniform scaling, twisting or bending
space by hand, and domain repetition near cell borders.
1. Scale the return: return d * 0.5; — halves the step size
for just this shape. The presets do this wherever they displace
(* 0.45, * 0.6, …).
2. Lower the Step knob — same effect, dialable live without editing, and it travels with the shape into consumers.
Rule of thumb: heavy displacement wants * 0.4–0.6; mild
rounding and welding needs nothing.
Playing with the Rest of the Graph
3D Transformer chains (Twist, Fractalize, Mirror XYZ, Stereo 4D, …) cable into the
Warp input and bend space before your function sees it —
p arrives pre-warped, in world orientation, before Spin and Zoom are applied.
Your script needs no changes to be twistable, foldable, or repeated.
Cabling Shape into a consumer (Blend 3D, Cloner, Shatter, Sequencer, or any presentation renderer) splices your script into that consumer's shader at compile time:
Your P1–P4 stay live and CV-driven inside the consumer.
Hue is ignored (the consumer shades); Zoom/Spin/Step still apply.
When only the Shape output is cabled, the GlyphSDF node's own preview pass is skipped entirely — a scripted shape feeding a Blend costs nothing extra.
Nesting depth (blends of blends of …) is capped at 4.
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.
Add a GlyphSDF from the 3D category — the plain node, or one of the
[sdf] preset entries with a teaching script preloaded.
Edit via right-click → Edit SDF Script. Apply
(or Ctrl+Enter) performs a structural check — the source must contain
float sdf(vec3 and have balanced braces — then hands the script to the node,
which recompiles itself and every consumer downstream of its Shape output.
Script edits are undoable, and the script is saved inside the project (and travels with copied/pasted nodes).
| Symptom | Cause | Fix |
|---|---|---|
| Node renders black | GLSL compile error | Details are in the debug log ([VisualGraph] … shader log). Usual suspects: missing semicolon, reserved name, non-constant loop bound. |
| Holes / flicker / crumbling edges | Overstated distances | Scale the return down, or lower Step. |
| Shape clips or vanishes in renderers | Too large for the stage | Keep the shape inside ~1.1 radius of the origin; use the node's Zoom rather than building it huge. |
| Runs hot | Per-step cost | Constant loop bounds, no variable array indexing, fewer texture() calls per step. |
| Works alone, breaks inside a Blend | Colliding un-namespaced construct | Rename global arrays / structs / macros to something unique. |
The Presets, as a Syllabus
Each [sdf] preset in the add-node menu teaches one technique:
| Preset | Teaches |
|---|---|
| Pulsing Gem | The minimal script: one primitive, rounding, a uBeat accent. Start here. |
| Spectral Urchin | Sampling uAudioTex so geometry maps the spectrum spatially. |
| Metaball Trio | Smooth-min welding, orbital motion, per-band followers. |
| Endless Columns | Domain repetition with mod(), per-cell hashing. |
| Nested Shells | Onioning with abs(), boolean subtraction cutaways. |
A good learning path is to open each, twist P1–P4 while reading the comments, then break something on purpose and watch what happens.
A Complete Worked Example
Everything above in ~20 lines — an audio-reactive gear ring with a knob-driven tooth count feel, safe stepping, and a beat accent:
// GEAR RING — P1 = tooth depth, P2 = ring thickness, P3 = spin rate.
const float TAU = 6.28318;
float sdf(vec3 p) {
// rotate the ring with P3 (this is *inside* the shape's own space,
// independent of the node's Spin tumble)
float a = uTime * (0.2 + pU3 * 1.5);
float c = cos(a), s = sin(a);
p.xz = mat2(c, -s, s, c) * p.xz;
// torus body, breathing with the bass
float R = 0.62 + uBass * 0.08;
vec2 q = vec2(length(p.xz) - R, p.y);
float d = length(q) - (0.10 + pU2 * 0.10);
// teeth: displace by the angle around the ring
float ang = atan(p.z, p.x);
d += sin(ang * 16.0) * (0.02 + pU1 * 0.04) * (1.0 + uBeat * 0.8);
// displaced field → step gently
return d * 0.6;
}
Cable a Twist 3D into Warp, its Shape output into a Studio Render, an LFO into P1, and a Light node into Studio's Light A — nothing in the script changes, and all of it composes.
18 Project
Save / Load
Projects are saved as .phonon files containing the full hierarchy,
all module states, arrangement regions, BPM, performance zones, visual graph data,
and global settings. Additional data is stored in sidecar files:
| File | Contents |
|---|---|
MySong.phonon | Full project state — hierarchy, modules, regions, automation lanes, BPM, zones |
MySong.phonon.studer | Tuber console channel strip settings |
MySong.phonon.midi | MIDI parameter bindings (CC → knob/slider) |
MySong.phonon.zones | Performance zone MIDI trigger assignments |
samples/ | Project sample directory — WAV files used by audio tracks, One-Shot Sampler, Tracker, etc., and where recorded audio takes are written. Copied automatically on save for portability. |
midi/ | Recorded MIDI takes, one .mid file per take. Browsable from the bank's Proj MIDI tab. |
meshes/ | 3D meshes used by visual nodes, copied in on save the same way samples are. |
The first time you save, Phonon creates a project directory (e.g., MySong/MySong.phonon)
to keep sidecar files organized. If you've already saved into a matching directory, it detects this.
| Action | Shortcut |
|---|---|
| New Project | Ctrl+N — confirmation dialog, then clears everything |
| Save | Ctrl+S — first save prompts for location |
| Open | Ctrl+O — opens file dialog |
| Extract to New Project | Ctrl+E — select tracks to clone into a fresh project. Deep-clones selected tracks with all modules, regions, and settings. |
Undo / Redo
Undo reverses exactly one operation at a time — "delete this region", "move this track" — rather than rolling the whole project back to an earlier state. Up to 200 actions are stored in the history.
Audio regions: Delete, add, paste, move, slice, cross-track drag, loop toggle, mute/unmute, resize (left and right edges), retime (left and right edges), loop duration change.
Non-destructive audio: Reverse toggle, Change BPM, quantize (warp markers), retime method change, remove retiming. All operations store before/after snapshots including warp markers, sample offset, and playback rate.
Audio processing: Normalize, pitch shift. Undo restores the original sample data and file path.
MIDI transforms: Transpose, velocity mod, quantize grid (via Inspector sidebar). All non-destructive — undo restores the original transform values.
MIDI regions: Delete, create, paste, move, cross-track drag, split, combine.
Tracks & modules: Add track, add audio track, add audio bus, add module, delete track/module, mute/unmute module.
Audio import: Drag-and-drop file import.
Automation: Adding, moving, curving and deleting points, clearing a lane, deleting a lane. A drag is one entry; deleting a marquee selection is one entry however many nodes it covers.
Markers: Create, rename, recolour, move, resize, delete.
Video regions: Slice, move, resize, duplicate, delete, mute audio.
Performance zones: Create, rename, recolour, move, resize, delete.
Notes in the piano roll: Every edit, including a held arrow-key nudge and a drag across the note inspector — each is one entry for the whole gesture, not one per step.
Things that change how you are looking at the piece rather than the piece itself: showing or hiding a track's automation lanes, expanding a lane, moving the loop brace, collapsing track headers, and arming a track or toggling audition.
Creating a loop or punch region is undoable; moving one afterwards is not.
| Action | Shortcut |
|---|---|
| Undo | Ctrl+Z |
| Redo | Ctrl+Y or Ctrl+Shift+Z |
The undo stack is cleared when loading or creating a new project. Knob and slider edits are not recorded in the undo history — they are considered real-time performance actions.
History Panel
Press Ctrl+H to show the complete undo/redo history as a clickable list. It shares the right edge of the window with the Tonnetz, so opening one puts the other away; Ctrl+H again closes it and leaves the edge clear.
Each action is displayed with a descriptive label (e.g., "Delete track 'Drums'", "Slice 'beat.wav' at beat 12.0", "Pitch shift +7 semitones"). The current state is highlighted — actions above are the undo history, actions below are redo-able.
Click any entry to jump directly to that point in history. Multiple undo/redo steps are applied automatically. This is equivalent to pressing Ctrl+Z or Ctrl+Y multiple times, but with precise visual targeting.
The panel header shows the current position (e.g., "↶ HISTORY (5/12)"). A Clear button resets the entire history.
© 2026 Phonon Music Software