Appearance
Subgraphs & Modules
These nodes let you take a chunk of your patch and tuck it neatly inside a single node you can reuse. A Subgraph is a node that holds a whole graph inside it. A Module does the same but adds its own front panel of controls. A Poly Module goes further and plays the inside as a polyphonic voice, meaning it can sound several notes at once. The Sub In and Sub Out port nodes decide which connection points the container shows on the outside, and the Voice helper nodes let you read what is happening with each individual note inside a Poly Module.
Module
A Module is a Subgraph that also brings along its own front panel. Any controls (widgets) you place inside it appear right on the Module's face, and you can drop the whole Module onto your main Front Panel as a single, reusable set of controls. Use a plain Subgraph when you just want to tidy up your graph. Reach for a Module when you also want a self-contained panel you can reuse across different projects.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Visible | On / Off | On | Shows or hides the Module on the front panel without removing it from the layout |
| Panel Alpha | 0.0 - 1.0 | 1.0 | Opacity of the Module's panel background |
| Stretch to Fill | On / Off | On | Scales the inner panel to fill the Module's body |
Inputs: an Appearance input pin (accepts a Visible property), plus any pins derived from the Sub In nodes placed inside. Outputs: any pins derived from the Sub Out nodes placed inside.
Poly Module
A Poly Module is a Module that can play several notes at the same time (polyphonic). Inside, you build just one voice (its oscillators, filters, envelopes and controls), and the container makes several copies of that voice and runs them side by side, mixing their sound together. Incoming notes are shared out among the copies by a built-in handler, and a voice stops using any CPU once it has gone quiet.
Needs: a Poly Module on the graph, ideally with the inspector open showing the Voices selector.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Voices | 1 - 16 | 4 | How many copies of the voice play at the same time |
| Note Priority | Last Only Retrigger / Stack Retrigger | Last Only Retrigger | Only shown when Voices = 1. Last Only Retrigger makes each new note retrigger and a release silence the voice. Stack Retrigger keeps held notes stacked, so releasing the top note falls back to the previous one |
| Visible | On / Off | On | Shows or hides the Poly Module on the front panel without removing it from the layout |
| Panel Alpha | 0.0 - 1.0 | 1.0 | Opacity of the Poly Module's panel background |
| Stretch to Fill | On / Off | On | Scales the inner panel to fill the Poly Module's body |
Because it is a Module, a Poly Module also has all of Module's panel settings (Visible, Panel Alpha, Stretch to Fill), shown alongside the polyphony settings above.
A brand-new Poly Module already comes with one Sub In (MIDI) and two Sub Out (Audio) nodes (left and right) connected up, so you can start building the voice straight away. To read the details of each note inside, use the Voice Gate / Pitch / Velocity / Index nodes. To make notes glide smoothly from one pitch to the next, drop a Smooth node on the pitch path inside the voice.
Inputs: an Appearance input pin (accepts a Visible property), plus any pins derived from the Sub In nodes placed inside. Outputs: any pins derived from the Sub Out nodes placed inside.
Subgraph
This is a node with a whole graph living inside it. Drop a Subgraph onto your patch and double-click it to step inside and edit its internal graph. The connection points it shows on the outside come from the Sub In and Sub Out nodes you place inside, so a Subgraph is a clean way to nest part of a patch and keep your top level tidy.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Oversample | Off / 2x / 4x / 8x | Off | Runs the inner graph at a multiple of the host sample rate, with anti-aliasing on the audio crossing |
Inputs: any pins derived from the Sub In nodes placed inside. Outputs: any pins derived from the Sub Out nodes placed inside.
Sub In (Data/CV)
Place this inside a subgraph to bring in a Data value from the patch outside. If something flowing (a live signal) is connected to the matching point on the outside, it switches into CV mode and works as a real-time signal input.
Inputs: none. Outputs: Out (the value arriving from the parent graph).
Sub Out (Data/CV)
Place this inside a subgraph to send a Data value back out to the patch outside. In CV mode it passes along a real-time signal.
Inputs: In (the value to send back to the parent graph). Outputs: none.
Sub In (Audio)
Place this inside a subgraph to bring in one channel of audio from the patch outside. Add one for each channel (for example, two for a stereo input).
Inputs: none. Outputs: Out (audio coming from the parent graph).
Sub Out (Audio)
Place this inside a subgraph to send one channel of audio back out to the patch outside. Add one for each channel (for example, two for a stereo output).
Inputs: In (audio sent back to the parent graph). Outputs: none.
Sub In (CV)
Like Sub In (Data/CV), but it always stays in CV (live signal) mode. Use it when you want to connect to CV nodes inside the subgraph even when nothing is wired up from outside.
Inputs: none. Outputs: CV Out (the CV value arriving from the parent graph).
Sub Out (CV)
Like Sub Out (Data/CV), but it always stays in CV (live signal) mode. Use it when you want to receive from CV nodes inside the subgraph even when nothing is wired up outside.
Inputs: CV In (the CV value sent back to the parent graph). Outputs: none.
Sub In (MIDI)
Place this inside a subgraph to bring in MIDI (note and control messages) from the patch outside.
Inputs: none. Outputs: MIDI (MIDI coming from the parent graph).
Sub Out (MIDI)
Place this inside a subgraph to send MIDI (note and control messages) back out to the patch outside.
Inputs: MIDI (MIDI sent back to the parent graph). Outputs: none.
Voice Gate
Sends out 1.0 while the note is being held and 0.0 once it is released. Use it as the gate (the on/off trigger) for an envelope inside a Poly Module. Outside a Poly Module the value just stays at 0.
Needs: a Voice Gate node inside a Poly Module voice, wired into an envelope's gate input.
Inputs: none. Outputs: Gate (1.0 while held, 0.0 otherwise, as CV).
Voice Pitch
Sends out the MIDI note number of the note this voice is playing (60 = middle C). Pass it through a CV To Freq node to turn it into a frequency in Hz before feeding it to an oscillator.
Needs: a Voice Pitch node inside a Poly Module voice, feeding a CV To Freq node into an oscillator.
Inputs: none. Outputs: Note (the voice's MIDI note number, as CV).
Voice Velocity
Sends out how hard the most recent note was played for this voice, scaled from 0 to 1. It holds onto the last value after the note is released.
Needs: a Voice Velocity node inside a Poly Module voice, modulating a level or filter.
Inputs: none. Outputs: Vel (note-on velocity, 0 to 1, as CV).
Voice Index
Sends out the number of the current voice (0 up to N-1), which stays the same for that voice. Handy for giving each voice a slightly different tuning (multiply by a small amount into an oscillator's frequency offset) or a different stereo position.
Needs: a Voice Index node inside a Poly Module voice, driving a small detune or pan offset.
Inputs: none. Outputs: Idx (the voice index, 0 to N-1, as CV).