# SoundGraph AI Guide

**For people:** attach this file to a chat with an AI (ChatGPT, Claude, Gemini...) and describe the sound
you want, for example *"a calm night soundscape with crickets, soft wind and a slow pad in A minor"*.
Ask it for a `.soundgraph` file. Save its answer as `something.soundgraph`, then:

- **Unity:** drop the file anywhere under `Assets/`. It imports as a SoundGraph; double-click opens it.
  Any mistakes show in the Console and the file's Inspector.
- **Web editor:** press **Import** in the side bar and pick the file. Problems are listed when it opens.

If SoundGraph reports problems, paste them back to the AI and ask it to fix the file.

---

**For the AI:** everything below is the complete specification. Follow it exactly. When the user asks for
a sound, answer with ONE complete `.soundgraph` file in a single ```json code block (plain JSON: no
comments, no trailing commas, no `...`), followed by two or three sentences on what it does and which
values to change. Only use the node types, port names and setting values listed here; anything else is
rejected or skipped. Before you answer, go through the checklist at the end.

SoundGraph is a modular synthesizer: a graph of nodes (oscillators, filters, envelopes, sequencers,
effects) joined by wires. It runs in Unity games, in a web editor and on a Daisy Seed audio board.
There is no code: the file *is* the instrument.

## 1. The file

A `.soundgraph` file is a JSON object:

```json
{
  "format": "daisy-audio-patch",
  "version": 1,
  "name": "Night Pad",
  "modules": [ ... ],
  "connections": [ ... ],
  "groups": [ ... ],
  "properties": [ ... ]
}
```

| Field | Required | What |
| --- | --- | --- |
| `format` | yes | Always `"daisy-audio-patch"`. |
| `version` | yes | Always `1`. |
| `name` | yes | The graph's display name. |
| `modules` | yes | The nodes (below). |
| `connections` | yes | The wires (below). May be `[]`. |
| `groups` | no | Labelled boxes around nodes, for readability. |
| `properties` | no | Blackboard values a game or app can change at run time (section 4). |

### A module (node)

```json
{ "id": "osc", "type": "oscillator",
  "inputs": { "freq": 130.81, "amp": 0.3 },
  "settings": { "waveform": "polyblep_saw" },
  "editor": { "x": 300, "y": 0 } }
```

- `id`: a unique short name you choose: letters, digits, `_` or `-`. **No dots and no spaces** (wires use `id.port`).
- `type`: one of the node types in section 6, exactly as written.
- `inputs`: knob values for the node's inputs, as numbers. Leave an input out to use its default.
  An input that has a wire into it ignores its knob value and uses the wire instead.
- `settings`: discrete choices, always as **strings** (even numbers such as `"4"`). Leave one out for its default.
- `editor`: where the node sits on the canvas, in pixels. Lay the graph out left to right in signal order:
  about **270 px between columns** and **220 px between rows** (x grows to the right, y grows downward).
- `bypass` (optional): `true` passes audio straight through the node, as if it were switched off.

### A connection (wire)

```json
{ "from": "osc.out", "to": "env_amp.in" }
```

`from` is `"<module id>.<output name>"`, `to` is `"<module id>.<input name>"`. Wires always go from an
**output** to an **input**. One output can feed many inputs, but **an input takes one wire**: to add
signals together, use a Mixer.

### A group

```json
{ "title": "Drums", "modules": ["clock", "kick", "snare"] }
```

## 2. A complete example

A clock steps through eight values, a quantizer keeps them in C minor pentatonic, an envelope shapes each note and a reverb adds space.

```json
{
  "format": "daisy-audio-patch",
  "version": 1,
  "name": "Pentatonic Melody",
  "modules": [
    {
      "id": "clock",
      "type": "clock",
      "inputs": {
        "bpm": 240,
        "width": 0.4
      },
      "settings": {},
      "editor": {
        "x": 0,
        "y": 0
      }
    },
    {
      "id": "seq",
      "type": "steps",
      "inputs": {
        "min": -1,
        "max": 1
      },
      "settings": {
        "values": "0.5 0.7 0.6 0.9 0.5 0.3 0.6 0.4"
      },
      "editor": {
        "x": 270,
        "y": 0
      }
    },
    {
      "id": "scale",
      "type": "quantizer",
      "inputs": {},
      "settings": {
        "notes": "C D# F G A#"
      },
      "editor": {
        "x": 540,
        "y": 0
      }
    },
    {
      "id": "osc",
      "type": "oscillator",
      "inputs": {
        "freq": 261.63,
        "amp": 0.35
      },
      "settings": {
        "waveform": "polyblep_tri"
      },
      "editor": {
        "x": 810,
        "y": 0
      }
    },
    {
      "id": "env",
      "type": "adsr",
      "inputs": {
        "attack": 0.005,
        "decay": 0.25,
        "sustain": 0.3,
        "release": 0.4
      },
      "settings": {},
      "editor": {
        "x": 810,
        "y": 220
      }
    },
    {
      "id": "amp",
      "type": "vca",
      "inputs": {},
      "settings": {},
      "editor": {
        "x": 1080,
        "y": 0
      }
    },
    {
      "id": "room",
      "type": "reverb",
      "inputs": {
        "size": 1.1,
        "decay": 0.85,
        "mix": 0.3
      },
      "settings": {},
      "editor": {
        "x": 1350,
        "y": 0
      }
    },
    {
      "id": "out",
      "type": "output",
      "inputs": {},
      "settings": {},
      "editor": {
        "x": 1620,
        "y": 0
      }
    }
  ],
  "connections": [
    {
      "from": "clock.gate",
      "to": "seq.clock"
    },
    {
      "from": "seq.out",
      "to": "scale.in"
    },
    {
      "from": "scale.out",
      "to": "osc.voct"
    },
    {
      "from": "clock.gate",
      "to": "env.gate"
    },
    {
      "from": "osc.out",
      "to": "amp.in"
    },
    {
      "from": "env.out",
      "to": "amp.cv"
    },
    {
      "from": "amp.out",
      "to": "room.in"
    },
    {
      "from": "room.out",
      "to": "out.in"
    }
  ],
  "groups": [
    {
      "title": "Melody: steps -> scale -> pitch",
      "modules": [
        "clock",
        "seq",
        "scale"
      ]
    }
  ]
}
```

## 3. Signals

Every port has a type (its kind):

| Kind | Range | Used for |
| --- | --- | --- |
| mono | -1 .. 1 | Sound, one channel. Keep the level at the output below about 0.8. |
| stereo | -1 .. 1, twice | Sound, left and right on one wire (reverb, chorus, pan, sampler, output...). |
| cv | the input's range | Knob values: frequencies in Hz, times in seconds, levels 0..1. |
| gate | 0 or 1 | On/off. An input counts it as on above 0.5; triggers fire on the rise from off to on. |
| note | volts | One pitch, 1 V per octave (see below). |
| notes | volts | A chord: several pitches on one wire, one per voice. |
| gates | 0 .. 1 | A multi gate: one gate per voice, in the same order as the notes. |
| cvs | the input's range | A multi CV: one value per voice (e.g. an ADSR's `env` in multi gate). |
| vec2 | two values | A Vector 2: x and y on one wire (a Vector 2 property). |
| mono or stereo | -1 .. 1 | Filters, Amplifier, delays and most effects: a stereo wire in makes the node stereo (it runs once per side) and its audio outputs stereo; a mono wire keeps it mono. |
| scale | | A Scale property from the Blackboard, into a Quantizer's or Arpeggiator's `scale`. |

Wires between types convert: mono into stereo plays in both channels, stereo (or vec2) into mono takes the
left channel (x), notes or cvs into a single input take the first voice, gates into a single gate is on while
any voice is held, a single gate into gates drives every voice, and cv, gate, note and mono pass their value
as it is. Clip, MIDI and scale ports only take their own type. Match the units: an LFO into a filter
`cutoff` must output Hz.

**Pitch (1 V per octave).** Inputs called `voct` add octaves: frequency = `freq` x 2^voct, so 1 = one
octave up, 1/12 = one semitone, -1 = one octave down. 0 V is the node's own `freq`. The Quantizer and the
Chord Sequencer output pitches in volts where 0 V means C, so pair them with an oscillator whose `freq`
is a C: 65.41 (C2), 130.81 (C3), 261.63 (C4, the default), 523.25 (C5).

Note frequencies (4th octave; halve per octave down, double per octave up):
C 261.63, C# 277.18, D 293.66, D# 311.13, E 329.63, F 349.23, F# 369.99, G 392.00, G# 415.30,
A 440.00, A# 466.16, B 493.88.

**Polyphony.** The Oscillator's `voct` takes notes (a chord): every note on its wire plays as its
own voice (up to 8). With `gate` = `multi`, its `gates` input turns each voice on and off. A Chord Sequencer's `chord` output carries all four notes on one wire, so one wire
from `chord` to `voct` plays the chord; Transpose keeps a chord a chord. To *add* two pitch CVs
(e.g. a melody plus a transpose), add them first with a Scale / Offset or Mixer node, or use the
Quantizer's `offset`.

**Tempo.** Set a Clock's `bpm` to the song tempo and its `steps` setting to the pulses per beat you
need (`"4"` for 16th notes); its `beat` output keeps pulsing once per beat. Use one clock and Clock
Dividers for slower parts, so everything stays in sync. The Chord Sequencer has its own `bpm`;
set it to the song tempo or wire the clock's `beat` into its `clock` input.

## 4. Blackboard properties (controls for games and apps)

Properties are named values a game script (`SoundGraphSource.SetFloat("Daylight", 0.7f)`) or the user
can change while the sound plays. Declare them in `properties`, then add a node of type `property`
for each place that reads one:

```json
"properties": [
  { "name": "Daylight", "type": "float", "value": 0.5, "min": 0, "max": 1, "exposed": true },
  { "name": "Calm",     "type": "bool",  "value": 1, "exposed": true },
  { "name": "Chime",    "type": "trigger", "exposed": true }
]
```

```json
{ "id": "daylight", "type": "property", "property": "Daylight",
  "inputs": {}, "settings": { "mode": "smooth" }, "editor": { "x": 0, "y": 400 } }
```

- Property types: `float` (`value` between `min` and `max`), `bool` (`value` 0 or 1), `trigger` (no value; fires a short gate).
- The `property` node has one output, `out`, carrying the value. Its `mode` setting must match the type:
  `"smooth"` for float (glides, no clicks), `"step"` for bool (or a float that must jump), `"trigger"` for trigger.
- `property` must name an entry in `properties`. Several nodes may read the same property.
- Scale a 0..1 property into the range you need with a Scale / Offset node (e.g. scale 3000, offset 400 for
  a cutoff of 400..3400 Hz) before wiring it into an input.

## 5. Rules (SoundGraph rejects or skips anything that breaks them)

1. Exactly **one** `output` node, with something wired into its `in` (stereo; a mono wire plays on both sides).
2. At most **128 nodes** and **256 wires**. Small graphs (10-40 nodes) work best.
3. **No feedback loops**: a wire may not lead back, directly or through other nodes, to a node it came from.
   Use the effects' own `feedback` inputs instead.
4. Module ids are unique, have no dots or spaces.
5. Only the types, inputs, outputs and setting values in section 6. Names are case-sensitive.
6. Input values are numbers inside the input's range. Settings are strings from the listed options.
7. **Notes** settings (Quantizer `notes`) are note names separated by spaces, using sharps only:
   `C C# D D# E F F# G G# A A# B` (write `A#`, never `Bb`).
8. **Chords** settings (Chord Sequencer `chords`) are chords separated by spaces, each `Root[quality][:beats]`:
   root `C C# Db D D# Eb E F F# Gb G G# Ab A A# Bb B`; quality one of
   `(none = major) m 7 maj7 m7 sus2 sus4 dim aug 6 m6 add9 madd9 9 m9 dim7`; beats 1-16 (default 4).
   Example: `"Am7:4 Fmaj7:4 C:2 G:2"`. Up to 32 chords.
9. **Values** settings (Step Sequencer `values`, Oscillator Bank `registration`) are numbers 0..1
   separated by spaces, up to 16 (Step Sequencer) or 7 (registration).
10. Don't use the nodes that need the user's own files (`drums`, `granular`, `midivoices`, `sampler`) unless the user asks for them;
    leave their clip/MIDI setting `""` so the user picks the file in SoundGraph. Synthesized drums
    (`bassdrum`, `snare`, `hihat`, `synthbass`, `synthsnare`) need no files.
11. Don't use hardware controls (`button`, `knob`) unless the user asks for physical knobs or buttons.
    For values a game or app should change, use Blackboard properties (section 4).

## 6. Nodes

Every node you may use, by category. Kinds: mono and stereo (-1..1 sound), cv (a value), gate (0/1), note / notes (pitch). An input left out of `inputs` takes its default.

Quick list: **Control**: `adsr`, `ad`, `lfo`, `randomlfo`; **Drums**: `bassdrum`, `snare`, `hihat`, `synthbass`, `synthsnare`; **Dynamics**: `limiter`, `blend`; **Effects**: `chorus`, `flanger`, `phaser`, `tremolo`, `autowah`, `pitchshift`, `reverb`, `moddelay`, `allpass`, `diffuser`, `decimator`, `wavefolder`, `shaper`; **Filters**: `filter`, `ladder`, `onepole`, `soap`; **Noise**: `noise`, `dust`, `fractal`, `particle`, `grainlet`; **PhysicalModeling**: `karplus`, `stringvoice`, `modal`, `resonator`, `drip`; **Sampling**: `sampler`, `drums`, `granular`; **Synthesis**: `oscillator`, `fm2`, `varshape`, `harmonic`, `oscbank`, `formant`, `vosim`, `zosc`; **Utility**: `delay`, `dcblock`, `samplehold`, `looper`, `chance`, `lag`; **Sequencing**: `bpmclock`, `bpmstepper`, `steps`, `pianoroll`, `arpeggiator`, `chords`, `midivoices`, `quantizer`, `transpose`; **Math**: `add`, `subtract`, `multiply`, `divide`, `scale`, `remap`, `oneminus`, `minmax`, `clamp`, `abs`; **Logic**: `compare`, `trigger`, `toggle`, `and`, `or`, `not`, `xor`, `select`; **Mixing**: `mixer`, `vca`, `pan`, `split`, `merge`, `width`; **Input**: `mic`; **Output**: `output`, `visualiser`; **Daisy/Input**: `knob`, `button`.

#### Control

### `adsr` (ADSR Envelope)

Attack, decay, sustain, release envelope (0..1) while gate is held. Its header menu picks Single gate (one envelope) or Multi gate: gates takes a multi gate (e.g. MIDI Voices gates) and env gives one envelope per voice, in the same order; wire env into an Oscillator's gates for a separate envelope on every note. A single gate into gates drives every voice. Envelope for held notes: rises while `gate` is high (> 0.5), falls on release. Long attack/release (1-4 s) for pads; short (0.005/0.2) for plucks. Setting `gate` = `multi`: `gates` takes one gate per voice and `env` gives one envelope per voice.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `gate` | gate | 0 | 0 .. 1 |
| `attack` | cv | 0.01 | 0.001 .. 10 s |
| `decay` | cv | 0.1 | 0.001 .. 10 s |
| `sustain` | cv | 0.7 | 0 .. 1 |
| `release` | cv | 0.3 | 0.001 .. 10 s |
| `gates` | gates (poly) | 0 | 0 .. 1 |

Outputs: `out` (cv), `env` (cvs, all of e1/e2/e3/e4/e5/e6/e7/e8 on one wire)

- Setting `gate`: `single` / `multi`. Default `"single"`.

### `ad` (AD Envelope)

One-shot envelope started by each rising `trig`: plucks, percussion, accents. `end` pulses when it finishes.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `attack` | cv | 0.005 | 0.001 .. 10 s |
| `decay` | cv | 0.5 | 0.001 .. 10 s |

Outputs: `out` (cv), `end` (gate)

### `lfo` (LFO)

Slow wave for modulation. Header menu: Hz (freq) or Beats (one cycle every beat, at bpm or the patch tempo while synced). Slow wave for movement. out = offset + amp x wave(-1..1), so the output is already in the unit of the input you wire it to: to sweep a cutoff between 600 and 1400 Hz use offset 1000, amp 400.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` | cv | 1 | 0.01 .. 50 Hz |
| `bpm` | cv | 120 | 1 .. 600 BPM |
| `step` (shown as "beat") | cv | 1 | 0.03125 .. 32 beats |
| `amp` (shown as "depth") | cv | 1 | 0 .. 20000 |
| `offset` | cv | 0 | -20000 .. 20000 |

Outputs: `out` (cv)

- Setting `waveform`: `sine` / `tri` / `saw` / `ramp` / `square`. Default `"sine"`.
- Setting `timing`: `hz` / `beats`. Default `"hz"`.

### `randomlfo` (Random LFO)

Smooth random wave for modulation. Header menu: Hz (rate) or Beats (one cycle every beat, at bpm or the patch tempo while synced). Wandering random values, `rate` new targets per second. smooth 1 glides between them, 0 jumps. Same offset/amp rule as the LFO.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `rate` | cv | 1 | 0.01 .. 50 Hz |
| `bpm` | cv | 120 | 1 .. 600 BPM |
| `step` (shown as "beat") | cv | 1 | 0.03125 .. 32 beats |
| `smooth` | cv | 0 | 0 .. 1 |
| `amp` (shown as "depth") | cv | 1 | 0 .. 20000 |
| `offset` | cv | 0 | -20000 .. 20000 |

Outputs: `out` (cv)

- Setting `timing`: `hz` / `beats`. Default `"hz"`.

#### Drums

### `bassdrum` (Analog Bass Drum)

808-style kick. attackfm is the click at the start, selffm the punchy pitch drop. Wire a clock or divider into `trig`.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `freq` | cv | 50 | 20 .. 200 Hz |
| `tone` | cv | 0.5 | 0 .. 1 |
| `decay` | cv | 0.5 | 0 .. 1 |
| `accent` (shown as "velocity") | cv | 0.8 | 0 .. 1 |
| `attackfm` | cv | 0.5 | 0 .. 1 |
| `selffm` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

### `snare` (Analog Snare)

808-style snare. snappy is the amount of noise (the snares). Wire a gate into `trig` (usually on beats 2 and 4: a divider with div 2, shift 1 on a quarter-note clock).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `freq` | cv | 200 | 60 .. 800 Hz |
| `tone` | cv | 0.5 | 0 .. 1 |
| `decay` | cv | 0.5 | 0 .. 1 |
| `snappy` | cv | 0.5 | 0 .. 1 |
| `accent` (shown as "velocity") | cv | 0.6 | 0 .. 1 |

Outputs: `out` (mono)

### `hihat` (Hi-Hat)

808-style hi-hat from six square waves (or ring-modulated oscillators). Short decay = closed, long = open. Wire 8th or 16th note gates into `trig`; decay 0.1-0.3 closed, 0.6+ open.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `freq` | cv | 3000 | 500 .. 10000 Hz |
| `tone` | cv | 0.5 | 0 .. 1 |
| `decay` | cv | 0.3 | 0 .. 1 |
| `noisiness` | cv | 0.8 | 0 .. 1 |
| `accent` (shown as "velocity") | cv | 0.8 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `noise`: `square` / `ringmod`. Default `"square"`.

### `synthbass` (Synth Bass Drum)

Digital kick with a pitch envelope (fmamount, fmdecay) and dirt for distortion.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `freq` | cv | 60 | 20 .. 200 Hz |
| `tone` | cv | 0.5 | 0 .. 1 |
| `decay` | cv | 0.5 | 0 .. 1 |
| `dirt` | cv | 0.3 | 0 .. 1 |
| `fmamount` | cv | 0.5 | 0 .. 1 |
| `fmdecay` | cv | 0.5 | 0 .. 1 |
| `accent` (shown as "velocity") | cv | 0.8 | 0 .. 1 |

Outputs: `out` (mono)

### `synthsnare` (Synth Snare)

Digital snare: an FM body plus noise (snappy).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `freq` | cv | 200 | 60 .. 800 Hz |
| `fm` | cv | 0.5 | 0 .. 1 |
| `decay` | cv | 0.5 | 0 .. 1 |
| `snappy` | cv | 0.5 | 0 .. 1 |
| `accent` (shown as "velocity") | cv | 0.6 | 0 .. 1 |

Outputs: `out` (mono)

#### Dynamics

### `limiter` (Limiter)

Keeps peaks under full scale. pregain pushes the level into it. Put it last before the output when many voices or drums play together.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `pregain` | cv | 1 | 0 .. 8 |
| `in` | stereo | | |

Outputs: `out` (stereo)

### `blend` (Blend)

Crossfades between `a` and `b` (mix 0 = a, 1 = b).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | mono | 0 | -1 .. 1 |
| `b` | mono | 0 | -1 .. 1 |
| `mix` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

#### Effects

### `chorus` (Chorus)

Thickens a sound into stereo. Mono `in`, stereo `out`.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `rate` | cv | 0.4 | 0.01 .. 8 Hz |
| `depth` | cv | 4 | 0 .. 12 ms |
| `spread` | cv | 0.5 | 0 .. 1 |
| `feedback` | cv | 0.2 | 0 .. 0.9 |
| `mix` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (stereo)

### `flanger` (Flanger)

A very short swept delay mixed with the input: the jet-plane whoosh.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `rate` | cv | 0.3 | 0.01 .. 10 Hz |
| `depth` | cv | 0.5 | 0 .. 1 |
| `feedback` | cv | 0.5 | 0 .. 1 |
| `delay` | cv | 0.75 | 0 .. 1 |

Outputs: `out` (mono)

### `phaser` (Phaser)

Swept all-pass notches. More poles = more notches.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `rate` | cv | 0.3 | 0.01 .. 10 Hz |
| `depth` | cv | 0.5 | 0 .. 1 |
| `feedback` | cv | 0.2 | 0 .. 0.75 |
| `freq` | cv | 300 | 20 .. 20000 Hz |

Outputs: `out` (mono)

- Setting `poles`: `1` / `2` / `3` / `4` / `5` / `6` / `7` / `8`. Default `"4"`.

### `tremolo` (Tremolo)

Volume wobble.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `rate` | cv | 5 | 0.01 .. 20 Hz |
| `depth` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `waveform`: `sine` / `tri` / `saw` / `ramp` / `square`. Default `"sine"`.

### `autowah` (Auto-Wah)

A wah filter that follows the input's loudness.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `wah` | cv | 0.5 | 0 .. 1 |
| `mix` | cv | 1 | 0 .. 1 |
| `level` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

### `pitchshift` (Pitch Shift)

Shifts audio up/down in semitones (12 = an octave up: shimmer).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `shift` | cv | 12 | -24 .. 24 st |
| `window` | cv | 0.1 | 0.01 .. 0.25 s |
| `mix` | cv | 1 | 0 .. 1 |

Outputs: `out` (mono)

### `reverb` (Reverb)

Stereo hall. Wire a mono or stereo sound into `in`; wire `out` (stereo) into the output's `in`. mix 0.2-0.4 for space, 0.6+ for washes.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `size` | cv | 1 | 0.3 .. 1.5 |
| `decay` | cv | 0.8 | 0 .. 0.99 |
| `damping` | cv | 6000 | 500 .. 18000 Hz |
| `predelay` | cv | 0.02 | 0 .. 0.5 s |
| `mix` | cv | 0.35 | 0 .. 1 |
| `in` | stereo | | |

Outputs: `out` (stereo)

### `moddelay` (Mod Delay)

Delay with a wobbling time: tape-echo flavour.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `time` | cv | 0.3 | 0.001 .. 2 s |
| `feedback` | cv | 0.5 | 0 .. 0.98 |
| `rate` | cv | 0.3 | 0.01 .. 10 Hz |
| `depth` | cv | 3 | 0 .. 20 ms |
| `tone` | cv | 5000 | 200 .. 20000 Hz |
| `mix` | cv | 0.4 | 0 .. 1 |

Outputs: `wet` (mono), `mix` (mono)

### `allpass` (All-pass Delay)

A building block for diffusion and metallic tones; rarely needed.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `time` | cv | 0.1 | 0.001 .. 1 s |
| `gain` | cv | 0.76 | -0.98 .. 0.98 |

Outputs: `out` (mono)

### `diffuser` (Diffuser)

Smears transients (softens clicks and plucks) before a reverb or delay.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `size` | cv | 1 | 0.05 .. 2 |
| `gain` | cv | 0.76 | 0 .. 0.98 |
| `mix` | cv | 1 | 0 .. 1 |

Outputs: `out` (mono)

### `decimator` (Decimator)

Lo-fi: lowers the sample rate (downsample) and the bit depth (crush). Lo-fi / chiptune grit. Keep crush low for warmth.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `downsample` | cv | 0.3 | 0 .. 1 |
| `crush` | cv | 0.3 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `smooth`: `off` / `on`. Default `"off"`.

### `wavefolder` (Wavefolder)

Folds the wave back on itself when it goes past full scale: more gain = more folds and harmonics.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `gain` | cv | 2 | 0 .. 10 |
| `offset` | cv | 0 | -1 .. 1 |

Outputs: `out` (mono)

### `shaper` (Wave Shaper)

Distortion: fold (buzzy), saturate (warm), clip (hard).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `drive` | cv | 2 | 1 .. 20 |
| `bias` | cv | 0 | -1 .. 1 |
| `mix` | cv | 1 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `mode`: `fold` / `saturate` / `clip`. Default `"fold"`.

#### Filters

### `filter` (State Variable Filter)

12 dB state-variable filter with four outputs: `low` (warm), `high`, `band`, `notch`. Wire an LFO or envelope into `cutoff` for movement (wire values are in Hz, see LFO).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `cutoff` | cv | 1000 | 20 .. 20000 Hz |
| `resonance` | cv | 0.3 | 0 .. 1 |

Outputs: `low` (mono), `high` (mono), `band` (mono), `notch` (mono)

### `ladder` (Ladder Filter)

Moog-style ladder filter (Huovilainen model). resonance self-oscillates near 1.8; passband keeps the lows when resonance is high. Warm Moog-style low-pass; the classic for basses and pads.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `cutoff` | cv | 1000 | 20 .. 20000 Hz |
| `resonance` | cv | 0.3 | 0 .. 1.8 |
| `drive` | cv | 1 | 0 .. 4 |
| `passband` | cv | 0.5 | 0 .. 0.5 |

Outputs: `out` (mono)

- Setting `mode`: `lp24` / `lp12` / `bp24` / `bp12` / `hp24` / `hp12`. Default `"lp24"`.

### `onepole` (One-Pole Filter)

The gentlest filter (6 dB/octave). Cheap: good for smoothing or taming harshness.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `cutoff` | cv | 1000 | 20 .. 20000 Hz |

Outputs: `low` (mono), `high` (mono)

### `soap` (SOAP Filter)

Second-order all-pass band-pass and band-reject around center.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `center` | cv | 1000 | 20 .. 20000 Hz |
| `bandwidth` | cv | 200 | 10 .. 5000 Hz |

Outputs: `band` (mono), `notch` (mono)

#### Noise

### `noise` (Noise)

Wind, surf, breath, hi-hat colour. Usually through a filter. Pink is softer.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `amp` (shown as "volume") | cv | 0.3 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `color`: `white` / `pink`. Default `"white"`.

### `dust` (Dust)

Random single-sample clicks; density sets how often. Good for crackle, or to excite a Resonator.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `density` | cv | 0.5 | 0 .. 1 |
| `amp` (shown as "volume") | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

### `fractal` (Fractal Noise)

Five octaves of stepped noise added together: color 0 is bright, 1 is dark and rumbly. A low freq makes a wandering CV.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` | cv | 2000 | 0.1 .. 20000 Hz |
| `color` | cv | 0.5 | 0 .. 1 |
| `amp` (shown as "volume") | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

### `particle` (Particle Noise)

Random impulses through a resonant filter whose pitch jumps around freq by up to spread semitones, random times a second. Rain, crackle, chirps. raw is the unfiltered impulses. Rain, crackle, chirps, insects.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` | cv | 1000 | 20 .. 10000 Hz |
| `resonance` | cv | 0.9 | 0 .. 1 |
| `density` | cv | 0.5 | 0 .. 1 |
| `spread` | cv | 12 | 0 .. 48 st |
| `random` | cv | 1 | 0 .. 100 Hz |
| `sync` | gate | 0 | 0 .. 1 |
| `gain` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono), `raw` (mono)

### `grainlet` (Grainlet)

Granular formant oscillator: short bursts of a formant at the carrier's rate (Plaits). Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct, 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Coarse & Fine (whole semitones -24 to +24 and cents from middle C) or Frequency (freq in Hz); the other modes' knobs and inputs are hidden.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 261.63 | 1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `formant` | cv | 220 | 20 .. 8000 Hz |
| `shape` | cv | 0.5 | 0 .. 1 |
| `bleed` | cv | 0.5 | 0 .. 1 |
| `amp` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `pitch`: `note` / `coarse/fine` / `freq`. Default `"note"`.

#### PhysicalModeling

### `karplus` (Karplus String)

Karplus-Strong string: excite it with audio on in, or a trigger (a short noise burst). nonlinear < 0 curves, > 0 rattles. Needs a `trig` (or audio on `in`) to make sound.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `trig` | gate | 0 | 0 .. 1 |
| `freq` (shown as "tune") | cv | 220 | 20 .. 4000 Hz |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `brightness` | cv | 0.5 | 0 .. 1 |
| `damping` | cv | 0.5 | 0 .. 1 |
| `nonlinear` | cv | 0 | -1 .. 1 |

Outputs: `out` (mono)

### `stringvoice` (String Voice)

Plucked or bowed strings from Plaits. structure adds non-linear (sitar-like) character; sustain held high keeps it ringing. Needs a `trig` to make sound. Plucked guitars, harps, kotos.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `freq` (shown as "tune") | cv | 220 | 20 .. 4000 Hz |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `accent` (shown as "velocity") | cv | 0.6 | 0 .. 1 |
| `structure` | cv | 0.5 | 0 .. 1 |
| `brightness` | cv | 0.5 | 0 .. 1 |
| `damping` | cv | 0.5 | 0 .. 1 |
| `sustain` | gate | 0 | 0 .. 1 |

Outputs: `out` (mono), `aux` (mono)

### `modal` (Modal Voice)

Struck objects (bells, bars, plates) from Plaits. structure goes from wood to metal to glass; sustain held high bows it instead of striking. Needs a `trig` (or `sustain` high) to make sound. Pitch with `freq` + `voct`.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `freq` (shown as "tune") | cv | 220 | 20 .. 4000 Hz |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `accent` (shown as "velocity") | cv | 0.6 | 0 .. 1 |
| `structure` | cv | 0.5 | 0 .. 1 |
| `brightness` | cv | 0.5 | 0 .. 1 |
| `damping` | cv | 0.5 | 0 .. 1 |
| `sustain` | gate | 0 | 0 .. 1 |

Outputs: `out` (mono), `aux` (mono)

### `resonator` (Resonator)

A bank of tuned resonant modes (Rings): feed it noise, clicks or audio to make it ring at freq. Needs audio on `in` (Dust or a short noise burst works well).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `freq` (shown as "tune") | cv | 220 | 20 .. 4000 Hz |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `structure` | cv | 0.5 | 0 .. 1 |
| `brightness` | cv | 0.5 | 0 .. 1 |
| `damping` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

### `drip` (Drip)

Water droplets: each trigger starts a random burst of drips that fades over length. Water drops: trigger it from a Chance node for irregular drips.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `length` | cv | 0.2 | 0.01 .. 2 s |
| `amp` (shown as "volume") | cv | 0.8 | 0 .. 1 |

Outputs: `out` (mono)

#### Sampling

### `sampler` (Audio Sampler)

**Needs a file from the user: avoid unless asked.**

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `clip` | clip | 0 | 0 .. 16 |
| `trig` | gate | 0 | 0 .. 1 |
| `pitch` | cv | 0 | -24 .. 24 st |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `volume` | cv | 0.8 | 0 .. 2 |
| `start` | cv | 0 | 0 .. 1 |

Outputs: `end` (gate), `out` (stereo)

- Setting `clip`: a file the user picks: leave `""`. Default `""`.
- Setting `mode`: `one-shot` / `gate` / `loop`. Default `"one-shot"`.

### `drums` (Clip Sequencer)

Each row plays its clip on the marked steps. rate sets the step length; the small knob is the row volume. Each row's port (t1..t8) pulses when the row hits. **Needs a file from the user: avoid unless asked.**

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `clock` (shown as "gate") | gate | 0 | 0 .. 1 |
| `reset` | gate | 0 | 0 .. 1 |
| `bpm` | cv | 120 | 20 .. 300 bpm |
| `swing` | cv | 0 | 0 .. 0.75 |
| `volume` | cv | 0.8 | 0 .. 2 |
| `pitch` | cv | 0 | -24 .. 24 st |

Outputs: `step` (cv), `clock` (gate), `t1` (gate), `t2` (gate), `t3` (gate), `t4` (gate), `t5` (gate), `t6` (gate), `t7` (gate), `t8` (gate), `out` (stereo)

- Setting `beats`: `1` / `2` / `3` / `4` / `5` / `6` / `7` / `8` / `9` / `10` / `11` / `12` / `13` / `14` / `15` / `16` / `17` / `18` / `19` / `20` / `21` / `22` / `23` / `24` / `25` / `26` / `27` / `28` / `29` / `30` / `31` / `32`. Default `"16"`.
- Setting `rate`: `1/4` / `1/8` / `1/16` / `1/32`. Default `"1/16"`.
- Setting `tracks`: drum rows of the user's clips: leave `""`. Default `""`.

### `granular` (Granular)

A cloud of short grains from a clip: position picks where in the clip (0..1), spray scatters it, size and density shape the cloud, spread pans grains apart. **Needs a file from the user: avoid unless asked.**

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `clip` | clip | 0 | 0 .. 16 |
| `position` | cv | 0.5 | 0 .. 1 |
| `spray` | cv | 0.1 | 0 .. 1 |
| `size` | cv | 0.1 | 0.01 .. 1 s |
| `density` | cv | 10 | 0.5 .. 100 /s |
| `pitch` | cv | 0 | -24 .. 24 st |
| `volume` | cv | 0.8 | 0 .. 2 |
| `spread` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (stereo)

- Setting `clip`: a file the user picks: leave `""`. Default `""`.

#### Synthesis

### `oscillator` (Oscillator)

The basic synth voice. Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct with 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Notes (the same with a chord on notes: every note plays as its own voice; a multi wire into velocity, e.g. MIDI Voices velocity or gates, gives each voice its own level and 0 silences it), Coarse & Fine (whole semitones -24 to +24 and cents from middle C, no note input) or Frequency (freq in Hz). There is no gate: velocity does that job. Wired coarse values are rounded. For stereo, wire out into a Pan node. The basic synth voice. The `pitch` setting picks its inputs: `note` (default: `voct` is one note, 0 V = middle C, `coarse` (shown as transpose) shifts it in semitones, `fine` in cents, `amp` is the velocity), `notes` (same, but `voct` takes a chord and plays every note as its own voice; a multi wire into `amp` gives each voice its own velocity, 0 = silent, e.g. MIDI Voices `velocity` or an ADSR's `env` in multi gate), `coarse/fine` (`coarse` -24..24 semitones and `fine` cents from middle C, no note input) and `freq` (`freq` in Hz). There is no gate input: wire an envelope into `amp` or use an ADSR into a VCA. `out` is mono; for a panned voice wire it into a Pan node. `polyblep_*` waveforms are the clean, non-aliasing ones: prefer them over `saw`/`square`.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 261.63 | 0.1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note (poly) | 0 | -5 .. 5 V |
| `amp` | cv (poly) | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `waveform`: `sine` / `tri` / `saw` / `ramp` / `square` / `polyblep_tri` / `polyblep_saw` / `polyblep_square`. Default `"polyblep_saw"`.
- Setting `pitch`: `note` / `notes` / `coarse/fine` / `freq`. Default `"note"`.

### `fm2` (FM Oscillator)

Two-operator FM: a modulator at freq x ratio bends a sine carrier at freq. index is the FM depth (brightness). Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct, 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Coarse & Fine (whole semitones -24 to +24 and cents from middle C) or Frequency (freq in Hz); the other modes' knobs and inputs are hidden. Bells, electric pianos, metallic basses. Integer ratios (1, 2, 3) sound harmonic; 1.41, 3.5 sound clangy.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 261.63 | 1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `ratio` | cv | 2 | 0.125 .. 16 |
| `index` | cv | 1 | 0 .. 8 |
| `amp` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `pitch`: `note` / `coarse/fine` / `freq`. Default `"note"`.

### `varshape` (Variable Shape)

One oscillator morphing saw -> triangle -> square (shape 0..1); pw sets the pulse width / triangle slope. Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct, 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Coarse & Fine (whole semitones -24 to +24 and cents from middle C) or Frequency (freq in Hz); the other modes' knobs and inputs are hidden.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 261.63 | 1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `shape` | cv | 0 | 0 .. 1 |
| `pw` | cv | 0.5 | 0 .. 1 |
| `amp` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `pitch`: `note` / `coarse/fine` / `freq`. Default `"note"`.

### `harmonic` (Harmonic Oscillator)

Additive: 16 sine harmonics. bright sets how slowly upper harmonics fade, even the level of the even ones (0 = hollow, clarinet-like). Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct, 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Coarse & Fine (whole semitones -24 to +24 and cents from middle C) or Frequency (freq in Hz); the other modes' knobs and inputs are hidden. Organ-like additive tones; bright and even shape the timbre.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 261.63 | 1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `bright` | cv | 0.5 | 0 .. 1 |
| `even` | cv | 1 | 0 .. 1 |
| `amp` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `pitch`: `note` / `coarse/fine` / `freq`. Default `"note"`.

### `oscbank` (Oscillator Bank)

String-machine style divide-down organ: 7 levels for saw 8', square 8', saw 4', square 4', saw 2', square 2', saw 1'. Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct, 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Coarse & Fine (whole semitones -24 to +24 and cents from middle C) or Frequency (freq in Hz); the other modes' knobs and inputs are hidden. String-machine / organ with seven footage levels in `registration`.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 261.63 | 1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `gain` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `registration`: numbers 0..1 (rule 9), up to 7. Default `"1 0 0.6 0 0.4 0 0.2"`.
- Setting `pitch`: `note` / `coarse/fine` / `freq`. Default `"note"`.

### `formant` (Formant Oscillator)

A carrier at freq shaped by a formant at its own frequency: vowel-like, nasal tones. Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct, 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Coarse & Fine (whole semitones -24 to +24 and cents from middle C) or Frequency (freq in Hz); the other modes' knobs and inputs are hidden.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 261.63 | 1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `formant` | cv | 800 | 50 .. 8000 Hz |
| `phase` | cv | 0 | 0 .. 1 |
| `amp` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `pitch`: `note` / `coarse/fine` / `freq`. Default `"note"`.

### `vosim` (VOSIM)

Voice-like oscillator made of two formants (the classic VOSIM technique). Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct, 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Coarse & Fine (whole semitones -24 to +24 and cents from middle C) or Frequency (freq in Hz); the other modes' knobs and inputs are hidden.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 110 | 1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `formant1` | cv | 1390 | 100 .. 8000 Hz |
| `formant2` | cv | 817 | 100 .. 8000 Hz |
| `shape` | cv | 0.5 | -1 .. 1 |
| `amp` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `pitch`: `note` / `coarse/fine` / `freq`. Default `"note"`.

### `zosc` (Z Oscillator)

Sine-based formant oscillator with three modes (mode -1..1), from Mutable Instruments Plaits. Its header menu button picks how it is played (the pitch setting): Note (default: note is 1 V/oct, 0 V = middle C, transpose shifts it in semitones, fine in cents, amp is the velocity), Coarse & Fine (whole semitones -24 to +24 and cents from middle C) or Frequency (freq in Hz); the other modes' knobs and inputs are hidden.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `freq` (shown as "frequency") | cv | 220 | 1 .. 20000 Hz |
| `coarse` | cv | 0 | -24 .. 24 st |
| `fine` | cv | 0 | -100 .. 100 cents |
| `voct` (shown as "note") | note | 0 | -5 .. 5 V |
| `formant` | cv | 550 | 50 .. 8000 Hz |
| `shape` | cv | 1 | 0 .. 1 |
| `mode` | cv | 0 | -1 .. 1 |
| `amp` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (mono)

- Setting `pitch`: `note` / `coarse/fine` / `freq`. Default `"note"`.

#### Utility

### `delay` (Delay)

Echo. `mix` output is dry + wet; `wet` is only the echoes. A `time` of 60/BPM (or half) keeps echoes in time.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `time` | cv | 0.35 | 0.001 .. 4 s |
| `feedback` | cv | 0.45 | 0 .. 0.98 |
| `tone` | cv | 6000 | 200 .. 20000 Hz |
| `mix` | cv | 0.4 | 0 .. 1 |

Outputs: `wet` (mono), `mix` (mono)

### `dcblock` (DC Blocker)

Removes a DC offset (a wave that sits off zero), e.g. after a Wavefolder or Shaper. After a Wavefolder or Shaper with bias.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |

Outputs: `out` (mono)

### `samplehold` (Sample & Hold)

Grabs `in` on each rising `trig` and holds it: with noise or a random LFO in, it picks random notes.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | cv | 0 | -10 .. 10 |
| `trig` | gate | 0 | 0 .. 1 |

Outputs: `out` (cv)

### `looper` (Looper)

Records the input and loops it. A rising record starts recording, the next one starts the loop; later rises overdub (mode). clear empties it, reverse and half play backwards / at half speed while high. mix is in + loop.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `record` | gate | 0 | 0 .. 1 |
| `clear` | gate | 0 | 0 .. 1 |
| `reverse` | gate | 0 | 0 .. 1 |
| `half` | gate | 0 | 0 .. 1 |

Outputs: `loop` (mono), `mix` (mono)

- Setting `mode`: `normal` / `onetime_dub` / `replace` / `frippertronics`. Default `"normal"`.
- Setting `length`: `2s` / `5s` / `10s` / `20s` / `40s`. Default `"10s"`.

### `chance` (Chance)

Lets each gate through with probability `chance`; the rest come out of `else`. Great for generative rhythms.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` (shown as "gate") | gate | 0 | 0 .. 1 |
| `chance` | cv | 0.5 | 0 .. 1 |

Outputs: `out` (gate), `else` (gate)

### `lag` (Lag)

Smooths a CV: glides up over `rise` and down over `fall` seconds (portamento, slow controls).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | cv | 0 | -10 .. 10 |
| `rise` | cv | 0.1 | 0 .. 10 s |
| `fall` | cv | 0.1 | 0 .. 10 s |

Outputs: `out` (cv)

#### Sequencing

### `bpmclock` (Clock)

Pulses gate at a steady rate. Its header menu button picks the format (the rate setting): BPM (once per beat at bpm; use a BPM Stepper to pulse every few beats or several times a beat) or Time (once every time seconds, for slow events). width is how long each pulse stays high (a fraction of the interval). One `gate` pulse per beat at `bpm`. Feed it through a BPM Stepper for other rates. With setting `rate` = `time` it pulses every `time` seconds instead (slow events: every 30 s, every 5 min).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `bpm` | cv | 120 | 1 .. 600 BPM |
| `time` | cv | 1 | 0.01 .. 60 s |
| `width` | cv | 0.5 | 0.01 .. 0.99 |

Outputs: `gate` (gate)

- Setting `rate`: `bpm` / `time`. Default `"bpm"`.

### `bpmstepper` (Beat Divider)

Turns beat ticks on in into ticks every beat: 2, 4 ... 32 waits that many beats, 1/2 ... 1/32 splits each beat. width is how long each tick stays high. Changes a beat clock's rate: `step` 2, 4 .. 32 = a tick every that many beats, 1/2, 1/4 .. 1/32 = that many ticks per beat (1/4 = 16th notes). Snaps to powers of two.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` (shown as "gate") | gate | 0 | 0 .. 1 |
| `step` (shown as "beat") | cv | 1 | 0.03125 .. 32 beats |
| `width` | cv | 0.5 | 0.01 .. 0.99 |

Outputs: `out` (gate)

### `steps` (Step Sequencer)

Steps through up to 16 values (0..1), scaled to min..max: one step per rising edge on gate (wire a BPM Clock or a BPM Stepper in). reset jumps back to the first step. out is the level, gate follows the input gate, step is the step playing (0, 1, 2...). Up to 16 values (0..1) stepped on each rising gate (input `clock`, shown as gate), scaled to min..max. For melodies use min -1, max 1 and feed a Quantizer; `gate` follows the clock.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `clock` (shown as "gate") | gate | 0 | 0 .. 1 |
| `reset` | gate | 0 | 0 .. 1 |
| `min` | cv | 0 | -10 .. 10 |
| `max` | cv | 1 | -10 .. 10 |

Outputs: `out` (cv), `gate` (gate), `step` (cv)

- Setting `values`: numbers 0..1 (rule 9), up to 16. Default `"0.2 0.5 0.8 0.4 1 0.3 0.6 0.9"`.

### `pianoroll` (Piano Roll)

Plays the notes drawn on its roll (click the picture to edit), one grid step per clock edge. note holds the last note, gate is high while a note plays, trig pulses on each note. One note at a time. The easiest way to write a melody or bass line: wire a Clock's `gate` into `clock` (Clock `steps` 4 = sixteenth notes, so Piano Roll `steps` 16 = one bar of 4/4), `note` into an Oscillator's `voct` and `gate` into an ADSR. Write the notes in `roll`, e.g. `"C4:0:2 E4:4:2 G4:8:2 C5:12:4"`; notes must start inside the loop (start < bars x steps). One note plays at a time.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `clock` (shown as "gate") | gate | 0 | 0 .. 1 |
| `reset` | gate | 0 | 0 .. 1 |

Outputs: `note` (note), `gate` (gate), `trig` (gate), `step` (cv)

- Setting `bars`: `1` / `2` / `3` / `4` / `5` / `6` / `7` / `8` / `9` / `10` / `11` / `12` / `13` / `14` / `15` / `16`. Default `"1"`.
- Setting `steps`: `4` / `8` / `12` / `16` / `24` / `32`. Default `"16"`.
- Setting `roll`: piano roll notes, space-separated `note:start:length` (C4 = middle C, start and length in grid steps, the loop is bars x steps long), up to 64. Default `"C4:0:2 E4:4:2 G4:8:2 C5:12:4"`.

### `arpeggiator` (Arpeggiator)

Plays its notes one at a time on each rising clock: up, down, ping pong or random, over 1 to 4 octaves. A chord wired into scale is played instead, low to high. Plays the enabled notes one at a time, moving on at each rising `clock` (wire a Clock or Divider into it): `mode` up, down, pingpong (bounces without repeating the end notes) or random (never the same note twice in a row). Notes are played low to high from C whatever order you list them, then repeated `octaves` times (1..4) an octave higher each time. `out` is V/Oct (0 V = C; put a Transpose node after it to change key): wire it into an oscillator's `voct` whose `freq` is a C, and `gate` (follows the clock) into an AD or ADSR. `reset` jumps back to the start.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `clock` (shown as "gate") | gate | 0 | 0 .. 1 |
| `reset` | gate | 0 | 0 .. 1 |
| `octaves` | cv | 1 | 1 .. 4 |
| `scale` | notes (poly) | | |

Outputs: `out` (note), `gate` (gate), `step` (cv)

- Setting `notes`: note names (rule 7). Default `"C E G"`.
- Setting `mode`: `up` / `down` / `pingpong` / `random`. Default `"up"`.

### `chords` (Chord Sequencer)

Plays a list of chords, each for its own beats (bpm, or clock edges when wired). chord carries the notes on one wire; gate is high for width of each chord; step is the chord's position. Use a Transpose node to change key. A chord progression player with its own tempo (`bpm`, or wire a clock into `clock`; each chord lasts its number of beats). Wire `chord` into ONE oscillator's `voct` to play the whole chord (it carries all four notes on one wire; or take it apart with a Split node, format `notes`, to give each note its own sound), and `gate` into an ADSR. Chord pitches are relative to the oscillator's `freq` (C4 = 261.63 by default), so use `voct` -1 for a lower register, or a lower `freq` such as 130.81.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `clock` (shown as "gate") | gate | 0 | 0 .. 1 |
| `reset` | gate | 0 | 0 .. 1 |
| `bpm` | cv | 60 | 1 .. 300 BPM |
| `width` | cv | 0.9 | 0.01 .. 1 |

Outputs: `gate` (gate), `step` (cv), `chord` (notes, all of n1/n2/n3/n4 on one wire)

- Setting `chords`: chord list (rule 8). Default `"Am:4 F:4 C:4 G:4"`.
- Setting `order`: `forward` / `backward` / `pingpong` / `random`. Default `"forward"`.
- Setting `voicing`: `close` / `spread` / `drop2`. Default `"close"`.

### `midivoices` (MIDI Voices)

Plays a MIDI file on 8 voices. chord carries every voice's pitch, gates one gate per voice, velocity each voice's level. Wire chord and gates into one Oscillator to play the whole file. loop repeats the file while on. **Needs a file from the user: avoid unless asked.**

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `clip` | midi | 0 | 0 .. 16 |
| `clock` | gate | 0 | 0 .. 1 |
| `reset` | gate | 0 | 0 .. 1 |
| `loop` | gate | 1 | 0 .. 1 |
| `bpm` | cv | 0 | 0 .. 300 BPM |
| `transpose` | cv | 0 | -24 .. 24 st |
| `start` | cv | 0 | 0 .. 1 |

Outputs: `notes` (notes, all of n1/n2/n3/n4/n5/n6/n7/n8 on one wire), `gates` (gates, all of g1/g2/g3/g4/g5/g6/g7/g8 on one wire), `velocity` (cvs, all of v1/v2/v3/v4/v5/v6/v7/v8 on one wire)

- Setting `midi`: a file the user picks: leave `""`. Default `""`.
- Setting `track`: `all` / `1` / `2` / `3` / `4` / `5` / `6` / `7` / `8` / `9` / `10` / `11` / `12` / `13` / `14` / `15` / `16`. Default `"all"`.

### `quantizer` (Quantizer)

Snaps in to the nearest note of its scale (0 V = C). A chord wired into scale is the scale while wired. Snaps a pitch CV (volts, 1 V/octave, 0 V = C) to the enabled notes. The note names are relative to C, so the oscillator's `freq` should be a C (65.41, 130.81, 261.63, 523.25) or the whole scale shifts. `offset` transposes in semitones after quantizing.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | cv | 0 | -5 .. 5 V |
| `offset` | cv | 0 | -12 .. 12 st |
| `scale` | notes (poly) | | |

Outputs: `out` (note)

- Setting `notes`: note names (rule 7). Default `"C C# D D# E F F# G G# A A# B"`.

### `transpose` (Transpose)

Shifts a note or a chord by octave, semitones and fine (cents). A chord in comes out as the same chord, transposed. Shifts pitch CV by `semitones` and `octave` (whole steps). Its `note` input keeps wires apart, so a Chord Sequencer's `chord` comes out as the same chord, transposed: wire `out` into the oscillator's `voct`. Use it for key changes after a Piano Roll, Arpeggiator, Chord Sequencer or MIDI node.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `note` (shown as "chord") | notes (poly) | 0 | -5 .. 5 V |
| `semitones` | cv | 0 | -24 .. 24 st |
| `octave` | cv | 0 | -4 .. 4 |
| `fine` | cv | 0 | -100 .. 100 cents |

Outputs: `out` (notes, all of v1/v2/v3/v4/v5/v6/v7 on one wire)

#### Math

### `add` (Add)

out = a + b. With b unwired it adds a constant (b) to a signal. Adds two values (an input takes one wire, so this is how two CVs are summed), or a fixed amount (`b`).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | cv | 0 | -10 .. 10 |
| `b` | cv | 0 | -10 .. 10 |

Outputs: `out` (cv)

### `subtract` (Subtract)

out = a - b: the difference between two signals, or a minus a constant.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | cv | 0 | -10 .. 10 |
| `b` | cv | 0 | -10 .. 10 |

Outputs: `out` (cv)

### `multiply` (Multiply)

out = a x b. Two signals multiplied (ring modulation for audio), or a signal times a constant. Two LFOs multiplied give a more complex wobble; an envelope times an LFO makes a wobble that fades in and out.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | cv | 0 | -10 .. 10 |
| `b` | cv | 1 | -10 .. 10 |

Outputs: `out` (cv)

### `divide` (Divide)

out = a / b. Gives 0 while b is 0. Wire a property or a slow LFO into `b` to scale a signal down by a changing amount.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | cv | 0 | -10 .. 10 |
| `b` | cv | 1 | -10 .. 10 |

Outputs: `out` (cv)

### `scale` (Scale / Offset)

Maths on a CV: out = in x scale + offset. Use it to turn a 0..1 control into Hz, volts, etc.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | cv | 0 | -10 .. 10 |
| `scale` | cv | 1 | -10 .. 10 |
| `offset` | cv | 0 | -10 .. 10 |

Outputs: `out` (cv)

### `remap` (Remap)

Maps in from the in range to the out range (x = low, y = high). Swap the out values to flip it; clamp keeps the result inside the out range.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | cv | 0 | -10 .. 10 |
| `inrange` | vec2 | | |
| `outrange` | vec2 | | |

Outputs: `out` (cv)

- Setting `clamp`: `on` / `off`. Default `"on"`.

### `oneminus` (One Minus)

out = 1 - in. Flips a 0..1 value: 0 becomes 1, 0.25 becomes 0.75 (e.g. turn daylight into darkness, or an envelope upside down).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | cv | 0 | -10 .. 10 |

Outputs: `out` (cv)

### `minmax` (Min / Max)

min is the lower of a and b, max the higher.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | cv | 0 | -10 .. 10 |
| `b` | cv | 0 | -10 .. 10 |

Outputs: `min` (cv), `max` (cv)

### `clamp` (Clamp)

Keeps in between min and max: anything outside is held at the limit. Keeps a modulated value in a safe range, e.g. a level between 0 and 1 or a pitch CV within two octaves (-1..1 V).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | cv | 0 | -10 .. 10 |
| `min` | cv | -1 | -10 .. 10 |
| `max` | cv | 1 | -10 .. 10 |

Outputs: `out` (cv)

### `abs` (Abs)

out = |in|: negative values turn positive (a full-wave rectifier for audio). Turns a -1..1 LFO into a 0..1 bounce (twice as fast).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | cv | 0 | -10 .. 10 |

Outputs: `out` (cv)

#### Logic

### `compare` (Compare)

Compares a with b: greater is high while a > b, less while a < b, equal while they are within window of each other (only one is high at a time). Turns a CV into gates: an LFO into `a` with `b` 0 gives a square gate on `greater`; a Random LFO into `a` fires `greater` only when it goes past `b`.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | cv | 0 | -10 .. 10 |
| `b` | cv | 0 | -10 .. 10 |
| `window` | cv | 0 | 0 .. 10 |

Outputs: `greater` (gate), `less` (gate), `equal` (gate)

### `trigger` (Trigger)

Turns the edges of a gate into short pulses: rise fires when in goes high, fall when it goes low, each length seconds long. Use `fall` to start something when a note ends, or to make a short trig from a long gate.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` (shown as "gate") | gate | 0 | 0 .. 1 |
| `length` | cv | 0.005 | 0 .. 10 s |

Outputs: `rise` (gate), `fall` (gate)

### `toggle` (Toggle)

A flip-flop: each rising trig flips out between 0 and 1 (inv is the opposite). A rising reset sets out back to 0. Every other clock pulse: wire a clock into `trig` for a half-speed square gate, or a button to latch on/off.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `trig` | gate | 0 | 0 .. 1 |
| `reset` | gate | 0 | 0 .. 1 |

Outputs: `out` (gate), `inv` (gate)

### `and` (AND)

High (1) while both a and b are high (above 0.5), otherwise 0. Gate a rhythm with another: a clock AND a slow gate only plays during the slow gate.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | gate | 0 | 0 .. 1 |
| `b` | gate | 0 | 0 .. 1 |

Outputs: `out` (gate)

### `or` (OR)

High (1) while a or b (or both) is high (above 0.5), otherwise 0.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | gate | 0 | 0 .. 1 |
| `b` | gate | 0 | 0 .. 1 |

Outputs: `out` (gate)

### `not` (NOT)

Flips a gate: 1 while in is low (0.5 or under), 0 while it's high.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` (shown as "gate") | gate | 0 | 0 .. 1 |

Outputs: `out` (gate)

### `xor` (XOR)

High (1) while exactly one of a and b is high (above 0.5), otherwise 0. Two clock dividers XORed make syncopated rhythms.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | gate | 0 | 0 .. 1 |
| `b` | gate | 0 | 0 .. 1 |

Outputs: `out` (gate)

### `select` (Select)

A switch: out is a while sel is low, b while sel is high (above 0.5). Swaps between two signals (pitches, rhythms, sounds) with a gate, e.g. a Toggle or a slow clock.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `a` | cv | 0 | -10 .. 10 |
| `b` | cv | 0 | -10 .. 10 |
| `sel` | gate | 0 | 0 .. 1 |

Outputs: `out` (cv)

#### Mixing

### `mixer` (Mixer)

Adds up to 8 inputs. Mono inputs give a mono out; any stereo input makes it stereo (mono inputs play in both sides). Each wired input gets a gain knob; a new input shows when the last one is wired. Adds up to eight signals (`in1`..`in8`), each with its own gain (0..2). Mono inputs give a mono `out`; any stereo input makes it stereo (mono inputs go to both sides). Use it before effects or the output.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in1` | mono | 0 | -1 .. 1 |
| `in2` | mono | 0 | -1 .. 1 |
| `in3` | mono | 0 | -1 .. 1 |
| `in4` | mono | 0 | -1 .. 1 |
| `in5` | mono | 0 | -1 .. 1 |
| `in6` | mono | 0 | -1 .. 1 |
| `in7` | mono | 0 | -1 .. 1 |
| `in8` | mono | 0 | -1 .. 1 |
| `gain1` | cv | 1 | 0 .. 2 |
| `gain2` | cv | 1 | 0 .. 2 |
| `gain3` | cv | 1 | 0 .. 2 |
| `gain4` | cv | 1 | 0 .. 2 |
| `gain5` | cv | 1 | 0 .. 2 |
| `gain6` | cv | 1 | 0 .. 2 |
| `gain7` | cv | 1 | 0 .. 2 |
| `gain8` | cv | 1 | 0 .. 2 |

Outputs: `out` (mono)

### `vca` (Amplifier)

Volume control: out = in x cv. Wire an envelope into `cv` to shape each note. Not clamped: keep cv in 0..1.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | mono | 0 | -1 .. 1 |
| `cv` (shown as "volume") | cv | 1 | 0 .. 1 |

Outputs: `out` (mono)

### `pan` (Pan)

Places a sound in stereo (-1 left .. 1 right). `in` and `out` are stereo (a mono wire into `in` feeds both sides).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `pan` | cv | 0 | -1 .. 1 |
| `in` | stereo | | |

Outputs: `out` (stereo)

### `split` (Split)

Splits a wire into its parts. Its input takes any wire and the node follows it: Stereo (left and right mono channels), Vector 2 (x and y), Chord (n1-n8, one note per voice), Multi gate (g1-g8) or Multi CV (c1-c8). A wire it can't split passes through unchanged. No outputs until something is wired in. A part with no voice gives 0. Splits a stereo wire into `left` and `right` mono wires, e.g. to process one side.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `notes` (shown as "in") | notes (poly) | 0 | -5 .. 5 V |
| `gates` (shown as "in") | gates (poly) | 0 | 0 .. 1 |
| `cvs` (shown as "in") | cvs (poly) | 0 | 0 .. 1 |
| `in` | stereo | | |
| `xy` | vec2 | | |
| `any` (shown as "in") | any | 0 |  |

Outputs: `left` (mono), `right` (mono), `x` (cv), `y` (cv), `n1` (note), `n2` (note), `n3` (note), `n4` (note), `n5` (note), `n6` (note), `n7` (note), `n8` (note), `g1` (gate), `g2` (gate), `g3` (gate), `g4` (gate), `g5` (gate), `g6` (gate), `g7` (gate), `g8` (gate), `c1` (cv), `c2` (cv), `c3` (cv), `c4` (cv), `c5` (cv), `c6` (cv), `c7` (cv), `c8` (cv), `out` (any)

- Setting `format`: `stereo` / `vec2` / `notes` / `gates` / `cvs` / `none` / `pass`. Default `"stereo"`.

### `merge` (Merge)

Joins separate wires into one. Its input takes any wire and the node follows the first one: mono makes Stereo (left, right), note makes Chord (n1-n8), gate makes Multi gate (g1-g8), CV makes Multi CV (c1-c8); Vector 2 (x, y) from the header menu. A wire it can't join passes through unchanged. Two inputs show at first; wiring the last one shows the next, up to 8. Only the wired inputs become voices, in order. Joins wires (setting `format`): `n1`..`n8` into `notes`, `g1`..`g8` into `gates`, `c1`..`c8` into `cvs`, `left`/`right` into stereo `out`, `x`/`y` into `xy`. Only wired inputs become voices. Format `pass`: `any` straight to `thru`.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `left` | mono | 0 | -1 .. 1 |
| `right` | mono | 0 | -1 .. 1 |
| `x` | cv | 0 | -1 .. 1 |
| `y` | cv | 0 | -1 .. 1 |
| `n1` | note | 0 | -5 .. 5 V |
| `n2` | note | 0 | -5 .. 5 V |
| `n3` | note | 0 | -5 .. 5 V |
| `n4` | note | 0 | -5 .. 5 V |
| `n5` | note | 0 | -5 .. 5 V |
| `n6` | note | 0 | -5 .. 5 V |
| `n7` | note | 0 | -5 .. 5 V |
| `n8` | note | 0 | -5 .. 5 V |
| `g1` | gate | 0 | 0 .. 1 |
| `g2` | gate | 0 | 0 .. 1 |
| `g3` | gate | 0 | 0 .. 1 |
| `g4` | gate | 0 | 0 .. 1 |
| `g5` | gate | 0 | 0 .. 1 |
| `g6` | gate | 0 | 0 .. 1 |
| `g7` | gate | 0 | 0 .. 1 |
| `g8` | gate | 0 | 0 .. 1 |
| `c1` | cv | 0 | 0 .. 1 |
| `c2` | cv | 0 | 0 .. 1 |
| `c3` | cv | 0 | 0 .. 1 |
| `c4` | cv | 0 | 0 .. 1 |
| `c5` | cv | 0 | 0 .. 1 |
| `c6` | cv | 0 | 0 .. 1 |
| `c7` | cv | 0 | 0 .. 1 |
| `c8` | cv | 0 | 0 .. 1 |
| `any` (shown as "in") | any | 0 |  |

Outputs: `notes` (notes, all of n1/n2/n3/n4/n5/n6/n7/n8 on one wire), `gates` (gates, all of g1/g2/g3/g4/g5/g6/g7/g8 on one wire), `cvs` (cvs, all of c1/c2/c3/c4/c5/c6/c7/c8 on one wire), `out` (stereo), `xy` (vec2), `thru` (any)

- Setting `format`: `stereo` / `vec2` / `notes` / `gates` / `cvs` / `none` / `pass`. Default `"notes"`.

### `width` (Stereo Width)

Narrows (0) or widens (2) a stereo pair.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `width` | cv | 1 | 0 .. 2 |
| `in` | stereo | | |

Outputs: `out` (stereo)

#### Input

### `mic` (Microphone)

The device's audio input: Unity's Microphone in the editor and in builds (SoundGraph Source picks the device), the board's audio input on the Daisy Seed (line level: a mic needs a preamp such as a MAX9814). level follows the loudness (0..1) for reacting to sound. Beware feedback when a mic plays through nearby speakers.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `gain` | cv | 1 | 0 .. 8 |
| `response` | cv | 0.1 | 0.005 .. 2 s |

Outputs: `level` (cv), `out` (stereo)

- Setting `channels`: `stereo` / `mono`. Default `"stereo"`.

#### Output

### `output` (Audio Output)

The speakers. Every graph has exactly one. Keep the final level around 0.5-0.8 peak: lower oscillator `amp` or use a Limiter if many voices add up.

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | stereo | | |

Outputs: none

### `visualiser` (Visualiser)

Shows the signal wired into it while previewing, in the editor only (games and the Daisy leave it out). Takes any type of wire. Pick the view from the menu: Auto (by wire type), Scope (waveform), Spectrum (frequency bars), Meter (level with peak hold), Lissajous (stereo width), Value (a CV or gate over time) or Notes (the notes playing, on a keyboard).

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `in` | any | 0 | -1 .. 1 |

Outputs: none

- Setting `view`: `auto` / `scope` / `spectrum` / `meter` / `lissajous` / `value` / `notes`. Default `"auto"`.

#### Daisy/Input

### `knob` (Knob / Analog Sensor)

Reads a potentiometer or analog sensor on the Daisy board (in Unity: SoundGraphSource.SetControl). Only use it when the user asks for a hardware control; otherwise use a Blackboard property. **Hardware only: avoid unless asked.**

| Input | Kind | Default | Range |
| --- | --- | --- | --- |
| `min` | cv | 0 | -20000 .. 20000 |
| `max` | cv | 1 | -20000 .. 20000 |

Outputs: `out` (cv)

- Setting `channel`: `0` / `1` / `2` / `3` / `4` / `5` / `6` / `7` / `8` / `9` / `10` / `11`. Default `"0"`.
- Setting `curve`: `linear` / `exponential`. Default `"linear"`.

### `button` (Button)

A push button on a Daisy pin. Only when the user asks for hardware. **Hardware only: avoid unless asked.**

Outputs: `gate` (gate), `trig` (gate)

- Setting `pin`: `D7` / `D8` / `D9` / `D10` / `D11` / `D12` / `D13` / `D14`. Default `"D7"`.
- Setting `mode`: `momentary` / `toggle`. Default `"momentary"`.

## 7. Recipes

Complete, working graphs to start from. Copy the parts you need; change ids so they stay unique.

### Warm chord pad

Chord Sequencer into one oscillator (four voices), slow ADSR, an LFO sweeping a ladder filter, chorus and reverb.

```json
{
  "format": "daisy-audio-patch",
  "version": 1,
  "name": "Warm Pad",
  "modules": [
    {"id": "chords", "type": "chords", "inputs": {"bpm": 70, "width": 0.95}, "settings": {"chords": "Am9:4 Fmaj7:4 Cmaj7:4 G6:4", "voicing": "spread"}, "editor": {"x": 0, "y": 0}},
    {"id": "osc", "type": "oscillator", "inputs": {"amp": 0.25}, "settings": {"waveform": "polyblep_saw", "pitch": "notes"}, "editor": {"x": 270, "y": 0}},
    {"id": "sweep", "type": "lfo", "inputs": {"freq": 0.07, "amp": 700, "offset": 1200}, "settings": {}, "editor": {"x": 270, "y": 220}},
    {"id": "lp", "type": "ladder", "inputs": {"resonance": 0.4}, "settings": {}, "editor": {"x": 540, "y": 0}},
    {"id": "env", "type": "adsr", "inputs": {"attack": 1.5, "decay": 1, "sustain": 0.8, "release": 2.5}, "settings": {}, "editor": {"x": 540, "y": 220}},
    {"id": "amp", "type": "vca", "inputs": {}, "settings": {}, "editor": {"x": 810, "y": 0}},
    {"id": "wide", "type": "chorus", "inputs": {"rate": 0.3, "depth": 5, "mix": 0.5}, "settings": {}, "editor": {"x": 1080, "y": 0}},
    {"id": "room", "type": "reverb", "inputs": {"size": 1.3, "decay": 0.9, "mix": 0.45}, "settings": {}, "editor": {"x": 1350, "y": 0}},
    {"id": "out", "type": "output", "inputs": {}, "settings": {}, "editor": {"x": 1620, "y": 0}},
    {"id": "transpose1", "type": "transpose", "inputs": {"octave": -1.0}, "settings": {}, "editor": {"x": 220.0, "y": 0.0}}
  ],
  "connections": [
    {"from": "transpose1.out", "to": "osc.voct"},
    {"from": "osc.out", "to": "lp.in"},
    {"from": "sweep.out", "to": "lp.cutoff"},
    {"from": "chords.gate", "to": "env.gate"},
    {"from": "lp.out", "to": "amp.in"},
    {"from": "env.out", "to": "amp.cv"},
    {"from": "amp.out", "to": "wide.in"},
    {"from": "wide.out", "to": "room.in"},
    {"from": "room.out", "to": "out.in"},
    {"from": "chords.chord", "to": "transpose1.note"}
  ]
}
```

### Drum beat

One clock at 100 BPM split into 16th notes (steps "4"); its beat output plays the kick, a divider picks the snare (beats 2 and 4) and hats (8ths, some skipped by Chance).

```json
{
  "format": "daisy-audio-patch",
  "version": 1,
  "name": "Simple Beat",
  "modules": [
    {"id": "clock", "type": "clock", "inputs": {"bpm": 100, "width": 0.3}, "settings": {"steps": "4"}, "editor": {"x": 0, "y": 0}},
    {"id": "backbeat", "type": "divider", "inputs": {"div": 2, "shift": 1}, "settings": {}, "editor": {"x": 540, "y": 220}},
    {"id": "eighth", "type": "divider", "inputs": {"div": 2}, "settings": {}, "editor": {"x": 270, "y": 440}},
    {"id": "maybe", "type": "chance", "inputs": {"chance": 0.8}, "settings": {}, "editor": {"x": 540, "y": 440}},
    {"id": "kick", "type": "bassdrum", "inputs": {"freq": 50, "decay": 0.5, "accent": 0.8}, "settings": {}, "editor": {"x": 810, "y": 0}},
    {"id": "snare", "type": "snare", "inputs": {"decay": 0.4, "snappy": 0.6}, "settings": {}, "editor": {"x": 810, "y": 220}},
    {"id": "hat", "type": "hihat", "inputs": {"decay": 0.15, "accent": 0.5}, "settings": {}, "editor": {"x": 810, "y": 440}},
    {"id": "mix", "type": "mixer", "inputs": {"gain1": 0.9, "gain2": 0.6, "gain3": 0.35}, "settings": {}, "editor": {"x": 1080, "y": 0}},
    {"id": "limit", "type": "limiter", "inputs": {}, "settings": {}, "editor": {"x": 1350, "y": 0}},
    {"id": "out", "type": "output", "inputs": {}, "settings": {}, "editor": {"x": 1620, "y": 0}}
  ],
  "connections": [
    {"from": "clock.gate", "to": "eighth.in"},
    {"from": "clock.beat", "to": "kick.trig"},
    {"from": "clock.beat", "to": "backbeat.in"},
    {"from": "backbeat.out", "to": "snare.trig"},
    {"from": "eighth.out", "to": "maybe.in"},
    {"from": "maybe.out", "to": "hat.trig"},
    {"from": "kick.out", "to": "mix.in1"},
    {"from": "snare.out", "to": "mix.in2"},
    {"from": "hat.out", "to": "mix.in3"},
    {"from": "mix.out", "to": "limit.in"},
    {"from": "limit.out", "to": "out.in"}
  ],
  "groups": [
    {"title": "Rhythm: one clock, divided", "modules": ["clock", "backbeat", "eighth", "maybe"]}
  ]
}
```

### Day/night soundscape with a control

Wind (filtered pink noise) and a drone, with a `Daylight` property (0 = night, 1 = day) opening the filter and fading in bright plucks.

```json
{
  "format": "daisy-audio-patch",
  "version": 1,
  "name": "Daylight Drift",
  "properties": [
    {"name": "Daylight", "type": "float", "exposed": true, "value": 0.5, "min": 0.0, "max": 1.0}
  ],
  "modules": [
    {"id": "daylight", "type": "property", "inputs": {}, "settings": {"mode": "smooth"}, "editor": {"x": 0, "y": 440}, "property": "Daylight"},
    {"id": "noise", "type": "noise", "inputs": {"amp": 0.5}, "settings": {"color": "pink"}, "editor": {"x": 0, "y": 0}},
    {"id": "gust", "type": "randomlfo", "inputs": {"rate": 0.3, "smooth": 1, "amp": 300, "offset": 500}, "settings": {}, "editor": {"x": 0, "y": 220}},
    {"id": "bright", "type": "scale", "inputs": {"scale": 1500, "offset": 0}, "settings": {}, "editor": {"x": 270, "y": 440}},
    {"id": "cut", "type": "add", "inputs": {}, "settings": {}, "editor": {"x": 405, "y": 220}},
    {"id": "wind", "type": "filter", "inputs": {"resonance": 0.5}, "settings": {}, "editor": {"x": 540, "y": 0}},
    {"id": "drone", "type": "oscillator", "inputs": {"amp": 0.15, "fine": 0.06616981861284899, "voct": -2.0}, "settings": {"waveform": "polyblep_tri"}, "editor": {"x": 540, "y": 660}},
    {"id": "tick", "type": "clock", "inputs": {"bpm": 90, "width": 0.2}, "settings": {}, "editor": {"x": 0, "y": 880}},
    {"id": "pick", "type": "samplehold", "inputs": {}, "settings": {}, "editor": {"x": 270, "y": 880}},
    {"id": "rnd", "type": "randomlfo", "inputs": {"rate": 5, "amp": 1, "offset": 0.5}, "settings": {}, "editor": {"x": 0, "y": 1100}},
    {"id": "notes", "type": "quantizer", "inputs": {}, "settings": {"notes": "C D E G A"}, "editor": {"x": 540, "y": 880}},
    {"id": "pluck", "type": "stringvoice", "inputs": {"freq": 261.63, "brightness": 0.6, "damping": 0.6}, "settings": {}, "editor": {"x": 810, "y": 880}},
    {"id": "fade", "type": "vca", "inputs": {}, "settings": {}, "editor": {"x": 1080, "y": 880}},
    {"id": "mix", "type": "mixer", "inputs": {"gain1": 0.6, "gain2": 1, "gain3": 0.5}, "settings": {}, "editor": {"x": 1080, "y": 0}},
    {"id": "room", "type": "reverb", "inputs": {"size": 1.4, "decay": 0.9, "mix": 0.5}, "settings": {}, "editor": {"x": 1350, "y": 0}},
    {"id": "out", "type": "output", "inputs": {}, "settings": {}, "editor": {"x": 1620, "y": 0}}
  ],
  "connections": [
    {"from": "noise.out", "to": "wind.in"},
    {"from": "gust.out", "to": "cut.a"},
    {"from": "daylight.out", "to": "bright.in"},
    {"from": "bright.out", "to": "cut.b"},
    {"from": "cut.out", "to": "wind.cutoff"},
    {"from": "tick.gate", "to": "pick.trig"},
    {"from": "rnd.out", "to": "pick.in"},
    {"from": "pick.out", "to": "notes.in"},
    {"from": "notes.out", "to": "pluck.voct"},
    {"from": "tick.gate", "to": "pluck.trig"},
    {"from": "pluck.out", "to": "fade.in"},
    {"from": "daylight.out", "to": "fade.cv"},
    {"from": "wind.low", "to": "mix.in1"},
    {"from": "drone.out", "to": "mix.in2"},
    {"from": "fade.out", "to": "mix.in3"},
    {"from": "mix.out", "to": "room.in"},
    {"from": "room.out", "to": "out.in"}
  ],
  "groups": [
    {"title": "Daylight opens the wind and fades in the plucks", "modules": ["daylight", "bright"]}
  ]
}
```

More ideas: *rain* = Particle Noise (density 0.7) + Dust into a Resonator, through a reverb; *bells* = FM
Oscillator (ratio 3.5, index 2) with an AD envelope on an Amplifier; *bass* = Oscillator at 65.41 Hz through a
Ladder filter, AD envelope on cutoff via Scale / Offset; *generative* = Chance and Clock Dividers on one
clock, Sample & Hold on a Random LFO into a Quantizer.

## 8. Checklist before you answer

- [ ] `format` is `"daisy-audio-patch"`, `version` is `1`, there is a `name`.
- [ ] Exactly one `output` node, and its `in` is wired.
- [ ] No input has more than one wire (use a Mixer to add signals).
- [ ] Every `type` is from section 6; every input, output and setting name matches that node's table.
- [ ] Every wire is `"id.output"` -> `"id.input"`, both ids exist, and no wire runs backwards into a node it came from.
- [ ] Input values are numbers within range; settings are strings from the listed options.
- [ ] Notes use sharps (`A#`, not `Bb`); oscillators fed by a Quantizer or Chord Sequencer have a C as `freq`.
- [ ] Every sound source passes through an envelope or Amplifier (`vca`) (or is meant to drone), and levels are moderate
      (oscillator `amp` 0.2-0.4 for several voices; master below 0.8).
- [ ] Every `property` node names a property in `properties`, with the matching `mode`.
- [ ] Every node has an `editor` position, laid out left to right in signal order with no overlaps.
- [ ] The answer is one complete JSON file in one code block.
