ADEF stands for ADDITIVE EQUATION FORMULATION. It is not a name invented for a piece of software. It is a synthesis method specified in 1990, written up on a dot-matrix printer, and this program is that specification finally built.

The centre of that specification is one idea: the patch is an equation, and you write it. Not chosen from a list of algorithms, not a menu of oscillator types — an expression you type, which the machine then evaluates into sound. That is what the EQUATION method does, and it does any equation you can write, not a fixed set. Everything else in this manual — every unit, every method, the sequencer, the song page — is the instrument built around that idea.

What the 1990 document says

It defines two things, and then one idea that joins them.

First, a WAVE is a formula. Not a stored table you pick from a list — a formula you write:

AMPLITUDE AT TIME = MAX AMP × (SIN OF TIME + TIME/PERIOD × PI) × POLARITY

"THIS WAVE IS THEN STORED AS W (MAX W = 128)." One hundred and twenty-eight user-written waves.

Second, an EQUATION joins waves and samples. S = sample, W = wave, and they are the same kind of thing — they combine in one expression:

S1 + W2 + (W109 / W46) ─────────────────────── EQUALS 'RES' W18 × S2

"SAMPLE 1 IS MIXED WITH WAVE 2 AND MIXED WITH THE RESULT OF WAVE 109 MODULATING WAVE 46; THE RESULT OF THIS MODULATES WAVE 18, AND IS MIXED AT THE END WITH SAMPLE 2"

Third — and this is the part that matters — the operators carry the method and the depth, inline:

S1 + [87.64] W2 + [92.13] (W109 / [FM.38] W46) ─────────────────────────────────────────────── × [57.99] S2 [AM.12] W18

+ mixes. / modulates. × multiplies. [FM.38] says modulate by FM, amount 38. [AM.12] says amplitude modulation, amount 12. [87.64] is a level. And "A RES CAN BE ONLY A W OR S" — the result of an equation re-enters as an operand, so equations nest without limit.

Then: "THIS EQUATION IS THEN STORED AS A PATCH. THE COMPUTER GENERATES A DIGITAL WAVEFORM ON A GRID, WHICH IS THEN EDITED FURTHER FOR OTHER FUNCTIONS, AND IS THEN PUT THROUGH AN A/D CONVERTER FOR FINAL OUTPUT."

Why that was early

In 1990, synthesis meant hardware with a fixed architecture: you got the oscillators the machine had, wired the way the machine wired them, and your patch was a list of parameter values. The idea in this document is a different one — the patch is an expression the machine evaluates, sources and processes are interchangeable terms in it, results feed back in as operands, and the modulation method and its depth are written into the operator itself.

Software modular synthesis reached musicians about seven years later: Native Instruments' Generator (1996), Seer Systems' Reality — the first commercial software synthesiser — and the Clavia Nord Modular (both 1997). The academic lineage is older still, back through Csound and Music V, but those were compilers for people who wrote code. What is set out here is a musician's instrument whose patch format happens to be algebra, with a grid editor after it for the parts algebra is bad at.

What survived, unchanged

Every term in the 1990 equation is a unit or a method on the build page today:

And the equation itself never went away. It is still there, still the truth of the patch — and it now runs in both directions.

The equation goes both ways

This is the part that took thirty-six years, so it is worth being clear about which is which.

The inspector was in the app first. The method is what the 1990 document was actually describing — "THIS EQUATION IS THEN STORED AS A PATCH" — and it does any equation, not the one on the printout. That formula is now one of eleven worked examples on the card, not the thing itself.

S1 one sine. the smallest equation there is S1 * S2 ring modulation — neither pitch survives S1 * (1 + 0.5*S2) multiplied around ONE instead of zero → AM S1(0.7*S2) a source read at a pushed phase → FM W12(2.5*W40) an ADEF wave FM'd by another ADEF wave (S1 x S2) / W5 division. daft on purpose, and worth hearing sin(2*pi*t) * (1 - mod(t,1)) no sources at all — written straight from t

The prefix picks the list. A name starting W reads a real wave from the ADEF wave library; one starting S reads a primitive — SINE, SAW, SQR, TRI, NOISE. The number seeds it, so W189 lands on wave 189. x means multiply, because that is how it is written by hand. t is the note's own phase in cycles, and f its frequency in hertz.

Calling a source with a value reads it at a pushed phase — that is FM. W189(0.38*W46) is not a function call borrowed from programming; it is the operation the 1990 sheet describes, written the way maths writes it.

The equation is the specification for the whole card. Type it, and the card rebuilds itself around what you wrote: the sources it names become rows, the numbers in it become knobs, the globals that no longer apply are withdrawn, and the card names the synthesis it describes — SINGLE SOURCE · ADDITIVE · RING MOD · FM · AM · DIVISION · PURE MATHS, read off the same tree that plays.

Here is the smallest case. S1 * S2 — two sources multiplied — and the card has already worked out that this is RING MOD, drawn itself two rows, and nothing else:

And here is the 1990 formula itself, typed in and playing, wired to an OUTPUT like any other unit:

Read the faceplate across: S1 + 0.88·W2 + 0.58·W189( 0.38 ·W46) × (1.00 + 0.12·W18) + 0.50·S2. Six sources, six rows, and METHOD: FM · AM · + MIX — because that is what the equation says it is.

Every number in it is a knob standing in its own place in the formula — with real fraction bars, and brackets drawn to grow with whatever they enclose. Turn one and the text above rewrites itself, so there is never a hidden value disagreeing with what is written. The end stops come from where the number sits, because the same digit means different things in different places:

Two rules it keeps:

• It never refuses — it comments. An impossible equation gets told what it will sound like and then plays anyway. Some of the best ones are the daft ones.
• What you hear is what the equation says, or you hear nothing. An equation that does not read is silence, with the reason in orange. It will never quietly substitute a different sound and hand it to you as yours.

The EQUATION inspector

Docked at the bottom of the build page's right-hand inspector, it reads the live canvas and recompiles whenever the patch changes. It shows:

Everything is resolved to real units. A knob at 62 means nothing on paper, so the inspector puts every 0–99 value through the engine's own curves and prints what it actually is — hertz, seconds, gain, cents. Reading the patch above:

(1/√8)·Σ_{v=0}^{7} [ F^(2)_{8377Hz, Q=5.292, lowpass}( fm( 0.909·saw(1·f0) + 0.859·sin(0.5·f0) ) + imp_pluck(decay≈99.0ms, LP≈15150Hz) ) ]@detune(±20.0¢)

That reads, right to left: a saw at the played pitch and a sine an octave below are FM'd together, an impulse pluck with a 99 ms decay is added on top, the sum goes through a 2-pole low-pass at 8377 Hz with Q 5.292, and the whole thing is played by 8 detuned voices spread ±20 cents and scaled by 1/√8 so the stack doesn't clip. f0 is the played note — 440·2^((note−69)/12).

"Hidden truths" are the things the panel cannot show you: a value the engine clamps, a modulation that is being ignored because a dedicated jack overrides it, a unison voice count capped at 8. If a patch sounds different from how it looks, this is where the reason is written down.

Use it three ways: to learn what a method is doing to your sound, to debug a patch that looks right and sounds wrong, and to write down a sound in a form you can rebuild from scratch.

The vocabulary

You wire an instrument together from units, and then you play eight of them at once.

Two consequences worth knowing on day one:

• A rack is an instrument, not an arrangement. Saving a rack saves how the sound is built. Sequences belong to the slot and travel with the performance. (One exception: a REX kit, where the loop's timing is the instrument — §23.)
• The slot that sounds is the slot that sends. Key zone, transpose, mute and solo are decided once, and live play, the sequencer, the arp and MIDI OUT all obey that one decision.

System MIDI → Choose Library. One folder holds your whole studio:

presets/ performances/ songs/ tracks/ sequences/ arps/ erx10/ efe/ sample-packs/ renders/

Your own WAVs go in sample-packs/<name>/ — each sub-folder becomes a category, and they appear under USER PACK OSC. Name a file with a note (PAD_C3.wav) and its root pitch is picked up.

SYNTH (build) · PERFORMANCE (play) · SONG (arrange) · SYSTEM MIDI (hardware). Effects opens as a floating window so you can change it while playing.

Inside PERFORMANCE, three sub-views on the top bar: PERFORM · SEQ · SONG. Sequences and songs keep playing as you move between them.

A canvas of units joined by cables.

Deleting heals the chain. Delete a single unit and ADEF bridges what fed it to what it fed, so the patch keeps playing. Mod cables to a deleted unit simply disappear. Deleting a multi-selection does not heal — it removes the lot.

Sound only exists where there is an unbroken chain of AUDIO cables ending at an OUTPUT unit.

Four rules govern every cable:

1. Kinds never mix. An audio jack only connects to an audio jack; a mod jack only to a mod jack. ADEF won't let you make the other connection.
2. Out to in only. Cables run from a right-side output to a left-side input.
3. Audio must terminate in an OUTPUT unit. A source with nothing between it and an OUTPUT is fine. A source wired only into mod jacks makes no sound at all.
4. An unplugged source is silent. That's deliberate — it's how you audition one oscillator of three.

In the reference below, IN jacks are on the unit's left, OUT on the right. (audio) and (mod) tell you which kind of cable that jack takes.

6.1 · Sound sources

Most sources share one jack layout: a PITCH (mod) input, and AUDIO (audio) + MOD (mod) outputs. The MOD output is the source's own signal usable as a modulator — that's how you get audio- rate modulation without an extra unit.

OSC UNIT

The main analog oscillator with standard sine, triangle, saw and square — plus ADEF's own wave building.

Waves: SINE · SQUARE · TRIANGLE · SAW · NOISE WHITE · NOISE PINK · S&H.

S&H — sample and hold. One new random level per cycle, held flat until the next. Choosing it reveals an extra S&H RATE knob. That rate is a ratio of the played pitch, never a free frequency in Hz — so the steps stay locked to the note and the waveform still repeats cleanly at the loop seam. Play it low and it is a stepped bass; play it high and it is digital grit that tracks the keyboard.

SUB OSC UNIT

If you need to add the real down low bass parts. A sub-oscillator below the main pitch. Same jacks as OSC UNIT. Waves: SQUARE · PULSE · SINE · S&H (with the same pitch-ratio S&H RATE knob described above).

ADEF WAVE OSC ★

The 310 ADEF WAVES, playable. The wave bank ADEF is named after, bundled in the box — 2.5 MB of short digital waveforms, banked as ADEF WAVES, ADEF WAVES EXTRA and ADEF PERCUSSION. Same jacks as OSC UNIT.

Pick a bank, pick a wave, play it. Then set how it repeats: LOOP · ONE-SHOT · FROM START · LOOP ONLY. That choice is yours and it matters — a good part of this bank is impulses and hits, and those are usually better not looped.

Every wave is pitched by its own measured root. Some of these files are a single cycle, some are long recordings — they are not one kind of thing, and ADEF tunes each one individually. You do not have to do anything about this; it is why the bank plays in tune.

Click the waveform picture in the Inspector to open the SAMPLE / LOOP editor and set your own loop points — see below.

MORPHINE OSC ★

Morphs across a list of up to 8 ADEF WAVES. Not a wave selector — a wave journey. POS walks the list; POS MOD sweeps it from an LFO, an envelope or an ARP step, and the timbre melts from one wave into the next.

Build the list, then sweep it. Fill the eight slots with waves that share a character and POS becomes a tone control; fill them with waves that fight and POS becomes a whole performance.

It is deliberately not MR OSC. MR OSC slides a read head through one long recording. MORPHINE crossfades between different waves — that is the difference, and it is why the two units both exist.

Try it with the ARP. The factory preset MORPHINE ARP wires the ARP's per-step RAMP into both POS inputs, so every arpeggiated step lands on a different wave.

NOISE UNIT

Pink and white noise when needed. Note the difference: noise has no pitch, so its mod input envelopes the amplitude.

EFE/ERX OSC UNIT ★

Load Ensoniq ASR-10 / EPS files extracted with ERX10 Library Control — free download at https://byme.today/softshop. This is the heart of the ASR-10 side of ADEF: it plays an Ensoniq .efe instrument or an ADEF .erx10 container.

Two audio outs is the point of this unit. Take FULL when you want the instrument as the ASR-10 plays it. Take RAW when you want the raw sample to go through your ADEF filter and envelope instead. Wire either, or both. Both unplugged = silent, like any oscillator.

USER PACK OSC

Load and create samples from any WAV files copied to your My Samples folder. Plays your own WAV packs from sample-packs/. Jacks as OSC UNIT.

DRUM OSC UNIT

Load one shots OR loops and set them up for your drum machine. One drum voice — a sample or a synthesized hit, with its own tune, decay, pan, level and play mode.

FORMANT OSC UNIT

Aaahs and ooohs from any source. A formant / vowel source. It has its own internal saw-pulse source — but wiring anything into its audio IN bypasses that and formants your signal instead.

IMPULSE UNIT

Add that extra kick to bass and percussion. No inputs at all — a pure generator.

ADEF SAMPLER UNIT

Create .erx10 files by sampling or importing wave files. The built-in sampler. It's an edit-only unit — deliberately no pitch-mod input, because its wavesamples are edited here and played by an EFE/ERX OSC unit.

Workflow: record/import → trim → set root → save as .erx10 → play it in an EFE/ERX OSC unit, or load it as a drum kit. See §23.

THE SAMPLE / LOOP EDITOR — click the waveform

Click the wave picture in any sample unit's Inspector and the SAMPLE / LOOP editor opens. That is the only way in, and it works for every unit that plays a sample — ADEF WAVE OSC, EFE/ERX OSC, USER PACK, DRUM OSC, the ADEF SAMPLER.

The top pane is the whole sample. The bottom pane is the join — a close-up of the loop seam, with the END of the loop drawn in orange on the left and the START in green on the right. You are looking at the two pieces of waveform that have to meet.

The readouts on the right tell you where you are: 2015 and /2016 SMP are the END marker and the total length, and 6.50 CYC is how many cycles of the sample's own pitch sit inside the loop.

Aim for a whole number of cycles. A loop of 6.50 cycles restarts half a cycle out of phase and you hear it as a buzz. SNAP does this for you.

Moving the loop markers does not change the pitch. The note is always taken from the root, never from the loop length — so you can move START and END freely and the instrument stays in tune.

6.2 · Processing and routing

FILTER UNIT ★

Standard resonant filter, with the Moog stepped filter alongside it.

PARAM EQ UNIT

GRAPHIC EQ UNIT

COMPRESSOR UNIT

AUDIO MIXER UNIT ★

Combine 4 audio sources — useful in the vocoder for a mix between dry and effect. Four audio channels into one, with a blend.

This is how you sum sources before a shared filter, and its channel balance is available as a performance control and can be automated — e.g. the vocoder's dry signal on CH1 against the vocoded signal on CH2, ridden live.

DIGITAL TO ANALOG MIXER ★

Use your EFE/ERX sample playback as an analog oscillator source. The bridge between the sample world and the normal audio graph, so an EFE/ERX sample and your oscillators can share one filter.

More than one instance is fine.

MIXER UNIT

Combine multiple modulation units. Not an audio mixer — this combines two modulation signals.

If you want to sum audio, use the AUDIO MIXER above.

OUTPUT UNIT ★

The standard OUTPUT — busses and pan can be modulated by various sources. Where audio has to end up. No outputs of its own.

VOL / BUS / PAN take modulation, so velocity or aftertouch can scale loudness, and modulation can move the pan or even switch the output bus. Re-opening a collapsed OUTPUT resets it to a safe volume.

On the panel: a big VU · VOLUME · GAIN (0…+12 dB) · PAN · STEREO / WIDE / MONO · the bus row · and PAN → FX: POST / PRE, which decides whether the pan happens before or after the effect send.

★ Wire the BUS jack and the bus row becomes a MORPH. Left alone, the bus row is single-select — DRY or FX1 or FX2… Plug anything into the BUS mod input and the same row turns multi-select: click as many as you like and the unit feeds all of them at once. That is a true aux send rather than an exclusive route, and it is the only way one voice can sit in two different reverbs at the same time. Clicking the last one off falls back to DRY, so the unit can never end up routed nowhere.

6.3 · Control units

ADSR UNIT ★

Your envelope for the amplitude of your sounds, or gated. Both an envelope and a VCA — it has audio in and out, plus a mod out.

So: put it in the audio path to shape level, and take its MOD out to a filter's MOD in at the same time, from one unit.

ENVELOPE UNIT ★

Your envelope for filters and wave synthesis — FM, moving MSEG, SQ80 type. A contour generator only; no audio path.

Time multipliers — ×1 · ×2 · ×3 · ×4 on DLY, ATK and DEC. Each stage has a multiplier button beside it that stretches its maximum time, taking a single stage out to roughly 16 seconds. This is how you get slow evolving pads and long filter opens without stacking envelopes. It was the only envelope in ADEF without them.

LFO UNIT ★

Very low frequency up to chopping, with a delay.

Rate, depth, delay (in ms), wave, reset, humanise, poly/mono. Rate and delay are on curves, so the useful range sits where your fingers are.

MIDI UNIT ★

Add mod wheel or aftertouch modulation to filters or output. Your controller, as a modulation source: mod wheel (CC1), expression (CC11), breath (CC2), foot (CC4), aftertouch, pitch bend, velocity, sustain (CC64).

This supersedes the old MOD SOURCES unit.

ARP UNIT ★

Drag a MIDI file in here, as well as the standard setup.

The arp lives in the rack, so it belongs to the instrument and follows it everywhere. Full detail in §13.

DRUM IN UNIT ★

Build drum kits or REX kits for your performance. The thing that turns loose DRUM OSC units into a kit.

The input labels follow the OCT transpose, so they always show the note that actually plays that pad. Wire each DRUM OSC's AUDIO out into the pad input you want it on, then DRUM IN's AUD out to a filter or OUTPUT.

TUNE UNIT / MONO-GLIDE UNIT — no jacks

MONO/GLIDE — just add MONO and glide to any synth. TUNE — different pitch tables.

Both are control panels, not patch points. Neither has audio or mod jacks, and that's deliberate: don't hunt for them.

A method is a process. Units make and shape signal; a method does something to signal that a knob cannot do on its own — multiply two waves together, bend one with another, re-spectrum it.

There are two kinds, and the jacks tell you which:

• Generators have no audio input — they make the note themselves. CZ-1, SINE 48, DRAW WAVE.
• Processors have audio inputs — they need something wired in. Everything else.

Every method has exactly one OUT (audio). Collapsed, a method shows a single IN/OUT pair.

Two rules that save a lot of confusion:

1. A method's audio inputs are not interchangeable. On FM, CARR and MOD do completely different jobs — swap the cables and you get a different sound, not the same sound. The labels matter.
2. Modulation is patched, never menu-picked. Where a method has mod jacks (SHAPE, DCW1, PIT…), you get there by wiring an ENVELOPE, LFO or MIDI UNIT into them. The per-wire amount is the modulation depth — on WAVE SHAPE that wire amount is the Prophecy's MOD INTENSITY control.

FM

What goes where. CARR is the wave you will hear. MOD is the wave that bends it. The modulator is never heard directly — it only shifts the carrier's phase, and that shift is what creates new harmonics.

What it does to the sound. Two things decide everything:

Setting up the ratio. ADEF has no ratio field. You tune the two oscillators, and the ratio is whatever falls out — which is more flexible than the DX7 ever was:

• the footage row (32' · 16' · 8' · 4' · 2') = octaves. MOD at 4' against CARR at 8' is a 2:1 ratio.
• SEMI = semitones, FINE = cents. A modulator at SEMI +7 is a fifth up — deliberately not a whole-number ratio, and that is exactly where tines, bells and clang live.

Where the envelope goes — this is the part people get wrong. In FM, the modulator's level over time is the timbre over time. So the envelope does not go on a mod jack: you put an ADSR UNIT in the modulator's audio path.

OSC (modulator) ──audio──► ADSR ──audio──► FM · MOD

The ADSR is an envelope and a VCA, so it acts as the operator's own output level. A fast decay to zero sustain gives you the classic FM attack: bright, percussive bite that dies away to a pure carrier tone. That one trick is most of what an electric piano is.

Where the LFO goes. Into the PITCH jack of an oscillator for vibrato — put it on the carrier, or on both, but be careful putting it on the modulator alone, because that modulates the ratio and the pitch will seem to wobble in tune while the timbre wobbles out of it.

Where velocity goes. A MIDI UNIT set to VELOCITY, wired wherever you want the playing to bite: into the OUTPUT's VOL for plain loudness, or into the modulator's level for "harder = brighter", which is what a real FM piano does.

Worked example — DX7 CHORUS PIANO

A six-operator DX7 electric piano, built as three independent 2-operator stacks running in parallel — which is precisely what a DX7 algorithm is, drawn in cables instead of chosen from a numbered chart.

All three FM outputs sum into one chain:

FM BODY ┐ FM TINE ├──audio──► WARMTH (filter) ──► EP AMP ENV (ADSR) ──► OUTPUT FM HARM ┘ MIDI 1 (VELOCITY, depth 75) ──mod──► OUTPUT · VOL

• WARMTH — a 12 dB low-pass at FREQ 47, RES 12, sending to FX1 at AMT 74. It is doing the job the DX7's own output filtering never did: taking the glassy top off.
• EP AMP ENV — the whole instrument's amplitude: 0 / 72 / 26 / 46. Instant attack, long decay, low sustain, medium release. Sent to FX2 at 50 — that is the chorus in the patch name.
• MIDI 1 — VELOCITY at depth 75 into OUTPUT VOL, so the piano responds to how hard you play.

Read it as a recipe. One carrier + one modulator + the modulator's envelope = one "voice" of character. Build three with different ratios and different decays, sum them, filter, shape the whole thing with one amp envelope. Change the three ratios and you have a different instrument entirely — bells, basses, mallets — with the same wiring.

RING

What goes where. IN A and IN B are multiplied together, four-quadrant. Arriving on IN B makes you somebody else's modulator.

What it does to the sound. Ring modulation outputs only the sum and difference frequencies of its two inputs — the originals disappear. Related pitches give you metallic harmony; unrelated pitches give you the classic clangorous, inharmonic, robot-voice snarl.

These are independent levels, not a crossfade. That matters: it means "full ring, with the direct signal pulled back underneath it" is a setting you can actually dial. A fresh RING is pure ring, exactly as before.

RING also works live, after the mixer, as a post-chain effect — see §10.

VOCODER

What goes where. CARR is what you play — it wants to be harmonically rich, so a saw or a pulse, never a sine. MOD is the modulator: a live input, or a recorded and named wave.

What it does to the sound. The modulator is split into bands, each band's loudness is tracked, and that shape is stamped onto the same band of the carrier. Speech shapes become a played chord.

SAMPLE KEYS (OFF / LOW C2–B2 / HIGH C5–B5) puts your recorded modulator samples on a small band of keys: those keys fire the sample at its root pitch while the rest of the keyboard stays a polyphonic carrier.

One rack at a time should be vocoding; two racks fighting for the modulator is not supported.

Worked example — VOCODER SAMPLE

OSC 1 (SAW 32', WIDTH 77) ──audio──► VOCODER · CARR ──► AUDIO MIXER · CH2 EFE OSC ("COUNT" instrument) ─────────audio───────────► AUDIO MIXER · CH1 AUDIO MIXER ──► OUTPUT (FX4)

VOCODER at BANDS 8 · Q 16 · ENV 31 · TILT 99 · GAIN 87, LIVE INPUT on, SOURCE default mic, SAMPLE KEYS: LOW.

The point of this patch is the AUDIO MIXER: the sampled voice goes in dry on CH1, the vocoded version on CH2, and the mixer's BLEND sits between them. That balance is a performance control and can be automated, so you can ride from "understandable voice" to "pure vocoder" as the track plays. A wide saw at 32' as carrier is why it sounds big rather than thin.

WAVE SHAPE

Korg Prophecy-style waveshaping, and the most modulatable thing in ADEF. It is a hybrid: wire audio into WS1/WS2 and it shapes that; leave them empty and it shapes its own internal oscillator.

What goes where. WS1 and WS2 are audio in. SHAPE, PITCH, PAN and LEVEL are mod jacks — and the wire amount into SHAPE is the Prophecy's MOD INTENSITY.

What it does to the sound. SHAPE drives a nonlinear transfer function, and MODE decides which:

How to set it up. Wire a source into WS1. Set MODE, then find the sweet spot on SHAPE by ear. Then — and this is the whole point — wire an ENVELOPE or LFO into SHAPE_MOD. A static waveshaper is a distortion box; a swept one is the Prophecy sound.

Worked example — PROPHECY CLUB DISCO BASS

``` OSC 1 (SAW) ─┬─audio──► WAVE SHAPE 1 ─┐ OSC 2 (SAW) ─┘ ├──► MIXER ──► FILTER ──► AMP ──► OUTPUT SUB (SQUARE) ─────────────────────────┘ WAVE SHAPE 2 (RESONANT) ─┘

SHAPE EG (ENVELOPE) ──mod──► WAVE SHAPE · SHAPE ← the sweep FILTER LFO ──────────mod──► FILTER · F.MOD ← the movement ```

Two detuned saws through the first waveshaper, a second waveshaper in RESONANT mode for the fold, a square SUB underneath for weight, all summed in a MIXER. The SHAPE EG is a dedicated envelope whose only job is to sweep SHAPE — that is the "wah" in the sound, and it is an envelope, not a filter. A separate FILTER LFO keeps the low-pass moving underneath. Amp envelope 0 / 30 / 70 / 24 for a bass that sustains while you hold it.

VZ

Casio VZ-1 "iPD". Each line is two operators — M1 and M2 — and MODE decides how they combine:

How to set it up. Two oscillators, one into M1, one into M2, MODE to PHASE. Then work PRE: low is clean, high folds and distorts. EXCITE puts body back into the attack when M1 hasn't started moving yet.

Worked example — VZ PLUCK BASS

``` M1 SAW (SAW 16', AMP 90) ──────audio──► VZ · M1 ┐ M2 SHAPE (SAW 16', FINE −3, AMP 85) ──audio──► VZ · M2 ┘ VZ ──► LPF ──► ENV ──► OUTPUT

ENV ──mod──► LPF · F.MOD ← filter envelope MIDI 1 (VELOCITY, depth 99) ──mod──► OUTPUT · VOL ```

VZ in PHASE, PRE 16, POST 41, EXCITE 71. The two saws are three cents apart, which is what gives the bass its thickness before the shaper even acts. PRE is deliberately low — at 16 the shaping is gentle, so the pluck stays tight rather than fizzy — and the high EXCITE is what puts the initial thump there. The filter is a 24 dB low-pass with an envelope on F.MOD (ATK 4, DEC 85, SUS 0) — a fast sweep down to nothing, which is the "pluck". Velocity at full depth on OUTPUT VOL.

CZ-1

Casio CZ-1 phase distortion. A self-contained generator — no audio in. It synthesises the played note as one or two "lines", each a DCO → DCW → DCA chain, exactly like the hardware.

What goes where — seven mod jacks, and they are the instrument:

How to set it up. The mistake is to leave DCW static — the CZ is made of DCW movement. Wire an ENVELOPE into DCW1, and a second, differently-shaped one into DCW2, so the two lines brighten and darken independently. That is the sound. Then DETUNE for width, and MODE RING when you want it to go metallic.

EQUATION ★

The 1990 handwritten ADEF equation, as a playable method. §1 tells the story of the notebook this came out of. This is that page turned into a unit — six sources, one FM pair, one AM pair and three mix weights, wired the way the original document wires them.

A pure generator: no audio in, mod jacks PIT and VOL.

Six source rows. Each row is one source, and each has four settings:

The rows do fixed jobs, in this order: S1 the base source · W2 its first mix partner · W189 the FM carrier · W46 the FM modulator · W18 the AM modulator (negative by default, as the 1990 spec has it) · S2 the final mix partner.

Globals: FM (index) · AM (index) · S1/W2, STAGE, MOD, S2 (the four mix weights) · OCT · FINE · VOL · PAN. Plus two switches for the places the original document could be read two ways, so you can A/B them by ear: S2 = MIX or RING, and STAGE → MOD or W2.

★ PERIOD is where the music is. Each source divides the played pitch. Keep the periods in simple whole-number ratios and every source stays harmonically related — the patch has a clear pitch and sounds like an instrument. Go off those ratios and the sources beat against each other, and you get texture, movement and noise instead of a note. Eric's own summary: "it's not easy to get useful tonal content, but for mods etc, cool." Both results are correct; the ratio is the dial between them.

The three 1990 mix weights arrive as their original decimals — 87.64 / 92.13 / 57.99 — and stay that way until you actually turn that knob.

STORE. The card has its own store: numbered face snapshots, no names. Turn knobs until something pops, hit STORE, keep going. It is a scratchpad, not the preset system.

Try it: the factory preset 01W EQUATION BELL runs EQUATION into AI SHAPE.

SINE 48

Casio FZ-1 style additive. A pure generator: 48 harmonic amplitudes are summed into one cycle that loops at the played pitch. Edit the spectrum in the bar editor on the card. Mod jacks: PIT and VOL. Knobs: OCT, FINE (cents), VOL, PAN.

What it does to the sound. You are drawing the spectrum directly. Low harmonics only = flute or sine-ish. Odd harmonics = square/clarinet. All harmonics falling off gently = saw. Peaks in the middle = formant, vocal, nasal.

Worked example — P800 DETUNED BASS

A Korg Poly-800. Two SINE 48 generators (labelled DCO 1 and DCO 2), both at OCT −1, with FINE 0 against FINE 18 — that ~18-cent detune between two additive oscillators is the entire character of the sound. Straight into a 12 dB low-pass, VCF EG (1 / 38 / 22 / 25) on the cutoff, AMP EG (1 / 45 / 55 / 28), MG (LFO) available for vibrato. The preset row on the card (SINE / SAW / SQR / TRI / ORGAN / CLIP) fills the 48 bars for you as a starting point; SAVE → SAMPLES bakes your spectrum into MY SAMPLES.

DRAW WAVE

Freehand single-cycle oscillator. Scribble the shape on the card; SMOOTH rounds the harsh edges (and with it the harshest harmonics). Generator, like SINE 48 — mod jacks PIT and VOL, knobs OCT, FINE, VOL, SMOOTH, PAN. Can also bake to MY SAMPLES.

Sharp corners make bright, buzzy waves; a hand-drawn wave is rarely symmetrical, which is why it sounds more alive than a maths-perfect one.

ADDITIVE

Rebuilds what comes in from harmonics. PART (1–16) sets how many partials, TILT (0–99) tilts the balance between low and high ones — down for a rounder, hollower tone, up for thin and bright.

DRAWBAR

Hammond-style. Re-renders the wired IN waveform at the nine classic footages — 16' · 5⅓' · 8' · 4' · 2⅔' · 2' · 1⅗' · 1⅓' · 1' — each scaled by its drawbar (0–8). A sine IN gives you a pure tonewheel; a saw or square IN gives fuller, reedier organ.

SWEEP is the party trick: an internal LFO animates the bars as a travelling wave between START and END levels, in DIR (top→bottom, bottom→top, or random), scaled by DEPTH, at RATE × MULT. Wire an external LFO or envelope into the MOD jack to drive the sweep phase yourself instead — that overrides the internal RATE. The card also emits a MOD OUT carrying its own sweep LFO, so the organ can modulate something else in time with itself.

UNISON

Stacks detuned copies of whatever is wired in. VOICE 2–8, DETUNE, SPREAD (stereo width), HP toggle to keep the low end from turning to mud.

The gain is scaled by 1/√voices so a big stack doesn't clip — you can see that term in the equation inspector. Eight voices is the engine's hard limit; ask for more and it clamps, and the inspector's "hidden truths" will tell you it did.

OVERDRIVE

Harmonic generator and saturation. Adds harmonics, compresses dynamics naturally, and warms a sterile digital signal.

DRIVE pre-gains into the curve, TONE is a single-pole tilt (cuts lows and boosts highs as it rises), MIX crossfades dry against saturated. For thickening rather than distorting, use TUBE with a low DRIVE and MIX around halfway.

AI SHAPE

Korg 01/W "AI²" waveshaping. The 01/W passed a PCM sample through one of 60 cycled waveform tables to re-spectrum it; ADEF curates the 16 most distinctive as lookup tables — SINE, 2 CYC, FREQ3, CACOON, PHASE, REZ 1, ZINGR, PROFL, HIPAS, LSINE, SOFT, LOGSN, PULS5, COMB, REZZO, PARAB.

Worked example — 01W ETHEREAL VOX

``` OSC AAH ─┐ OSC OOH ─┴─audio──► AI SHAPE ──► UNISON ──► ┐ AIR (SAW) ──────► AIR HPF ─────────────────┤ FORMANT ├──► VOX ENV ──► PARAM EQ ──► OUTPUT

1 VIBRATO (LFO 2.0 Hz) ──mod──► OSC · PITCH ← vibrato FORMANT MG (LFO 0.32 Hz) ─mod──► FORMANT · VWL ← slow vowel morph MG 3 (LFO 2.0 Hz) ──mod──► OUTPUT · PAN ← auto-pan MIDI 1 (VELOCITY 99) ─mod──► OUTPUT · VOL ```

AI SHAPE on CACOON with AMT 85 and a high PRE, then UNISON at 5 voices / DETUNE 23 / SPREAD 46 to turn one shaped tone into a choir. A separate high-passed "AIR" saw sits on top for breath. The instructive part is the three LFOs, each doing a different job: a fast one on pitch for vibrato, a very slow one on the FORMANT's vowel for the "aah→ooh" drift, and a third on OUTPUT PAN so the pad moves across the stereo field. None of that is a preset — it is three cables.

When you need no method at all

Worth seeing, because it is easy to forget. MONO POLY MG is a Korg Mono/Poly: four SAW oscillators at AMP 65, detuned by FINE 0 / −3 / −3 / −1, straight into one 24 dB low-pass (FREQ 44, RES 50, F.MOD 45), an ADSR (6 / 50 / 65 / 40), and out at 82. No method anywhere.

Four oscillators a few cents apart through one resonant filter is a complete instrument. Reach for a method when you want a sound that addition alone cannot make — and not before.

The three mod wires, and why each one is different

This patch is the best short lesson in ADEF modulation, because its three mod cables use all three kinds of destination.

MG 1 (LFO) ──mod──► VCF · MOD ← a DEDICATED jack MIDI 1 (AFTERTOUCH) ──mod──► MG 1 · RATE ← an ADD MOD jack, on an LFO MIDI 2 (VELOCITY) ──mod──► VCF · FREQM ← an ADD MOD jack, on a filter

1 · MG 1 → the filter's own MOD jack. The LFO is a TRI at 0.43 Hz, DEPTH 34, with a 280 ms DELAY — so it fades in a fifth of a second after you play, which is what stops a slow sweep from sounding mechanical on short notes. It lands on the FILTER's dedicated MOD input, and the filter's F.MOD knob (45) scales it. Dedicated jacks work like that: the wire brings the signal, the panel knob sets how far it goes.

2 · MIDI 1 (AFTERTOUCH) → MG 1's RATE. The LFO unit has no inputs of its own — only a MOD out. The RATE jack on its left rail is one you made, with + ADD MOD on the RATE knob (§10). Now leaning into the keys speeds the LFO up: press harder and the wobble quickens. Depth 99, so it goes from a 0.43 Hz drift to a proper shudder.

Worth knowing: only a MIDI UNIT can drive an LFO's rate or depth this way. LFO→LFO is deliberately skipped by the engine to avoid recursion, so if you wire one LFO into another's ADD MOD jack, nothing will happen. Rate modulation adds up to ±50 Hz on top of the knob and is clamped to 0.05–50 Hz.

3 · MIDI 2 (VELOCITY) → the filter's FREQM. A second ADD MOD jack, this one on the filter's FREQ parameter — note that it is not the same as the MOD jack in wire 1. The dedicated MOD input is scaled by the F.MOD knob; an ADD MOD jack carries its own per-wire amount and adds straight to the parameter. So the filter has an LFO sweeping it and velocity opening it, from two separate jacks, with independent depths. Play harder, it gets brighter — the oldest trick there is, and here it costs one cable.

The pattern to take away: a dedicated jack (FILTER MOD, OSC PITCH, OUTPUT VOL/BUS/PAN) is there because that destination is used constantly. For everything else — an LFO's rate, a filter's resonance, a method's PRE — you make the jack yourself with + ADD MOD, and the per-wire amount is the depth.

STEP EFFECT CREATOR. A per-step effect sequencer that processes slices of time, running per voice, inside the instrument.

Why it exists

Every other unit in the ADEF voice path is instantaneous. Filter, compressor, EQ, graphic EQ, overdrive, waveshape, AI shape, vocoder — each one answers the modulation value at that sample and has no memory of the sample before it. An envelope changes a value over time; it does not remember the signal. The only time-based processing in ADEF used to live at the bus level, after the voice was finished, so it smeared the whole patch instead of dirtying it from the inside.

The UNIQUENCER is the missing piece: a sequence of processes running across time, inside the voice, retriggering with every note.

★ The idea: three clocks, nested

PATTERN duration ÷ quantise → N STEPS (1 bar @ 1/16 = 16 steps) └ STEP DIVISION → N SEGMENTS (e.g. 4) └ SEGMENT MIN · MAX · CURVE · DIRECTION · GATE

• A STEP picks one effect and its settings.
• DIVISION chops that step into segments. Each segment gets its own dot on the step graph.
• Each SEGMENT sweeps the effect's main parameter from its own MIN to its own MAX, along its own CURVE, in its own DIRECTION.

That one extra level is what makes it more than a step filter. DIVISION alone gives you the nested clock, the ratchet (division 4 = four hits inside one step) and most of a gate, without adding a single extra control.

Click a dot and that segment's MIN / MAX / CURVE load into the knobs. The selected dot draws in a brighter gold than the rest — that is the whole selection UI.

Where it sits, and why that matters

The UNIQUENCER has no jacks. Like MONO/GLIDE and TUNE, it is not wired into the graph. It sits at the end of the voice, after the filter and the envelope, and processes the finished voice.

Two consequences worth knowing:

1. DRY at full plays your preset exactly as it was. The dry signal is the untouched voice. So you can drop a UNIQUENCER onto any existing patch — including the factory ones — and nothing changes until you turn the wet up.
2. It runs live on the playing voice, which is why every phase and retrigger mode is available to you on musical grounds alone. It also means it costs CPU rather than memory.

The face

Four areas: the step strip across the top, and under it the step graph, the edit panel and the global panel, left to right.

Title row — the UNIQUENCER nameplate, a duplicate button, and the master DRY / WET at the right.

The step strip runs the full width under the title: your voice's own waveform drawn across the whole pattern, with each step's curve drawn over it in translucent green. The shape is the information — you read a pattern as a silhouette, no numbers needed.

• Step colour intensity follows that step's DRY/WET. A step at WET 0 shows nothing. The strip is a heat-map of where the pattern actually does something.
• The strip scales to the step count. 1 BAR 2 BEATS @ 1/16 = 24 steps, and it draws 24.
• Under the numbers, a red bar shows DIRECTION as a gradient — to the middle = BOTH, red→white = FORWARD, reversed = BACKWARD — and it also carries the play marker.

On the strip: CLICK = SELECT · SHIFT-CLICK = MATCH · DRAG ↕ = DRY/WET. You can set a step's wet amount by dragging on the step itself.

MATCH EVEN · MATCH UNEVEN · MATCH ALL copy the selected step's shape onto the even steps, the odd ones, or every one — the fastest way from one good step to a pattern.

A matched step is labelled with what it was matched from — MATCH 4 × M4 T2.4 W2.4 — so a pattern never loses track of where its shapes came from.

The step graph shows the selected step's segments: division lines, one draggable dot per segment, the contour drawn through them, MAXIMUM rail in brown at the top, MINIMUM rail in green at the bottom.

The edit panel mirrors that graph vertically — and that is deliberate:

Effect column: EFFECT · four param slots · TYPE. Unused slots read — so the panel never reflows when you change effect.

★ TYPE re-labels the four slots, because each type of a family is a genuinely different process. FILTER · 303 gives you RESO · DIST · DRIVE · ACCENT; the same family on ADEF gives WAVE · BANDS · PEAK · MORPH. Same swept value, read a different way.

Output column: VOLUME · PAN (per segment) · VEL DEPTH · KEY TRACK (per step) · BUS SEND to FX1–FX4.

Global panel: DIRECTION (FORWARD / BACKWARD / BOTH) · DURATION (bars + beats, with −/+ steppers) · QUANTISE (1, 1/2, 1/4, 1/8, 1/16, 1/32 with D dotted and T triplet) · SWING · TEMPO · SYNC · RETRIGGER · MOD ⤳ QNT · pattern SAVE / LOAD.

★ DURATION × QUANTISE = how many steps you get

This is the one relationship to hold in your head, and the readout at the bottom of the global panel always tells you the answer:

DURATION says how long the pattern is in musical time. QUANTISE says how finely that time is cut. Two bars and two beats is ten beats; at 1/8 that is two steps per beat, so twenty.

★ Change QUANTISE and the pattern keeps its LENGTH but changes its RESOLUTION — the same bar and a half, sliced finer. Change DURATION and it keeps its resolution but runs longer. They are independent on purpose, and the strip redraws to whatever the pair produces.

Patterns SAVE and LOAD by name, independently of the patch, so a rhythm you like can be dropped onto any voice.

The effects — six families, three types each

The swept parameter is never one of the four slots. That is the one MIN / MAX / CURVE drive.

Every family reads the same swept value in its own way — which is why a pattern you built on a filter still means something when you switch it to a delay.

The four slots, per type:

Three that deserve a note:

FILTER 303 is a 4-pole diode ladder, low-pass only. DIST is a distortion stage in FRONT of the filter — that is the point of the whole family. A plain saw gives a filter very little to find; distort it first and there are harmonics for the cutoff to carve. DIST and DRIVE are different jobs and you want both: DIST makes the harmonics in front, DRIVE pushes the ladder itself for squelch and a thinned low end. ACCENT ties to velocity like the real circuit — louder and more resonant.

★ FILTER ADEF — a filter whose response curve is an ADEF WAVE. Pick one of the 310 waves and its spectrum becomes the filter's frequency response: peaks where the wave has harmonics, notches where it does not. MIN / MAX then slides that entire shape up and down the spectrum instead of moving one corner. BANDS (8 / 16 / 32) goes from smooth and vocal to spiky and resonant; PEAK flattens toward a plain filter at 0 and exaggerates every peak and notch at 99; MORPH blends toward the next wave in the bank. On a pad it is a formant sweep. On a bass it is one wave smeared across another — literally a filter over a filter.

CRUSH RATE. Decimator artifacts mirror around the reduced Nyquist, so they move inversely to pitch — they do not track the keyboard, they run away from it. That inversion is why it sounds so wrong and so good.

Editing a pattern without doing it 24 times

A step carries an effect, a type, four params, a division count and N segments each with its own min / max / curve / direction / gate. Rebuilding that by hand across 24 steps is not a thing anyone would do, so:

• Shift-click a step to add it to the MATCH set. Every edit you make now lands on the selected step and every matched step. The readout beside the step number shows the set: MATCH 3,5,7 ✕.
• MATCH EVEN · MATCH UNEVEN · MATCH ALL are the same thing fanned out. They are latches — while one is lit, every edit reaches those steps. Clicking it off stops future edits; it never un-copies what you already did.
• A plain click on a matched step re-anchors the set on that step rather than wiping it.

Segments, gates and handles

• MIN greater than MAX inverts the sweep. MIN 100 / MAX 0 runs the segment upside down. No extra control needed.
• DIRECTION is per segment as well as global. It earns that because BOTH — up then down inside one segment — cannot be expressed by swapping MIN and MAX.
• ★ The segment handles are the gater. Drag the bottom strip of a segment to set how much of it is actually active. Pull them down and the effect arrives and then stops, leaving a hole. ⌘-drag moves all segments together.
• FADE softens the gate's edges. It has a hard floor of about 3.5 ms whatever the knob says — below that the edge is an audible tick rather than a gate.
• The gate is deliberately NOT scaled by DRY/WET. It multiplies the finished sum, so 6% wet still gates 100%. A gate is a gate.
• DIVISION splits and copies. New segments inherit the one you are looking at, not a default.

Clock, tempo and retrigger

TEMPO is the unit's own. SYNC is a momentary copy of the song tempo, not a live link — lit means it is already at song tempo. Copying rather than linking is what keeps a rendered voice reproducible.

★ RETRIGGER is the sync control, and its name undersells it:

If the timing is not doing what you expect, check RETRIGGER first.

MOD ⤳ QNT — the modwheel drives QUANTISE. The amount is a proportion of the distance left, not a fixed number of steps: from 1/4, full wheel takes you to 1/32, half to 1/16, a quarter to 1/8. From 1/16 there is only one division left, so full wheel moves one step. A negative amount runs the other way, toward whole bars. The pattern re-bakes when the wheel crosses a bucket and swaps at the next pattern boundary, so the note never re-attacks.

Sends and output

Per-step BUS SENDS are live — FX1 to FX4, ramped, not switched. What gets sent is that step's own output, after its effect and after its gate. Sends are additive, so one step can reach two buses at once, which the exclusive bus model never could.

VOLUME and PAN ride the step curve rather than jumping at a boundary. An amplitude jump at 16ths is a click train.

V / K blocks beside each effect slot are tri-state: blank → + → −. They send velocity or key tracking to that slot. Velocity is centred on half velocity and key track on middle C, so the value you set on the knob is what you get at the neutral point, and + / − decides which way playing harder or higher moves it.

Saving patterns

SAVE / LOAD on the face writes to presets/uniquencer/ in your library. A pattern carries the musical content — steps, segments, duration, quantise, swing, direction — and never your cursor position or match set.

Duplicate on the title row copies the whole unit, including its pattern.

Build page → header → 🎲 GENERATE. Pick three things and press a button.

ENGINE which units exist and how they wire the skeleton — never rolled ROLE octave · envelope · filter behaviour how it plays under the fingers STYLE detune · width · wave choice · resonance what era it smells of WILDNESS 1–10, how far outside the safe middle │ ▼ a finished patch on the canvas

The seed is in the name. A generated patch is called something like 80s BASS · HELD A4 #50986, and that five-digit number is the patch — same seed, same three choices, same patch, every time. So a sound is shareable as five digits.

What it will not do. The generator can never write a value a unit would reject, because the limits are read out of the units' own code rather than typed into a table. Anything it is not sure of is left at its default rather than guessed at.

It goes through the normal load. A rolled patch hits the same SAVE-CURRENT and LAYOUT gates as any other load, so it can never wipe unsaved work. If you don't like it, roll again.

Wildness is the honest control. Low keeps you inside what the factory presets measure as normal. High goes looking. There is a novelty check, so it will not hand you the same patch twice.

Three modulators: ENVELOPE / ADSR (contour), LFO (cyclic), MIDI UNIT (your hands). Any unit's MOD out also works as a modulator, including an oscillator's — that gives you audio-rate modulation with no extra unit.

Some destinations have a dedicated jack already (FILTER's MOD, OSC's PITCH, NOISE's AMP, OUTPUT's VOL/BUS/PAN). For anything else, you make the jack yourself:

1. On the destination unit, press + ADD MOD.
2. Choose the parameter to modulate. A new mod input jack appears on that unit's left rail, labelled with the parameter name.
3. Wire a modulator into it.
4. Set the wire's amount (0–99) and polarity (±).

ADD MOD makes a jack — it does nothing until you wire a source into it. The jack is the invitation, the cable is the connection. Each wire carries its own amount and polarity, so one LFO can open a filter a little and pan a lot.

Still in ADD UNIT but no longer the way in — ASR-10 OSC (ASR-10 ROM wave material) and ROM PLAYER (ROM wave playback) are both superseded by the EFE/ERX OSC and USER PACK OSC units above. Jacks on both: PITCH (mod) in; AUDIO (audio) + MOD (mod) out.

Off the ADD UNIT menu, but old patches still load them: MR OSC (jacks: PITCH + POS in for the transwave scan head; AUDIO + MOD out), SQ OSC, VFX-SD OSC, D-50 OSC, JP-8000 OSC, MOD SOURCES (no jacks — superseded by MIDI UNIT). The SQ-family units (SQ SYNTH / SQ FILTER / SQ ENV / SQ OUT) drive their own engine directly and carry no jacks at all — they're an assembly that drags as one locked group.

Eight synth channel strips plus drum lanes. Everything about how an instrument sits in your music is here.

Playing. The floating keyboard (⌘⇧K) or your controller.

Play is selection-driven and multi-timbral: every slot whose key zone and MIDI channel match an incoming note sounds, each with its own transpose. Two controllers on two channels drive two instruments with no extra routing.

Performance shortcuts

★ SPACE on this page runs the SONG. That is deliberate: you arm a track for song automation (§18), come to PERFORMANCE, hit space, and reach straight for the knobs. Per-slot start/stop lives on the SEQUENCER page, where it is what you actually want.

One sequence belongs to one slot. A sequence holds up to 8 patterns; a chain plays them in order.

Automation lanes record or draw parameter moves alongside the notes. They're role-based, so a lane written against one synth resolves sensibly onto another.

Recording what your hands do

Knobs are not the only thing an automation lane will record. Arm AUTOM, play, and lean on the keys — your aftertouch is written into a lane of its own, named after the unit and the controller it came from: MIDI 1 · AFTERTOUCH.

The mod wheel works exactly the same way, and so do pitch bend, expression, breath and foot. There is nothing to switch on: whichever source a MIDI UNIT in the rack is set to, that is the controller that gets recorded onto it. Two MIDI units set to two different sources give you two lanes.

Once it is a lane it is just a lane — drag the nodes, bend the segments, delete what you overplayed, and it travels into the song with everything else.

It records on the SONG page too. Arm a track and record a live MIDI take: the controllers ride along with the notes into the same LIVE clip, as that clip's own automation. So a take captures what your hands did, not just which keys you pressed — and because the lanes are role-based, dropping that clip on a different synth later carries the performance with it.

It hands the controller straight back when you stop. While the sequence runs, the lane drives that MIDI unit; the moment you stop, the wheel under your hand is live again. And because the recorded value belongs to the unit rather than to one global, two slots can hold two different recorded controller moves at the same time.

A chain gets a section per pattern. With CHAIN LEN 4, the lane spans all four bars and marks them P1–P4, so each pattern in the chain carries its own automation rather than repeating one bar's worth four times.

Segments can be curved. Every node carries the shape of the line leaving it. Grab the small dot at a segment's midpoint and drag — up bulges the move up, down sags it down — or hold ⌘ and drag anywhere on that segment. Double-click the dot to straighten it again. A curve is not just drawn: playback reads the same shape, so a bent filter sweep opens late and rushes at the end instead of climbing evenly. The same handles appear in the song clip's automation view.

A lane maps to its parameter's own range, so a bipolar parameter like PAN draws with 0 in the visual middle and a unipolar one like filter cutoff runs 0–127 bottom to top. The scale down the left tells you which you're looking at.

Groove is preserved. Notes carry a fractional offset, so imported swing, REX slice timing and printed arp triplets keep their feel rather than snapping to the grid.

Import a .mid into a sequence; anything longer than 8 bars is cut into 8-bar sequences.

Importing a multi-channel MIDI file

Drop a .mid onto a track's SEQ lane or its LIVE lane. A SEQ drop makes normal library-backed clips; a LIVE drop makes self-contained gold takes, exactly like a recorded pass. Either way, anything longer than 8 bars is cut into consecutive 8-bar clips.

The bar you drop on is where the import starts — the header line confirms it.

If the file has more than one channel, an import chooser opens instead of flattening everything onto the one lane you dropped on. It lists every channel with its track name (read from the file), note count, bar count and pitch range, and lets you send each one to a slot. The defaults follow the ADEF layout — MIDI ch 1–8 → slots 1–8, ch 10 → the first drum lane, ch 11 → the next one — and anything else starts on SKIP.

Two options sit above the list:

• TEMPO — adopt the file's tempo or keep the song's. This defaults to on only when the file genuinely carries a tempo; a file without one reads as 120 by MIDI convention, and adopting that would silently re-tempo your song.
• PROGRAM CHANGES — BYPASS or IMPORT. Imported ones become real PROG events on the mapped track, so they fire at whatever hardware that track's MIDI OUT points to. It defaults to BYPASS because General MIDI patch numbers rarely mean anything on your own synths.

Importing drums — how pads are assigned

A drum lane must exist before you can import to it. With no drum machine loaded, the chooser shows the drum channel as "no drum lane yet — load a kit first" and leaves it on SKIP. Add one with ＋ DRUM, pick a kit, then drop the file again — the drum channel can then be pointed at that lane like any other.

How the notes reach the pads depends on where the file came from:

• A .mid ADEF itself exported lands natively — pad 1 is the kit's base note, pad 2 the next semitone up, and so on.
• Any other file — a General MIDI drum track, or anything written for another machine — won't line up with that window, because GM puts its kick at note 36 while ADEF pads start at 48. So each distinct pitch in the file is given its own pad, lowest to highest. The pattern arrives intact — kick, snare and hats each land on their own pad — but the sounds won't match, so load the samples you want onto each pad afterwards. A message tells you how many pads were used.

Pad numbering is worked out once for the whole file, so it stays identical across every 8-bar clip the import cuts.

Moving clips between tracks and lanes

Drag a clip up or down to move it to another track — it picks up that track's synth and its MIDI channel, so re-voicing a part is a drag. Drag it between the SEQ and LIVE lanes of any track in either direction. ALT-drag duplicates first, so alt-drag downward copies a part to another track and leaves the original where it was; set the clip's transpose afterwards and you have a harmony line in two moves.

A hint follows the cursor showing where it will land. Synth and drum clips hold different data, so a synth clip won't drop onto a drum lane or the reverse — the hint says so rather than letting you place a clip that can't play. Moving a clip to the LIVE lane makes it a self-contained take, so editing it there can never alter a library sequence other clips share.

The in-lane editor ("the TV") edits a clip's notes and automation inside the song lane itself, with a keyboard gutter down the side. Shift-click a song clip to open it — and while the song plays, that clip live-syncs, looping in place so you can edit it against everything else.

Note-editor shortcuts

In the drum grid: click a cell to toggle a step; drag an empty area to marquee a selection; shift-click adds a single hit to it; ⌘- or ctrl-drag moves the whole selection — across steps and up or down between pads — and M mutes selected hits. A move is clamped at the edges, so a drag that would push part of the selection off the start or off the last pad simply stops rather than losing those hits, and the whole drag undoes as one step with ⌘Z.

A drum lane is a rack whose voices are DRUM OSC units, one per pad, feeding a DRUM IN unit that sets the base note.

Per pad: sample or synth voice, VOL, +6 boost, tune, decay, pan, output bus, mute/solo, play mode (NORMAL / ONE SHOT / REVERSE), and its MIDI OUT note + mode.

ADEF PERCUSSION — a drum bank that ships in the box

A DRUM OSC can load the ADEF PERCUSSION bank: 22 pads pulled out of the ADEF WAVES library.

The percussion end of that wave library was sitting there wearing melodic names — a wave labelled PLUCK that is unmistakably a snare, several called things like LOW HIT and MID TOM. Rather than leave them mis-filed among the tonal waves, they were auditioned by ear and re-labelled as what they actually sound like, then banked as drums. A one-shot is what a drum pad wants anyway.

It needs no external content, so it works on any machine, out of the box.

Selecting more than one pad

Press ▦ SEL above the pads — or ALT-drag across the grid (ALT-shift-drag adds, ALT-click toggles one). Every per-pad control then applies to the whole selection: level, boost, bus, mode, mute, solo, and the voice knobs.

A plain click clears the selection, so an edit meant for one pad can't silently hit eight.

↑ ASCEND NOTES numbers a selection upward from the focused pad — which is what a drum map wants, rather than every pad on the same note.

Per-drum-rack channel-strip FX — EQ, compressor, filter, 31-band graphic EQ, formant — live on the drum rack itself.

The drum sequencer is the grid, with a tie indicator row under it.

The ARP UNIT goes in the rack, so the arp belongs to the instrument and follows it everywhere — live, sequenced, and in the song. It phase-locks to the song grid, so it stays in time instead of drifting.

Two ways to drive it:

1. Rule-based — direction, range, rate, gate, random.
2. Pattern-based — the PAT dropdown plays a saved pattern from arps/, or a sequence straight out of sequences/.

MOD OUT lets the arp modulate as well as play.

Drop a .mid on the PAT row (it outlines on hover) and bar 1 becomes the pattern: root = its lowest note, mode = TRANSPOSE, and polyphony, velocity, note length and groove are all kept. It's saved into arps/ under the file's name so it's reusable. GM channel-10 drums are refused; so is an empty bar 1.

→ ARP copies a sequence into an arp pattern, losslessly.

PRINT is a different thing: it bakes the arp's actual output into notes, offline, by walking the arp engine over the trigger clip. Deterministic and repeatable, printed in time rather than in steps (so triplets survive), and it carries the MOD into the automation lane so the printed sequence sounds like what you heard. RANDOM freezes one roll of the dice — which is how you keep a good take. PRINT needs trigger notes in the lane; an empty lane correctly refuses.

Printing asks REMOVE ARP?

• YES (default, usually right) — saves and loads the printed sequence, strips the arp from the rack, saves the rack as <name>_NOARP and loads that. Without this the printed notes re-trigger the arp and you get an arp arpeggiating its own output.
• NO — keeps the arp, for printing a pattern to use on a different instrument. The sequence lane's ARP badge is your safety net there.

This is the join people trip over, so plainly:

The one deliberate asymmetry: MIDI OUT's INT/MIDI/BOTH governs live play only. The sequencer, the song and rendering never read it. That's what lets one track be an external part under your hands and an ADEF part in the arrangement at the same time. Drum pads are the exception — see §21.

LIVE is a fourth page, beside SYNTH, PERFORMANCE and SONG. It shows the same music as the song page with everything else stripped away: what is playing, on which track, right now.

The top half is the grid. One row per track, one block per clip, bar numbers across the top — the whole arrangement as a map. No lanes, no automation curves, no channel strips. At a glance you can see which tracks are sounding at bar 63 and which are not.

The bottom half is the mixer. One row per slot, and only what you need with your hands on a keyboard:

That row is the point of the page. INT / MIDI / BOTH decides whether a slot plays inside ADEF, drives the synth on your desk, or does both at once — and it is one click, on stage, without opening a panel or leaving the page.

★ The slot that sounds is the slot that sends. LIVE does not invent a second routing scheme. It surfaces the decisions the performance already holds (§12), so what you change here is the same setting the sequencer, the arp and MIDI OUT are all obeying.

One row per track, each with three lanes:

The track header carries the channel strip — volume, pan, gain, bus, EQ, MIDI out, record arm, quantise — plus ◇ AUT for its automation lane (§18).

The channel strip saves with the song. Track EQ, arm state and quantise all travel in the song file, so a song sounds the same when you load it as it did when you saved it. Record-arm is deliberately not restored: reloading a song should never silently put you back into record.

Working with clips

The ruler

Song shortcuts

Time signature, and T for triplets

SIGNATURE — 4/4 · 3/4 · 5/4 · 6/8 · 7/8 · 12/8 decides how many beats fall in a bar, which moves the barlines. It does not move your music.

★ The notes don't move, the barlines do. Pick 3/4 on a song written in 4/4 and not one sixteenth changes position or pitch — the same music is simply counted in threes, so the bar numbers, the grid emphasis and the snap all re-draw around it. Nothing is rewritten and nothing is lost. Put it back and you are exactly where you were.

T is different, and it is the one that really re-times.

Pressing T divides every beat in three instead of two, across the whole song. A 16-step bar becomes 12. Because ADEF asks first, you get told exactly what that means before anything happens:

"8 sequences will be converted: each beat divides in THREE, so a 16-step bar becomes 12. Your hits and notes are NOT moved or deleted — they keep their step numbers, so the ones past the new bar end simply stop playing until you shorten or re-place them. Switching T back off restores them exactly. Nothing is written to disk unless you save."

Read that carefully, because it is the whole design:

The bar count changes to match — an 8-bar sequence reads 10.67 bars on the triplet grid, because the same notes now need more bars of 12 steps to hold them.

★ This is the honest way round. A triplet button that quietly threw away your last four steps would be a trap. This one tells you what it is about to do, does it reversibly, and waits for you to save before it means anything.

A sound that develops across the whole song, not one that repeats every 8 bars.

Sequence automation (§13) lives on the sequence's step grid, so a lane can only be as long as the pattern and then it repeats. That is the right axis for a groove and the wrong one for a filter that opens over three minutes. Song automation puts the points on a different axis — song bars — and saves them with the song.

Recording a pass

The whole workflow is five moves:

1. Arm the track. The ● button beside a track header's ◇ AUT button. Arm is on the track, not on master — so you arm the thing you are about to play with, and you are already there.
2. Go to PERFORM.
3. SPACE. In PERFORM, space is the song transport.
4. Open the synth on that track and turn knobs while the song runs.
5. SPACE to stop.

The master console shows ◆ SONG AUTOM · TR n while a track is armed, and ◇ SONG AUTOM when nothing is.

★ A recorded pass becomes a CLIP

On stop, what you just played is written out as an ordinary song clip on that track's LIVE lane, marked AUTOM.

That is the whole design, and it is worth understanding because it means you already know how to work with it. An automation clip can be dragged, copied, coloured, muted, split, resized, opened, saved and exported — because it is a clip, and clips do all of that already.

• Stretching a clip stretches its automation. Make it longer and the same curve happens more slowly. That is Eric's "slowed".
• Double-click it and the clip editor opens on its automation view.
• An automation clip is not capped at 8 bars. The 8-bar limit is a sequence rule for live-take capture. A curve is a one-shot shape, not a repeating phrase, so an AUTOM clip can be any length — and it can be shortened down to a single bar.

The lane editor

Double-click an AUTOM clip and every automated parameter opens as its own lane, stacked, sharing one bar ruler. Each lane shows the parameter, its real range, and an ON switch — so a curve can be silenced without being deleted, which is how you A/B a move instead of undoing it.

NOTES / AUTOM switches between the notes and the curves. FIT sizes the view to the clip.

Zoom in and the points are editable individually. The highlighted band is the clip the curve belongs to, so you can always see where the shape starts and ends relative to the music.

+ PARAM — what you can automate

+ PARAM lists every destination this patch actually has, grouped by the unit that owns it — OSC A · WAVE / LEVEL / OCT / FINE / PAN, SUB · SEMI / P.MOD, BAND 24 · CUTOFF / RESO / TYPE, ENV 1 · A / D / S / R / MODE, MIDI 1 · SRC / DEPTH / THRU, OUTPUT · VOL / GAIN / PAN, and so on.

★ The list is built from your rack, not from a fixed menu. Wire a different patch and the destinations change with it, because they are the patch's parameters. Same idea as the EQUATION card building itself from the equation you typed (§1).

Anything already given a lane is greyed out, so the list only ever offers you something new.

Reading the lanes

Each track header carries ◇ AUT — or ◆ AUT 4 when it has automation, where the count is the number of automated params. The count is the affordance: a track with nothing to show says so rather than opening an inviting empty panel. Click it to show the lane.

★ One lane, all curves overlaid. However many params a track automates, they share one lane under that track's live lane. Each curve draws in its own colour and is scaled to its own minimum and maximum, because a 0–99 cutoff and a 0–1 mix cannot share a vertical scale and both stay readable. The caption is the legend — each param name wears its curve's colour.

Transparent bands show where each automation clip sits on the bar grid, so you can see which curve belongs to which clip without opening anything.

Lanes on the song page are read-only — a picture of what is there. Double-click to edit the clip under the cursor in the clip editor.

Discrete parameters draw as steps

Some parameters are not numbers. QUANTISE has six states, a bus selector has about five. Drawing a sloping line between two of those is a lie — the value never passes through anything in between. So switches, quantise values, directions and retrigger modes draw as held blocks labelled with the state name (1/8, FX2), stepping at each change, with the state names down the left as the scale. Curve handles are switched off on those lanes: there is nothing between two states to bend through.

Lanes are attached to the TRACK, not the patch

A song automation lane is keyed by role — which kind of unit, which one of them, which param — not by a unit's identity. So a UNIQUENCER · MIX lane lands on whatever UNIQUENCER the patch on that track has, and is skipped in silence if that patch has none. That is what makes it automation of a track rather than of one particular patch, and it is why swapping the instrument under a lane does something sensible instead of breaking.

What travels

Automation inside a clip has always travelled with the clip. .adeftrack export now also carries the track's song automation. The rule is export everything — anything you don't want, you can delete after importing.

Automation edits are covered by ⌘Z, once per gesture rather than once per mouse move.

Right-click a sequence clip → ● RENDER → AUDIO.

ADEF makes a fresh dry render of that clip's own sequence at the current tempo, one cycle, wrapped so the tail joins seamlessly, and drops it on the AUD lane as a looping green clip with its waveform. The sequence clip mutes — its notes are kept, nothing is destroyed. Right-click a track header to do the whole track.

• Audio clips play through the same bus the synth used, so the track's effects still process them.
• VOL / PAN / GAIN / bus moves apply to a clip that is already playing.
• Mute and solo apply instantly to a playing clip, and it keeps rolling underneath so unmuting drops back in on the grid.

A render is baked audio and cannot follow tempo. Move the song's BPM away from the render and the clip's name turns red to tell you to re-render.

A clip that has been cut renders only the part you kept. Shorten a clip and the render is that length, not the whole underlying sequence.

Transpose bakes in. A transposed clip renders transposed.

Live takes render too. Render a LIVE-lane MIDI take and the audio lands on that track's AUD lane in place, waveform and all, with a ♪ LIVE badge and the tempo it was rendered at — the take itself mutes and is kept.

Rendering the whole song

RENDER SONG bounces the whole arrangement; ALT-drag the ruler to set a blue render area and RENDER SECTION bounces just those bars. Both are real-time captures — a four-minute song takes four minutes, because ADEF is recording itself playing.

★ THE RENDER CURTAIN

Because it is real-time, anything the screen is doing while it records is CPU stolen from the audio. So when a song render starts, ADEF drops a curtain: a full-screen page with the ADEF logo, a countdown, a progress bar and a CANCEL button. Nothing else.

This is not decoration. Behind the curtain, every per-frame loop on the song page switches off — the playhead, the meters, the per-clip play markers, the transport readout, the automation lane follow. The countdown and the progress bar are drawn directly, so the interface does no work at all while your song records. It buys the render real headroom on the machine.

The music underneath is unaffected: scene changes on the master lane still happen on their bars.

Watch the countdown, not the screen. Cancel is always there if you started it by accident.

Two things that used to go wrong and no longer do

No more silent head. ADEF now warms up every synth, drum and sample voice in the song before it opens the recording, so the first bar is music instead of four and a half seconds of nothing while voices bake.

A silent render tells you. If the capture comes back essentially empty, ADEF shows ⚠ SILENT — SOLO/MUTE ACTIVE? instead of quietly saving five minutes of nothing. Nine times in ten it is a solo you left on.

⭳ MIDI — export the song as MIDI files

Beside RENDER SONG. Where a render is a real-time capture, this is instant — it is writing notes, not recording sound.

One click writes, into a <SONG> MIDI folder beside your song:

• one .mid per track, named after the track, and
• one Type-1 song file carrying every track together.

Both at once, because they are for different jobs: the per-track files are for dropping one part onto one instrument, the song file is for opening the whole arrangement somewhere else.

It writes silently. No Save-As dialog — eleven dialogs in a row is a punishment, not an export.

What comes out is the arrangement you hear, not the raw patterns: block positions, lengths, chained patterns, repeats, per-clip transpose and stretch, and pad mute/solo are all resolved into absolute notes on the timeline.

Drums export as real notes, on channel 10, so a drum track lands on a drum instrument in another DAW instead of arriving as nonsense. Synth tracks go out on channels 1–8, matching ADEF's own slot rule.

The groove survives. ADEF stores swing and human feel as a sub-step offset, and the export writes that offset back into the note timing rather than quantising it away — the same information the MIDI import reads, running in the other direction.

Verified end to end: an ADEF song exported, opened in Logic with every track named, channelled and placed on the right bar, and played back through the ADEF Player plugin.

What it does not carry: parameter automation. A MIDI file has no way to say "the second filter's cutoff" — and a UNIQUENCER pattern in particular is a per-step structure, not a stream of values, so flattening it to controller data would throw away the very thing that makes it what it is. Send the patch for that, not the MIDI. Controller moves you actually recorded from a wheel or pedal are a different matter — those were controller data to begin with and travel honestly.

Under the tracks, one lane carrying two kinds of event:

TRACK SWAP (gold ◆). Right-click the lane at a bar, pick a track from your library, and at that bar the selected lane loads it — sequence + MIDI, no renders, live. Rewinding back past the marker restores the original, and edits you make to a swapped scene are remembered when you leave and come back. Non-destructive live scenes. Right-click an event to remove it.

PROG (cyan). Patch recalls captured by ARM — §22.

Both units carry a library of presets imported from hardware. Renders are real-time captures, so they contain exactly what you hear — live effects and all — and land in renders/.

MATCH EQ — borrow the tone of a record you like

MATCH sits in the master chain between the EQ and the limiter: EQ → gain → GRAPHIC → LIMITER. It analyses a reference recording, analyses your song, and builds the 31-band curve that moves one toward the other.

Three curves are drawn together: REFERENCE (orange), THIS SONG (blue) and RESULT (green). The result is what you will hear.

⚠︎ Two things about the picture that will otherwise cost you an afternoon.

The display is tilted +3 dB per octave, so pink noise draws FLAT. Audio spectra fall away with frequency, so an untilted plot makes every record look like a bass-heavy triangle and every difference at the top invisible. The tilt is a display choice — it changes the drawing and not one sample of the sound.

★ If a curve ever looks wrong while the sound is right, suspect the drawing before you suspect the audio. That has been the answer more than once in this program.

A match is only meaningful where the reference actually has content. Where the reference is silent there is nothing to match to, so MATCH says so on the graph rather than inventing a correction:

That band is left alone. It is not a failure — it is the honest answer to a question the reference cannot answer. Loading a reference that rolls off at 40 Hz will never tell you what to do below it.

TRACK MATCH — the same thing, on one track

Every track's channel strip carries REF and MATCH of its own, so you can match a single instrument to a reference rather than the whole mix — a kick to a kick, a pad to a pad.

REF remembers what you have used before under MY REFERENCES, so the records you work against are one click away.

★ Matching the EQ curve of a commercial record is an ordinary studio technique and always has been — engineers have referenced records since records existed. You are measuring a tone and applying a curve to your own music; nothing of the reference ends up in what you export.

Four effect buses — FX1 · FX2 · FX3 · FX4 — plus DRY.

What can be routed here:

Effects open in a floating window, so you can work on them while playing.

FX1 and FX2 — the built-in effects

Each of the two built-in buses picks one of REVERB · CHORUS · DELAY · PHASER · FLANGER · SATURATE and gives it a full parameter row, a stereo/ping-pong mode where it applies, tempo-locked time divisions from 1/1 down to 1/32 (including dotted and triplet), and its own MIX and LEVEL.

FX3 and FX4 — plug in anything you own

FX3 and FX4 are not built-in effects at all. They are plugin inserts: the bus feeds an AU or VST3 plugin you already own, and the plugin's output goes on to the master. There is no MIX or LEVEL on these two — the audio goes through the plugin, so use the plugin's own controls.

LOAD opens the picker, which lists every plugin found on this machine, filterable by AU, VST3 or effects-only, with a RESCAN if you've just installed something. EDIT opens the plugin's own native window — live, while it plays. ✕ clears the slot.

The loaded plugin and its full state save with the instrument, so a rack that depends on your favourite compressor comes back with it set the way you left it.

Ownership. A performance and a song each own their effects settings. Load one whose effects differ from what's set and ADEF asks which should win rather than quietly overwriting your sound.

Clock detail. SPP means starting mid-arrangement locates your gear to the same bar rather than restarting it. The delay offset compensates for gear that runs early. Everything is timestamped against the audio clock, so MIDI leaves when the audio is heard, not when it was written into the buffer.

★ There are TWO delays, and they are different numbers on purpose. The sequencer transport and the song transport announce their start differently, so they need different compensation. On Eric's rig the numbers land around 45 ms for the sequencer and 95 ms for the song — yours will differ, so set them by ear against a hardware box you trust. Both are saved, and the song delay rides inside the song file, so a song that syncs on your rig still syncs when you reload it next week.

Starting mid-song sends SPP + Continue rather than Start, so external gear jumps to the same bar instead of restarting from the top.

Notes go to one port on one channel — not to every output. "Send everywhere" is right for clock and useless for notes.

Destinations

A destination is a name you give a port (with a default channel): VIRUS, ROLAND STUFF, SYNC AND DRUM. Tracks and pads reference the name.

Why a name and not a raw port: you assign the same handful of destinations across dozens of tracks and pads, so re-cabling should edit one row — and port names are not stable between sessions, so the named layer is what stops a saved song silently playing the wrong synth next week.

Destinations are studio-level, not saved in the project: your rig doesn't change per song, and a project from another machine must not repoint your gear.

Per track

MIDI OUT [ destination ▾ ] [ INT · MIDI · BOTH ] CH [ − n + ]

CH is the track's own channel (shift-click ± moves by 8). It defaults to the destination's channel, because a multi-timbral synth carries many parts on one port — the channel belongs to the track, not the cable.

This row is identical on the Performance strip and the Song track header — the same control, not two that can disagree.

Governs live play only. Sequencer, song and render never read it (§16).

No destination = it sounds internally rather than going silent, and the label says so in orange. Unroutable never means inaudible.

The arp transmits its output, not the chord you're holding — so the external synth plays the arpeggio. In MIDI mode the arp still runs internally, to have something to transmit.

Drum pads

Per pad: an OUT NOTE and INT/MIDI/BOTH. Unlike the synth side, the drum send lives in the sequencer and song paths, because your patterns are what drive an RX5 or a TR-8.

• cyan → badge = MIDI only · green ⇉ = both
• The note matters. ADEF fires 48+i internally; a TR-8 wants 36 kick, 38 snare. That's what OUT NOTE is for, and ↑ ASCEND NOTES across a selection builds the map in one go.
• The song path sends the transposed pad — the pad actually struck, not the one it started from.

Your banks and effects live on the synths, so ADEF's job is to recall the right patch at the right bar.

1. On the song master console, press ARM. It listens on all sixteen MIDI channels.
2. Select patches on your synths. Each recall lands in the tray as a clip: CH3 P11 ·B0.12. KEEP LAST (default) keeps one clip per channel — audition thirty patches and you keep the one you chose. KEEP ALL keeps every recall, in order.
3. Click a clip to send it now to the selected track — audition the recall against the real synth before committing it.
4. Drag a clip onto a track at a bar. It becomes a cyan PROG pill on the master lane.
5. Press play. The recall leaves on that track's port and channel, 30 ms ahead of the downbeat so the patch is up before the first note.

Things it gets right that are easy to get wrong:

• A bank recall is three messages — bank MSB (CC0), bank LSB (CC32), then the program change. ADEF captures and re-sends all three as one event. Capturing only the program change recalls the right number in the wrong bank.
• Re-channel on drop — the clip stores only the numbers, so re-cabling the studio or moving a part to another synth doesn't break it.
• Patch chase — start at bar 33 and every track still gets the patch the arrangement had reached by then.
• A looped section re-sends its recalls each pass.
• A pill turns orange if its track has no destination. Right-click removes it.
• Events ride in the saved song and performance, and survive a trip to the Synth page.

Reading Ensoniq instruments. ADEF plays .efe and .erx10 directly through the EFE/ERX OSC unit — your own disks, in a modern sequencer, with modern filters and effects on top.

The ADEF SAMPLER (● SAMPLE): record or import, trim, set the root, save as .erx10. That container is then playable by an EFE/ERX OSC unit, loadable as a drum kit, and embeddable when you export an instrument for sharing.

REX — loops sliced to pads. A REX loop is a loop that has been cut at its transients, so every hit becomes its own pad. Once it is a kit you can mute a slice, retune one, swap the order, put a filter on the snare only — all the things a stereo loop won't let you do — and it still plays back as the loop you started with.

The whole walk-through, start to finish:

1. Load the loop into the ADEF SAMPLER and switch to REX.

   

2. TRIM to bars, then divide it — DETECT finds the transients, or set a straight number of equal divisions. Markers are editable in both views and the zoom goes deep, so you can put a marker exactly on an onset rather than near it. 24 slices maximum: a DRUM IN holds 12, so 24 is exactly two drum mixers and the layout is always two, never three.

3. CREATE → SAVE it as an .erx10.

Off-grid timing is kept. A transient at 3.99 sixteenths is written as step 4 with a −0.01 offset, not step 3 with a +0.99 — so a detected groove stays slightly ahead of or behind the beat rather than being rounded onto the grid. That is the difference between a sliced loop that grooves and one that marches.

Because the pattern is the instrument in this one case, a REX kit carries its pattern with it — unlike every other rack, where the sequence belongs to the slot. Each pad stores where its slice sat in the loop, so the pattern is rebuilt from the kit itself: it survives saving, loading and quitting, and it seeds only into an empty drum lane, so it can never overwrite work you've done.

⌘S just saves. No dialog, no overwrite prompt — a green ✓ SAVED toast and back to work. You cannot be surprised by replacing what you already have open. The overwrite warning is kept for Save As and for a first save, where the thing you might clobber is a different project.

Tracks are the unit of sharing. Right-click a track header → EXPORT / IMPORT. On import ADEF checks the tempo and offers to bring the track in without renders.

Save Project explodes into a performance, a song, an FX preset, a manifest and one .adeftrack per track — you give one name, ADEF handles the parts. Load Project reassembles it, and older single-file banks still load.

Sharing an instrument that uses your own samples: use export for share, which bundles the sample packs the rack references into one self-contained file. Normal saving references samples rather than embedding them — which is why an instrument can go quiet on another machine if you copy only the preset.

Press ⌘K in the app for this list at any time; ? gives help for the page you're on.

Global

Page navigation

Performance

Synth (build page)

Song

Note / automation editor

Drum pads

If it stutters

First, the thing worth knowing: it is almost never the sound.

ADEF builds every voice as audio before it plays it. Once a note is baked, playing it back is cheap — that is why "if it starts, it runs" has held true since the first version. What is expensive is drawing: the song page redraws every clip, every barline, every automation curve and the playhead, continuously, while the music runs.

The measurement makes the split plain — the same song, on the same machine:

So on an older or slower machine the song page runs out of headroom before the audio engine does. Confirmed on a 2017 MacBook Air: one project played without a hitch, another stuttered on the song page and was clean on PERFORM — same audio, same notes, different amount of picture.

What to do, cheapest first.

1 · Collapse the tracks you are not editing. The − on a track header drops it to a single row, and the lanes underneath stop being drawn. On a ten-track song this is the biggest single win and it costs you nothing.

2 · Play from the LIVE page. LIVE draws a clip grid and a mixer — no lanes, no curves, no channel strips. It is the same music with a fraction of the drawing, and it exists precisely so you can play a set on a machine that cannot draw a song page at sixty frames a second.

3 · Play from PERFORM when you are auditioning sounds. You do not need the arrangement on screen to hear whether a patch is right.

4 · Close the automation editor when you are not drawing in it. It is a live canvas.

5 · Render the expensive tracks to audio. A track's ▾ menu → RENDER → AUDIO replaces the synth with the recording of itself. From then on that track is a file being played back, and the DSP behind it stops being computed at all.

★ The UNIQUENCER is the one that earns this most. It is a per-step effect sequencer running six families of DSP on slices of time — by far the most expensive thing in the program per voice. A UNIQUENCER track rendered to audio sounds identical and costs almost nothing. The same goes for a heavy EQUATION patch, the vocoder, and any big unison stack.

6 · Render the section, not the song. ALT-drag the ruler to set the blue RENDER AREA and use SECTION — you get the part you are working on without waiting for the whole arrangement.

Does a stutter get into my render? Renders are real-time captures, so anything that genuinely interrupts the audio will land in the file. A stutter in the picture will not. The two are easy to tell apart: if the sound is steady while the display hitches, you are fine. Either way, listen back to the render before you send it anywhere — that is thirty seconds and it settles the question completely.

An instrument loads but makes no sound. Work the audio rule (§5): is there an unbroken chain of audio cables to an OUTPUT unit? A source wired only into mod jacks is silent by design. Then: is the slot muted, outside its KEY RANGE, or on the wrong MIDI channel? If it's sample-based, has the sample source resolved?

A sample instrument is silent until I open and edit it. Fixed. If you still see it, the sample source didn't resolve — ADEF now also looks for the same filename in your library's erx10/, efe/ and wav/ folders.

MIDI OUT isn't playing my synth. In order: 1. Is a destination set on that track? (An unset one falls back to internal and says so.) 2. Is the mode MIDI or BOTH, not INT? 3. Is the channel the one that synth's part is on? 4. Is that output muted on the System page? 5. Check the gear. Volume up, MULTI / multi-timbral mode on, right instrument selected. This is genuinely the most common cause — more than once "it stopped working" has been a knob.

External drums stopped triggering. All of the above, plus the pad's OUT NOTE — your machine may want 36/38 where ADEF sends 48+.

A mod I made with ADD MOD does nothing. ⚠︎ Known: ADD MOD is unreliable on some units. Report it rather than re-patching around it.

A filter modulation sounds right sequenced but wrong live. ⚠︎ Known: the LFO + envelope same-filter case (§6.2).

Audio glitches / jerky playback. ADEF pre-warms every voice a song will play before the transport rolls, so this should be rare — let the pre-roll finish on a big arrangement. Avoid dragging heavy windows during playback.

A rendered clip is out of tempo. A render is baked audio. Red clip name = the song has moved away from the tempo it was rendered at. Re-render.

A note is stuck on my hardware. ⏻ MIDI PANIC (System page) — All Notes Off + All Sound Off on every channel of every destination port. ⌘. panics ADEF's own voices.

Clicks at a loop point. Voices are meant to ring their natural release across a loop seam. A click at an exact boundary is a bug — note the bar and report it.

Your ADEF racks, in your DAW. A plugin that loads one ADEF instrument and plays it from MIDI — so a sound you built here can sit on a track in Logic, Live, Cubase or Reaper without rendering it to audio first.

MIDI in ─┐ ├──► one ADEF rack (synth OR drum kit) ──► Main + FX1 + FX2 + FX3 + FX4 outs Audio in ─┘ (sidechain — vocoder modulator, formant source, DIGI→ANA B, ring source)

It is not the workstation. No sequencer, no song page, no track mixer, no performance page, no library browser, no project system. One rack, MIDI in, audio out. Everything that makes ADEF big stays in the app — and that is the point: you compose here, you play there.

Why it works at all. ADEF does not play notes with a live modular graph. It renders each note into a buffer with pure maths, loops it, and plays it back with a small live chain on top. So ADEF is already, architecturally, the kind of engine that ports cleanly to a plugin. This is not an approximation of your sound — it is ADEF's actual playback model.

A rack that needs an input gets one. The plugin declares a stereo sidechain input, so vocoder, formant, RING and DIGI→ANA racks work in a DAW instead of being refused. Feed it from another track and that track becomes your vocoder modulator.

Five stereo outputs. Main plus FX1–FX4, so the buses you set up inside the rack arrive in the DAW as separate outs and you can process them with the DAW's own effects.

Possession of ADEF is the licence. No separate purchase, no separate edition, and no licence check inside the plugin itself.

Formats. AU and VST3 on macOS; VST3 on Windows. A standalone build exists too.

The plugin installs to the standard locations — /Library/Audio/Plug-Ins/Components for the AU and /Library/Audio/Plug-Ins/VST3 for the VST3.

Loading a rack. LOAD opens a browser. It looks in your ADEF library first, then falls back to your Documents ADEF Presets folder and your Downloads folder — so a rack you have just downloaded is one click away rather than buried.

Saving your changes. SAVE writes a <name>_P.json beside the original. It patches the document you loaded rather than rewriting it from scratch, so nothing in the rack that the plugin does not itself voice can be lost on a save.

MIDI patterns come out. A rack built on a REX loop carries its pattern, and you can drag a real .mid file straight out of the plugin onto a DAW track — the notes, not the audio. Useful when you want ADEF's groove but the DAW's instrument, or when you want to edit the pattern by hand.

One panel, laid out to be read at a glance on a busy screen rather than to mirror the app's build page. The rack you loaded is named across the top; NO RACK LOADED means exactly that.

The knobs are real parameters, and the DAW can automate all of them. They are exposed to the host, so cutoff, resonance, envelope depths and the UNIQUENCER's controls can all be drawn into your arrangement as automation.

The plugin is deliberately not a clone of the app, and in one place it is actually better.

★ UNIQUENCER RETRIGGER ▸ FOLLOW works in the plugin, and does not in the app. In the app, a voice is baked and cached, and a cached bake must never read the transport — so FOLLOW has nothing to lock to. The plugin runs in real time off the host's playhead, so FOLLOW genuinely phase-locks every voice to your DAW's bar line. If you want a UNIQUENCER pattern welded to the grid, the plugin is where you get it.

The two engines are kept deliberately in step, and where they are not, it is on purpose. They are separate codebases — one JavaScript, one C++ — and a difference between them is either a considered decision or a bug worth reporting. If a rack sounds different in the plugin from how it sounds in the app, that is worth telling us about.

The ADEF WAVES bank ships inside the plugin. All 145 waves travel as one packed block, and the UNIQUENCER's FILTER ▸ ADEF type carries the wave spectra it needs as a small table rather than the audio — so the plugin stays under 10 MB and still tunes within one cent of the app.

Host tempo sync. The UNIQUENCER locks to your DAW's tempo by counting beats, not seconds, so a tempo change moves the pattern with the music instead of making its phase lurch.

What is not in the plugin yet: some of the sample-player sources, the ARP and the vocoder are still being brought across, and the vocoder's key split needs finishing. A rack that leans on one of those will load and play — it just will not sound like the app until that piece arrives. Roughly three quarters of the factory presets voice correctly today, and that number is climbing.

ADEF · manual draft 3 · 2026-08-04 · jacks, rules and shortcuts generated from the source