REF: MOD_O01 // GENERATIVE MIDI // VST3 · CLAP · WINDOWS

Orrery

Ideas,
not performances.

A generative MIDI universe, in your DAW

Patch a small solar system — clocks, keys, chord logic, gravity — wire the bodies together, and let the thing decide what to play. Seeded and deterministic: the same universe plays out the same way, forever. Set the rules. Let the material speak. Judge by ear.

▸ It emits MIDI on sixteen channels. You bring the synths.

$69 beta  · $99 at 1.0

Paid beta · out now · 14-day trial, fully featured

VST3 + CLAP Windows 10/11 64-Bit 16 MIDI Channels Out OSC Broadcast

Hear The Evidence

// no mockups. this is the plug-in, running in a DAW, playing your instruments.

DEMO_01 // IN THE HOST

Fugue

Orrery driving three instances of Decent Sampler in real time, Reaper hosting. One plug-in, three voices, sixteen channels available — the universe on the left, your instruments on the right.

DEMO_02 // THE MATERIAL

Undertow

One static texture, three rhythms braiding against a bar. An additive ladder climbs D5 to D6, a tresillo thumps the grid, a 2-in-7 pulls against both. Nobody sequenced this. The patch did.

What You Actually Do With It

Three things: build the universe, keep what it gives you, and send the numbers somewhere.

USE_01 // BODIES

Gravity is a chord.
Wormholes are canon machines.

You drop bodies into a sky and wire their ports together. A clock keeps time. A key holds the tonality. A progression walks the changes, a voice-leader smooths them, and a gravity well bends everything nearby toward its centre. Wire a body's output into another's input and the second one starts listening.

Beads sit on the wires and do the arithmetic — scale, offset, clamp, curve, lag — so a die roll can drive a filter sweep and a slow contour can nudge a whole section. The machine has no opinions. It has a clock.

The Orrery Celestial Canvas, showing patched bodies and wires
USE_02 // DETERMINISM

The score is a patch.
The patch is text.

Everything you build saves as a plain .orr file — readable, diffable, a thing you can keep in a repo next to the song. Load it in the plug-in or the desktop app and you get the same universe.

It is deterministic all the way down. Same patch, same seed, same performance — every time, at any tempo, at any buffer size, on any machine. Offline render is exact, not approximately exact. That is why it records ideas rather than performances: the idea is the file, and the file will still play in ten years.

// firstlight.orr — excerpt
sun    : clock    bpm=host
key    : key      center=D scale=dorian
prog   : progression follow=(i bVII i v)
grav   : gravity  mass=0.4
voice  : midiout  ch=1

sun.beat  -> prog.clock
key.out   -> prog.key
prog.out  -> voice.note
grav.pull -[scale 0.6]-> voice.cc74
USE_03 // CONTROL

Numbers leave
the universe too

Any number stream in the patch can walk out as MIDI control. Wire a contour, an LFO, a gravity well's pull or a dice roll into a channel's cc, pb or at port and MIDI-learn it on your synth. Fourteen-bit CC when seven is not enough.

Control is generated with the notes, so it is sample-accurate and identical at any buffer size. Repeated values are not resent, and a rate cap keeps a fast stream from storming the host. Loop or drop the playhead mid-piece and every controller is restated at the new position — a synth is never left holding a stale value.

// 0..1 is the unit of exchange
ramp.out  -> voice.cc74     # cutoff
swell.out -> voice.pb       # bend, 0.5 = centre
grav.pull -> voice.at       # aftertouch
swell.out -> voice.cc1_14   # 14-bit pair

dice.roll -[scale 0.2]-> voice.cc1
sun.tempo -[clamp 0 1]-> voice.cc74
LAW_02 // AUTHORSHIP

Built For Humans And Agents

// the patch is text, and text is a thing a machine can write

An .orr patch being plain text is not an implementation detail. It is the point. Anything that can write text can build a universe — you, dragging bodies around the canvas, or an agent, working in a loop. Both Orreries read the same file either way.

And because the engine is deterministic, an agent's work is checkable. Same patch, same seed, same performance, every run. You can diff two versions and hear exactly what changed, which is not a sentence you can usually say about generative music.

Retro, Tensorpunk's language for agents, speaks it natively. You declare the guarantees a piece has to satisfy — the key journey, the section count, what must land where — and refine backwards until a .retro file emits the patch. Retro specifies it. Orrery performs it.

▸ Undertow, further up this page, came out of exactly that pipeline.

// specify, emit, perform
  .retro     declare the guarantees
     |
     |        retro emit
     v
  .orr       the universe, as text
     |
     |        load
     v
  Orrery     it plays
Retrolang.dev
// SAME CONVERSATION, TWO HALVES

Orrery and Retro grew up together. Recluse Studios and Tensorpunk have spent the past year trading notes — one of us building an instrument that keeps ideas instead of performances, the other a language that says what it means before it writes any code. Neither is a bolt-on for the other. Both came out of the same discussion: how do you tell a machine what you actually want, and know that it did it?

We recommend each other on purpose.

The Celestial Canvas

// where you build it and watch it run, without leaving the plug-in window

The Celestial Canvas running, bodies glowing as they fire

Direct Manipulation

Drag bodies. Draw wires between ports. Drop beads on the wires. Click a body for its full parameter list. The text is just what gets saved.

It Glows When It Fires

Every emission lights its port and every note lights its body, so you can see which part of the machine is doing the thing you are hearing.

Never A Dead Plug-In

A patch that fails to build leaves the last good one playing and tells you why in a toast. Ctrl+Z undoes. The music does not stop because you typed something wrong.

Four Skins

Celestial, Boring, Zodiac and Cyber. Panels collapse when the DAW is stingy with pixels. The window is resizable.

LAW_01 // TRANSPORT

The Host Is Truth

  • TEMPO

    Your DAW's tempo and transport are the sun. The universe follows your grid at any tempo, and the same passage lands on the same beats whether you are at 93 or 174.

  • LOOPS

    Stop, loop, seek, scrub. Every sounding note is released first — no stuck notes, ever. That is a law with a torture test behind it, not a hope.

  • RENDER

    Offline render is exact. Bounce it faster than real time and you get the identical event stream, sample for sample, at every buffer size from 32 to 2048.

  • CHANNELS

    One MIDI port, sixteen channels. Each output body owns a channel; split them onto tracks with your DAW's MIDI sends, or feed one multitimbral instrument.

Specifications

// what it is, what it emits, what it will not do

Product Orrery
Version 0.9.0 · Paid Beta
Format VST3 + CLAP (64-Bit)
OS Platform Windows 10 / 11 (64-bit)
Download Size 6.0 MB · ZIP
Output MIDI Only · 1 Port / 16 Channels
Control Out CC · 14-Bit CC · Pitch Bend · Aftertouch
Resolution 960 PPQN · Sample-Accurate
Buffer Sizes 32 – 2048 · Identical Output
OSC UDP Broadcast · TouchDesigner, Max, Resolume
Patch Format .orr · Plain Text
Trial Period 14 Days Fully Featured
Licensing 3 Machines per Licence

There Are Two Orreries

// same engine, same patch files, two different jobs

ORR_01 // THE PLUG-IN

In Your DAW

The one this page is about. VST3 and CLAP, sitting on a track, emitting MIDI to whatever instruments you already own. Your DAW keeps the time, does the recording, and renders the result.

Commercial, proprietary, one-time purchase. Out now as a paid beta.

$69 beta  · $99 at 1.0
ORR_02 // THE DESKTOP APP

The Whole Observatory

The bigger animal. It hosts your plug-ins itself and makes actual audio, writes MIDI files, drives visuals over OSC, and has a command line for people who want one. Same engine, and it reads the same .orr files the plug-in writes.

It is what the demos on this page were built in. It is not released.

// when there is something to announce, this is where it gets announced

Straight Talk

  • ▸ It makes no sound on its own. Orrery is a MIDI generator. It plays your instruments; it does not contain any. If you want the version that hosts plug-ins and makes audio, that is the desktop app, and it is not out yet.
  • ▸ Reaper is the host of record. That is where it is tested and gated every build. It is a well-behaved VST3 and CLAP elsewhere, but Live's VST3 MIDI-out routing is the known-awkward one — try the trial in your DAW before you buy.
  • ▸ Recording needs one setting changed. Orrery makes its MIDI inside the FX chain, so a track set to record its input hears nothing. Record the track's output instead — or just render, since the performance is deterministic anyway.
  • ▸ It is a beta, and the universe is still expanding. New bodies and beads land most weeks. Patches you write keep working, and the reference lives inside the plugin — click any body and read what it does, what every port carries and what every value may be, without leaving the DAW.
  • ▸ Windows will warn on the installer. It is unsigned. Click More info → Run anyway. A SHA-256 checksum is published next to the download so you can verify what you got.
// PAID BETA

Buy The Beta, Keep The Universe

Orrery is out as a paid beta. It makes the music on this page today, and it grows most weeks — new bodies, new beads, new things to wire together.

Buy it now and you buy all of that: every update through 1.0 and beyond is included, at the beta price, however far the vocabulary gets. The price goes up when it stops being a beta. What you paid does not.

$69 beta  · $99 at 1.0

One-time purchase · 3 machines · 14-day trial, fully featured · Windows

Read The Manual First

Buy Orrery — $69 Download The Trial

Orrery 0.9.0 beta · 6.0 MB · ZIP · VST3 + CLAP · Windows 10/11 64-bit

SHA-256 (extracted .exe): bce7a46912c053e97776404f96424c60735fb0b2ad5ea812c0449ba2f5c8cc72

No spam · one message, with the download and the beta price