DUNA draws automation curves and sends them as MIDI, so any parameter of any plug‑in in any host — and any hardware synth — can be moved in time with your music. This page documents the whole instrument: lanes, the curve editor, recording in Logic's four modes, the three output resolutions, host setup for AUM and Loopy Pro, the standalone routing view, and the clock.
Overview
DUNA is a native automation instrument that ships as an AUv3 plug‑in and a standalone app, for iOS, iPadOS and macOS (Mac Catalyst). One purchase covers both. The engine is header‑only C++17, the AU bridge is Objective‑C++, the interface is SwiftUI.
It makes no sound. What it does is move things: you draw a shape, point it at a knob, and DUNA plays that movement forever, locked to the beat. It is the only app in the Temperamento family that is silent on purpose.
Why it sends MIDI rather than reaching into the plug‑in. An AUv3 cannot touch another AUv3's parameters — every plug‑in runs sealed in its own process, and there is no API across that wall. So the host has to mediate, and MIDI is the one language every host and every plug‑in already speaks. That indirection is not a limitation to work around; it is exactly why DUNA works with plug‑ins you already own, and with the hardware on your desk, without either end being modified.
The same rack either way — in a MIDI slot in your host, or as its own app with a virtual MIDI port.
Each with its own shape, length, depth and destination. All independent, all locked to the same beat.
Lanes loop from the beat position, so they work in hosts that have no arrangement at all — which is most of them on iOS.
The speaker icon in the header silences every lane, the NOTES loop and the arp at once, and every ON chip shows OFF while it's engaged — the rack looks as silent as it is. Nothing underneath is actually switched off, so tapping it again brings everything back exactly as it was.
Read this first
This is the single thing most likely to confuse you, and it is structural rather than a missing feature. It is worth two minutes now.
In Logic, the recorder is the host. Logic owns every plug‑in it loads, so it can see any knob you touch anywhere. Arm a track, move a control, and Logic captures it.
DUNA is a plug‑in. It cannot see another plug‑in's controls — that is the same sandbox wall described above, seen from the other side. No AUv3 on iOS can watch another one's knobs.
So DUNA's fader is the knob. Do not reach for the synth's control. Move DUNA's record fader instead: it drives the parameter, and that movement is what gets recorded. It is precisely the same as dragging in Logic's automation lane rather than on the plug‑in's own panel. Everything downstream is identical — the only thing that changes is where your finger lands.
A hardware knob closes most of the remaining distance. Bind one with LEARN CC and you are turning a real control, DUNA records it, and the synth follows — which is as close to the Logic feel as a plug‑in can get.
Getting started
Any AUv3 synth, drum machine or sampler. Play it and check you can hear it.
In a MIDI slot, not an audio channel — DUNA makes no sound of its own.
One connection to your instrument carries every lane. Some hosts, AUM among them, also need a second connection to their own control-mapping bus before MIDI Learn can see it — see the AUM walkthrough below for exactly which.
In your host, on the parameter you want to move.
The lane sweeps its destination across the full range — exactly what a learn function is waiting for. It binds on the spot.
Press MIDI LEARN again, flip the lane on, and the parameter is now following the shape.
The 1 2 3 strip under the mode bar says the same thing in nine words, and disappears once you dismiss it.
Nothing moving? A lane on 16 BAR takes 32 seconds at 120 BPM to complete one pass, which looks like nothing is happening. Set it to 1 BAR while you are learning.
The lane
A lane is somebody turning one knob for you, forever. You tell it three things: what shape to move in, how long a pass takes, and which knob. Everything else is refinement.
| ON / OFF | Arms the lane. Off sends nothing at all — not a zero, not a held value, nothing. |
| Name | Tap it to rename. CUTOFF is worth more than LANE 3 once there are eight of them. |
| CURVE / LFO | Which generator runs. Tapping CURVE opens the editor; LFO uses the shape chip beside it. |
| Shape | Sine, triangle, ramp, saw, square, sample‑and‑hold. The sparkline shows the real waveform, drawn by the same evaluator that plays it. |
| Division | How long one full pass takes: 1/32, 1/16, 1/8, 1/4, 1/2, or 1 to 16 bars. |
| Destination | Tap → CC102 to set the controller number, MIDI channel and resolution. The number beside it is the value going out right now. |
| MIDI LEARN | Sweeps this lane's destination so a learn function can catch it. Press again to stop. |
| DEPTH | Shrinks the shape without redrawing it. The movement stays, the range narrows. |
| TRIM | Slides the whole shape up or down. Depth is how far it turns; trim is where it starts. |
| ARM | Arms the lane for recording. Only visible while REC is on. |
| Grip (≡) | Drag the handle at the left of a row to reorder it — a lane, ARP, or the XY pad all move the same way. Dragging anywhere else still scrolls, which is why reordering lives on a handle. A lane carries its destination, curve and name with it; ARP and the pad simply take their spot in the stack, since neither has a destination of its own. |
| ▾ / ▸ | Folds a lane down to just its header, hiding the shape and depth/trim rows — the same disclosure ARP and the XY pad already had. Useful for shrinking a lane you are not working on so there is less to scroll past. Persisted, so it stays folded. |
| 🗑 | Deletes the lane — tap once to arm it, tap the same icon again to confirm. Not shown if this is the only lane left, since DUNA always keeps at least one. |
Want to wiggle a knob instead of picking a shape? An LFO lane only offers preset waveforms, but you can record your own move: press REC, tap ARM on the lane, and move DUNA's record fader (or a hardware knob bound with LEARN CC). The lane switches from LFO to a drawn curve and keeps what you played. DUNA cannot watch the synth's own knob, so the fader stands in for it. See Recording.
Give lanes different lengths. A three‑bar lane against a four‑bar one takes twelve bars to line up again, and never repeats the same way in between. It costs nothing, because every lane reads the beat independently — and it is the cheapest way to make a loop stop sounding like a loop.
ADD LANE at the foot of the rack asks what the new lane should be — a drawn curve, an LFO, or either axis of the XY pad — with a live preview of each shape and what it is for. Up to sixteen lanes. Sixteen is the ceiling because MIDI has sixteen channels and HI‑RES lanes need one each; past that they would fight.
The curve editor
Tap a lane's CURVE chip to open it. The white dot riding the curve is the playhead — it shows exactly what the lane is sending as you edit.
| Tap empty space | Adds a breakpoint there. |
| Drag a point | Moves it. It cannot cross its neighbours, so the shape can never fold back on itself. |
| Drag a ring | The hollow ring at a segment's midpoint bends that segment — convex, concave, or straight again. |
| Hold a point | Deletes it. The first and last points stay, since they define where the shape starts and ends. |
| Two fingers | Fine adjust: every drag slows to about a fifth of its travel, with a FINE badge to say so. |
| EDIT | The default tool — add, drag, bend, delete. |
| DRAW | Freehand pencil. Drawing over the same place again redraws it rather than piling points up. When you lift, the stroke is tidied: drawing samples densely so nothing is missed, then the points that carry no shape are dropped. A bend is never dropped, because interpolation cannot reproduce one. |
| ERASE | Rubs out every point you drag over, not just the nearest one. The first and last points always survive, since they define where the cycle starts and ends. |
| LINE | Rules a straight ramp across a span in one drag. |
| SNAP | Sixteenths horizontally, eighths vertically. Off when you want it loose. |
| RAMP / PEAK / DIP / FLAT | Starting shapes. Grab one, then bend it into what you want. Replaces the whole curve, so it needs a second tap on the same chip to confirm — a first tap only arms it. |
The readout under the plot gives the selected point's position, value and bend as numbers, so a shape can be matched by eye or by figure.
Fine adjust is genuine multi‑touch, so it works on iPhone and iPad. On a Mac a trackpad arrives as a mouse, so use SNAP for precision there instead.
Notes
NOTES is a loop of MIDI notes, from one bar to sixty‑four, played from the same beat as every lane. Like the lanes it has no position of its own: it is locked to the host's beat, plays when the host plays, holds still when it stops, and starts again from bar 1 when it rolls. It sends on a channel of its own.
Press REC and play. Notes land where you played them as the loop goes round, from a keyboard your host routes into DUNA, from a hardware controller in the standalone app, or from the two-octave keyboard in the NOTES panel itself. Held notes grow on screen while you hold them.
| OVERDUB / REPLACE | Add to what is there, or clear the loop the moment your first note of the take lands. |
| Q | Record quantise. Moves each note's start onto the grid as it lands; the length you played is kept. |
| Length | 1, 2, 4, 8, 16, 32 or 64 bars, and up to 2,048 notes. Shortening keeps the notes past the end — they go quiet, and come back when you lengthen again. |
| CH | The MIDI channel the loop and DUNA's own keyboard send on. |
| Keys | Real multi-touch, so chords work. Slide for a run; strike lower on a key to play it louder. |
The piano roll. Tap the loop in the NOTES panel, or EDIT, to open it. It opens in SELECT, so a tap never drops a note by accident. On iPhone it fills the screen.
| ▶ / ■ | Arms and mutes the loop. It plays with your host: when the host's transport is stopped the loop is silent whatever this says, and it comes in from bar 1 when the host rolls. In the standalone app, or a host that offers no transport, DUNA keeps its own clock, so this starts and stops the loop from bar 1. Stopping also ends a take. |
| DRAW | Tap to add a note and drag to size it. Tap an existing note to delete it. |
| SELECT | Tap to pick, drag to move (time and pitch together), drag a note's right end to resize, drag across empty space to box several. |
| ERASE | Rubs out every note you drag across. |
| SNAP | The grid that notes, moves and resizes land on: 1/4 to 1/32, triplets, or off. |
| Velocity | Paint it in the strip under the roll. One stroke across a phrase is a crescendo. |
| Actions | QUANT, −OCT / −1 / +1 / +OCT, DUP, LEGATO, ×2 (double the loop and repeat it), ALL, DELETE, CLEAR. Each acts on the selection, or on every note when nothing is selected — no need to select all first. QUANT's label says which (QUANT ALL or QUANT SEL), and the footer reports how many notes it moved. |
| Moving around | Two fingers scroll and a pinch zooms; on a Mac, trackpad and wheel scroll. Drag the keyboard or the ruler, or use the − / + zoom buttons. A long loop opens on its first eight bars, and while you record the view follows the playhead. |
| Keys | Space plays and stops, B / V / E tools, Delete, arrows transpose (Shift for octaves), Q quantise, R record, ⌘Z and ⇧⌘Z, ⌘D duplicate, ⌘A select all. |
Every gesture is one undo step, however long you dragged for. Notes play sample-accurately inside a host, and the engine tracks what it has started on its own, so editing or deleting a note while it rings never leaves it hanging.
The arp
DUNA sits in the MIDI chain, which makes an arpeggiator a natural thing for it to own: notes arrive, it holds them, and re-emits them on the beat. Open ARP at the foot of the rack.
With the arp off, notes pass straight through untouched — a MIDI processor that swallowed notes while idle would break the chain it sits in. It only takes them over when it is on.
| Patterns | UP, DOWN, UP‑DN, RND, DN‑UP, PLAYED, CHORD, CONV. PLAYED follows the order you pressed the keys rather than pitch; CONV works outside in, lowest then highest then second lowest. |
| Rate | 1/4 down to 1/64, including 1/8 and 1/16 triplets. |
| Octaves | One to four, walked up, down or alternating. |
| HOLD | Keeps it running after you let go of the keys. |
| GATE | How much of its step each note holds, from staccato to legato. |
| SWING | Pushes the off-steps late. |
| RATCHET | Up to four retriggers inside every step. |
| ACCENT | Every second, third or fourth step at full velocity. |
| CH | Which MIDI channel the arp sends on, so it can be aimed at a different synth from your lanes. |
It is clocked by the same host beat everything else in DUNA uses, so it locks to your host and to your lanes with nothing to set up. The engine is the one from MESA, vendored unchanged.
The XY pad
The pad itself does nothing except sit at an X (left‑right) and a Y (up‑down) position, each 0 to 1. On its own it is silent — it does not send MIDI, does not touch anything. To use it, set a lane's source to PAD X or PAD Y: that lane's value becomes whatever the pad's position is right now, and it sends that out to its own destination exactly like any other lane.
So the pad is really a shared LFO with two outputs instead of one. Draw one path and two lanes can ride it at once — one on X, one on Y — each with its own destination, depth and trim. One gesture, two knobs moving.
There are two entirely different ways the position gets set:
| PLAY | Your finger IS the position, live. Touch the pad and X/Y jump to wherever you touch; any lane watching it follows instantly. Let go and it goes back to whatever it was doing before. |
| DRAW | You are not playing it — you are recording a route for it to walk on its own, forever, in a loop. Drag across the grid to lay a path of up to 64 cells, painted once per cell you cross. Once drawn, the pad automatically walks that path in time with the beat, at the length set by the division chip. |
| ERASE | Removes cells you drag over from a drawn path. |
| GLIDE / STEP | GLIDE slides smoothly between the cells on the path. STEP jumps discretely from one to the next, which is the rhythmic, Kaoss‑like version. |
| FWD / REV / PING / RND | Which way the walk moves through the path — forward (the default), backward, out to the end and back within one cycle, or a shuffled hop between cells. The same idea as the arpeggiator's UP/DOWN/RANDOM patterns, applied to the pad instead of notes. |
| Division | How long one full walk of the path takes. A pad lane's own division chip is greyed, because the pad owns the timing. |
| CLR | Empties the whole path. Needs a second tap to confirm — a first tap only arms it. |
| LEARN X / LEARN Y | Binds a hardware controller — two knobs, a joystick, an XY touch strip — to drive the pad live, the same way LEARN CC drives the record fader. Tap, move the control, it is bound. While it keeps sending, the pad follows it; when it goes quiet, the pad hands itself back to the drawn path. |
The tools sit outside the surface on purpose. Mid‑performance, a stray touch on the pad must never change what the next drag does.
One gotcha: if a lane's source is PAD X and you record into it, DUNA switches that lane over to a drawn curve to capture your move. What gets captured is the pad itself — a PAD X or PAD Y lane records the pad's own live position (your finger in PLAY, or a hardware axis bound with LEARN X/Y), not the record fader. Recording always means drawing a curve, so a lane cannot record and keep following the pad's own drawn path at the same time.
The drawn path is a closed loop — the last cell leads back to the first — and it is walked from the host beat like every other lane, so it needs no start and cannot drift.
Recording
Press REC, tap ARM on a lane, and play the move on DUNA's record fader — or on a hardware knob bound with LEARN CC. The one exception is a PAD X or PAD Y lane: it records the pad itself, driven by touch or by a hardware axis bound with LEARN X/Y, not the fader. It writes only while you are actually holding the control, so the rest of the curve is never touched. Press REC again when you are done.
| REC | Arms recording. There is no mode to choose: it writes where you touch, and nowhere else. |
| ARM | Which lane receives. Only shown while REC is on. |
| LEARN CC | Binds a hardware knob to the record fader. Tap it, move the knob, done. |
Why one button and not five. Desktop DAWs offer Touch, Latch, Write and Trim. Three of those already exist elsewhere in DUNA and do the job better: every lane has a TRIM slider that offsets its curve without destroying it, the pencil overwrites a region in the editor where you can see what you are changing, and Latch is only Touch with a longer hold — on a loop that comes round in seconds. What is left is the one behaviour worth a control.
Recording is drawing with the playhead holding the pen. It writes through exactly the same mechanism the DRAW tool uses, so a recorded take is an ordinary curve — open the editor afterwards and tidy it by hand, bend a segment, delete a wobble. There is no separate "recorded" state to convert.
Because a knob sends no "release", a gap of about a quarter of a second in its stream ends the gesture — which is what lets TOUCH let go when you do.
MIDI LEARN and recording are two different bindings that have nothing to do with each other. MIDI LEARN decides where the lane's value goes; what shapes that value is the control the lane actually records from — the record fader for most lanes, the pad itself for PAD X/PAD Y. A lane that is ON is already sending to its destination whether or not you are recording — there is no silent rehearsal. The moment you move that control, the destination hears it live and it is written into the curve at the same time. DUNA cannot see what happens at the destination to record it back — the same wall that makes it a plug‑in rather than a host — so recording only ever captures the control you are physically touching.
Resolution
A slow filter sweep on ordinary MIDI climbs in audible stairs, because a control change carries only 128 values. Tap the resolution chip until it reads HI‑RES and the lane switches to pitch bend, which carries 16,384 — and needs nothing whatsoever from the receiving app.
| CC | 7‑bit control change, 128 steps. Universal, and enough for most things. |
| CC14 | A pair of controllers, n and n+32, giving 16,384 steps. Only some targets read the second half; hardware often does. |
| HI‑RES | Pitch bend, natively 16,384 steps. One per MIDI channel, so up to sixteen glassy destinations at once. Give each its own channel. |
| Defaults | Lanes start on CC 102–119, then 20–31 — ranges the MIDI spec leaves undefined, so DUNA can never collide with a synth's factory map. |
Use HI‑RES for filter cutoff, volume and pitch — anything where a step is audible. Plain CC is right for everything else and uses a fraction of the bandwidth.
Hosts
AUM saves its MIDI mappings into the session, so this is a one‑time setup rather than something you redo each time you open the set.
Hosts
Loopy Pro exposes every parameter an AU publishes, so a lane can reach anything in the session. Its sliders, buttons and XY pads can drive those parameters too — DUNA is the one that moves them over time, on the beat, without a finger.
apeMatrix, Audiobus and Cubasis follow the same principle: load DUNA, start the host's learn, press MIDI LEARN. Only the menu names change.
Hosts
Automation needs one connection — DUNA into the instrument. Recording into NOTES needs a second, and it is the one that is easy to miss: your keyboard has to go into DUNA, not around it.
| Other hosts | Loopy Pro, apeMatrix, Audiobus and Cubasis need the same two connections — keyboard into DUNA, DUNA into the instrument — wherever that host sets up MIDI routing for a plug‑in. These steps are written in general terms until someone confirms the exact menus; if you know them, tell us. |
| With the arp on | What you play is arpeggiated live, but the loop records the notes you actually played, not the arp's run. The loop itself plays straight to the instrument. |
| Standalone | No routing needed: DUNA records from every MIDI source switched on in CONNECT, and plays the loop out through its DUNA MIDI port. |
Hardware
Anything on a MIDI interface is a destination. Check the synth's manual for which controller number does what, set the lane's CC to match in the destination sheet, and it moves — no learn step, because the mapping is already in the instrument.
Hardware is also where traffic starts to matter. A DIN MIDI cable carries roughly 350 messages a second. Sixteen HI‑RES lanes produce about 3,000, which is fine over virtual MIDI and far more than a physical port can pass. Watch the readout in the header.
A hardware controller in the other direction is the best way to record: bind a knob with LEARN CC and you are playing a real control while DUNA writes it down.
Standalone
The standalone app publishes a virtual MIDI port called DUNA, and can also send straight into other apps' MIDI destinations. The CONNECT button shows both, with an activity dot on each so you can see traffic rather than infer it.
| Sends to | The virtual DUNA port (on by default, so apps that connect to it themselves keep working), plus every destination on the device. Tick one and DUNA sends directly to it. |
| Listens to | Every MIDI source, each with a toggle. These drive LEARN CC and knob recording. |
| Activity | A dot lights as messages pass. A tick says "should be connected"; the dot says "is". |
One thing to watch. If an app is ticked here and connects to the DUNA port itself, it receives everything twice. CoreMIDI does not tell an app who has subscribed to its virtual port, so DUNA cannot detect this — if something behaves oddly, turn the virtual port off or untick the app.
Many standalone instruments connect to every MIDI source automatically, so there is often nothing to route at all — just MIDI-learn a control and press MIDI LEARN.
Clock
The badge in the header says where the beat comes from. HOST means your host is supplying tempo and beat position. STOPPED means the host's transport is stopped, so DUNA is holding still. INT means DUNA is running on its own clock — normal, not a fault, and always the case standalone.
A lane has no position of its own. It works out where it should be from the beat:
phase = fmod(beat / cycleBeats, 1)
Bar 3, beat 2 always gives the same point in the shape. So lanes are automatically in step with each other and with the host, nothing can drift, and nothing needs restarting. There is no play button of its own — your host's is the one.
It follows the host's transport. Stop the host and DUNA holds still: lanes park at the host's position, the arp lets played notes straight through, NOTES goes quiet, and nothing is left ringing. Press play and everything starts again from the host's bars — every lane, the arp and the loop together. MIDI LEARN still sweeps with the transport parked, so you can map a lane without rolling anything. Where a host offers no transport at all, and always in the standalone app, DUNA runs on its own clock. Bars follow the host's time signature, so a 3/4 session gets true three‑beat bars rather than hardcoded fours. On a transport start, every lane restates its value, so a receiver that missed the last change is brought back into agreement.
Saving
Two different things, and they are easy to confuse.
| Session state | Running as a plug‑in, your lanes travel inside the host's project file. Save the AUM or Logic session and everything comes back with it. There is nothing extra to do. |
| Presets | Named banks of lanes, recalled independently of any session. The PRESETS button saves the current rack by name. |
| Shared | Presets live in a container shared between the app and the plug‑in, so one saved in the standalone shows up in the plug‑in and the other way round. |
| RESET | Under START OVER in the presets sheet. Back to one lane of each kind. |
The standalone also remembers its rack between launches on its own, so you pick up where you left off without saving anything.
Traffic
Outgoing MIDI messages per second. It matters because traffic, not processing, is what actually limits how many lanes make sense — the engine costs a fraction of a percent of one core even with sixteen lanes running full curves.
| Under 350/s | Grey. Safe anywhere, hardware included. |
| 350–1000/s | Amber. More than a DIN cable carries. Fine for apps, too much for gear. |
| Over 1000/s | Red. Heavy. Fine over virtual MIDI, nowhere near passable on a physical port. |
DUNA keeps this down on its own in two ways: a value that has not changed is never transmitted, and each lane has a rate ceiling. A full sweep at 7‑bit is exactly 128 messages, not thousands. Slow shapes are nearly free — sixteen lanes on four‑bar cycles produce about 500 a second, against 3,000 for the same lanes at HI‑RES.
Specifications
| Formats | AUv3 MIDI processor (aumi) · standalone app |
| Platforms | iOS · iPadOS · macOS via Mac Catalyst. Requires 17.6 / 15.4 or later. |
| Lanes | Up to 16, each independent |
| Sources | Drawn curves up to 64 breakpoints · sine, triangle, ramp, saw, square, sample‑and‑hold · XY pad X and Y |
| Lane lengths | 1/32 · 1/16 · 1/8 · 1/4 · 1/2 · 1, 2, 3, 4, 8, 16 bars |
| Notes loop | 1, 2, 4, 8, 16, 32 or 64 bars · up to 2,048 notes · its own MIDI channel · sample‑accurate playback |
| Output | 7‑bit CC · 14‑bit CC pairs · pitch bend (16,384 steps) |
| Input | MIDI CC for learn and recording, and MIDI notes for the arp and the NOTES recorder — from the host or from CoreMIDI |
| Recording | One button — writes while you hold the control, from a finger or a MIDI knob |
| Arp | 8 patterns · 1/4 to 1/64 with triplets · 1‑4 octaves · hold, gate, swing, ratchets, accents |
| Clock | Host tempo, beat position and time signature, or its own |
| Engine | Header‑only C++17, real‑time safe, allocation‑free on the render thread |
| Interface | SwiftUI · DUSK, DAYLIGHT, BASALT, GYPSUM and SUMI · three layout densities for short plug‑in windows |
| Privacy | No accounts, no analytics, no network requests. See Privacy. |
Getting more out of it
CUTOFF beats LANE 3 the moment you have more than two.