ORRERY

A generative MIDI universe, in your DAW. Orrery runs a patched solar system of musical bodies — clocks, keys, progressions, gravity — and streams the result to the host as multichannel MIDI. You bring the synths.

SEC.01 // INSTALL

Run Orrery-Setup-x.y.z.exe. No admin needed. It puts

%LOCALAPPDATA%\Programs\Common\VST3\Orrery.vst3 %LOCALAPPDATA%\Programs\Common\CLAP\Orrery.clap

on your DAW's default scan paths, and the quickstart, EULA and example patches under %LOCALAPPDATA%\Programs\Recluse Studios\Orrery. Rescan plugins once. Windows 10/11 x64. Both formats behave identically; pick the one your DAW likes.

SEC.02 // FIRST LIGHT

1. Insert Orrery on a track. It arrives with FirstLight loaded.
2. Put a synth after it on the same track (or on another track — see routing).
3. Press play in the DAW. It plays. Stop, loop, seek — every sounding note is released first. Host tempo and transport are truth: the universe follows your grid at any tempo, and offline render is exact.

The editor is resizable. The footer reads engine ∥ patch file ∥ license.

SEC.03 // ROUTING

Orrery emits on one MIDI port, sixteen channels — each midiout body in the patch owns a channel (ch=N). Split channels onto tracks with your DAW's MIDI sends (REAPER: send → MIDI 5 → 1, or All → All into a multitimbral instrument). Multiple CLAP note ports are on the roadmap.

Recording. Orrery makes its MIDI inside the FX chain, so a track's default Record: input hears nothing. REAPER: set the track's record mode to Record: output (MIDI) (Orrery on its own track, MIDI send to the synth track), or Record: output (stereo) on the synth track for audio. Or just render — the performance is deterministic.

Control. Numbers can leave the universe too. Wire any number stream — a contour, an lfo, a gravity body's pull, a dice roll — into a midiout body's cc<N>, pb or at port and it becomes MIDI control on that body's channel:

  ramp.out  -> voice.cc74          # filter cutoff, MIDI-learn it on your synth
  swell.out -> voice.pb            # pitch bend, 0.5 sits at centre
  grav.pull -> voice.at            # channel aftertouch
  swell.out -> voice.cc1_14        # 14-bit: MSB on CC 1, LSB on CC 33

cc<N>_14 works for N up to 31 (its LSB rides N+32) and always sends the pair together, MSB first. The separator is there because cc114 is already CC 114 — cc1_14 is the 14-bit one.

A body's mod1…mod4 slots work too. On the desktop those name a hosted plugin's parameters; name one after a controller and the plugin routes that slot there, so one file means the right thing in both places:

  voice : midiout  ch=1  mod1="cc11"
  ...
  swell.out -> voice.mod1          # expression, on CC 11

Type the port name into the wire dialog's TO PORT field (it takes any name; the list is only a suggestion), or write it in the patch text.

0..1 is the unit of exchange — 0 becomes 0, 1 becomes 127 (pitch bend gets the full 14 bits, centred at 0.5), and anything outside clamps rather than wraps. That is the range lfo, gravity.pull, morph drift, collide force and a default contour already speak. A stream that lives somewhere else is brought into range by the wire's own bead:

  dice.roll -[scale 0.2]-> voice.cc1     # a 0..5 die into the full sweep
  sun.tempo -[clamp 0 1]-> voice.cc74    # keep an unbounded number in bounds
  swell.out -[curve 2]->   voice.cc11    # bend the taper

Control is generated with the notes, so it is sample-accurate, identical at any buffer size, and follows the host tempo exactly like the music does. Repeated values are not resent and a rate cap keeps a fast stream from storming the host. Relocate — press play mid-piece, or loop — and every controller is restated at the new position, so a synth is never left on a stale value. A patch that draws no control wires sends no control at all.

control.orr in the install folder is this by example — LOAD it, learn CC 74 on your synth's cutoff, and press play.

SEC.04 // THE CANVAS

The window is the Celestial Canvas — where you build and watch the universe. Everything is direct manipulation; the patch text is just what gets saved:

• Drag bodies. Wire ports (palette → WIRE, click source, click destination). Add beads on wires. Click a body for PARAMS.
• The reference is in the sidebar. Click a body, a bead, or a palette entry and its whole entry appears under PARAMS: what it does, every port with what it carries and why, every param with its range, its default, and whether a scene can move it. Clicking a palette entry shows it before you place it, which is the fastest way to learn what a body is for. It is read straight from the engine's own vocabulary, so it is never out of date with the build you have — and you never have to leave the DAW to look something up.
• PALETTE / SIDEBAR buttons in the canvas top bar collapse the panels when the DAW is stingy with pixels. MODE cycles Celestial → Boring → Zodiac → Cyber (the drafting-paper light motif). The chrome's DK/LT toggle switches Celestial ↔ Cyber with it.
• Every edit rewrites the patch text in the project. Ctrl+Z on the canvas undoes. SAVE writes the .orr to disk (Shift-SAVE = save as); LOAD, or drop an .orr onto the window, swaps universes.
• A patch that fails to build leaves the last good one playing and says why in a toast. Never a dead plugin.
• The Sky draws one headline value per body — a channel, a mass, a scale — never every param. Editing something else in PARAMS still applies (watch for a brief ring on the body and a confirmation toast); the sidebar is always the full, accurate readout.
• List-shaped params — a progression's follow chord list, dice's faces, a sequencer's frozen notes — round-trip through PARAMS with or without their wrapping parens ((i bVII i v) or just i bVII i v); the field always ends up correctly written either way.

Scenes and nudges are live. Click a scene and it lands on the next bar, carrying whatever is still sounding -- no cut notes, no re-articulation, no seam. The Scene parameter is host-automatable, so you can draw scene changes into an automation lane and they arrive the same way. Nudging a body's control on the canvas takes effect almost at once. Behind either, the plugin quietly re-derives the rest of the piece and swaps it in on the beat; the patch's own @work chain keeps running on its schedule regardless.

One consequence worth knowing: because the future is re-derived from the patch text, a nudge is an offset held by the plugin, not an edit. It lasts as long as the patch does, and loading another patch clears it. To make a change permanent, type it into PARAMS and SAVE.

SEC.05 // OSC OUT

The header's OSC button broadcasts what the universe is doing to any OSC listener -- TouchDesigner, Resolume, Max, a homebrew shader rig -- over UDP. Off until you ask for it, remembered with the project, and it keeps sending with the plugin window closed, which is the point: set it up, close it, work.

The wire format is the desktop Orrery's, byte for byte, so a rig built against orrery play --osc host:port works here unchanged:

  /orrery/note          (iiff)  channel (1-based), pitch, velocity, dur_beats
  /orrery/<body>/<port>         numbers (f), triggers (), gates (i)
  /orrery/scale/<body>  (i x12) the ring: one int per pitch class, 1 = lit
  /orrery/chord/<body>  (i x n) midi pitches
  /orrery/scene         (s)     on a scene change
  /orrery/meter         (ii)    the patch's opening meter, once per rebuild
  /orrery/tempo         (f)     the HOST's tempo -- see below

/orrery/tempo is the one addition: it carries the tempo of the DAW you are running in, which the desktop has no way to know. A patch's own transport still announces itself as /orrery/<sun>/tempo exactly as it does on the desktop.

Two things are deliberately not sent, because sending them would mean guessing: gravity fields (the plugin's telemetry keeps the well's weights but not its centre, and a half-message would misparse in a receiver expecting the desktop's), and mid-patch meter changes. Notes, numbers, scales, chords and scenes -- the things a visuals rig actually rides on -- are all there.

Sending happens on its own thread, never the audio thread, and is fire-and-forget: an unreachable destination is silence, not a dropout. Expect telemetry within a few milliseconds of the audio that caused it -- fine for frame-rate visuals. The MIDI itself is unaffected and stays sample-accurate.

SEC.06 // PATCHES

Patches are plain text (.orr). Bodies in @bodies, wires in @orbits, positions in @sky, scenes in @scenes, scene chains in @work. Wires carry music, never audio.

New to this? Read Part II first — it builds a patch from an empty sky in a few minutes and explains the way of working, which is genuinely unlike most plugins. Part III is the language reference — every body you can place, every port you can wire, every param you can write, with its range and default. It is generated from the vocabulary the plugin itself runs on, so it always matches the build you have.

Example patches ship in the install folder: firstlight.orr, the universe the plugin opens with, and control.orr, the control-output example above.

SEC.07 // AUTHORIZATION

Fourteen-day trial, full function. After that, note-ons are muted (note-offs always pass) until you activate: LICENSE → email + ORR-XXXX-XXXX-XXXX-XXXX serial → ACTIVATE. Three seats per license; DEACTIVATE frees this machine's seat. Activation talks only to key.reclusestudios.net and sends the serial, the email, and a non-reversible machine id — never your music.

Support: support@reclusestudios.net · Licensing: licensing@reclusestudios.net

Recluse Studios

Most plugins hand you an instrument and you play it. Orrery hands you an empty sky and you build something that plays. That is the whole difference, and it is worth ten minutes before you touch anything.

You are not sequencing notes. You are wiring up a small machine — a pulse, a sense of key, something that decides what to play, forces that bend it — and then you press play in your DAW and listen to what the machine does. Change one wire and everything downstream changes with it. That is the instrument.

Nothing here needs the patch text. Everything below is done by clicking in the canvas; the text is just what gets saved.

---

SEC.01 // THE SPINE

Almost every patch that makes a sound has the same five parts. Learn this shape and you can read any patch, including the ones that ship.

   a pulse  ->  something that decides notes  ->  a way out
                          ^
                   a sense of key
                  (and, optionally, forces that bend the result)

Concretely, the smallest thing that plays:

you need	a body	why
a pulse	clock	nothing happens without time passing
something deciding	sequencer	turns pulses into notes
a way out	midiout	notes leave here, on one MIDI channel

Three bodies, two wires, and it plays. A key comes next, and everything else in Orrery is making that middle part more interesting.

---

SEC.02 // BUILD ONE FROM AN EMPTY SKY

Do this once by hand. It takes about two minutes and it makes every other patch readable.

1. Place three bodies. In the palette on the left, click clock, then click somewhere in the sky. It lands there. Do the same for sequencer and midiout. Drag them into a rough left-to-right line — the layout means nothing to the music, only to you.

2. Wire the pulse. Press W (or click wire two bodies), click the clock, then click the sequencer. A little dialog appears asking which port on each end. Take tick out of the clock, and gate into the sequencer. Click wire it.

3. Wire the way out. W, sequencer → midiout, notes out into in.

4. Press play in your DAW. Not in the canvas — the transport is your host's. Put a synth after Orrery on the track (or send its MIDI to a synth track). It plays: a seeded, wandering line. Every note it will ever play is already decided — the same seed gives the same performance forever — but it is not yet in any key.

5. Give it a key. This is the step that teaches you how Orrery thinks. A sequencer has no "key" input; it does not know about scales at all. Instead you put a notefilter in the path and hand that the key:

• place a key and a notefilter
• rewire sequencer → notefilter (notes into in)
• wire notefilter → midiout (out into in)
• wire key → notefilter (scale into scale)

(To rewire, click the old sequencer → midiout wire so it turns red, press Delete, then draw the new ones.)

Now the wandering line is filtered — notes off the scale simply do not get through. That is the shape of nearly everything here: a thing that generates, and things in the path that judge and bend what it made.

If that feels too lossy, set the notefilter's miss to snap. Instead of turning a stray note away it moves it to the nearest note that fits, so nothing is lost and everything is still in key. drop (the default) curates; snap corrects. Both are useful, and the difference is worth hearing — set it, press Enter, and listen to the same seed both ways.

6. Change one thing. Click the key body and, in PARAMS on the right, set scale to aeolian, press Enter. The universe restarts and the same machine plays something else. That is the loop you will spend all your time in.

---

SEC.03 // WHAT THE FAMILIES ARE FOR

Full detail — every port, every param, every range — is in Part III. This is just the map, so you know what to reach for.

Time. transport is the sun: one tempo for the patch (your DAW's tempo still rules the grid). clock is the pulse. sections counts out a form. lfo and contour are slow movement — an lfo runs on its own, a contour steps each time something pokes it. counter counts what arrives and fires when it reaches its target: the plain way to say every fourth one.

Pitch & harmony. key sets the tonal centre and mode, and hands a scale down the wire. progression walks roman numerals against that key and emits chords. voicelead turns chords into actual playable notes, choosing inversions that move least. notefilter is the bouncer — it takes a scale and refuses anything off it, or on degrees you ban, unless you set miss=snap and it moves them into the key instead. intervals walks a shape rather than a scale.

Only some bodies accept a scale. A scale can be wired into notefilter.scale, progression.key, intervals.scale, phrase.scale, mirror.scale and gravity.center — and nowhere else. A sequencer has no opinion about key; you shape what it made further down the chain. When in doubt, the wire dialog only suggests ports that exist.

Rhythm & chance. euclid spreads N hits over M steps — the classic generative rhythm. Wire its pattern into a sequencer's gate and the line steps only on the hits; wire its shape into that sequencer's mask instead and the line walks every step and only sounds on the hits. Same rhythm, two different tunes — worth trying both on the same patch.

A euclid's shape is a thing you can pass around and change on the way. The flip bead turns hits into rests, reverse reads the necklace backwards, and a pulsar plays whatever shape you hand it. That gets you a second part built from the first:

  puls.tick            -> ring.clock
  ring.pattern         -> kick.step       # the kick plays the hits
  ring.shape -[flip]-> beam.shape         # beam : pulsar
  puls.tick            -> beam.clock
  beam.pattern         -> hats.step       # ...and the hats play the gaps

Change ring.hits and both parts follow — one source of truth instead of two euclids to keep in step. A pulsar's rotate is scene-settable (a euclid's is not), so the derived part can turn against the source while the piece plays.

And interfere lays two shapes over each other. Two rhythms already layer without it — wire both euclids at the same port and both fire. What it gives you is where they agree (op=and) or where they trade off (op=xor):

  three.shape -> mesh.a          # mesh : interfere op=and
  eight.shape -> mesh.b
  mesh.out    -> accent.shape    # accent : pulsar — hits only where they agree

Shapes of different lengths run out to the length where the pair repeats, so a 3 against an 8 gives you the whole 24-step conversation rather than the first eight steps of it. That is the cheapest polyrhythm in the system. dice picks from a list, seeded, so it is random but repeatable. seq / sequencer step through notes.

Physics. This is where Orrery stops resembling other tools. gravity has a centre and a mass, and it pulls notes toward the stable tones of that centre — so you can have a key saying one thing and a gravity well bending it somewhere else. Negative mass pushes away instead. inertia gives a line momentum, so it keeps heading the way it was going. Others (wormhole, redshift, neutronstar, supernova) are stranger still — worth an afternoon.

Output & glue. midiout is the door: one MIDI channel per body, and that is how you drive several synths from one patch. capture records what passes. balance weighs two number streams against each other and fires when one overtakes the other — the comparison a bead cannot make, since a bead only ever sees one stream.

---

SEC.04 // MAKING IT MOVE

A patch that plays the same thing forever is a loop, not a universe. Three ways to give it a life:

Beads — shaping on the wire itself. Click a bead in the palette, then click a wire, and whatever passes gets transformed: note -12 drops it an octave, scale 0.5 halves a number, clamp 0 1 bounds it, lag 0.6 smooths it, curve 2 bends its taper, invert turns it upside down so that as one thing rises another falls. One bead per wire, and a neutral setting changes nothing, so they are safe to try.

Scenes — a set of changes with a name. A @scenes block names values for several bodies at once (a key change, a new mass, a different mode). A @work chain moves between them on schedule — Dawn -> Noon after=2bar. This is how a patch gets an arrangement. You can also fire one by hand — click it, and it lands on the next bar, carrying whatever is still sounding. The Scene parameter is host-automatable, so you can draw scene changes into an automation lane and they arrive the same way.

Numbers that wander. Wire an lfo or a contour into a param-shaped port and the patch breathes on its own. Anything that carries a number can drive anything that accepts one.

An lfo can be moved too. Its rate is a port as well as a param, so one slow shape can steer a faster one, and reset restarts the cycle — wire a section boundary or a beat into it and the wobble locks to the music instead of drifting against it:

  drift.out     -[scale 4]-> breath.rate   # a slow tide bends a faster one
  form.boundary ->           breath.reset  # every section opens on a fresh cycle

The rate port offsets what you wrote, the way a clock's does, so a 0..1 stream barely moves a 1hz LFO until you scale it up.

An lfo can be written in musical time, which is usually what you want in a DAW — a cycle measured on the grid stays locked to bars however the piece is played:

  swell : lfo  rate=4bar          # one full cycle every four bars
  tide  : lfo  rate=8th           # one every eighth note
  slow  : lfo  period=16bar       # `period` says the same thing

Note values are written the way you would write them — 8th, 16th, 32nd, 4th (a beat), 1st (a whole note) — and bar / beat work too. An LFO emits 32 times per cycle, so a 4bar cycle lands on an eighth-note grid, exactly.

Real time still works where you want a shape that ignores tempo: rate=0.5hz, period=90s, even period=1day for something that drifts across a session.

The other way to move in musical time is a contour driven by a clock, which steps once per trigger rather than sweeping continuously. contour's span is how many steps make a full cycle, so span=32 clocked at 8ths is a four-bar shape. control.orr is built this way.

---

SEC.05 // GETTING IT OUT

Notes. Each midiout body owns a MIDI channel (ch=). Several bodies means several channels out of the one plugin, which you split in your DAW — that is how one patch drives a pad, a bass and a bell at once.

Control. Wire a number into a midiout body's cc74 (or pb, at, cc<N>_14) and it leaves as MIDI control on that channel — MIDI-learn it on a synth and the universe is moving your filter. 0..1 is the unit of exchange. See <a href="#qs-sec-03-routing">Routing MIDI to your instruments</a>.

A note stream can drive one too, through a bead that reads what the note carries — loudness for how hard it was played, pitch for which note it was:

  lead.notes -[loudness]->    voice.cc11   # louder playing opens the swell
  lead.notes -[pitch 127]->   voice.cc74   # key tracking: the filter follows the line

The 127 matters. A pitch is a MIDI number, not a 0..1 value, and anything above 1 pins the controller at full scale — so dividing it is part of the bead, because a wire carries only one.

Visuals. The OSC button broadcasts everything the patch is doing — notes, numbers, scales, chords, scenes — to a visuals rig. See <a href="#qs-sec-05-osc-out">OSC out</a>.

---

SEC.06 // IT IS NOT MAKING A SOUND

In order of how often it is the answer:

Is your DAW playing? Orrery follows the host transport. The canvas's own Space bar does nothing here.

Does the wire land on a port that exists? This one now tells you. A wire to a port a body does not have is refused when you draw it, and the message names the port you asked for and lists the ones that body really has. It is worth knowing the shape anyway, because the near-misses are so plausible: a sequencer listens on gate, but a progression listens on clock — not gate; an arp steps on step while a euclid steps on clock, which is the reverse of most people's guess; a sequencer has no scale port at all, so a key wired straight at it is not a quiet key, it is a wire that cannot exist. A midiout takes notes on in.

The exception, and it is deliberate: midiout, capture and script accept any port name, because that is how a midiout names control output (voice.cc74, voice.pb — SEC.05) and how a script names whatever its Lua listens for. On those three, a typo is still yours to catch.

Is a notefilter eating the line? It is a bouncer by default: a note that is not in the scale does not get through, and a chromatic source against a narrow scale can be turned away almost entirely. Set the notefilter's miss to snap and it moves those notes into the key instead of refusing them — same scale, nothing lost. (Ban every degree with deny and even snap has nowhere to put a note; that is the one case where it is still silent.)

Is it emitting chords where notes are wanted? A progression emits chords, and a midiout only plays notes. A chord wired straight at the output makes no sound. Put a voicelead between them — that is its whole job.

Does the thing have what it needs to decide? A progression with no key wired in counts along forever and never emits, because it has no scale to build chords from. Same shape of problem elsewhere: if a body looks inert, check what it is missing rather than what it is doing.

Is the trial over? After the trial the footer reads OUTPUT MUTED and note-ons stop (held notes are still released properly — it never leaves a note hanging).

Did the patch fail to build? Then the last good universe is still playing and a toast said why. Orrery never goes dead on a bad edit.

---

SEC.07 // HABITS THAT PAY

• Change one thing. The patch is a system; two changes at once and you have learned nothing about either.
• Seeds are your friend. Anything with a seed is random but repeatable — the same seed is the same performance, every time, forever. Audition seeds like presets.
• Let it run. Generative patches reveal themselves over bars, not beats. Some of what ships takes 32 bars to show its hand.
• Save often, under new names. SAVE writes the .orr; Shift-SAVE saves as. They are small text files — keep the interesting accidents.
• Read the ones that ship. firstlight.orr is the default universe; control.orr wires numbers out as MIDI control. Open them, follow the wires, change one thing.

---

Recluse Studios · Orrery. the earlier parts for install, routing and the canvas; Part III for every body, port and param.

Every body you can place, every port you can wire, every param you can write.

This file is generated from the engine's own vocabulary table, so it is never out of date with the plugin you have: if a body gained a port, it is here. Prose in the tables is the engine's own.

A patch is plain text. The sections it can carry:

@patch  <name>          the name shown in the canvas header
@bodies <name> : <kind>  key=value  key=value …
@orbits <body>.<port> -> <body>.<port>          a wire
        <body>.<port> -[<bead> <opts>]-> …      a wire with a bead on it
        <body>.<port> ~> <body>.<port>          a feedback wire (delivered one tick later)
@sky    <body> (x,y)  <body> (x,y) …            where bodies sit on the canvas
@scenes <name> : <body>.<param>=<value> …       a named set of changes
@work   <from> -> <to>  after=2bar              a scene chain
@notes  (x,y) "text"                            sticky notes on the canvas

Values are numbers (120, 0.5, -6db, 120bpm, 2bar), bare words (dorian, saw), quoted text ("Cutoff"), note names (C, F#, Bb), or lists in parentheses ((i bVII i v)).

Wires carry music, never audio — a note, a scale, a chord, a number, a trigger, a gate. What a port carries is in its carries column below, and a wire only makes sense when the two ends agree.

---

Time

transport

The sun: one master tempo that stretches time for the whole patch, and anything can conduct it.

Inputs

port	carries	what it does
tempo	number	bpm offset — anything can conduct

Outputs

port	carries	what it does
tempo	number	the effective tempo, whenever it changes

Written params

param	range	default	scenes	what it does
tempo	10…1200bpm	120bpm	a scene can ramp it	the master tempo
meter	quoted text	"4/4"	a scene can set it (jumps)	the time signature — every bar-denominated thing follows it (the bar unit, scenes, works, sections, the trace, the MIDI grid). Scene-settable: a meter map is scenes moving it, always landing on a bar line. Numerator 1-32, denominator 1/2/4/8/16

clock

The pulse: a trigger every beat, with an optional swing that keeps each pair of ticks the same total length.

Inputs

port	carries	what it does
rate	number	bpm offset
swing	number	offsets the written swing

Outputs

port	carries	what it does
tick	trigger	once per beat

Written params

param	range	default	scenes	what it does
rate	1…1200bpm	120bpm	a scene can ramp it	beats per minute
swing	0.5…0.9	0.5	a scene can ramp it	0.5 straight, 0.66 a triplet lean

counter

Counts what arrives and fires when it reaches the target, then starts over — the plain way to say every fourth one. Deaf to the value, so it counts notes and triggers as happily as numbers.

Inputs

port	carries	what it does
clock	any	anything arriving here counts as one
reset	any	back to zero — the next arrival is 1 again

Outputs

port	carries	what it does
out	trigger	fires the moment the count reaches target
count	number	the running count, 1 up to target

Written params

param	range	default	scenes	what it does
target	1 and up	4	a scene can set it (jumps)	count this many, fire, and start over

sections

The arrangement as a body on the map: write the form as bars per section, feed it beats, and it names the section you're in and fires a trigger at every handover.

Inputs

port	carries	what it does
clock	any	one value per pulse of the meter — quarters in 4/4, eighths in 7/8

Outputs

port	carries	what it does
section	number	which section you're in (1-based), announced at start and at every handover
boundary	trigger	fires as each section hands over to the next — wire it into reset ports, or name it in a work link (on=form.boundary)
beat	any	the clock, passed through AFTER any boundary work — drive your loops from here and resets land before the downbeat plays

Written params

param	range	default	scenes	what it does
plan	a list — (bars per section)	(4 4)	written only	the form — (4 8 8 4) is intro, verse, chorus, outro; it rounds forever

lfo

A slow sine from 0 to 1 — breathing, drifting, tides. Write a cycle in musical time (4bar, 8th) to sit on the grid, or in hz / seconds / days / years to float free of it. Free-running until you wire its reset.

Inputs

port	carries	what it does
rate	number	offsets the written rate, in hz — scale a 0..1 stream first
reset	any	start the cycle again from zero — wire a bar or a section boundary here to phase-lock it

Outputs

port	carries	what it does
out	number	0..1, 32 times per cycle

Written params

param	range	default	scenes	what it does
rate	0.0001 and up (hz)	1hz	a scene can set it (jumps)	cycles per second — or write a musical cycle instead: 4bar, 2beat, 8th
period	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	1s	written only	one full cycle — wins over rate; musical (4bar, 8th) or real (s/min/hour/day/year)

contour

A shape you step through by hand: each trigger on advance nudges it one notch between min and max.

Inputs

port	carries	what it does
advance	any	any value steps it once

Outputs

port	carries	what it does
out	number	somewhere between min and max

Written params

param	range	default	scenes	what it does
shape	triangle · saw · sine	triangle	written only	the curve it walks
min	any number	0	a scene can ramp it	the bottom of the swing
max	any number	1	a scene can ramp it	the top of the swing
span	1 and up	64	a scene can set it (jumps)	advances per full cycle

Pitch & harmony

key

The tonal centre of your universe — pick a note and a mode, and everything downstream derives from it.

Inputs

port	carries	what it does
mode	number	0-6, rotates the mode — modes ARE rotations

Outputs

port	carries	what it does
scale	scale	the scale in force
key	scale	the same, as a key

Written params

param	range	default	scenes	what it does
center	a note name (C, F#, Bb) or a pitch	C	a scene can set it (jumps)	the tonic
scale	ionian · major · dorian · phrygian · lydian · mixolydian · aeolian · minor · locrian	ionian	a scene can set it (jumps)	the mode (alias: mode)

notefilter

The bouncer — notes off the scale, or on degrees you have banned, do not get through. Set miss=snap and it stops turning them away and starts moving them into the key instead.

Inputs

port	carries	what it does
scale	scale	wire it from a key
in	note	notes to judge

Outputs

port	carries	what it does
out	note	the ones that made the cut — or, with miss=snap, all of them, moved to fit

Written params

param	range	default	scenes	what it does
deny	a list — (1-based degree)	()	written only	degrees to refuse: (2 6)
miss	drop · snap	drop	a scene can set it (jumps)	what happens to a note that does not fit — turn it away, or move it to the nearest note that does (never onto a denied degree)

progression

Roman-numeral chord changes against whatever key is wired in, advancing every few bars.

Inputs

port	carries	what it does
key	scale	the key to build on
clock	any	counts 4 beats to the bar

Outputs

port	carries	what it does
chord	chord	one chord per each

Written params

param	range	default	scenes	what it does
follow	a list — (roman numerals — quality suffixes 7 maj7 9 sus2 sus4 dim aug; flats borrow the root (bVII); case is color in written spelling)	(i)	written only	the changes
spell	scale · written	scale	written only	scale climbs the key's ladder; written plays the page — case picks major/minor
each	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	4bar	written only	how long one chord lasts — unit-aware (2bar, 8beat, 6s)

voicelead

Gives each chord the smoothest path from the last one — it auditions every inversion and picks the one that moves least.

Inputs

port	carries	what it does
in	chord	chords to voice
velocity	number	offsets the written velocity — anything can conduct dynamics

Outputs

port	carries	what it does
out	note	the chord's notes, voiced

Written params

param	range	default	scenes	what it does
velocity	0…1	0.6	a scene can ramp it	chords arrive with no dynamics of their own — this is the hand that plays them

intervals

Melody as motion instead of position — you write the intervals, and each trigger takes the next step.

Inputs

port	carries	what it does
scale	scale	needed for degree mode
root	number	re-root, transposing the current position
reset	any	back to the root
step	any	take the next interval
velocity	number	offsets the written velocity — anything can conduct dynamics

Outputs

port	carries	what it does
notes	note	where the walk landed

Written params

param	range	default	scenes	what it does
intervals	a list — (semitones, or scale steps in degree mode)	(0)	written only	the walk
root	any number	57	a scene can ramp it	where it starts (MIDI, or a note name)
mode	degrees	semitones	written only	degrees counts scale steps; anything else is semitones
onkey	drift · reanchor	drift	written only	what a key change does mid-walk: drift holds position (old behavior), reanchor re-walks the climbed degrees up the new ladder (degree mode only)
velocity	0…1	0.78	a scene can ramp it	how hard the walk lands

Physics

gravity

Tonal gravity: notes are pulled toward the stable tones of a centre — or, at negative mass, pushed away from them.

Inputs

port	carries	what it does
in	note	notes to bend
mass	number	offsets the written mass
stretch	number	offsets the tide
center	scale	a scale (degree-shaped well) or a pitch (a bare centre)

Outputs

port	carries	what it does
out	note	where the note landed
field	field	the well itself, for a seq or a wellmix
pull	number	how far this note moved, 0..1

Written params

param	range	default	scenes	what it does
center	a note name (C, F#, Bb) or a pitch	C	written only	the centre of the well
mass	-3…3.5	0.5	a scene can ramp it	0 no-op · 2+ event horizon · 3 singularity · -2 and below anti-horizon
reach	1 and up (semitones)	12	a scene can set it (jumps)	how far it searches for a target
stretch	0.1…4	1	a scene can ramp it	tides: 1 is a bit-identical no-op
anchor	any number	3	written only	the octave the tide pivots around
seed	any number	7	written only	which way the dice fall

inertia

Momentum for melodies — the line keeps heading the way it was already going.

Inputs

port	carries	what it does
in	note	notes to bend
amount	number	offsets the written amount

Outputs

port	carries	what it does
out	note	the blended note
drift	number	how far it bent, 0..1

Written params

param	range	default	scenes	what it does
amount	0…1	0.5	a scene can ramp it	0 is a bit-identical no-op, 1 is pure ballistics

wellmix

Field superposition — wire up to four wells in and the summed field flows out: binary systems, interdiction lines.

Inputs

port	carries	what it does
a	field	first well
b	field	second well
c	field	third well
d	field	fourth well

Outputs

port	carries	what it does
out	field	the combined field

hold

Sample and hold: it watches in and says nothing until trigger fires, then lets the last thing it saw out.

Inputs

port	carries	what it does
in	any	the signal to watch — nothing passes through on its own
trigger	any	let the held value out now

Outputs

port	carries	what it does
out	any	whatever it was holding, in the type it arrived as

Written params

param	range	default	scenes	what it does
repeat	0…1	1	written only	1 speaks on every trigger; 0 only when the held value has changed

wormhole

Swallows a chunk of music and returns it later, backwards or upside down — a time machine for phrases.

Inputs

port	carries	what it does
in	note	notes to swallow

Outputs

port	carries	what it does
out	note	the chunk, erupting
hawking	note	a faint quantum leaking while it holds

Written params

param	range	default	scenes	what it does
mode	retrograde · invert · both	both	written only	anything else makes it a plain delay
gulp	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	1bar	written only	how much it swallows at once
delay	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	1bar	written only	how long it holds
hawking	0…1	0	a scene can set it (jumps)	chance of a leak
seed	any number	13	written only	which quanta escape

weak

Radioactive decay for notes — some fade, some vanish, some transmute a semitone.

Inputs

port	carries	what it does
in	note	notes to irradiate

Outputs

port	carries	what it does
out	note	what survived

Written params

param	range	default	scenes	what it does
decay	0…1	0.2	a scene can set it (jumps)	chance a note halves — deep rolls annihilate it
transmute	0…1	0.1	a scene can set it (jumps)	chance it shifts a semitone
seed	any number	17	written only	which notes are unlucky

em

Two charged voices push or pull each other by pitch distance — every sounding note is its own charge, and a shield damps what stands between.

Inputs

port	carries	what it does
a	note	the first voice
b	note	the second voice
shield	note	a voice that damps the field
strength	number	sets the coupling outright (not an offset)

Outputs

port	carries	what it does
a_out	note	the first voice, deflected
b_out	note	the second voice, deflected
force	number	how hard they shoved, 0..1

Written params

param	range	default	scenes	what it does
qa	-2…2	1	a scene can ramp it	charge on the first voice
qb	-2…2	1	a scene can ramp it	charge on the second — flip it negative and they attract
strength	0…4	1	a scene can ramp it	how strong the coupling is

strong

Notes that land close together in time and pitch fuse into a chord; loners pass through.

Inputs

port	carries	what it does
in	note	notes that might bind

Outputs

port	carries	what it does
fused	note	cluster members, given one shared length
chord	chord	the cluster, as a chord
out	note	a note that stayed single

Written params

param	range	default	scenes	what it does
window	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	0.25beat	written only	how close in time counts as together (release=grid only)
radius	1 and up (semitones)	4	a scene can ramp it	how close in pitch counts as together
release	grid · exact	grid	written only	grid waits out the window before releasing (catches strums, costs latency); exact fuses only notes that land on the SAME tick and releases them instantly — stabs stay on the beat

mirror

Turns a melody upside down around an axis you name — and unlike a wormhole's inversion, you can see the axis, move it with a wire, and hear it instantly.

Inputs

port	carries	what it does
in	note	notes to reflect
axis	number	a pitch NAMES the axis; a number offsets the written one
amount	number	sets the blend outright, 0..1
scale	scale	needed for degree mode — without one it reflects chromatically

Outputs

port	carries	what it does
out	note	the note, inverted

Written params

param	range	default	scenes	what it does
axis	0…127midi	C4	a scene can ramp it	the line it folds around — a note name or a MIDI number
mode	chromatic · degrees	chromatic	a scene can set it (jumps)	degrees reflects by scale steps and stays in the key
amount	0…1	1	a scene can ramp it	1 is a full reflection; 0 is a bit-identical no-op

echo

A canyon wall: every note comes back N times, quieter each time. Per-note and untransformed — the opposite of a wormhole, which returns a whole chunk once.

Inputs

port	carries	what it does
in	note	notes to repeat

Outputs

port	carries	what it does
out	note	the note, then its repeats

Written params

param	range	default	scenes	what it does
times	0…16	3	a scene can set it (jumps)	how many times it comes back; 0 is a bit-identical no-op
delay	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	0.5beat	written only	the gap between repeats
decay	0…1	0.6	a scene can ramp it	velocity multiplier per repeat — an inaudible tail is never scheduled
shift	a number in semitones	0	a scene can ramp it	transpose each repeat; combine with redshift for a receding echo

Rhythm & chance

euclid

Euclidean rhythms — hits spread as evenly as possible across steps.

Inputs

port	carries	what it does
clock	any	each value advances one step
reset	any	the necklace snaps back to its first bead

Outputs

port	carries	what it does
pattern	trigger	fires on hit steps only
shape	pattern	the whole shape, once, at start

Written params

param	range	default	scenes	what it does
hits	0 and up	4	a scene can set it (jumps)	how many land
steps	1 and up	8	a scene can set it (jumps)	how many slots
rotate	any number	0	written only	turn the necklace (a scene set of hits/steps resets this to 0)

pulsar

Plays a rhythm shape somebody else made. Same outputs as a euclid, but the necklace arrives on a wire instead of being worked out from hits and steps — so a shape can be flipped, reversed, and played several ways at once. Its rotate is the one a scene can turn.

Inputs

port	carries	what it does
shape	pattern	the necklace to play — from a euclid, or one a bead has changed on the way
clock	any	each value advances one step
reset	any	back to the first bead

Outputs

port	carries	what it does
pattern	trigger	fires on hit steps only — the same output a euclid gives
shape	pattern	what it is actually playing, rotation and all

Written params

param	range	default	scenes	what it does
rotate	any number	0	a scene can set it (jumps)	turn the necklace — and unlike a euclid's, a scene can move this one

interfere (also combine)

Two rhythm shapes laid over each other, the way two waves interfere: and keeps the steps where both hit, xor the steps where exactly one does, or where either does. Shapes of different lengths are carried out to the length where the pair repeats, so a 3 against an 8 gives you the whole 24-step conversation.

Inputs

port	carries	what it does
a	pattern	the first shape
b	pattern	the second — it may be a different length

Outputs

port	carries	what it does
out	pattern	the composite, ready for a pulsar or a seq.mask

Written params

param	range	default	scenes	what it does
op	and · or · xor	and	a scene can set it (jumps)	how they interfere — and is the default because it is the one nothing else can do: two rhythms already layer by wiring both at the same port, but their COINCIDENCES have never been reachable

dice

Seeded uniform choice from a list of faces — repeat a face to weight it.

Inputs

port	carries	what it does
roll	any	any value rolls

Outputs

port	carries	what it does
roll	number	the face that came up

Written params

param	range	default	scenes	what it does
faces	a list — (number)	(0 1)	written only	what can come up
seed	any number	1	written only	same seed, same rolls, forever

seq (also sequencer)

A step sequencer: your written notes one per trigger, or a seeded random line — and if you wire a field in, sway decides whose pen it is.

Inputs

port	carries	what it does
step	any	advance and play
gate	any	the same thing, by another name
mask	pattern	a rhythm shape from a euclid — the line still walks every step and only SOUNDS on the hits, which is a different tune from wiring that euclid at gate
field	field	a gravity field with designs on your melody — see sway
reset	any	snap back to step one — wire a section boundary in and every section starts on the loop's downbeat
velocity	number	offsets the written velocity — anything can conduct dynamics

Outputs

port	carries	what it does
notes	note	one note per step — or the whole chord, together

Written params

param	range	default	scenes	what it does
notes	a list — (note name or MIDI number; join with + for a chord (50+57, D3+A3))	()	written only	a written melody; leave it out for seeded chaos
sway	0…1	1	a scene can set it (jumps)	the wired field's grip on the pen: 1 = it writes every step (the interdictor), 0.3 = it grabs a third of them, 0 = your notes regardless
velocity	0…1	0.8	a scene can ramp it	how hard the notes land — scenes can morph it (a written crescendo)
steps	1 and up	8	written only	how many random steps to invent
seed	any number	1	written only	which random line you get

arp

Holds the latest chord and walks it one note per trigger — up, down, bouncing or seeded-random.

Inputs

port	carries	what it does
chord	chord	the chord to walk
step	any	take one note
reset	any	back to the bottom of the ladder, climbing
velocity	number	offsets the written velocity — anything can conduct dynamics

Outputs

port	carries	what it does
notes	note	the next rung

Written params

param	range	default	scenes	what it does
dir	up · down · updown · random	up	a scene can set it (jumps)	which way it climbs
velocity	0…1	0.75	a scene can ramp it	how hard the steps land (ratchet repeats stay softer, proportionally)
octaves	1 and up	1	a scene can set it (jumps)	how far the ladder reaches
ratchet	0…1	0	a scene can set it (jumps)	chance of a stutter repeat
seed	any number	3	written only	for the random direction

phrase

A bar you write by hand at 16th resolution — melody, reusable trigger hits, and a seeded variation each time round.

Inputs

port	carries	what it does
clock	any	one value per 16th
scale	scale	what the degrees mean
reset	any	back to beat one of the phrase — sections and phrases breathe together
var	number	sets the variation chance outright (not an offset)
velocity	number	offsets the written velocity — anything can conduct dynamics

Outputs

port	carries	what it does
notes	note	the melody
hits	trigger	the rhythm, reusable

Written params

param	range	default	scenes	what it does
steps	quoted text	"1..............."	written only	digits 1-9 degrees, accidentals # b beside them (b7, 4#), . rest, - tie, x repeat; ! accent, , ghost
octave	any number	3	a scene can set it (jumps)	which octave the degrees land in
meter	free · follow	free	written only	free: the pattern's own length is its loop (bar-agnostic — polymeter lives here); follow: ask the sun — the phrase loops exactly at the meter's bar (a short pattern rests out the remainder, extra steps are ignored)
var	0…1	0	a scene can ramp it	chance a step wanders
velocity	0…1	0.8	a scene can ramp it	the base velocity — accents scale from it (! and , keep their proportions)
seed	any number	5	written only	which variations you get

Exotica

supernova

Hoards notes as stellar mass, then flings the whole hoard out at once and leaves a remnant behind.

Inputs

port	carries	what it does
in	note	mass to hoard (and pass through)
detonate	any	blow it now

Outputs

port	carries	what it does
out	note	the passthrough
burst	note	the hoard, flung
boom	trigger	the moment itself
remnant	note	the drone left behind

Written params

param	range	default	scenes	what it does
critical	2 and up	24	a scene can set it (jumps)	how many notes before it goes off by itself
yield	0…48semitones	24	a scene can set it (jumps)	how far the burst scatters
remnant	neutronstar · blackhole · none	neutronstar	written only	what it leaves
dark	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	4bar	written only	how long a black hole swallows everything
seed	any number	1987	written only	which way the debris flies

neutronstar

Crushes every note into a narrow band around a drifting centre of mass, and sometimes the crust cracks.

Inputs

port	carries	what it does
in	note	notes to crush

Outputs

port	carries	what it does
out	note	the crushed note
quake	trigger	the crust cracking

Written params

param	range	default	scenes	what it does
density	1 and up (semitones)	5	a scene can set it (jumps)	how narrow the band is
center	any number	48	written only	where it starts — it drifts from there
quake	0…1	0.08	a scene can set it (jumps)	chance of a crack
seed	any number	33	written only	which notes quake

comet

A frozen phrase that visits once an orbit, brightening toward perihelion and shedding a quiet trail.

No inputs.

Outputs

port	carries	what it does
notes	note	the visit
dust	note	an octave up, very quiet

Written params

param	range	default	scenes	what it does
notes	a list — (note name or MIDI number)	(69 72 76 72)	written only	the frozen phrase
orbit	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	16bar	written only	how often it comes round
pace	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	0.5beat	written only	how fast it passes

redshift

The source is receding: notes drift progressively flat and dim. Negative rate is an approaching blueshift.

Inputs

port	carries	what it does
in	note	notes to shift

Outputs

port	carries	what it does
out	note	the shifted note

Written params

param	range	default	scenes	what it does
rate	a number in semitones	1	a scene can ramp it	semitones per per; 0 is a bit-identical no-op
per	a duration — musical (4bar, 2beat, 8th, 1/8) or real (500ms, 1.5s, 1day)	8bar	written only	how long one semitone of drift takes

Output & glue

midiout (also instrument)

Where notes leave the universe: one MIDI channel, optionally a real CLAP or VST3 synth, with four wires that reach inside its knobs.

Inputs

port	carries	what it does
in	note	notes to play (any port name works, but say in)
octave	number	re-homes incoming notes; 4 is as written
mod1	number	0..1 into the plugin param named by mod1=
mod2	number	0..1 into the plugin param named by mod2=
mod3	number	0..1 into the plugin param named by mod3=
mod4	number	0..1 into the plugin param named by mod4=

Outputs

port	carries	what it does
gain	number	telemetry: the fader's position in dB, announced when a scene moves it

Written params

param	range	default	scenes	what it does
ch	1…16	1	written only	MIDI channel
humanize	0…1	0	written only	seeded velocity breath
seed	any number	11	written only	which breath (only used when humanize > 0)
plugin	quoted text		written only	path to a .clap or .vst3 — quoted
id	quoted text		written only	which plugin inside a bundle
preset	quoted text		written only	a preset file to load
state	quoted text		written only	a saved state file — what the workshop writes
set	quoted text		written only	"Cutoff:0.7, Res:0.2" — plugin params at start
mod1	quoted text		written only	name a plugin param for the mod1 port
mod2	quoted text		written only	name a plugin param for the mod2 port
mod3	quoted text		written only	name a plugin param for the mod3 port
mod4	quoted text		written only	name a plugin param for the mod4 port
wave	sine · triangle · saw · square · noise	sine	written only	builtin voice only — noise is the drum kit (pitch tints it: low thud, high hiss)
attack	0.0005 and up (s)	0.005	written only	builtin voice only
release	0.005 and up (s)	0.25	written only	builtin voice only
detune	any number	4	written only	cents — builtin voice only
brightness	0.5 and up	6	written only	lowpass, as a multiple of the note — builtin voice only
gain	-96…24db	0db	a scene can ramp it	the fader — scenes can snap it, morphs RAMP it (the house mute is pad.gain=-96)
pan	-1…1	0	written only	-1 left, 1 right

balance (also compare)

A beam balance: two number streams in, the tilt out. out is how far a outweighs b, and tip fires the moment the beam swings the other way. This is the one thing a bead cannot do — over and under weigh a stream against a number you wrote; this weighs it against another stream.

Inputs

port	carries	what it does
a	number	the near pan
b	number	the far pan

Outputs

port	carries	what it does
out	number	a minus b — positive while the near pan is heavier
tip	trigger	fires when the beam swings the other way

Written params

param	range	default	scenes	what it does
slack	0 and up	0	a scene can set it (jumps)	how far past level the beam must swing before it counts as tipped — keeps a near-level pair from chattering

capture

The tape: wire any point in the patch into it and everything passing is written to a multi-track MIDI file.

Inputs

port	carries	what it does
in	note	notes to tape (any port name works)

No outputs.

Written params

param	range	default	scenes	what it does
path	quoted text	"take.mid"	written only	where the take lands — must be quoted

script

A node you write yourself in Lua — it gets ports, a seeded dice and a clock, so determinism holds for your code too.

Inputs

port	carries	what it does
in	any	whatever your script listens for

Outputs

port	carries	what it does
out	any	whatever your script emits

Written params

param	range	default	scenes	what it does
file	quoted text	"node.lua"	written only	required, quoted — every other param is passed through to Lua
seed	any number	1	written only	feeds self:rand()

Beads

A bead rides on a wire and transforms what passes: lead.notes -[note -12]-> voice.in. Strictly one in, one out. A wire carries at most one bead; its neutral setting is a no-op, so -[lag 0]-> changes nothing.

index

unit float to an integer 0..n-1 (7 = the modes)

option	range	default	what it does
n	1 and up	7	how many slots

scale

multiply by k

option	range	default	what it does
k	any number	1	multiplier

offset

add k

option	range	default	what it does
k	any number	0	how much to add

note

transpose notes (or add k to bare numbers)

option	range	default	what it does
k	a number in semitones	0	how far to transpose

clamp

bound the value (on notes, bounds the pitch)

option	range	default	what it does
lo	any number	0	floor
hi	any number	1	ceiling

wrap

wrap into the range (0..12 = pitch classes)

option	range	default	what it does
lo	any number	0	floor
hi	any number	12	ceiling

flip

on a rhythm shape: hits become rests and rests become hits. ring.shape -[flip]-> hats.mask is a hi-hat that plays exactly where the kick does not — the complement, which no euclid setting can give you. Anything that is not a shape passes through untouched

No options.

reverse

on a rhythm shape: turn the necklace over, last step first. Not the same as rotating it — a lopsided rhythm read backwards is a different rhythm. Anything that is not a shape passes through untouched

No options.

invert

turn it upside down: top - x, so as one thing rises the other falls. The default top of 1 is the unit range every control port speaks; write the top when the stream lives somewhere else (-[invert 127]-> for a pitch). No neutral setting — inverting is the whole job. Notes pass through untouched; to turn a MELODY over, use a mirror body

option	range	default	what it does
top	any number	1	what counts as full — the value is taken away from this

curve

bend a unit range: x^e, sign preserved

option	range	default	what it does
e	0.001 and up	1	exponent; 1 is a no-op

lag

one-pole smoothing; the first event snaps

option	range	default	what it does
a	0…1	0.5	0 instant, 1 frozen

accum

running sum — deltas in, a walk out

option	range	default	what it does
span	0 and up	0	0 = never wrap

count

how many events have come down this wire — deaf to the value, so it counts notes and triggers too

option	range	default	what it does
span	0 and up	0	wrap after this many; 0 = never wrap

over

a gate that opens while the value is above k (comparing two live streams needs a node)

option	range	default	what it does
k	any number	0	the threshold

under

a gate that opens while the value is below k

option	range	default	what it does
k	any number	0	the threshold

diff

change since the last value — a walk in, deltas out

No options.

vel

dynamics on a wire: every passing note lands factor× as hard, clamped to 0..1

option	range	default	what it does
factor	0…4	1	multiplies each note's velocity — 1 is a bit-identical no-op

loudness

a meter, not a transform: each passing note comes out as its velocity (0..1) — the wire's dynamics curve. Smooth it with a lag if it flickers; non-note values pass through untouched

No options.

pitch

the other half of loudness: each passing note comes out as its pitch, a MIDI number (60 = middle C). Key tracking — lead.notes -[pitch 127]-> voice.cc74 and the synth follows the line it is playing. The divisor is there because a wire carries one bead, so reading the pitch and bringing it into range has to happen in the same breath; leave it at 1 for the pitch itself. Non-note values pass through untouched

option	range	default	what it does
over	0.000001 and up	1	divide by this — 127 puts a pitch on the 0..1 scale a control port wants

density

how fast events arrive on this wire, in events per beat

option	range	default	what it does
beats	0.001 and up (beats)	1	the window; wider reads truer

Control output — the plugin's own ports

These are not engine ports; they are the plugin's, and they exist only here. Wire any number stream into one of them on a midiout body and it leaves as MIDI control on that body's channel:

port	becomes
cc0 … cc127	Control Change on that number
cc<N>_14 (N ≤ 31)	a 14-bit pair — MSB on N, LSB on N+32, always sent together
pb	pitch bend (14-bit; 0.5 is centre)
at	channel aftertouch
mod1 … mod4	whatever the body names it: voice : midiout mod1="cc11"

0..1 is the unit of exchange — 0 becomes 0, 1 becomes full scale, and anything outside clamps rather than wraps. That is already the range of lfo.out, a gravity body's pull, inertia's drift and a default contour. Bring anything else into range with the wire's own bead:

  dice.roll -[scale 0.2]-> voice.cc1     # a 0..5 die across the full sweep
  swell.out -[curve 2]->   voice.cc11    # bend the taper

Key tracking is the one worth knowing. The pitch bead reads a note's own pitch out as a number, so a synth follows the line it is playing:

  lead.notes -[pitch 127]-> voice.cc74   # filter opens as the melody climbs

Mind the 127. A pitch is a MIDI number (60 is middle C), not a unit value, and anything above 1 clamps to full scale here -- so a bare -[pitch]-> would pin the controller at 127 and never move. The divisor is part of the bead because a wire carries only ONE bead, so reading the pitch and bringing it into range has to happen in the same breath. Its sibling loudness reads velocity, which is already 0..1 and needs nothing.

Control is generated with the notes, so it is sample-accurate, identical at any buffer size, and follows host tempo exactly as the music does. Repeated values are not resent, a rate cap keeps a fast stream from storming the host, and every controller is restated when you relocate — so landing mid-sweep never leaves a synth on a stale value.

---

Recluse Studios · Orrery. Generated from the engine vocabulary — see QUICKSTART for getting started, routing, the canvas and OSC.

---

Recluse Studios · Orrery 0.9.0. Part III is generated from the engine's own vocabulary table, so it is never out of date with the plugin you have.