Appearance
Routing
Routing nodes help you move signals around your patch without running long cables everywhere, and let you choose which signal gets through. "Virtual wires" let you send sound or a control signal from one place and pick it up somewhere else, even when the signal needs to loop back on itself, just by giving both ends the same wire name. You label each wire with a name you type, and both ends that share a name are connected, which makes it easy to see where a send comes from and where it goes. (Older patches that used wire numbers still work: the number simply acts as the name.) The rest of this group are pickers and traffic controllers: grab a value the moment something fires, flip between several inputs, follow whichever source you touched last, make sure a control value and its trigger arrive in the right order, pass a message through untouched, or break one message into separate outputs by type. Reach for these whenever you want tidier wiring or precise control over what goes where, and in what order.
Audio Send
Sends a sound into a named "virtual wire", like dropping it into a labelled mailbox. An Audio Receive with the same name picks it up again, arriving one tiny audio chunk later. Use it to skip long cables, send one sound to many places at once, or build your own feedback loop (where a signal feeds back into itself).
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. The Audio Receive that reads it must use the same name. |
Inputs: In (audio fed into the virtual wire), Wire (the wire name as text; a plain number also works for older patches). Outputs: none.
The same name connects the wire anywhere in the project: the matching Audio Receive can sit in the main patch or inside any subgraph (a patch nested inside a node). If you want a wire that stays private to one subgraph, use Audio Sub Send and Audio Sub Receive instead.
Audio Receive
Picks up a sound from a named "virtual wire". It plays back exactly what the matching Audio Send put in, arriving one tiny audio chunk later. The very first chunk is silent because the wire starts out empty.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the Audio Send that feeds it. |
Inputs: Wire (the wire name as text; a plain number also works for older patches). Outputs: Out (audio read from the wire, one block behind the Audio Send).
Audio Sub Send
Sends a sound into a local "virtual wire". Local means the wire stays private to the subgraph (the patch nested inside a node) it lives in, or to the main patch if that is where you put it. It never leaks out to the patch around it, to a neighbour, or to a deeper nested patch. If several Audio Sub Sends use the same local wire, their sounds are mixed together.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. The Audio Sub Receive must use the same name, in the same subgraph. |
Inputs: In (audio fed into the local virtual wire), Wire (the wire name as text; a plain number also works for older patches). Outputs: none.
To send and pick up across the whole project, use Audio Send and Audio Receive instead.
Audio Sub Receive
Picks up a sound from a local "virtual wire". It plays back what the matching Audio Sub Send put in, arriving one tiny audio chunk later, and stays private to the subgraph (the patch nested inside a node) it lives in. The very first chunk is silent because the wire starts out empty.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the Audio Sub Send in the same subgraph. |
Inputs: Wire (the wire name as text; a plain number also works for older patches). Outputs: Out (audio read from the local wire, one block behind the Audio Sub Send).
CV Sample & Hold
Takes a snapshot of the control signal at the In input the instant the Trigger input crosses 0.5, then keeps that value frozen until the next trigger. This is the classic "sample and hold", great for stepped, jumping modulation, turning noise into random melodies, or freezing a moving value. Everything here runs at full audio speed.
Inputs: In (CV to sample, stream-capable), Trigger (a rising edge past 0.5 captures the input). Outputs: Out (the held CV value, updated on each trigger).
CV Switch
A two-way chooser. When the Cond input is above 0 it sends out A, otherwise it sends out B. Think of it as the basic "if this, then A, else B" building block for control signals. All three inputs run at full audio speed.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Cond | unbounded | 0.0 | Condition. Greater than 0 selects A, 0 or less selects B. |
| A | unbounded | 1.0 | Value sent when the condition is true. |
| B | unbounded | 0.0 | Value sent when the condition is false. |
Inputs: Cond (condition, accepts float, int or bool), A (value when true), B (value when false). All stream-capable. Outputs: Out (the selected value, A or B).
CV Input Select
A four-way chooser. The Index input decides which of the four inputs gets passed to the output (0 = A, 1 = B, 2 = C, 3 = D). Handy for switching between different modulation sources on the fly. Index and all inputs run at full audio speed, and if you feed Index a value with decimals it is rounded to the nearest slot and kept within 0 to 3.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Index | 0 - 3 | 0 | Which input is sent to Out (0 = A, 1 = B, 2 = C, 3 = D). |
| A | unbounded | 0.0 | CV input A. |
| B | unbounded | 0.0 | CV input B. |
| C | unbounded | 0.0 | CV input C. |
| D | unbounded | 0.0 | CV input D. |
Inputs: Index (selector, rounded and clamped to 0 to 3), A, B, C, D (the four CV inputs). All stream-capable. Outputs: Out (the selected CV value).
Route Sequencer
Picks one of up to 128 control-signal inputs by number. It works like CV Input Select, but you choose how many inputs it has. That lets you drive the Index with a step counter or sequencer to step through many modulation sources in patterns. The inputs and Index both run at full audio speed, and if you feed Index a value with decimals it is rounded to the nearest slot and kept within the valid range.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Inputs | 1 - 128 | 4 | How many source inputs the node shows. |
| Index | 0 - (Inputs - 1) | 0 | Which source input is sent to Out. |
Inputs: Inputs (source count, stream-capable), Index (selector, rounded and clamped to the valid range, stream-capable), and the source inputs In 0 to In N-1 (one per input, stream-capable). Outputs: Out (the selected CV value).
CV Last-Changed
Keeps an eye on several control-signal inputs and passes along whichever one moved most recently. Use it when several sources should control the same thing, but you want only the last one you touched to win, instead of all of them being added together. The active input keeps driving the output until a different one moves by more than the Threshold.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Inputs | 1 - 16 | 4 | How many source inputs the node shows. Set in the inspector. |
| Threshold | 0.0 - 1.0 | 0.001 | Dead-zone for change detection, so jitter on a static input does not steal focus. |
Inputs: Threshold (change dead-zone, stream-capable), and the source inputs A, B, C and so on (1 to 16 of them). Higher-numbered inputs take priority on simultaneous changes. Outputs: Out (the value of whichever input changed most recently).
CV Send
Sends a control signal into a project-wide "virtual wire". A CV Receive with the same name picks it up again, arriving one tiny audio chunk later, so you can build control-signal feedback loops (where a signal feeds back into itself). The same name connects the wire anywhere in the project. If several CV Sends use the same wire, their signals are mixed together.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the CV Receive on the other side. |
Inputs: In (CV written into the wire), Wire (the wire name as text; a plain number also works for older patches). Outputs: none.
Control-signal wires and audio wires are kept separate: a CV wire and an audio wire with the same name never share the same storage. A CV wire carries the control value at its full range, so it can pass positions, frequencies or note numbers far outside the -1..1 audio range; audio wires keep a tighter safety range because audio is meant to sit near -1..1.
CV Receive
Picks up a control signal from a project-wide "virtual wire". It plays back exactly what the matching CV Send put in, arriving one tiny audio chunk later. The same name connects the wire anywhere in the project.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the CV Send that feeds it. |
Inputs: Wire (the wire name as text; a plain number also works for older patches). Outputs: Out (CV read from the wire, one block behind the CV Send).
CV Sub Send
Sends a control signal into a private "virtual wire" that belongs only to one subgraph (a patch nested inside a node). It only pairs with a CV Sub Receive with the same name, inside the same subgraph, so the signal never leaves that nested patch.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the CV Sub Receive in the same subgraph. |
Inputs: In (CV written into the wire), Wire (the wire name as text; a plain number also works for older patches). Outputs: none.
CV Sub Receive
Picks up a control signal from a private "virtual wire" that belongs only to one subgraph (a patch nested inside a node). It plays back what the matching CV Sub Send put in, arriving one tiny audio chunk later, and only pairs within the same subgraph.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the CV Sub Send in the same subgraph. |
Inputs: Wire (the wire name as text; a plain number also works for older patches). Outputs: Out (CV read from the wire, one block behind the CV Sub Send).
Data Send
Sends a data message into a project-wide "virtual wire". Every Data Receive with the same name receives it immediately, with no cable in between and no delay. Any kind of message passes through unchanged: a bang, a number, a true/false, or a text string. The same name connects the wire anywhere in the project.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the Data Receive on the other side. |
Inputs: In (the data message sent into the wire), Wire (the wire name as text; a plain number also works for older patches). Outputs: none.
Unlike audio and CV wires, a Data Wire is a direct path with no delay, so it does not build feedback loops: a loop through a Data Wire is rejected just like a normal data cable, unless the receiving end is a Set pin. Data wires keep their own names, separate from audio and CV wires.
Data Receive
Receives the data message sent by a Data Send with the same name, immediately. Any kind of message comes through unchanged. The same name connects the wire anywhere in the project.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the Data Send that feeds it. |
Inputs: Wire (the wire name as text; a plain number also works for older patches). Outputs: Out (the data message received from the wire).
Data Sub Send
Sends a data message into a private "virtual wire" that belongs only to one subgraph (a patch nested inside a node). It only pairs with a Data Sub Receive with the same name, inside the same subgraph.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the Data Sub Receive in the same subgraph. |
Inputs: In (the data message sent into the wire), Wire (the wire name as text; a plain number also works for older patches). Outputs: none.
Data Sub Receive
Receives the data message sent by the matching Data Sub Send with the same name, immediately, and only pairs within the same subgraph (a patch nested inside a node).
| Parameter | Range | Default | Description |
|---|---|---|---|
| Wire | text | (none) | Wire name. Must match the Data Sub Send in the same subgraph. |
Inputs: Wire (the wire name as text; a plain number also works for older patches). Outputs: Out (the data message received from the local wire).
CV Order
Makes sure a control value and a trigger reach the next node in a chosen order. It fixes timing problems where, say, a sequencer's pitch and its note-on need to land at exactly the right moment. It passes both through but nudges one slightly later. Set the Order so a later oscillator or envelope sees the new value before the trigger, or the trigger before the value, whichever you need.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Order | CV -> Trigger / Trigger -> CV / Same Sample | CV -> Trigger | Which path arrives first. |
| Delay (samples) | 0 - 32 | 1 | Sample offset used for the selected ordering. |
Inputs: CV In (the CV or value to pass through, accepts float, int or bool), Trigger In (the trigger or gate to pass through, accepts an event, float, int or bool). Outputs: CV Out (the CV, optionally delayed relative to the trigger), Trigger Out (the trigger, optionally delayed relative to the CV).
Event Value
Re-orders the two parts of an incoming message: the trigger (Event) and the number (Value). You choose which one reaches the next node first. Handy when a chain needs to fire something and then receive the number, or receive the number and then fire.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Order | Event -> Value / Value -> Event | Value -> Event | Whether the Event or the Value is emitted first. |
Inputs: In (the message to split into Event and Value), Order (chooses the output order, 0 = Event then Value, 1 = Value then Event). Outputs: Value (the original incoming value; nothing is sent if the input was an Event), Event (one Event for each incoming message).
Pass
A cable in a box. Whatever goes in comes straight back out, unchanged, triggers (Events) included. Useful as a meeting point for cables, to keep your wiring easy to follow, or as a stand-in while you are still building a patch.
Inputs: In (any message). Outputs: Out (the same message as the input).
CV Pass
A cable in a box for control signals. Whatever control signal goes in comes straight back out, unchanged, at full audio speed. It is the CV counterpart to Sig Pass (audio) and Pass (data): use it as a tidy meeting point to gather or fan out CV connections, or as a stand-in while you are still building a patch.
Inputs: In (CV, stream-capable). Outputs: Out (the same CV signal as the input).
TypeSplit
Takes one incoming message and breaks it into separate outputs by type (Event, Int, Float and Any), then sends them in an order you choose. Useful for turning a single value into a little sequence of events, or whenever a later chain needs the outputs to fire in a particular order. The order is checked every time a message arrives, so any change takes effect right away.
| Parameter | Range | Default | Description |
|---|---|---|---|
| Order | Event-Int-Float-Any / Any-Float-Int-Event / Any-Event-Float-Int / Event-Any-Int-Float | Event-Int-Float-Any | The order the outputs fire in. Values outside 0 to 3 are clamped. |
Inputs: In (any message, fires all outputs in the selected order), Order (sets the order preset by sending 0 to 3; stream-capable; an Event does nothing). Outputs: Event (always an Event), Int (input converted to Int, Event becomes 0), Float (input converted to Float, Event becomes 0.0), Any (the original message unchanged).