Auracle

A synthesizer that grows toward you. Pick the sound you’d reach for. It learns your ear, and every generation grows a little closer.

Auracle is a modular synthesizer you play in the browser. Pick between two sounds, and it learns what you like, breeds new sounds toward it, and shows you what it learned. Every sound is a patch you can open and change.

This guide is for playing it: each page is one level or one task, and says what to do and what you’ll see. The reference is for how it works, with the math.

It’s a synthesizer first. Four voices, a keybed, MIDI, an arpeggiator, and a rack of 45 modules with typed cables. You can play it without teaching it anything.

What it does

• Every sound is a real patch. Each one is built from typed modules and cables, so every change breeding or your hands make leaves a patch that still plays. There is no crossover: every child grows from one seed.
• It learns your taste, and says how sure it is. Your taste can have several sides, each a style, so you can like unrelated sounds at once. Before every pick it guesses which you’ll pick, and LEARNING grades those guesses.
• New sounds grow toward you. What the model learns shapes where breeding steps, not only what it keeps. Lock the parts you love, and breeding leaves them alone.
• What you play is what it heard. The patch you play live is the same one that was bred, checked, and measured.

The five levels

The instrument is one space around the sound you’re playing: zoom out to see it among every sound, in to see what it is made of, and step beside it to breed.

PERFORM is where you play, EVOLVE is where you teach, and PATCH is where you open the sound up. TASTE and LEARNING are where you see whether it’s learning. ⌘K finds any sound, and anything to do, from any of them.

What to expect

Auracle is pre-1.0. The instrument plays for hours, and the taste loop runs end to end, but:

• It takes picks to learn. A handful of picks isn’t a taste yet. The first useful generations come after a dozen or two, and sure ones later. From nothing it would take hundreds, which is why the warm start exists.
• It says when it doesn’t know. LEARNING counts toward 20 guesses before it grades the model, and then, early on, says not beating a coin flip yet. That is the grading working.
• The saved format may change between versions. Your session lives in your browser and older ones are upgraded, but download anything you care about.
• A phone is slower to start. Every size plays, a phone too, but a phone renders the same sounds at boot on a slower processor; see phones and tablets.

Where to go next

• New to it: your first session.
• Running it yourself, or offline: running it yourself.
• Already playing, and want the keys: keyboard and MIDI.
• How it works: the reference.
• Something’s wrong: troubleshooting.

Your first session

This page takes you from the first sound to a generation bred toward your taste, in about fifteen minutes. Each step is one thing to do, and what you’ll see when you’ve done it.

Open the instrument. There is nothing to install, and everything below happens in one browser tab. Your session is kept in this browser as you play, and it’s there when you come back.

1. Let it listen

1. Open the instrument.
2. Wait for the boot card to fill.

The card carries Auracle's line, A synthesizer that grows toward you, and reads listening to 40 sounds: you start as soon as the first 8 land. Each of the 40 is drawn from the grammar, rendered on one five-second phrase, checked, and measured. Once eight have landed the instrument opens, and the rest arrive while you play. When you come back, it reads restoring your bank & taste… instead, and opens once your whole session is back.

2. Pick the three you’d reach for

The warm start opens over the instrument. It teaches the model 18 picks in about thirty seconds, which is the difference between a model that has a guess by the end of this session and one that doesn’t.

1. Press ▶ on a card to hear it. Press it again to stop.
2. Click the three you’d reach for. Pick on sound alone: there is no wrong answer.
3. Press TEACH IT.

The card is headed PICK THE THREE YOU’D REACH FOR, over nine presets drawn one per family from the library, each with its face, which comes with the app, so it is there with the card. The button under them counts down as you pick (PICK ANY THREE, 2 MORE, 1 MORE). At the third pick it reads TEACH IT and lights up amber: that’s the next step. On a phone the cards scroll, and SKIP and the button stay at the bottom of the screen.

When you press it, PERFORM opens on your first pick, and TAUGHT in the menu bar reads 18. The toast says what happened: Your three taught it 18 picks, so it starts out pointed at you. Your three are saved, and Glass Pad is under your fingers.

Your three are saved, so no generation will replace them. They take 3 of your 10 save slots; release any of them from its row if you want the room.

At the bottom left, a pill shows the first things to try in PERFORM, one step at a time: Play a key, then a control to turn on this sound (on a sound none of them reach, the pill leaves this step out, pip and all, and asks for it again on a sound one of them turns), then Press OFFER, then Press ⌥↑ to zoom out to TASTE, and last Hold ⌥ to see what the model believes. Each ticks off (a pip fills) when you do it, not when you read it. When they are done, the pill says what the loop was and goes; it says that only once, so a turn it comes back for later just ticks off. × stops PERFORM's showing. PATCH has four of its own, in the same pill under its well: Play it (done already if you have played), Drag a knob, Lock what you love, and Press ⚡ EVOLVE FROM THIS; its × stops those. It is the one place first steps are shown.

SKIP goes straight to the instrument. A few picks later it offers the warm start once more, and you can run it again any time from ⌘K: Re-run the three-pick warm start.

3. Pick between pairs

EVOLVE is where you teach the model most. It plays you two sounds, A and B, on the same phrase, and you pick the one you’d reach for.

PERFORM, PATCH, EVOLVE, TASTE and LEARNING are the levels of one space around the sound you’re playing, and the stops at the stage’s right edge show where you are: TASTE and LEARNING above PERFORM, PATCH below it, and EVOLVE beside it. Click a stop to go there, or press ⌥← for EVOLVE, ⌥↑ and ⌥↓ to zoom out and in (or hold ⌥ and turn the wheel), and ⌥1–⌥5 for each level (Alt off a Mac). The menu bar names the level you’re at, and as you move, the face of the sound you’re playing travels with you to where the next level draws it.

1. Go to EVOLVE: its stop, left of PERFORM’s, or ⌥←.
2. Press 1 and 2 (or ▶ PLAY on each card) to hear A and B.
3. Click a card’s body to play that sound live on the keys, if the phrase doesn’t tell you enough.
4. Press ← or → (or PICK A, PICK B) for the one you’d reach for.
5. Press ANOTHER PAIR (N) when a pair tells you nothing.

Ten or fifteen picks is a good first batch. If neither sound is one you’d reach for, pick the nearer one: what the model learns from a pick is a direction, and that’s still one. The model expects answers to waver, and averages over them.

What you see:

• The line above the cards. Before your first pick it reads Play both. Pick the one you’d reach for. After that it counts down to the next redraw (3 more picks and it redraws your taste map.), and six pips fill as you go.
• The forecast. After each pick, the model says what it guessed before you picked: it guessed this · 72% · fairly sure, or it guessed the other · 62% · leaning. Its misses are how it learns.
• The toast. Picked Glass Pad over Soft Wash., with NOT WHAT I MEANT for seven seconds. ⌘Z (Ctrl Z) does the same.
• The refit. On the sixth pick the line reads ● learning from your last 6 picks…, and the amber lamp after the wordmark lights while the model fits. Then it reads ● it just learned: see what changed ▸, and the link opens TASTE.

4. See what it learned

1. Go to TASTE (⌥↑ from PERFORM or EVOLVE): every sound in the pool, glowing by how much the model guesses you’d like it. Point at one to see its card.
2. Go to LEARNING (⌥↑ again), and read each style’s name on its chip.
3. Read ITS FORECASTS, and see how close it is to grading the model.

Early on the glows are a first guess, and the styles too. A style is named for what it leans toward until you rename it, so a style called analog sustain means the model has heard you leaning that way.

LEARNING grades the model once it has made 20 guesses, one before each pick, and until then it counts toward them (calibrating · 4/20). Once it has 20, it will likely say not beating a coin flip yet. That is the honest answer this early, and the LEARNING guide says why a plain hit rate would have flattered it.

5. Breed a generation

1. Go to EVOLVE.
2. Press EVOLVE POOL.
3. Play the new sounds as they land at the top of the bank.

The model takes the ten sounds it rates highest and walks a short way from each, toward what it has learned. Hover EVOLVE POOL before you press it, and the bank marks those ten SEED. EVOLVE POOL becomes its own progress bar, saying each walk as it comes back (WALK 3 OF 10 joined the pool), with STOP beside it, and the job slot in the menu bar counts the walks at every level. A generation takes from under a minute to a few, depending on the machine, and the instrument keeps answering while it breeds.

Each child appears the moment it’s bred, at the top of the bank under NEW · GENERATION 1, tagged NEW, with the seed it grew from under its name. The WHAT EACH GENERATION DID, under EVOLVE POOL, says what each step changed:

gen 1 ⚡ bred from Soft Pad → Warm Drone 2 · release 100 ms → 251 ms,
cutoff 1.78 kHz → 20 kHz, delay → chorus, +lfo · liked +0.62

liked is how much more the model guesses you’d like the child than its seed. A step it rated lower is tagged exploring: the walk sometimes steps sideways or down so it doesn’t get stuck, and your next picks say whether it was worth it.

Then go back to picking. The new sounds are in the pairs now, and every pick still teaches the model and tests its forecast.

6. Keep what you’d reach for again

A bank row has two ways to keep a sound, and they do different jobs:

• ★ rates it. That teaches the model.
• save keeps it. The sound stays in POOL, is listed in SAVED too, and no generation will replace it. It teaches the model nothing.

Stars are not saves says when you want which.

What to try next

• Turn some knobs: reading and editing the rack.
• Rewire it: wiring and the catalog.
• Play it: playing it and PERFORM.
• Lock what you love and breed around it: ⚡ evolve from this.
• See what the model learns from: what the model learns from.

Press ⌘K in the app at any point (or ? anywhere but over one of PERFORM’s controls) for every command with its key, and the keyboard map has them all in one place.

Running it yourself

Auracle runs in a browser: the hosted app, a release bundle you serve yourself, or a build from source. This page covers all three, a booth set-up, and what it asks of your machine.

In the browser, hosted

1. Open auracle.alexnodeland.com/play/.

That’s the live build. It tracks main: it deploys from main once main’s CI is green. A tagged release doesn’t deploy on its own; it is tagged on main, and the live build follows main.

There is nothing to install, and nothing leaves your machine. The engine is WebAssembly running in your tab, and your sounds and taste live in your browser’s storage. There is no account, and no server to send anything to.

From a release bundle, offline

Every release carries auracle-vX.Y.Z-web.zip: the instrument, built, with no tools needed.

1. Unzip it.
2. Serve the folder over HTTP.
3. Open the address it prints.

unzip auracle-vX.Y.Z-web.zip
cd auracle-vX.Y.Z-web
python3 serve.py        # → http://localhost:8642

Any static server works (npx serve, php -S, and others), but it must be HTTP, not file://. The instrument uses module workers, and browsers won’t load those from a file.

The bundle is pinned to its tag. The live site tracks main, so it’s the same build on the day a release is cut, and may be newer after.

From source

Auracle’s foundations (quiver-dsp, fugue-ppl, and fugue-evo) come from crates.io.

1. Install a Rust toolchain with the wasm32-unknown-unknown target, and wasm-pack.
2. Clone the repository, build the engine, and serve it:

git clone https://github.com/alexnodeland/auracle.git
cd auracle
make wasm     # build the engine into apps/web/pkg
make serve    # → http://localhost:8642

make wasm puts ~/.cargo/bin first in PATH: a Homebrew rustc earlier in the path lacks the wasm standard library, and fails in confusing ways.

To work on Auracle rather than with it, see CONTRIBUTING.md.

At a booth

For a kiosk or a show floor:

1. Turn on Booth mode in ⌘K, or open the app with ?booth on the address (?booth=30 sets the idle time to thirty seconds; the default is a minute).
2. Leave it. With nobody at the keys, it plays itself.

What happens:

• It plays itself. With nobody at the keys, the instrument plays itself in PERFORM, through a set of presets. It holds a chord progression, moves two named controls under an invisible hand (their dials turn), lets Wander turn the knobs, then grows an offer in B and blends it in.
• It hands over. Any key, click, touch, wheel, or MIDI note stops it on the spot. The visitor is holding whatever was playing, with Wander still and BLEND home. Nothing it did while playing itself is logged or counted as a pick.
• The next visitor. ⇧Esc (or New visitor in ⌘K) forgets the visitor’s taste and starts again with the warm start, on a new pool (it takes ?seed off the address). Booth mode and PERFORM’s measured controls are kept, so the set stays instant.
• It measures ahead. As soon as booth mode is on, it measures the set’s presets for PERFORM in the background (Glass Pad, Acid Line, Loom, Undertow, Sub & Sparkle, Detune Dream, Wobble Board, and Cathedral), one at a time and only in a quiet moment. PERFORM keeps each measurement across reloads, so after the machine’s first boot no visitor waits for one.

A MIDI controller with eight knobs is picked up with nothing to set: the first eight knobs you turn take the first eight controls on PERFORM’s deck: with the six named controls on the panel, those six, BLEND, and WANDER.

Browser support

Auracle needs a current browser, with AudioWorklet, WebAssembly, module workers, and IndexedDB. All have been standard for years, and Auracle uses them hard.

Without Web MIDI, everything still works from the computer keyboard and the keybed on screen; see playing it.

Phones and tablets

Every size starts the instrument. On a phone held upright the levels are the bar along the bottom, KEYS at its end brings the keys up, and the bank rises from the bottom when you press the button of three lines at the start of the menu bar; any window under 1000 px wide keeps the bank behind that button. Boot costs about 40 renders, which a phone pays for on a slower processor, so its first sound is ready later than a desktop’s. The accessibility page says what goes where.

Every rack gesture works under a finger: knob drags, cable pulls, locks, and the ⋯ menus. Whatever a mouse finds by hovering is shown outright on a touch screen, because on a tablet, hover-to-reveal means never.

What it asks of your machine

• At boot: about 40 renders, spread across min(cores − 2, 6) background workers, or two if the device reports 4 GB of memory or less. Add ?farm=0 to the address to boot without them.
• While you play: four voices of modular sound on a real-time audio thread, and four more while PERFORM’s B holds an offer. Modest, but heavy work in another tab can cause dropouts. When the sound starts to fall behind (a slower laptop), Auracle protects it for as long as that lasts: B stays silent at BLEND’s home, and what the instrument does on its own (filling the bank, a generation’s walks, Wander, measuring in the background) waits while notes sound and for a second after, going on a step at a time after eight seconds of playing.
• At a refit: a few seconds of work at most, off the audio thread. You can keep playing through it.
• Storage: your session, in IndexedDB. Tens of megabytes at most, mostly the log of what you taught it.

Overrides

Added to the address, these change how it runs on your machine, or what it deals:

Without ?seed, every new session starts from a random seed of its own. With it, a fresh session (nothing saved in this browser yet) deals the same pool of sounds, under the same names, on any machine running the same version, at any worker count, so you can send the address to someone and they start where you did. (A sound you haven't named takes its name from the bank as it stood when the sound arrived, the first eight from each other, so how fast the bank filled can't change it.) The pairs, refits and offers after that draw from the same random seed, and repeat when the same things happen in the same order. A pair dealt before the pool has finished filling is dealt from the sounds that arrived first and waits for any not there yet, so the machine's speed can't change it either. (Without ?seed, a pair is dealt at once from the sounds that have arrived, and never waits for more.) A saved session comes back as it was. Which side of the table a sound stands on, and the warm start's nine cards, are shuffled either way, so no side or card is favored. Reset your taste… and a booth's next visitor take ?seed off the address as they start over, so a reset deals a new pool.

One space: the levels

PERFORM, PATCH, EVOLVE, TASTE and LEARNING are not pages. They are levels of one space around the sound you’re playing: zoom out to hear it among every sound, zoom in to see what it is made of, and step beside it to breed what it could become. ⌘K finds anything in any of them.

Where each level is

The menu bar names the level you’re at, with its line beside it:

The levels at the right edge of the stage draw this as a cross: a stop for each level, out at the top, in at the bottom, and EVOLVE’s stop branching left of PERFORM’s. The stop you’re at is lit. The app opens at PERFORM, or at the level you were at last time, and a link that ends in a level’s name (…/play/#taste) opens that level.

Move between them

1. Click a stop on the levels.
2. Or press ⌥↑ to zoom out and ⌥↓ to zoom in, ⌥← to go beside it to EVOLVE and ⌥→ to come back. From EVOLVE, out goes to TASTE and in to PATCH.
3. Or press ⌥1 to ⌥5 to go straight to PERFORM, PATCH, EVOLVE, TASTE or LEARNING (Alt off Apple platforms).
4. Or hold ⌥ and turn the wheel, one level a turn; a trackpad’s pinch does the same, except over PATCH’s patch, which it zooms instead.
5. On a touch screen, spread two fingers to zoom in and pinch to zoom out.
6. On a phone held upright the levels are the bar along the bottom: tap a stop to go there.

As you move, the face of the sound you’re playing flies from where one level draws it to where the next does: PERFORM’s well, the face at OUT in PATCH, its mark on TASTE’s map, its ring on LEARNING’s, and the card in EVOLVE that holds it, if one does. Where a level doesn’t draw it, the face fades instead of flying. Played as it flies, the face keeps drawing what you hear over it (while you play it). A light travels along the levels from the stop you left to the one you reach, and at either end of the zoom the levels nod and nothing moves. With reduced motion set on your system every move is instant.

The keys work with a knob or a list focused, but not in a text field, where ⌥← moves by a word, nor under a dialog that asks you something. Every key and gesture is in the keyboard map.

The model view

Hold ⌥ for a moment, at any level, and what the model believes comes up over it (MODEL’s light in the menu bar comes on halfway as you press, and fully when the view comes up; ⌥ with an arrow or a digit moves a level, and the view never shows): each bank row’s guess and the pool in the model’s order, TASTE’s halos, EVOLVE’s guess before you pick, PATCH’s belief line and which way your taste leans on each module, and which way your taste leans along each of PERFORM’s controls, from the sound in your hands (it leans brighter). Let go and it goes. MODEL in the menu bar does the same held, and a tap on it keeps the view up until you tap it again or press Esc. Reading what it learned says what each mark means.

⌘K: find anything

⌘K (Ctrl K off Apple platforms), or Find or do anything in the menu bar, opens one list of everything the instrument can do and every sound it holds. So does ?, anywhere but over one of PERFORM’s controls, where ? shows what that control does instead.

1. Type part of what you want: a sound’s name, a level, or what to do (taste, octave, download).
2. Choose with ↑ and ↓, and press ↵ to do it, or click it.
3. Esc closes the list and puts the focus back where it was.

It lists, in three groups:

• THIS LEVEL: what the level you’re at does, its pads and buttons: at PERFORM, OFFER, TAKE, PASS, KEEP, BACK, ARRANGE, stage mode and What does BRIGHT do?; at PATCH, ADD MODULE, the camera, the layouts, the locks and NEW PATCH; at EVOLVE, PLAY and PICK for each card and ANOTHER PAIR.
• ANYWHERE: the levels; play the sound you’re playing; save or cut the sound you’re on; the bank’s previous and next; ⌘Z; the model view; the keys bar (the octave, VOL, MIDI, ● REC and every setting in KEYS ⋯); your files (your data); the scope; the warm start again; Reset your taste; Show measurements; booth mode; What are the three banks?; Learn: what a filter does; Record again for each sound kept safe; and links to the films and to this guide’s keys and gestures.
• SOUNDS: the pool, then the presets, each with its face. With nothing typed it shows five; with a query, the eight that match best. Choosing one puts it in your hands at the level you’re at, as a click or Enter on its row in the bank does.

Each command prints its key beside it, where it has one, so the list teaches the keys as you use it, and a setting that is on says on. A name’s start ranks first, then a word’s start, then the letters anywhere, then the letters in order with others between: dyt finds Download your taste.

While the list is open, what you type goes into it: no note plays, no level moves, and ⌘Z takes nothing back. It is drawn from what the page already holds, so it opens and narrows at once: a sound’s face is the one the bank has drawn, or for a preset the one shipped with the app, and a sound whose face it hasn’t got yet keeps an empty place for it.

What to try next

• Play the sound under your hands: PERFORM.
• See what it is made of: PATCH.
• Teach the model what you like: EVOLVE.
• Every key in one place: the keyboard map.

PERFORM: the sound under your hands

PERFORM is for playing a sound. It shows the sound large, in a well, and gives you up to eight controls named for what you hear, chosen from a palette of eighteen, WANDER and four pads, and nothing in it stops to ask you a question.

PATCH shows what a sound is made of, knob by knob. PERFORM is for playing it: you reach for brighter, not for a filter’s cutoff, and the instrument works out which of this patch’s knobs make it brighter. It plays the sound already under your fingers, and the keybed below is the same one every level shares. It is the middle of the levels, where the app opens: zoom out (⌥↑) to TASTE, in (⌥↓) to PATCH, or step beside it (⌥←) to EVOLVE.

Play it

1. Play a key: A to L on your computer keyboard, or tap the keybed.
2. Turn a named control: drag it up or down. Double-click it to go back to the center.
3. Press OFFER (N), then hold PEEK (or hold B) to hear the variant it grew beside your sound, or press TAKE (⇧↵) to make it yours.
4. Once the sound has moved, moved · KEEP · BACK shows by its name. Press KEEP (↵) when you like where you are; BACK (⇧⌫) returns there.
5. Turn WANDER, at the start of the pads, up, and let the sound move on its own.

Until you have done five first steps once, a pill at the bottom left shows them one at a time, with a pip for each, and ticks each off as you do it: the first three above, then zoom out to TASTE (⌥↑, or a pinch on a touch screen), and hold ⌥ (MODEL on a touch screen) to see what the model believes. Its second step names a control that turns on this sound (Turn BRIGHT: drag up or down), never one it can’t reach. On a sound none of the controls reach (every one amber), the pill leaves that step out, pip and all, and asks for it again on a sound one of them turns. When the steps it shows are done, it says what the loop was (That is the loop. Every offer you hear, then take or pass, teaches it what you like.) and goes. It says that only once, so a turn it comes back for later just ticks off. Its × stops it showing. When PERFORM has no other room for a toast (on a small phone, or with the XY pad or HOW IT WORKS filling the well), the pill steps aside while the toast stands in its place, and comes back, × and all, when the toast goes.

What you see

On a phone PERFORM is one screen that stands still: the sound's name and its well on top, then two tabs, controls and under the hood, beside ARRANGE and HOW IT WORKS. Under controls are the controls and the pad row, Wander at its head (its dial and its name); under under the hood the hood's rows, a list that scrolls. A control that turns only one way says so as an arrow and its end's word (→ bright); the sentence is its name for a screen reader and in its tooltip.

On a phone held upright with the keys down, the line over the controls says how many reach the patch, what it is listening to, and to turn an amber one to ask for it. With the keys up, and on a phone on its side, that line goes: each control's own line says what it is listening to, and an amber control is still the one to turn to ask.

On a phone on its side the well is on the left and the controls one row of six on the right; with the keys up the well gives its room to them. Six across, a control's line shows only its one-way arrow; the knobs it turns are under under the hood and in its tooltip. The keys come up with KEYS at the end of the bar along the bottom; held upright, while they are up, a phone shorter than 800 px gives the name and the well's room to the controls (a taller one keeps them), and they come back when the keys go.

On the left, the sound:

• The head. Its family and in hand (BASS · IN HAND; the family only for a sound opened from the library and not edited since: a bred or edited sound has none, so it reads IN HAND), its name, large, with share beside it, and its blurb where it has one. Share opens Download a picture on the sound’s card: its face, its name and its patch in one picture. When the sound has moved from home, moved · KEEP · BACK shows at the end of the first line (see the pads).
• The well. The sound’s face, large, standing on a floor that reflects it, as stage mode draws it. The face is the sound as it was last rendered, so turning a control doesn’t change it; keeping or taking does. While you play, what you hear is drawn over it as stage mode draws it, and fades when the sound stops (while you play it). Click it to play the phrase, as Space does. While B holds an offer, B’s face stands beside it in amber, with BLEND under the two (see Blend, Peek, and B), and each face answers what you hear of its own sound; a click on B’s face plays nothing, since B is heard with PEEK or by holding B. In its corner: XY (see the XY pad) and ⇧F for stage mode; in the top left, a small trace of what is sounding now.

On the right, what you turn:

• CONTROLS, with ARRANGE (see the palette) and HOW IT WORKS (see How it works), then a status line saying what PERFORM is doing with the sound: 4 of 6 controls reach this patch once it is measured; listening… while a sound you haven't played is measured behind controls that already turn, naming the ones still waiting for it (listening to Motion, Body…), with the count once the measurement lands (see a sound you haven't played); listening to this sound… when there is nothing to start it on yet, re-checking while it measures again in the background, or listening to Bite… while it measures a control you just placed. If the engine fails partway, it says so instead: couldn’t measure this patch, or, after the count, couldn’t re-check this patch when the controls still play on their last measurement. After the engine has crashed, PERFORM asks it for nothing more: an offer it would have to grow says the engine crashed: reload to continue (one grown ahead before the crash still comes into B).
• Your controls, three to a row: to start, BRIGHT, SNAP, MOTION, BODY, GRIT, and SPACE (a longer panel takes four to a row). The line under each says what it turns, or what state it’s in; under the model view (hold ⌥), which way your taste leans along it (see which way your taste leans). A small vel on one says your velocity plays it (see what velocity plays).
• UNDER THE HOOD. The patch’s own knobs the controls and Wander are turning right now, each a bar with its value in its own units.
• The pads: WANDER, ringed in amber, then OFFER, PEEK, TAKE and PASS, each with its key. On a window under about 1360 pixels wide, WANDER takes a line of its own above the four.

Show measurements, in ⌘K, adds the numbers behind each control to its tooltip: purity, reach in σ, the measured halves, and the knob gains.

What velocity plays

ARRANGE has a row, Velocity plays: what your playing velocity drives, loudness only or one of the named controls that turns both ways on this sound (bright: soft dark, hard bright), with depth, a slider for how far it reaches, and a note naming the knobs velocity moves. The control it plays carries a small vel in its corner.

Each note sets those knobs at its own velocity when it starts, so a chord can hold a soft dark note beside a hard bright one. While notes are held, PATCH draws the knobs where the last note you struck plays them (see opening the circuit).

The named controls

The panel starts with six:

The name is fixed, and the knobs behind it are not. Each control is wired to at most four of this patch’s knobs: the ones that move the sound most purely in its direction. A full turn moves any one knob at most half its range. Hover a control to see which knobs it moves, how purely, and how far it measured. The knobs are named as PATCH’s rack names them, from the moment a sound opens, with the module beside a name two of them share.

A small amber dot on a control’s outer ring shows where the sound measures on that axis, compared with the sounds in your session. A sound that is already very bright has its BRIGHT dot near the right stop.

A named control is in one of five states, each with its own look:

A sound you haven't played

Measuring a sound takes a render for every knob and a few more for each control, seconds on a fast computer and a minute or more on a slow one, so a sound you haven't played starts on a wiring PERFORM has without rendering: a sound of the same shape that it has measured (the same modules, selectors included: the one a sound was bred from, a preset you changed only by turning its knobs), lending how its controls turn the knobs, or else what each kind of knob usually does to the sound, learned from measuring the presets and sounds like the ones in your pool. That second kind plays only the controls it gets right well more often than not, Bright, Snap and Space among the six today; the others say listening… until the sound is measured, as before. Some sounds still wait for their measurement with every control listening: one none of whose controls PERFORM can start this way; one changed in PATCH by a selector, or by an undo whose render is still on its way; and the sound a graft just changed, until its measurement says whether the graft reached the control (another sound you open meanwhile starts at once). The controls that play turn at once, their travel drawn thin and dim, and their tooltip says not measured yet, while the status line says listening… as the sound's own measurement runs. When it lands the controls settle on what the sound really does, without moving what you hear; a control left turned a way the measurement finds it can't go stops at the center on that side, as a drag into a stop does. A control that turned the wrong way before the measurement landed turns the right way once it settles.

The palette

The six are a start. ARRANGE opens the palette: all eighteen controls the instrument can measure, in six families, with the ones on your panel at the top.

1. Press + on a control to place it on the panel, at the end. Up to eight sit there at once; with eight placed, + waits until you hide one.
2. Press × to hide one. One always stays.
3. Press ↑ or ↓ to move one earlier or later.

The panel is kept with your session, through a reload. Press Esc or × at the top to put the palette away. It is a panel, not a dialog: the keys play while it is open.

Each placed control has a mark to the left of its name: a green dot where it turns this sound, a dashed amber ring where this patch’s knobs can’t reach it (a search control), and a dotted amber ring with listening… while it is being measured. A control that isn’t placed isn’t measured, and has no mark.

A placed control is measured on the sound you’re playing, and only then. Each control on the panel costs about five renders a sound, so nothing off the panel is measured. While it is, the control reads listening… in amber where the line under it goes, and the status line names it (listening to Bite…). The controls beside it keep playing. A set of controls measured on a sound before is kept, so on that sound it plays at once, after a reload too.

Hiding a control you have turned leaves the sound where it is: what it was doing stays in the knobs, and the controls you keep turn on from there. BACK returns to the last sound you kept, from before it; ⌘Z doesn’t, because hiding a control is not an edit of the patch. A mod wheel or pressure held on the control you hide is let go. If velocity was playing it, velocity moves to the first control left that turns both ways, or to loudness only, and a note says which. Reordering costs nothing at all: the same controls are the same measurement.

Turning them

Turning a control changes knob values only. The voices take them without rebuilding the patch, so a held chord keeps sounding through the turn.

The controls re-center without moving the sound. After a KEEP, a TAKE, a fresh measurement, or a Wander glide, what the controls were doing is folded into the patch, and they return to 12 o’clock. The pointer glides home over a quarter of a second, and a faint tick marks where it was. A MIDI knob on a re-centered control keeps working from where it is (see soft takeover).

A measurement never moves a control you are holding. While your hand is on a control or the XY pad, or a control plays its sweep (below), and for a second and a half after you let go or the sweep ends, a measurement that lands waits: the control stays where you put it, and nothing you hear jumps. Then the measurement takes over. A control that was still listening keeps saying so until the measurement is in; then, while your hand is on a control or the XY pad, it says after you let go, and the status line heard: the controls turn after you let go, also on a sound that opened on a guess, whose guessed controls play on meanwhile. With nothing held (you have let go, or turned a control with the keys, or a control is playing its sweep), it says in a moment instead, and the status line heard: the controls turn in a moment. A listening control you held springs back when you let go, and starts turning a second and a half later. Pressing a pad is not a hand on the controls: a sound you open right after plays at once.

Long-press to hear it

A long-press with a mouse plays the control to you, and so does Enter on a control you reached with the keyboard. Over about two and a half seconds it sweeps to the low end, across to the high end, and back to where it was. If no note is held, it plays a C3 for the length of the sweep. On a touch screen a long press opens the control's figure instead (below), and its HEAR IT plays the same sweep. A measurement that lands meanwhile waits until the sweep has ended, as it does for your hand, so it never moves the control under the sweep. Pressing the control stops the sweep and puts the control back where it was, and turning it stops the sweep too. Enter while it plays starts it over. KEEP while it plays keeps the sound where the sweep has it at that moment, and the control re-centers from there, as after any KEEP.

This is the quickest way to learn what a control does on this sound, since the same name moves different knobs on different patches.

Ask what it does

Point at a control and a small ? appears beside it. Press it, or press ? while the pointer is over the control or it has focus, or hold it on a touch screen (a ring fills under your finger, then it opens). An answer opens beside the control: BRIGHT · WHAT IT DOES, a figure, and a sentence.

The figure is the sound in your hands rendered twice, once with the control at its center and once turned, and each render measured the way the model hears it. A turn means where you have the control; at the center, a full turn toward the end it opens to. The render with the control at its center is dashed, the turned one lit. What the figure draws is the measurement the control listens to:

The sentence says the measurement before and after, in its own unit, then what the control turns on this sound: Turned to bright, its center moves from 359 Hz to 2.5 kHz. Here it turns filter cutoff. A control nothing here turns says so, and gives the measurement as it stands. While the two renders are made (about half a second), the figure reads measuring…; one you have asked about before opens at once.

The figure draws itself in, band by band or along time, and holds; MOTION's keeps running while it is open. Click it to draw it again. Under reduced motion it is drawn whole at once.

Every control on the panel is a tap away under the figure, or an arrow key. Turn the control while its answer is open and the answer follows: a moment after your hand rests, it is measured again, and the last figure stays, dimmed, under measuring… until the new one is drawn. A control placed from the palette and asked about before it has been measured says so, and answers once it has. Esc, the ×, a click elsewhere, another level, or booth mode's attract puts it away. HEAR IT plays the long-press sweep. Space still plays the sound while it is open, after a click on one of its buttons too, and ? answers for the control under the pointer, or one you reached with the keyboard; a control you just turned with the mouse, once the pointer has left it, is not asked again, and ? opens ⌘K’s list instead. In ⌘K, What does BRIGHT do? opens BRIGHT’s answer while BRIGHT is on the panel, and Learn: what a filter does opens the lesson below from any level.

Learn: what a filter does

BRIGHT's answer has a LEARN: WHAT A FILTER DOES button, a lesson of about a minute that uses the sound in your hands as its example. It has three steps; Enter or NEXT moves on, and Space plays the step's sound wherever focus is in the lesson (NEXT and DONE take Enter).

1. A sound has a shape. The sound's face, low at the base: wide where it has more than most of your sounds, narrow where it has less (with under four faces in your bank, its spectrum stood up instead). Play it, and a bright line shows what you hear as it plays, against the same bank.

2. A filter lets some through. A lowpass filter from the instrument's own modules is put on the sound, and you drag its cutoff along the graph (or use the arrow keys, and Home and End for its ends). PLAY … THROUGH IT plays the sound, looping, through a lowpass in your browser as soon as you move the cutoff, so you hear it while you drag; its curve is drawn dashed amber and marked not measured yet, a guess at the instrument's filter. Where you leave the cutoff, the sound is rendered with the instrument's own filter, and the render takes over: it fades in over the browser's filter, its measured curve lights the graph in place of the guess, and the shape's top narrows above the cutoff while the unfiltered shape stays dashed behind it. The render is played as loud as the sound itself (every phrase the instrument plays is set to one loudness), so you hear it darken, not fade; through the browser's filter the level is an estimate from the sound's spectrum, about as loud, so it can step a little when the render comes in. The line across the shape marks the cutoff you hold, before its render too. The browser's filter goes after the whole sound, and the instrument's inside it, so the two can differ until the render lands. The cutoff is the knob's value in its own unit on the held note, as PATCH shows a filter's cutoff.

   A sound with no room for one more module (about one pool sound in ten; none of the presets) gets the filter after it instead, at one cutoff for every note, and the lesson says so. If the filtered sound doesn't render at a cutoff (it goes silent, or doesn't pass the vet), the lesson says that too, draws no curve for it, and plays nothing under THROUGH IT; another cutoff may. If the sound itself doesn't render, the lesson says why and has nothing to play.

3. What to remember. What a lowpass does, and what BRIGHT turns on this sound: a filter's cutoff on some sounds, other knobs on others.

The filter is only the lesson's. DONE (or Esc) leaves the sound as it was. The keyboard plays the sound without it.

Half-closed controls

Sometimes a control can only go one way. A sound with no movement at all can’t be made stiller, and the knobs that would try may do something else. On First Bass, turning MOTION down made the sound very slightly more restless: the opposite of its name.

So each half of each control is checked on real renders before it is offered, and a half that didn’t move the sound the way its word says is closed. The ring is solid on the side you can turn toward and dotted on the other, with a stop at the top. The control won’t go past the center on the closed side, and the line under it says which way it turns:

turns toward restless only

That is a statement about the control, not about where the sound sits. The amber dot can sit anywhere.

Amber, dashed: search controls

A control drawn in amber with a dashed ring is a search control: this patch’s knobs can’t make that change. A patch with no drive can’t get rougher by turning a filter, and one with no delay or reverb can’t get much farther away. Over the preset library, GRIT and SPACE are search controls on most sounds for that reason. A search control has no line under it at rest: the line over the controls says turn an amber one to ask for it, once, while one is on the panel.

1. Turn it past the amber notch, three tenths of the way to either end. The line under it reads turn further to ask short of the notch, then let go to ask for rough, or let go to add a tone EQ.
2. Let go. It always springs back to the center.

Let go short of the notch, and it asks nothing. Past it, one of two things happens.

Where one change would give it something to turn, that change is made.

The toast says Bright: giving it a tone EQ to turn…. The change goes onto the sound as one undo step, and the patch is measured again. The control is set to where your hand left it, and the toast then names the knobs it turns. Each control gets this once per sound, never twice.

Otherwise (SNAP, MOTION, GRIT, SPACE turned down, or a change that still didn’t reach it), no knob moves. An offer is grown from the sound, aimed the way you turned, and arrives in B. The toast says so (Grit: no knobs here make it rough, so it’s growing a grittier offer instead.), and B counts the seconds while it grows.

When it arrives, B says how far it went, in amber: grittier by 1.8σ. σ is the spread of the sounds in your session, so by 1σ is about as far as a working control moves the sound at a full turn. When the walk didn’t get there, B says so: not grittier: this walk found no way there. Turn it again to try another.

Which way your taste leans

Hold ⌥ (Alt off Apple platforms), or press and hold MODEL in the menu bar, and each control shows which way your taste leans along it, from the sound in your hands. An amber arc runs from 12 o’clock toward the end it leans to, just outside the ring, and the line under the control says it in the model’s words:

it leans brighter
it leans softer?

The longer the arc, the more the model’s rating of a sound changes as it moves that way: the whole panel is drawn on one scale. Behind it, a thin arc shows how far that could be off. When that thin arc crosses 12 o’clock, the model can’t yet tell which way you lean, so the lean is drawn as a guess: dashed and faint, its words ending in ?, as LEARNING marks one. Before the model has fitted anything there is no lean, and nothing is drawn.

A lean is about your taste, not the knobs. An amber, dashed search control has one too: its knobs can’t move the sound that way, but your taste may still lean there. Let go of ⌥ and the lines under the controls are back. The lean is asked for as the view comes up, and again when the sound in your hands changes (for a sound with AUDIO IN, a new clip of an input it reads too) or the model learns from a pick or fits again. Open a taste file and the leans go until the model has fitted again (at once from a file with picks in it; from one with none, once you have taught it).

How it works

To see what one control does to this sound, ask it. HOW IT WORKS, in CONTROLS’ head, opens in the well over the dimmed face, on the control you last touched, with every control on the panel a tap away; the controls stay in reach beside it. ×, Esc or HOW IT WORKS again puts the face back. For each, it says what you hear it do (A soft attack and few harmonics.), what it listens to, and what it does on this sound, from its measurement: the knobs it turns (On this sound it turns amp attack and filter cutoff.), that nothing here turns it, or that it hasn’t been measured yet. Under that, the rest of this page in short: the amber dot, half-closed controls, search controls, and WANDER.

Opening the circuit

Everything PERFORM does lands on real knobs, and PATCH shows it while it happens. A knob PERFORM is playing away from its kept value carries a second, amber pointer at the value sounding, and its readout shows that value in amber. The green pointer is the kept value. Hover the amber pointer to see what is moving it: a control, a glide, Wander, or velocity for the knobs your last struck note plays, which fold back when the note ends (the sustain pedal or HOLD keeps it).

KEEP writes the amber into the patch, and the two pointers become one. Velocity's part belongs to the note, so KEEP leaves it out. It works the other way too: a knob you turn in PATCH is the kept value from that moment, PERFORM plays from it, and BACK glides home to it.

Click a knob under UNDER THE HOOD to open its module in PATCH, pulsing where it is.

The XY pad

XY, in the well’s corner, puts two named controls under one finger: the well becomes the pad, with the face dimmed behind it, the axis drop-downs along its top and each control’s end words at its edges. XY again, or Esc, puts the face back. It starts as BRIGHT across and MOTION up, and either axis can be any control on the panel.

1. Choose an axis from its drop-down. The note keys play straight away after, so a note letter can’t change the axis.
2. Drag to play both controls at once. Double-click to go back to the center.
3. With the pad focused, use the arrow keys. Hold Shift for fine steps.

The pad follows the controls, so turning BRIGHT on its dial moves the dot too. Only an axis whose control reaches the sound moves. A search control’s end words are struck through, and an axis not measured yet is dimmed, with listening to this sound…. The pad has no “turn to ask” gesture; use the dial for that.

Blend, Peek, and B

An offer is a second sound in a second set of voices that follows the same hands: every note you play is played on both. You hear B by crossfading to it, never by a jump.

B stands in the well beside your sound: its label (B, or B · GRITTIER for an aimed offer), its face in amber, and under its floor what changed, then where it grew from and how to hear it (grown toward your taste · offered · hold B to peek). While an offer grows, B says so where its face will be (growing an offer…). With nothing in B, your sound stands alone.

• BLEND, the slider under the two faces while B holds an offer, sets the mix, from home at the left to B at the right.
• PEEK plays B alone for as long as you hold it, or hold B. Let go, and the mix returns to wherever BLEND is.
• TAKE (⇧↵) makes the offer your sound.

The named controls turn the sound you’re on, not the offer.

What you see is what happened. An offer is grown from the sound you’re playing, so B grows out of the sound’s face into its place. TAKE fills B with green from the bottom, and B goes into the face: it is the sound you play now, heard or not. NEXT folds B back into the face it grew from: it is dropped, nothing joins the pool, and you keep playing what you had. With reduced motion on, nothing moves: B fills for a moment when taken, and empties when passed.

Wander

WANDER sets how alive the sound is on its own. It is one dial with four zones, left to right:

Three short ticks outside the ring mark where ideas, drift, and roam begin. Let go of WANDER in a new zone, and it answers in a second and a half; the zone’s pace sets the moves after that.

The line under WANDER says what it is doing:

• drift · next in 9 s while it waits, with a thin amber arc inside the ring filling toward that move;
• drift · walking… while the walk looks for the next setting;
• drift · gliding while the knobs glide;
• ideas · one in B while B holds an offer;
• paused 3 s while your hands are on other controls;
• frozen while it is frozen;
• nothing better nearby when the walk finds nothing it prefers, and stays.

Wander runs only while PERFORM is on screen. While the sound is running short on a slower computer (Blend, Peek, and B), a walk waits while notes sound, so the line reads walking… longer: it starts a second after your last note, and after eight seconds of playing it goes on a step at a time.

Structure never changes on its own. Drift and roam move knob values only, and they respect the locks you set in PATCH. A new module only ever arrives as an offer in B, and becomes your sound only if you take it.

Hands on, it waits. Touching any other control or pad, or moving one from MIDI, pauses Wander for three and a half seconds, and the line counts them down. A touch mid-glide stops the glide where it is, and the sound stays there. Turning WANDER itself is not a touch: it waits while you turn it, and answers once you let go.

Tap to freeze. A short tap on WANDER stops it where it is: its ring lights, and the line reads frozen. Tap again to release it. With WANDER focused, Enter does the same. Freeze has no key of its own.

The pads

PEEK, TAKE and PASS wait, dashed, until B holds one, and OFFER says so once, then peek, take or pass under its name. Their keys pressed while an offer grows say it is still growing, until it lands, and B held until then plays it as it lands.

Moved · KEEP · BACK. When the sound has left home (a control turned, a drift not kept, a glide under way), moved · KEEP · BACK shows at the end of the head’s first line, in a place it always keeps, so nothing moves when it comes or goes.

With a control you reached with Tab focused, ↵ is that control’s (a button presses, a named control plays its sweep), not KEEP. A turn with the mouse or a finger leaves nothing focused, so ↵ keeps straight after it. With the sound at home, either key says there is nothing to keep or go back to. None of the pad keys act while you type in a field or a dialog is open (the key map).

KEEP changes the sound you’re playing, not the bank. To keep the result as a sound of its own, press KEEP AS NEW in PATCH. Until a sound you opened has arrived, KEEP and TAKE change nothing and say why: Take waits for Acid Line to finish opening. Try again in a moment.

Stage mode

In PERFORM, ⇧F, or ⇧F in the well’s corner, puts the sound you’re playing on the whole screen, for a gig or a stream: the wordmark and the model’s lamp at the top left, × at the top right, its name and family · in hand at the bottom left (the family only where it has one), the keys along the foot, and its face, large, standing on a floor that reflects it, and over the face what you hear, drawn in the face’s own bands against the same bank, with 100 Hz, 1 kHz and 10 kHz marked beside it. The face stands whether or not anything sounds; what you play lights the face’s outline and draws its own outline over it, and fades like phosphor, so nothing moves while nothing sounds.

Everything still plays: the keys, a MIDI keyboard, and Space for the phrase (a tap does the same on a touch screen). ⇧F again, or Esc, or × in the corner leaves, and the keyboard is back where it was. Tab stays on the stage: nothing behind it can be reached until you leave. A refusal said while it is on (Nothing to undo here) shows over the stage, and in its line at the bottom for a few seconds.

In PERFORM, ⇧F takes the place of F’s accent (Shift with a note key plays it harder). F on its own is still a note, and at every other level ⇧F is the accented F it always was.

Nothing opens a dialog

Nothing PERFORM does on its own opens a dialog. A player in the middle of a phrase can’t answer a question, so everything PERFORM needs to tell you arrives as a line: the status line, B’s words in the well, or a toast. Everything it offers you is a pad you can ignore. The dialogs you can open from it are your own choice: ⌘K’s list, stage mode (⇧F) and the lesson on filters, and Esc closes each.

In ⌘K

At PERFORM, ⌘K’s list starts with THIS LEVEL: the pads and the buttons, each with its key. Offer: grow a variant into B (N), Take the offer in B (⇧↵), Pass on the offer in B, and once the sound has moved Keep: make the sound home (↵) and Back: glide back to the last sound you kept (⇧⌫); Freeze Wander, Arrange your controls, How it works, XY pad: two controls under one finger, Stage mode (⇧F), Share this sound as a picture, and What does BRIGHT do? while BRIGHT is on the panel.

Before you have taught it anything

Offers and drift walk toward your taste. Before there is a fitted model there is no taste to walk toward, so they are drawn from the grammar instead. They still only land on sounds that pass the vetting gate. PERFORM says which you’re hearing:

drift · gliding · no taste yet
grown before it has learned your taste

The first is the line under WANDER, the second B’s words in the well. Once the model has been fitted, the first loses · no taste yet, and the second reads grown toward your taste.

What PERFORM teaches the model

An offer you heard and answered is a pick. An offer is the model’s proposal, played against the sound in your hands: the question an EVOLVE pair asks, without stopping the music. Once you have heard B, your answer counts:

Heard means PEEK held, or BLEND past half, for at least a second while notes were sounding. An offer you answer without hearing it teaches nothing, and the toast says so: a take reads Took B. Not counted, because you hadn’t heard it., a pass Skipped B. Not counted, because you hadn’t heard it.

Each answer can be taken back while its toast is up. A take carries DON’T COUNT IT for eight seconds, since taking a sound to hear it in place isn’t always a verdict. A pass carries UNDO for seven, which brings B back and records nothing.

KEEP, BACK, control turns, and Wander are logged with your session, and they don’t teach the model. A KEEP might mean this is the one or hold on a moment, and a turn is a gesture, not a verdict.

MIDI

Plug in a controller and turn its first eight knobs: they take the first eight of PERFORM’s slots, in the order you turn them: the panel’s controls in its order, then BLEND and WANDER. A slot is a place in that order, so after you rearrange the panel the same knob turns whatever is in its place now. Channel pressure brightens, and the mod wheel drives MOTION, wherever they sit on the panel; while one is off it, its source adds nothing. MIDI has the whole map, including learn, endless encoders, and soft takeover.

What to try next

• Turn WANDER into ideas, and let the offers come to you.
• Turn an amber control past its notch, and hear what B grows.
• Hold ⌥, and see which way your taste leans along each control.
• Open the sound in PATCH, and watch the amber pointers move as you play.
• Performance: named controls and the drift walk has the measurements and the math.

PATCH: the patch, opened up

PATCH opens one sound as its whole patch: every module, cable, and knob, in signal order, live while you change it. Use it to hear a sound properly, change it, and aim the next breeding at it.

PATCH is the level zoomed in from PERFORM (⌥↓, or ⌥2): it shows the sound you’re playing as its patch, every knob at its true position, on a rounded canvas: the well. Sound flows left to right, from the sources to the amp, out through OUT into the sound’s face. It runs live the whole time: turn a knob and you hear it on the next note you play.

Open a sound and change it

1. At PATCH, click a row in the bank. It opens here as the sound you’re playing (a row opens its sound at whichever level you’re at).
2. Play it from the keybed. Hold a chord, or run the arpeggiator.
3. Drag a knob, and hear it change.
4. Press KEEP AS NEW in the edit bar to add your edit to the pool as a new sound. The original stays as it was, and the new sound is safe until it has been in a pick (the bank).

You can also open a sound with ↓ PATCH on either side of a pair in EVOLVE, or by clicking a sound on the TASTE map.

The head

The cap: PATCH · BASS. The family shows only where the engine has one: a preset's category, as it was made. A bred or edited sound has none, and a patch started from nothing says PATCH · FROM NOTHING.

The name, at the level's size, (edited) once you have changed it.

The subtitle counts what the rack is made of: 4 modules · 1 modulator, in signal order. Modules are the ones in the audio path (not the amp, not an empty socket); modulators are the ones moving a knob. With another layout it says packed tight or placed by hand. After it come what is happening to the patch: opening Glass Pad…, 2 locked, silent: nothing reaches the output, 1 edit waiting. Near one of the ceilings breeding searches within (24 modules, a depth of 6, a modulation depth of 3) it says that too: one short of it, its number in amber (5/6 depth); at it, the whole count in amber (6/6 depth), since a patch at a ceiling has no room to grow. An edit that would take the patch past one is refused, and the count of the ceiling it would pass shows in red while the refusal is said, however far from it the patch was. Under the model view the subtitle becomes the belief line instead: what the model makes of this sound.

What a generation changed. On a sound a generation bred, as it was bred, the subtitle starts with its seed and how many changes the generation made (from Reese · 3 changes, counted as its bank row lists them), each module the generation changed or added has a silk tick on its top edge, and each knob it moved shows the seed's value as a pale pointer (the same glyph as a knob you have turned shows where it was when you opened the sound). It is the engine's record of that breeding, so it shows at rest. Edit the sound and it goes, since the patch is no longer the one that was bred; undo to as opened brings it back.

What to do next, a small amber line at the head's top right, and pressing it does the step it names:

• Teach it your taste: 6 quick picks ▸ before your first pick, and 3 more picks and it refits ▸ until the first refit, both taking you to EVOLVE. While a pair is dealt here they leave the count to TEACH at the well's foot (TEACH) and say nothing;
• It’s learned something. Breed a generation ▸ once it has;
• Breeding: keep playing ▸ while the first generation breeds (this one does nothing when pressed);
• Generation 3 bred 4 new sounds: they’re at the top of the bank ▸ after one.

On a fresh session it says nothing until you play: playing first is the first steps'.

The acts, on the name's row:

• ⚡ EVOLVE FROM THIS, amber: breeding from this sound alone. Its ▾ holds the locks that prepare it (LOCK KNOBS, LOCK WIRING, CLEAR LOCKS) and, while a ⚡ that can be stopped runs, STOP EVOLVING. See locks, and evolving from here.
• ADD MODULE (/): opens the catalog.
• NEW PATCH: a patch from nothing.
• HOW TO READ THIS: what each mark on the canvas is, over the well's foot.

Under 1400 px wide the acts show their glyphs only (each says its name on hover); ⚡ keeps its words.

The edit bar, on the subtitle's row, once you have edited the sound: 2 changes · KEEP AS NEW · PICK THE EDIT ☐ · UNDO TO AS OPENED. The count is the undo steps since you opened the sound, the number ⌘Z would take back. KEEP AS NEW plays your edit against the original and asks which you'd reach for (keep an edit as a new sound); PICK THE EDIT, ticked first, skips that once. UNDO TO AS OPENED (↺ in a narrower window) takes every change back at once, in one render; its toast's undo, or ⇧⌘Z pressed once per change, brings them back; the toast says so once the sound is back as it was opened, and its undo retires as soon as anything else changes the patch. Pressed when it can't go, it says why: Already as it was opened, Waiting for the last edit to land, Waiting for the sound you opened to arrive (another sound is on its way, and these changes are the sound you are leaving). Past the 60 steps undo keeps it says so and leaves the rest to ⌘Z.

The well

The modules, in signal order, at about the size the patch opens at on a 1440 px screen: each one's name in caps, and on the right of its head the setting that says which kind of it this is (vco · saw, filter · svf lp, lfo · tri), which a click changes. Under every knob its value as set, in its own units, then its name (448 Hz / cutoff); a setting that is not a knob prints its value where the knob would be, over its name and a dotted rule (-1 / oct), and a click changes it too. The amp's head draws its envelope from its four knobs: attack, decay and release each as the share of its knob's travel, sustain as its level; it draws the knobs, not the sound. A modulator is dashed, under the module it moves. The selected module (the one you pressed on, or the keyboard stands on) has its edge and name lit, and its ⋯ (its structure menu) and ▢ (its lock) on its top edge, at the right; the others show them under the pointer. A locked module's edge is solid amber. Under detail: automatic (the default), drawn smaller than its own size (a narrow window, a big patch, the catalog open beside it), each module's name prints larger, so at the fit it never reads smaller than the rest of the app's text, and the values and labels go once they would print smaller than the rack's own type; every knob is still there to turn. Zoomed out further by hand, each module keeps three of its knobs to read; zoom in for the rest. See reading and editing the rack.

OUT and the face. The amp's lead runs to OUT, and past it stands the sound's face: the face of the patch as it stands, measured on its latest render (an edit shows once its render lands), the same face as the sound in hand in the menu bar. It is never an estimate. A click on it plays the standard phrase, as Space does. Pressed while an edit is still on its way, it wears a dotted amber ring and plays once the edit lands; press it again to take that back. Space plays the same phrase from PERFORM and EVOLVE, and waits the same way: ▶ waiting for the edit… stands in for the name in the menu bar until it lands. While you play, what you hear is drawn over the face, and fades when the sound stops (while you play it). Coming to PATCH from another level, the face flies here from where that level drew it (or fades in, from a level that doesn’t draw it). A sound opened from the bank while you’re here flies from its row to the sound in hand in the menu bar, and OUT shows its face once the rack is that patch.

Without this module. Select a module and, over the face at OUT, a dashed outline shows the face of the patch without it: what that module does to the sound, by eye. It is measured, not estimated: the engine renders the patch as the structure menu would leave it (a processor bypassed, a source's socket left empty, a modulator unplugged) and takes its face. It takes a moment (about three seconds after a fresh open on a fast machine), and nothing is drawn until it lands: it waits for work you asked for, the model's guess and cable levels, and PERFORM's measurement of the sound it plays, but goes before the bank's faces and PERFORM's background re-checks. Once measured, the same module on the same patch comes back at once. A knob of that module leaves it as it is (the patch without it is unchanged); any other edit takes it away until the patch is measured again. When the patch would be silent without the module (the only source), the readout says silent without it instead; when it would not pass the safety check, without it, it fails the safety check. The amp and an empty socket have no outline.

The cables. Each green cable curves from one module's output to the next one's input. Into a module you've placed by hand anywhere but clear to the right of the module feeding it, the cable runs backwards, below both in straight lines, on purpose: it says at a glance that it goes back. Each carries light by the level the engine measured on it, and a mark on its middle lights a bar for each third of the meter's range; point at it for the number. A module with two inputs names them beside the cables that arrive (a, b, or carrier and mod). A modulation cable is dashed amber, pulses at its modulator's rate, and says how far and how fast it moves the knob, depth 25% · 0.51 Hz: the module's mod depth and the modulator's rate, as their knobs are set. A module's modulation input nothing is plugged into is drawn faintly under it until you point at the module. Cables and their levels. AUDIO IN modules that read the same input show it as one stream fanning out to each.

The edges. When the patch is wider than the view, each side says how many modules lie past it (‹ 2, 3 ›); a press brings the nearest one in (the amp with OUT and its face, as one). A patch too big for the well at the size its names read (a big patch, a phone) opens at that size showing where it starts, and the rest past the right edge: drag to it, press n ›, or press MAP for the whole patch.

The model's guess, along the well's top once the model has fitted your taste: GUESS · REVERB, then its reason in the model's italic, then how likely it guesses you'd pick the patch with it over the patch as it is:

GUESS · REVERB   it moves toward still, as your picks lean · 67% · leaning

The module itself is drawn dashed amber at its place in the patch: above the cable it would be patched into, over the empty socket it would fill, or under the module whose modulation input it would take, with a dashed lead to that place. It stays in view: with no room above the cable it hangs below the patch, or at the top of the view. Click it (or reach it with the arrows and press Enter) to add it, the same edit the catalog makes, and ⌘Z takes it out. Its × (or Delete) skips it: that kind of module stays away from that place for this patch, and the next guess shows. Undoing a guess you added counts as skipping it. The catalog marks the guessed module with an amber dot beside its name.

Beside the guessed module stand two faces: as it is, the patch's own, and with it, the patch with the guessed module added. The second isn't an estimate: to rank its guesses the engine rendered the patch with each candidate module, and this is that render's face. Until a face arrives its place stays empty; an empty patch has no sound, so it has no as it is. Both describe the patch as it was when the guess was made, so turning a knob takes them away: a knob doesn't change the guess, and the faces come back when the next one is made (after you add, remove or skip a module, or open another sound).

• It ranks by how sure it is the module helps, not by the percentage, so its first guess can be one it isn't sure of. Then the line ends it may not help.
• Before the warm start it has nothing to guess from, and shows nothing.
• With no room left (the patch is at a ceiling), it says no guess: nothing more fits, so a module has to come out first.
• On an empty patch, the percentage is over your pool's average sound, and the line says so.

What goes here? The guess looks at the output. To ask about another place, select a module and choose what goes here? from its ⋯ (or press Q on it): the model ranks the modules that could go after it, on its modulation slot, or in it if the socket is empty (on a modulator, its module's slot), and draws its guess there, saying where (GUESS · DELAY · AFTER THE MIX) with its reason. While it listens, the line says hearing the modules that fit at the mix…. Click it or press Enter to add it, × to skip it (the next for that place shows), and Esc on it, or the ✕ at the end of its line, to go back to the guess for the output, which also comes back after any change to the patch's structure. Asked with Q, the guess takes the keyboard's focus when it lands, unless you have gone into a module's knobs since. Before the warm start it says no guess yet: it needs a few picks first. It renders within the same budget as the guess at the output.

It is worked out again after each change to the patch's structure and after each refit, never per knob turn: it renders the modules that could go at the output, all of them on a render crew where the machine has the cores, or the likeliest eight with none. A guess takes a few seconds, longer the first time: the crew has to start (and right after the warm start, the refit runs first), and the three seconds of rendering it allows itself count from there. How it guesses.

The thing in hand. With a module taken from the catalog, the well's top line is about it instead: its name, in hand, its price (what the model expects it to be worth: it prices what you are adding, not where, the same at every lit socket), ▶ to hear it at the socket under the pointer (with that socket's scope), how many sockets are lit, and what happens at the socket under the pointer (insert after filter). ✕ or Esc puts it down. Adding a module.

The foot. Along the well's bottom:

• The camera, bottom left: FIT, −, +, MAP, and the layout's ▾ (chain, compact, by hand; snap to the grid and reset positions for a layout by hand; the level of detail). See getting around.
• SET ASIDE n, beside it, once anything is set aside: anything you unplug, delete, or bypass lands there instead of vanishing, and stays across a reload. It opens the shelf; drag a module's ● back onto a lit ○ to put it in. The catalog lists them first too. The socket a module left reads empty and makes no sound.
• The readout: the module under the pointer, or the selected one, by name, with its setting and what it does in one sentence. Where PERFORM's named controls turn its knobs, it says which, as PERFORM measured them: for the knob under the pointer (or the one the keyboard is on) BRIGHT and SPACE turn this cutoff, and for the module BRIGHT turns its cutoff and res; SPACE turns its decay. PERFORM measures the sound it plays, so a sound opened here that PERFORM hasn't measured yet says nothing of it. Pointed at in the catalog, a module's longer description opens over the well's bottom edge: its ports, what it arrives set to, and what is heard, and, while you hold ⌥, how your taste leans on it. Where the foot is narrow (beside the catalog, or in a narrow window) its parts stack and it scrolls.
• TEACH · 6 PICKS ▸, bottom right, while a pair is dealt: see TEACH.

The scope is put away until you ask for it: Scope & analyzer… in ⌘K sets it up (waveform or spectrum, where it listens, FFT size, color, corner, size, trigger, and freeze) and brings it into its corner of the well, tracing the output while you play. It steps out of the way of any module it would cover.

The model view in PATCH

Hold ⌥ (Alt off Apple platforms), or press and hold MODEL in the menu bar, and PATCH shows what the model believes about the patch; let go and the canvas is exactly as it was. Tap MODEL to keep it up: that is how it stays on while you work, and it is still up after a reload. A tap again ends it, and so does Esc once nothing nearer is waiting for it: in PATCH a press first walks out one thing (a menu, a module in hand, the guess for a place, the selected module, the catalog), and the view stays. On a touch screen, MODEL's press and hold is the model view (a finger held on a module opens its menu, as before). Nothing here is shown at rest, and every mark is the model's own data:

The belief line, in place of the subtitle's counts, in the model's voice; what is happening to the patch (opening…, 1 edit waiting, 2 locked, a bred sound's seed) stays after it:

it’d like this 79% · fairly sure · was 74% ▲

That is how likely it guesses you’d pick this sound, and a word for how sure that reads. The words come from one scale: a hunch (46–54%), leaning (55–69%, or 31–45%), or fairly sure (70% and over, or 30% and under). was is what it said before your last edit, and the arrow shows only when the printed number moved. While an edit is on its way, the line dims and ends in · rating…: the model rating the edited sound again. When the model has no basis for a guess it says why instead of printing a number: no guess yet: it needs a few picks first, fitting to what you taught it…, or nothing to rate: no source reaches the output (the patch’s only source socket is empty). Near a ceiling the budget stays beside it.

The readout, at the well's foot, with nothing selected: what adds up to that number. The three qualities that count most, each with its part of the model's utility (they add up to it exactly), the style that rates it highest, by name, and the utility itself with its doubt:

THE PATCH   even branches +0.39 · plucked strings +0.18 · mod chaining +0.17
            in your analog sustain style   utility 1.43 ± 0.31

With a module selected (or under the pointer), a note opens above the readout: its family's part of that utility (filtering +0.12 of this patch’s utility), then which way your taste leans on that family, from how many of your sounds. The model counts how many of a family a patch has, not which one is where, so the note is about the family (a filter, an EQ and a vocoder share one), and says so.

Each module's edge is tinted by which way your taste leans on its family: amber toward, red away, stronger where the model is surer. A family it has only a guess about, or too little evidence for, gets no tint, and when no module's family is settled the model says so in the well's top right: no settled lean on anything in this patch yet.

What each kind is worth, in the well's top right: one chip for each family of module the patch holds, with what one more of that family is worth to the model, in the same units as the readout's parts (filtering +0.12). It is a chip per family, never per module: the model counts how many filters a patch has, not which is which, so two filters share one figure (VCOs −0.07 · shared by 2), the same wherever they sit. A figure the model isn't sure of is dashed and says a guess; a family too thin to price gets no chip. It is the price the catalog quotes for a module in your hand.

The edges, the chips and a selected module's note all read one style: the one that rates the patch highest, which the readout names.

The guess's runners-up. Beside the model's guess, the two it ranks next, fainter and smaller, each with its lower bound (2 · DELAY, lower bound +0.03): the guess is ranked by that bound, what it expects the module to add less its doubt, so these are the next two it would show if you skipped. A runner-up for another place in the patch has a faint lead to it. They are only to read: the guess itself is what Enter adds.

Reading what it learned says how to read all of it.

The catalog

ADD MODULE (or / from anywhere in PATCH) opens the catalog over the well's left: its search (grit, vowel), what is set aside, what is in this patch, then every module by group, each with what it does to a signal and its cables. ✕ or Esc closes it. While it is open the patch is fitted beside it. Hold ⌥ (the model view), or press model, to see which way your taste leans on each module: its bar in the list, a line in its description, and in the card that stands beside the catalog while the keyboard walks it. At rest they leave it out. On the canvas the same view tints each module's edge (the model view in PATCH). Wiring and the catalog has the rest.

TEACH

TEACH ▸ at the well's foot opens the same pair EVOLVE deals, over the well, so you can pick without leaving PATCH. Until the first refit it counts the picks still to go (TEACH · 3 PICKS ▸); the head's next step leaves that count to it. ▶ A and ▶ B put each sound under your keys, and then PICK A, PICK B, or ↻ for another pair; ← BACK returns to the sound you were playing. ✕ or Esc folds it.

First steps

The first time, PATCH's own first steps show one at a time in the pill under the well: play it (a key, or the face at OUT; already done if you have played), drag a knob, lock what you love, ⚡ EVOLVE FROM THIS. Each ticks off when you do it; × stops showing PATCH's steps, and PERFORM's still show there (and the other way round).

On a touch screen

On a phone held upright the head is stacked over the well (the name, what the patch is made of, then the acts on one line), and the readout takes its own line over the camera at the well's foot. With the keys up the well is short, and keeps only the rack: the words and the well's foot come back when the keys go. The patch opens at the size its names read, showing where it starts: swipe across the well for the rest. Two fingers on the patch zoom it. On a phone on its side the catalog (ADD MODULE) is the screen's height.

Tap a module to open its settings in a sheet: every knob as a wide slider with − and + steps, every named setting as its choices, AUDIO IN's input line, MONITOR, NEW CLIP and ALLOW INPUT, and CAPTURE's RECORD, each a finger's size. The sound's face stands beside them: as made, measured once you have edited it, measuring… while an edit is on its way. Hold − or + to keep stepping. Close it with ×, a swipe down, a tap outside, or Esc. REMOVE MODULE at its foot deletes the module, as delete in its ⋯ menu does. Every module shows its ⋯ on a touch screen; hold a finger on a module for the same menu, where what goes here? is too. A tap on the rack beside a module's ⋯ or its lock is theirs, as a tap on them is (a tap on the module itself opens its settings), and a tap beside an out ○ picks its cable up; then tap beside a lit ○ to put it in. Press and hold MODEL for the model view while your finger stays down, or tap it to keep it up.

A patch from nothing

NEW PATCH empties the sound you're playing down to its amp envelope: the cap reads PATCH · FROM NOTHING, the name New patch, the subtitle 0 modules · nothing to hear yet, and the well holds one empty socket before ENV / OUT. The catalog opens beside it. Then:

1. Add modules from the catalog, or take the model's guess.
2. Delete any module from its ⋯ menu. A source leaves its socket empty; the toast's undo, or ⌘Z, puts it back.
3. CLEAR empties it again, with an undo.
4. KEEP AS NEW adds it to the pool as a sound of its own, once it makes a sound.

BACK TO the sound's name (or Esc, once nothing else is waiting for it: a selected module, then the catalog) reopens the sound you started from. A new patch with modules in it waits: NEW PATCH from that sound brings it back. ⌘Z past the start, or opening another sound, also ends it.

In ⌘K

At PATCH, ⌘K’s list starts with THIS LEVEL, each with its key where it has one: Add a module (/), How the catalog works (its walkthrough), How to read this patch, ⚡ Evolve from this and the three locks of its ▾ (Lock knobs, Lock wiring, Clear locks), Keep as new and Undo to as opened once you have edited, Undo an edit (⌘Z, one step) and Redo an edit (⇧⌘Z), the camera (Fit the patch ⇧Home, Fit what you’re on ., Actual size ⌘0, Zoom out on the patch ⌘−, Zoom in on the patch ⌘=, Show the minimap), the three layouts, The first module (Home) and The last module, at OUT (End), Set aside: the shelf and Teach it your taste while they show, and New patch (or Clear the patch and Back to the sound you started from, in a new patch).

The three things PATCH is for

Hearing a sound properly

The standard phrase is five seconds and the same for every sound, which is what makes two sounds comparable. It isn’t a performance, though. Play the sound from the keybed: hold a chord, run the arpeggiator. A sound that seems thin on the phrase can be the one you’d reach for under your hands.

Changing it

Drag knobs, click a named setting (or, from the keyboard, press Space or Enter on it) to cycle it, drag cables between jacks, and place modules from the catalog. Your changes stay on the sound you’re playing until you press KEEP AS NEW. That adds the edit to the pool as a new sound, and leaves the original alone. Turning knobs has the details.

Aiming the search

1. Lock the knobs or the wiring you like.
2. Press ⚡ EVOLVE FROM THIS.

Breeding then changes everything except what you locked. See locks.

What to try next

• Rewire it from the catalog.
• Hold ⌥, and see which modules your taste leans toward and what the model makes of the patch.
• Open the sound in PERFORM, and play it with the named controls.

EVOLVE: breeding sounds you’d reach for

EVOLVE is where you teach the model and breed from what it learned. It plays you two sounds, you pick the one you’d reach for, and EVOLVE POOL grows new sounds toward your picks.

EVOLVE is the level beside PERFORM: ⌥← (or ⌥3, or the stop left of PERFORM’s) goes there, and ⌥→ comes back. Zooming from it is measured from PERFORM: ⌥↑ goes to TASTE, ⌥↓ to PATCH.

Pick between two sounds

1. Press 1 and 2 (or ▶ PLAY on each card) to hear A and B. Press again to stop.
2. Click a card’s body to play that sound live on the keys, when the phrase doesn’t tell two sounds apart. Its face flies from the card to the sound in hand in the menu bar.
3. Press ← or → (or PICK A, PICK B) for the one you’d reach for.
4. Press ANOTHER PAIR (N) to deal a new pair without picking. It records nothing.

Both sides play the same five-second phrase: a held C4, a C5 stab, a C4 and E4 together, and a low C3 with a long release. The same phrase is what makes two sounds comparable, and the reference says why each part is there.

A pick counts the moment you make it: TAUGHT in the menu bar and the pips move at once. For seven seconds you can take it back, with ⌘Z (Ctrl Z) or NOT WHAT I MEANT on its toast (Picked Glass Pad over Soft Wash.). After that it goes into the log for good. Nothing replaces the two sounds of a pick in those seven seconds, nor the pair on the table: not a generation, not a preset or a patch file you open. So a pick on a whole pair counts, unless a generation ended in the moment the pair went up (below).

⌘Z in EVOLVE only ever takes back a pick or a cut. With none to take back it says Nothing to undo here. PATCH edits undo in PATCH.

What you see

On a phone the head is the pips and the teaching line (the bar along the bottom names the level, and the line asks the question), the small map runs the screen's width under it, and each card keeps its PLAY and PICK under its name. The level is one screen that stands still, upright or on its side: the two faces take what the words, the map and the foot leave, so PLAY and PICK are always in sight. CIRCUIT and PATCH are a row of their own at the top of each card's well, over the face rather than on it, and the foot reads one line each: ANOTHER PAIR beside EVOLVE POOL, how the pair was dealt, then what each generation did. With the keys up the map and the foot (ANOTHER PAIR, EVOLVE POOL, what each generation did) give their room to the pair, and come back when the keys go.

On a touch screen, swipe a card up to pick it: the card follows your finger, and let go past a third of its height (or swiped up fast) it is picked as its PICK picks it, with the same moment to take it back. Short of that it settles back and nothing is picked; a drag down or sideways leaves the card where it is, and nothing under it scrolls. A long press on a card shows the model view while your finger stays down (as holding ⌥ does).

The head. Pick the one you’d reach for., with the six pips and the teaching line under it (below), and at its right a small TASTE map: every sound in the pool where the map puts it, with A and B ringed where they are on it. Click it to go to TASTE.

The cards. Each card is one sound: its face, large, in a well, then its name, its family and blurb where it has them (a sound opened from the library keeps its preset’s), and ▶ PLAY and PICK A (or PICK B). While its PLAY sounds, what you hear is drawn over its face (while you play it), and the other card’s stays still. While a sound’s audio is on its way, rendering… sweeps across its well and its ▶ PLAY is dimmed; press it anyway and a dotted amber ring says your press was taken, and the phrase plays the moment the audio arrives. In the well’s corner, ⇄ CIRCUIT flips the face to the patch’s modules (and back, ⇄ FACE), and ↓ PATCH opens the sound in PATCH without picking, its face flying from the card to the sound in hand in the menu bar as you go. Hold ⌥ for the model view and each card also shows the style that rates it highest, and the card the model favours says so before you pick: it guesses this · 62% · leaning. The names come from what the sound is, so Round Wash and Gritty Swell mean something.

The teaching line. Under the question, six pips count down to the next refit, and the line says how far it is:

• Play both. Pick the one you’d reach for. before your first pick;
• 3 more picks and it redraws your taste map. on the way;
• ● learning from your last 6 picks… while the refit runs;
• ● it just learned: see what changed ▸ when it lands. The link opens the TASTE map, and the line says so until your next pick.

During a generation or a ⚡ walk the line reads ● it will learn from these 6 when breeding finishes instead, because a refit waits for them.

The forecast. After each pick, the line beside ANOTHER PAIR says what the model guessed before you picked, and how sure it was: it guessed this · 72% · fairly sure, or it guessed the other · 62% · leaning. The words come from one scale: a hunch, leaning, and fairly sure. It is the same guess the model view shows on a card before the pick; if the model refits while the pair is up, the card’s guess is asked again.

How the pair was dealt. Beside ANOTHER PAIR, ◇ random pair · a fair test says that every pair is dealt at random from the pool. The model doesn’t choose what you hear, so every pick is a fair test of its guess. its forecasts in LEARNING are graded on them all.

EVOLVE POOL, at the right under the cards, with WHAT EACH GENERATION DID under it. It’s the next section. Until your picks have taught the model (its first refit), EVOLVE POOL is dashed amber: a generation then breeds from the grammar alone, a guess. It can still be pressed.

Breed a generation

1. Make a few picks first, so the model has something to breed toward.
2. Hover EVOLVE POOL to see what it would do, in the bank: the ten sounds it would breed from get a solid amber rail and SEED, and the sounds it may replace a dashed rail and MAY BE REPLACED. Save any you want to keep.
3. Press EVOLVE POOL. The bank shows POOL, where the children land.
4. Play the new sounds as they land at the top of the bank.

EVOLVE POOL becomes its own progress bar, with STOP beside it. It says each walk as it comes back, and what came of it: WALK 3 OF 10 joined the pool, rated below the pool, already in the pool, came back unchanged, or couldn’t start. The job slot in the menu bar counts the walks with the time left (⚡ breeding 3/10 · about 40 s), at every level. GENERATIONS, at the top of EVOLVE beside its name, counts the generation once its first child lands. Hover EVOLVE POOL while it breeds and the bank marks this generation’s seeds, and WILL BE REPLACED on the sounds its end will replace so far, passing over the pair on the table while it’s up; each child still to come can add one more, so save what you want to keep.

Each child appears the moment it’s bred, at the top of the bank under NEW · GENERATION 1, tagged NEW with a green dot until you hear it, and can be played at once. The line under its name says which seed it grew from and what changed. The ranked rows below it don’t move. While your pointer is over the bank, or you are stepping through it with the arrow keys, the child waits: it lands when the pointer leaves, or after a second of rest, and then the list scrolls so the row under the pointer stays where it is. Where the seed’s row is in view, the child buds out of it, its seed’s rail lit, and moves up into its place in New. A child the pool won’t take buds beside its seed with the reason (rated below the pool) and fades: the engine dropped it. With your system set to reduce motion nothing moves, and the button, the row, and the line under New say the same.

When the generation ends, its toast says what joined and what was replaced, and REPLACED · GENERATION 1 at the foot of the pool lists the replaced sounds by name. It never replaces a sound of the pair on the table, nor of a pick you can still take back. Only if it ends in the moment a new pair goes up can it replace one of that pair’s sounds, and then the pair stays where it is: that card dims, its ▶, ⇄ and ↓ PATCH go off, and its line reads Replaced in the pool. A pick or ANOTHER PAIR deals the next pair. A pick on that pair teaches nothing (the sound is gone, so the engine can't take it), says so, and puts up the next pair. The bank has the marks, and Compare shows a child beside its seed.

A generation takes from under a minute to a few, depending on how many cores your machine has to spare. On a busy four-core machine it takes about two to three and a half minutes. While the sound is running short on a slower computer (Blend, Peek, and B), the walks not yet under way wait while notes sound, and go on a second after the last one. The instrument goes on answering while it breeds. A pick deals its next pair at once, a ▶ plays, a sound opens, and PERFORM measures and grows offers.

STOP ends the generation with the children bred so far. Then, as at any generation’s end, the pool goes back to its size.

When a generation adds nothing

Before the model has been fitted there is nothing to breed toward, and the toast says so: Nothing to breed toward yet. Make a few picks first, then evolve.

A generation can also end with nothing new in the pool. Its toast says why, from each walk’s own outcome:

• Generation 4: every walk came back unchanged.
• Generation 4: 3 were bred, but none rated above the sounds they would replace.
• a count of each, when the walks differ.

Troubleshooting says what to do when it keeps happening.

What each generation did

WHAT EACH GENERATION DID, under EVOLVE POOL, opens EVOLUTION · what each generation did over the foot of the cards (Esc, × or the button again folds it). It lists the three most recent steps, newest first:

gen 1 ⚡ bred from Soft Pad → Warm Drone 2 · release 398 ms → 759 ms, mod depth 25% → 4%,
      filter → delay, +1 more, +mix, +filter, −supersaw · liked −0.48 exploring
gen 0 ✎ your edit from Glass Rain → Glass Rain 2 · cutoff 1.78 kHz → 20 kHz · liked −0.31

• The names are the seed and the child it became, as the bank names them. A seed since replaced keeps the name it had.
• The changes show each knob before → after in its own units (ms, dB, Hz, %). A module that became another reads filter → delay, and one added or removed reads +mix or −supersaw.
• liked is how much more (or, below zero, less) the model guessed you’d like the child than its seed, when the step was made.
• exploring marks a bred step it rated lower: the walk stepping sideways or down. Your picks decide whether it was worth it.
• ✎ your edit marks a sound you kept as new in PATCH. It records everything that made a sound, not only breeding.

The sparkline to the left has one point per step, oldest to newest: amber for a bred step, green for your edit. Each point is the child as the model rated it when the step was made. It’s a record of the steps, not a score of the pool over time.

Before any step, it says so: No generations yet. Make a few picks, then press EVOLVE POOL, or ⚡ on a sound you like. If generations have run and none added a sound, it says that instead (2 generations ran, and none put a new sound in the pool.).

In ⌘K

At EVOLVE, ⌘K’s list starts with THIS LEVEL, each with its key: Play A (1) and Play B (2), Pick A (←) and Pick B (→) while a pair is dealt, Another pair (N), Evolve pool: breed a generation from the seeds it marks, and What each generation did.

What to try next

1. Make picks until the line says ● it just learned. Ten to fifteen is a good first batch.
2. Open TASTE, and see whether a style has separated out.
3. Press EVOLVE POOL, and play the children.
4. When a child is one you’d reach for, open it in PATCH, lock what you like, and press ⚡ evolve from this for variations around it.

TASTE: the sound among all sounds

TASTE is the map of your pool: every sound placed by how it sounds, with an amber glow for how much the model guesses you’d like it. Each pick draws as an arrow, and every glow moves with it.

TASTE only shows; nothing here changes the model. What it has learned in detail (the weights, which way liking rises, how its guesses have scored) is one level up, in LEARNING.

1. Make a few picks in EVOLVE. The glows light once the model first fits: at the sixth pick, or right after the warm start.
2. Go to TASTE: its stop above PERFORM’s, ⌥↑ from PERFORM, or ⌥4 (the levels).
3. Point at a sound to see its card, and click it to open it.

On the way, the face of the sound you’re playing flies to its mark on the map. A sound that isn’t on the map as it is (one you have edited since you opened it) has no mark to fly to, and its face fades as you go.

The line under the title says what the map is drawn from: From 18 picks., or before the first fit, how far away it is (3 more picks and it fits your taste.).

Reading the map

The legend at the top right says which you are looking at: it likes more beside two glows, or still a guess beside a dashed ring.

SOUND and TASTE

The switch at the map’s top left chooses how the sounds are shown. No sound is drawn under it, or under the track along the map’s foot, so every sound can be pointed at, clicked or touched.

• SOUND, the default, shows the sounds as they are. Once the model has fitted, their glows show too; before that, there are none.
• TASTE colors the map by what the model thinks you’d like: every sound is dimmed by how little it is liked, so the ones it guesses you’d reach for stand out. Before the first fit it shows every glow as a dashed ring, a guess.

Holding ⌥ for the model view switches the map to its TASTE side while you hold it (or while MODEL is tapped on), and back to where you left the switch when it goes. While the view is up the switch rests, dimmed, and its tooltip says why. On a touch screen, a long press on the map shows the model view while your finger stays down; a long press on a dot does not open its sound, as a tap does.

Size is the one people miss, and it’s the useful one. A big, dim face is a sound the model has no guess about. A small, bright one is a sound it’s sure you’d reach for. The sizes are spread over this map’s own range of doubt, and before the first fit every face is the same middling size.

The footer says how much a flat picture can hold:

A flat view of 40 sounds: close dots usually sound alike (it shows 31% of how they differ).

That is often a third or less, so read a distance as a hint, not a measurement.

A sound’s card

Point at a sound and its card opens beside it: the sound’s name, how much the model guesses you’d like it (would like: 59% · leaning), ▶ PLAY, which plays its phrase (if it has to be rendered first, a dotted amber ring says it’s on its way), and OPEN, which opens it as the sound you’re playing.

Clicking a sound opens it too. It plays at once, and the green ring moves to it with the click. A sound the app can’t play yet, as it starts, wears a dotted ring until it’s yours.

The card’s percentage is the model’s rating after your last pick. The bank’s rows, under the model view, show the rating from the last refit, so between refits the two can differ.

From the keyboard: Tab to the map, then the arrow keys move to the nearest sound in that direction, Enter opens it, and Esc closes its card. Space plays the sound you’re playing, as it does at every level.

Taste over time

Once there are two moments to move between, a track runs along the map’s foot. Its room is kept from the start, so no sound moves when it appears. Each tick is one moment: amber for a pick (thin and dim before the first fit), a short silk tick below the line for a star or a cut, a faint line where the map was redrawn, a green diamond for a generation, with how many sounds joined (+3), and a bright full-height line where you opened a taste file. The label says which moment the map shows: now · after 26 picks at the right-hand end, counting your picks as the title does; an earlier moment counts the picks the model had taken then.

1. Drag along the track, or click it, to look back. The line under the title reads Looking back., and the map shows the glows and places as the model had them then. Stepping one moment at a time draws that moment’s pick as its arrow (reversed when you step back past it); a jump draws none.
2. With the track focused, ← and → step one moment, and Home and End go to the first and to now.
3. ▶ at the track’s left replays every moment in turn, from the first.

The track shows exactly what the model posted at each moment, because the page keeps each reply as it arrives: the model itself keeps no history of its ratings. The track begins when this session began keeping it, so a session from before this version starts its track at its first load since. It holds the last 200 moments and is saved with your session; a reset clears it.

A pick, drawn as what it teaches

When you pick between two sounds, TASTE draws an arrow from the sound you passed to the sound you picked, and every glow on the map moves at once.

Every glow moves because a pick is not only about the two sounds you heard. The model learns which way your taste leans, along the difference between the two, so its rating of every sound moves with it: the ones that differ the same way rise, and the ones that differ the other way fall.

• When. The arrow appears when the pick reaches the model, as its seven-second undo window closes. Picks you made while TASTE wasn’t showing are drawn in turn when you open it, up to the last six.
• Stars and cuts move the glows without an arrow: they rate one sound, not a direction between two.
• A PERFORM offer you took or passed moves the glows too, but draws no arrow: an offer never joins the pool, so it has no place on the map.

The arrow stays a moment and goes. With reduced motion set on your system it appears whole, stays as long, and goes, and the glows step to their new brightness rather than easing there.

A refit settles everything

Every sixth pick the model fits your taste again from everything it has learned. Then the map is drawn again, and every glow and every place settles to the new one together. The map turns rather than flips: a place you recognize stays near where you left it. Nothing moves under your hand: if your pointer is on the map when the refit lands, the refit waits until you move off it, or rest a second. A generation's new map, or a taste file's, that lands under your pointer, or a refit that lands while a sound's card is up, settles the glows at once, and the places wait the same way; a generation's new sounds appear on the map when the places settle.

In ⌘K

At TASTE, ⌘K’s list starts with THIS LEVEL: Color by taste (it says on while the map is colored by taste) and Replay how your taste moved, the track’s ▶.

What to try next

• Open a big, bright dot: a sound the model guesses you’d like but isn’t sure of.
• Make a pick in EVOLVE, then open TASTE, and watch which way the glows move.
• LEARNING shows what it weighs to make those guesses, and Reading what it learned has the habits that keep you from over-reading it.

LEARNING: how it learns

LEARNING is the model room: what the model weighs, which way liking rises on the map, how its guesses have scored, your taste as JSON, and the math behind all of it.

LEARNING only shows; nothing here changes the model, except a style’s name. It is the level above TASTE, out at the top, for when you want to see inside.

1. Make a few picks in EVOLVE. LEARNING fills in once the model first fits: at the sixth pick, or right after the warm start.
2. Go to LEARNING: its stop at the top of the levels, or ⌥5.
3. Choose a style, read what it weighs, and name it.

The line under the title says what the model was fitted from (From 18 picks.), or how far its first fit is (3 more picks and it fits your taste.).

On a phone LEARNING is one screen that stands still: three tabs under the title show one of its panels at a time, where liking rises (the map, first), what it weighs (a list that scrolls) and its forecasts, with COPY AS JSON and THE MATH under them.

What it weighs

The model hears every sound as 44 numbers: 18 about how it sounds and 26 about how its patch is built. For each style it holds one weight per number, and WHAT IT WEIGHS shows them, largest first.

The styles. A chip for each style that claims at least 2% of the pool, with its share. Click a chip to show its weights; a dot at the chip’s left marks the one shown. Click its name and type to name it, and every place the style appears uses your name; a refit keeps it on the style it named. ▶ plays the sound that style rates highest today, with a dotted amber ring while it is rendered first.

The rows. Each row is one quality: its name (body, grit, drive & fold), the technical name beside it, a bar, and the weight.

• A bar to the right of the center line: it likes more of this. To the left: less.
• The thin line across the bar is how far the weight could be off, one standard deviation each way.
• Solid: that line clears the center. It is sure which way the style leans, however short the bar.
• Hollow, with a ? in the margin: the line crosses the center, so the lean could go either way. Early on nearly every row is hollow.

The bars move with every pick. A pick reweights the model’s draws, and after each one LEARNING asks for the weights under the reweighted draws and moves every bar to them; a refit, a generation or a file you open moves them too. A pick's new weights that land while your pointer is on the bars move only their lengths; the rows take their new order, sliding there, when you move off them or rest a second. A refit that lands then waits whole, the same way.

Point at a weight (or Tab to it) and the small map beside it shades every sound by how much of that quality it has: brighter and larger for more, dimmer for less. The legend names it (dots: grit).

REPLAY (or R) steps the bars through the moments this session kept, one after another, and each bar moves to where that moment left it. The label beside it says which moment: after 21 picks for a pick, refit · after 24 picks for a refit, and likewise a generation, an opened taste file, a star or a cut. A step is credited to what it was. Only a step from one pick to the very next draws where each bar was as a dashed outline and lights the weight the pick moved most; a step across a refit, a generation or a file says that it moved, and a step across moments that weren’t kept (a quick run of picks keeps only the last one’s weights) says what moved since the moment before. It ends on now, and starts from the first moment the session kept, as TASTE’s track does.

On a narrow window the six that weigh most show, and ALL 44 WEIGHTS opens the rest. Before the first fit there are none: none yet: it weighs nothing until it first fits.

Where liking rises

The pool on the map, each sound glowing by how much the model guesses you’d like it, with the sound you’re playing ringed and named. While you play it, its face’s outline lights up on the ring, as loud as it sounds. The arrow is the way liking rises across the map: a summary fit, made by the model, of each sound’s liking on the map’s two axes, and the legend gives that fit’s r², how much of the glow one direction explains (the arrow: liking rises · explains 16%). A low share means your taste doesn’t lie along one line across this picture, which is common: the map is flat, and your styles can pull different ways.

The arrow follows every pick. When a pick moves the ratings, it turns to its new heading, and the old one stays a moment as a dashed line. Before the first fit there is nothing to point along: no direction yet.

Its forecasts

Before every pick between two sounds, the model writes down the chance it gives each side. Then your answer arrives, and the forecast is scored against it.

• The count: how many it guessed right, out of every forecast (14 / 22).
• Under it: what it expected against what it got (expected 64% · was 58%). Expected is the average confidence it had in its own guesses; close to what it got means its confidence is honest.
• The strip: each forecast as the chance it gave the sound you picked, from 0% to 100%. Bright where it guessed right, dim where it guessed the other. The newest drops in as it lands.
• The skill line: calibrating · 4/20 until it has 20 guesses, then how much sharper than a coin flip it has been (13% sharper than chance), on the fair-test picks once there are 20 of them.
• By kind, once there is more than one: dealt pairs, edits you heard, edits you asserted, offers you took or passed, each with its own skill.

Pairs in EVOLVE and PATCH’s strip, KEEP AS NEW’s comparison and PERFORM’s offers are all forecast. Nothing is forecast before the first fit, so the warm start’s picks have none, and after it the panel says none yet: it guesses before each pick from here until your next pick.

Copy as JSON

COPY AS JSON puts your taste’s data on the clipboard, as the engine posted it: what it learned from, the math’s numbers, every style’s weights, every sound’s rating, every forecast, and the calibration. Where the browser won’t let a page write to the clipboard, the JSON appears in a box below to select and copy. Nothing is downloaded; Download your taste, in ⌘K, saves the whole record as a file.

The math

THE MATH opens the model in one line and five sentences, with every number read from the engine:

P(A over B) = σ(u(A) − u(B)), u = max over styles of w · φ

φ is a sound’s 18 audio and 26 structural features, standardized, and w holds one weight for each. A pick moves w along φ(picked) − φ(passed), so every sound’s rating moves at once, not only the two you heard. It holds 500 draws of w. Each pick reweights them, and every 6 picks it fits them again. It is allowed one more style for every 20 things it learns from, up to 5. It rates a sound by the style that likes it most.

“Things it learns from” are what TAUGHT counts: picks, stars and cuts. The reference goes further.

In ⌘K

At LEARNING, ⌘K’s list starts with THIS LEVEL: Replay what it weighs (R), Copy as JSON, and The math (it says open while the math is open).

What to try next

• Name your largest style for what it leans on, then find the name in PATCH’s catalog (point at a module).
• Make six picks, and watch a hollow row turn solid at the refit.
• Copy the JSON and look at a forecast: the chance it gave, and what you picked.

The bank

The bank, on the left of every level, holds your sounds in three tabs. This page is about finding a sound, keeping it, seeing where a bred sound came from, what the model thinks of each, and knowing which sounds a generation may replace.

Each tab carries its count, and its tooltip says what it holds. SAVED’s tooltip also counts your saves (3 of 10 saved), and its count turns amber when every save is used. While the pool is still filling after a start, POOL reads +12 beside its count, the sounds still on their way.

The ? at the end of the find row walks you through the three tabs and what a generation is, starting at the tab you’re on.

On a window under 1000 px wide the bank is not on the left: the button of three lines, at the start of the menu bar, opens it as a sheet over the level (from the left, or on a phone held upright from the bottom). A sound chosen in it opens and the sheet goes; a row's ▶, ★, save and cut leave it up. A tap beside it, Esc, that button again, or on a phone its handle pulled down, puts it away.

Find a sound

Type in Find a sound under the tabs, and the bank keeps only the sounds whose name, family, or description has what you typed: bass, bright, saws. It works in every tab, and what you typed stays as you switch tabs, rate, cut, or rename. While it narrows POOL, the rows stand on their own, without the groups below. Esc clears it.

A preset’s family and description are its own; a pool sound you opened from a preset is found by that preset’s too. Typing in the field plays no notes.

Find and keep a sound

1. Click a row to open it as the sound you’re playing. You stay at the level you’re at, and its face flies from the row at once to where that level shows it (PERFORM’s well, its mark on TASTE’s map), or to the sound in hand in the menu bar (from EVOLVE, and from PATCH, whose rack follows once the sound has opened). The well keeps the face it had until the new one lands; with reduced motion set, the new face is simply there.
2. Point at a row (or put the bank’s cursor on it) and its actions appear on the line under its name (on a touch screen they are always there): ▶ plays the standard phrase without opening it.
3. ★ opens five stars in the actions’ place: press one to rate the sound and teach the model what you think of it. From the keyboard, 1–5 rate the row under the cursor.
4. The save icon (a disk) keeps it: no generation will replace it.
5. × cuts it: it tells the model “not this one” and takes the row out of the pairs.

From the keyboard, [ and ] step through the bank at any level; the keys are below.

Reading a row

• The face, left of the name, is the sound’s face: its spectrum against the rest of the bank, from the sound’s own render. Every row keeps the face’s column, so the name is in the same place before the face arrives, and the bank is wider by the column rather than any name narrower.
• The glyph says where the sound came from: ◇ grown fresh, with no taste in it yet; ⚡ bred toward your taste; ✎ your edit, kept as new; ▤ a hand-made preset.
• NEW, in the glyph’s place, marks a child of the latest generation (every one of them is bred, ⚡). In POOL, those children lead the list under NEW · GENERATION 3 and their count, in the order they were bred, and the rest follow under IN THE POOL, in the order they joined it. A child of ⚡ evolve from this joins the group the same way, since ⚡ counts as a generation of its own. If the generation bred children the pool didn’t keep, a line under the group counts them (2 more were bred and rated below the pool.).
• The green dot after the glyph marks a child you haven’t heard yet. It goes when its phrase plays (its ▶, a pair’s ▶ PLAY, Compare, or Space while it’s the sound you’re playing) or you play a note on it, and it is remembered across a reload until then. Playing an edit of it doesn’t count: that’s another sound.
• The name comes from what the sound is, and it keeps that name as the bank changes around it. Double-click it to rename it. NEW and the dot sit in a column every row keeps left of the name, so the name never moves for them. On a computer’s or a tablet’s screen a name has the row’s width, the first of the row’s two lines. The actions and the stars are on the second, so pointing at the row or opening its stars never covers the name. On a phone the actions you swipe out and the stars share the name’s line and take the room at its end: the name ends where they begin. A name too long for the room it has ends in an ellipsis, and the whole of it is in its tooltip. The words a row carries while you point at EVOLVE POOL (SEED, MAY BE REPLACED) and the model view’s percentage are the exceptions: they stand over the end of the name’s line while they show.
• The line under a bred sound’s name says which seed it grew from and what changed: from Soft Pad · +delay, cutoff 1.2 kHz → 3.4 kHz, the first three changes and then how many more. The modules are counted, so the line says what the patch gained and lost: a module that moved from one place in the patch to another isn’t a change, and a swap (filter → delay) is said only where one module went and another came. Click the line, the row’s EVOLVE mark among its actions, or press c on the row, to compare the sound with its seed.
• The actions, on the line under the name, at the row’s end, when you point at it or the cursor is on it: the EVOLVE mark for a bred sound (compare), ▶, ★, the save icon and ×. Out of sight they can’t be pressed either. Every row keeps that line, so a row is as tall with its actions or its stars showing as without, and none moves when you point at one. On a touch screen every row shows them at rest, on a line under its name, since a tap on the row would open it. On a phone the ▶ is at the row’s end and the others slide out beside it when you swipe the row left; the name keeps the room to their left, and ends in an ellipsis where it doesn’t fit.
  • ▶ plays the standard phrase, and shows ■ while it plays. If it has to be rendered first, a dotted amber ring says it’s on its way.
  • ★ opens the five stars; a rated sound’s ★ is filled. Rating teaches the model.
  • The save icon keeps it, and teaches nothing: Saved Glass Pad. No generation will replace it (3 of 10 saved). The row shows it saved as you press. If every save is used, the row goes back and the toast says so: That would pass your limit of 10 saved sounds. Release one first.
  • × cuts it, which teaches the model “not this one”. The sound is never dealt to you in a pair again; if it was on the cards, a new pair is dealt. The toast, Cut Soft Wash. It won’t be dealt again., carries UNDO for seven seconds (⌘Z, or Ctrl Z, does the same), and nothing is recorded until they’re up.

A cut sound stays in the pool until a generation replaces it. With Show measurements on, a row also shows its id, and its tooltip its signature.

The rows hold still under your hand. While your pointer is over the bank, a finger is on it, or you are stepping through it with the arrow keys, what would move them on its own waits: a generation's child landing, a generation's end, the pool filling, a refit's new order under the model view, ⚡'s child. It lands when the pointer leaves, or after a second of rest, the rows that moved gliding to their places, and the list scrolls so the row under the pointer stays where it was, as far as it can scroll. What you do yourself shows at once: a star leaves the row under the pointer where it is, and a cut takes its row out and the rows below close up. The tabs' counts change at once: they move no row. Pointing at a row, and opening its stars, move none either. Turning a knob redraws no row, so a click on the bank is never lost to one.

What the model thinks of each: hold ⌥

Hold ⌥ (Alt off Apple platforms), or press and hold MODEL in the menu bar, and the bank shows the model view:

• A percentage at each row’s end: the model’s guess, roughly how likely you are to pick this sound in a pair. Its tooltip adds the word for how sure that reads (59% · leaning). Before the model has been fitted it reads ·.
• A bar along the row’s foot draws the same guess. The bright tick is the guess, and the dimmer block around it shows how unsure it is: a narrow block is a sure guess, a wide one an unsure guess. Before the first fit it is hatched: there is no guess yet.
• The pool in the order the model rates it, highest first, under RANKED BY THE MODEL, once it has been fitted. The rows glide to their places, and when you let go they glide back to the order they joined the pool. NEW keeps its children in the order they were bred. A refit's new order waits while your pointer is over the bank, as the rows do.

Let go and the bank is as it was. A tap on MODEL keeps the model view up until you tap it again or press Esc. The row’s actions still come when you point at it. A screen reader hears the guess in every row’s name, at rest too.

On a touch screen, a long press on a row shows the model view while your finger stays down, and opens nothing. A row's actions stay on it at rest, under its name, as before.

Compare a sound beside its seed

Click the line under a bred sound’s name, its EVOLVE mark among the row’s actions, or press c with the bank’s cursor on it. Compare opens beside the bank:

• The figure draws the seed’s phrase as a dashed outline, and the child’s growing out of it into its own. Only the two ends are the engine’s: a walk keeps no record of its steps, so the frames between are the one shape turning into the other, not the walk’s path.
• What changed, every change the walk made, one a line: modules added (+) or removed (−), a module swapped (filter → delay), counted as the row’s line counts them, and knobs in their own units. A walk can change a couple of dozen things, and past about ten lines the list scrolls.
• What the model rated each when it bred them, in its own words: when it bred them, it rated Soft Pad 60% · leaning and Warm Drone 2 52% · a hunch. A child rated well below its seed is marked exploring, as the EVOLUTION marks it.
• ▶ for each, the seed and the child, while both are in the pool. A seed a generation has replaced is only a name (Soft Pad · replaced): its sound was dropped, so there is nothing to play.

Press Esc, ×, or click anywhere else to close it. From the keyboard, Esc hands the keys back to the bank.

Stars are not saves

The two controls do different jobs.

★ teaches. A star rating goes into what the model learns from, and moves its guess about your taste. Rate the sounds you wouldn’t reach for, too: that is information.

save keeps. It lists the sound in SAVED as well as POOL, and no generation replaces it. It records nothing about your taste.

They are kept apart on purpose. The pool replaces the sounds the model rates lowest. If a star decided what stayed, a high rating would become a way to protect a sound, and every protective rating would teach the model a taste you don’t have.

A sound you keep as new is safe until it’s been in a pick

A sound you make in PATCH and keep as new, or open from a patch file, isn’t replaced until it has been in a pick. Until then nothing replaces it, not a generation, not a preset you open, not a ⚡ child, even when the model rates it lowest of all: it hasn’t heard an answer about it yet. These end the wait, with the sound on either side, whatever you picked:

• a pair in EVOLVE (or PATCH’s TEACH) with it in it;
• an offer in PERFORM you heard and answered while playing it, TAKE or NEXT, counted when the answer is (after its window), and only if you had kept the sound before you answered;
• keeping an edit of it as new with an answer: you picked between your edit and it on the WHICH WOULD YOU REACH FOR? card, or ticked PICK THE EDIT;
• a cut: you told the model “not this one”.

The question KEEP AS NEW asks about the sound you’re keeping doesn’t count: that one is about the sound you edited from, and the new sound is safe whatever you answer. SKIP COMPARING on a later edit doesn’t count either, and nor do stars. After its first pick it’s an ordinary pool sound, rated and replaced like any other, so save it if you want to keep it for good.

It isn’t a save. The row carries no mark, it doesn’t count toward your saves, and it isn’t listed in SAVED. A quarter of the pool, 10 of 40, can wait this way at once, not counting any you have also saved: keep an eleventh as new before any of them has been in a pick, and the oldest of them goes back to being an ordinary pool sound (it stays in the pool; it can be replaced again). Saves and these together never take more than half the pool, so there is always room for what a generation breeds.

Which sounds a generation breeds from, and replaces

The pool holds 40 sounds. A generation’s children join it as they are bred, and when the generation ends (or you stop it), it replaces the lowest-rated sounds it can to bring it back to 40: not a saved sound, nor one you kept as new that is still waiting for its first pick (above), nor the pair on EVOLVE’s table or a pick you can still take back. The toast names them: Generation 3: 4 new sounds in the pool. It replaced the 4 lowest-rated sounds it could: Bell Jar, Soft Wash, Glass Rain, and 1 more.

1. Hover EVOLVE POOL in EVOLVE (or move the focus to it). The ten sounds the next generation would breed from get a solid amber rail and SEED; the sounds it may replace get a dashed rail and MAY BE REPLACED. No other sound can be replaced when it ends, but for a sound you kept as new that has its first pick while the generation runs. A saved sound is never marked, and nor is a sound you kept as new that hasn’t been in a pick yet. The pair on EVOLVE’s table can be marked: nothing replaces it while it’s up, but you’ll have put it away long before the generation ends. Up to four more sounds are marked than the generation can replace, because when it ends it passes over the pair up then, and a pick you can still take back, and replaces the next sounds instead. The words sit at the row’s end, on the name’s line, and give way while you point at the row, so no name moves.
2. Save any you want to keep before you press it.

The marks are the engine’s own lists, and they move as your picks move the model’s ratings.

While a generation runs, hovering EVOLVE POOL marks that generation’s seeds, and WILL BE REPLACED on the sounds its end will replace, whether you stop it now or let it finish: none before its first child, then one more with each child it takes in. That isn’t all that can go: each child still to come can add the next lowest-rated sound it can replace. A save still keeps a sound while the generation runs: its mark goes, and the sound that will be replaced in its place is marked instead. The pair on EVOLVE’s table, and a pick you can still take back, are kept the same way, but only while they’re there: once a pair is put away, its marks come back.

While ⚡ evolve from this walks, hovering EVOLVE POOL marks its seed, and MAY BE REPLACED on the one sound its child would replace: the lowest-rated sound it can replace other than its seed, if the pool is full and the child rates high enough to join it.

When a generation ends, REPLACED · GENERATION 3 at the foot of POOL counts what it replaced. Click it for their names. Names are all that’s kept: a replaced sound can’t be played or brought back.

Saves are capped at a quarter of the pool, 10 of 40, so the pool always has room for new sounds. The engine’s own default pool is 48; the app asks for 40, which is why the reference quotes 48.

Presets

Sixty-two hand-made sounds in seven families (bass, lead, keys, pad, texture, perc, and weird), browsed in place under each family’s name and count. A preset’s description is its name’s tooltip. Each row carries the preset’s face, from a render of the preset itself made ahead of time and shipped with the app, so no row waits for a render of its own: each has its face as soon as your bank has faces to draw it against.

1. Open PRESETS.
2. Point at a row and press ▶ to hear it (on a touch screen the ▶ is always there), or click the row to open it as the sound you’re playing.

The engine can only play what it holds, so a preset you hear or open joins the pool and replaces the lowest-rated sound it can. The toast names what it replaced (It replaced the lowest-rated sound it could: Bell Jar.), and saved sounds are never among them, nor is a sound you kept as new that hasn’t been in a pick yet. From then on the row reads IN POOL at its end, on the line under its name, just left of its ▶ whenever the ▶ shows (on a tablet, where the ▶ is on a line of its own, it stays level with the name at the end; on a phone it is level with the name too, left of the ▶, and the name stops short of it), and a second click opens the same copy.

The presets are worth playing through early. They are what the warm start draws from, and they cover the range of modules more evenly than the fresh sounds do.

The bank from the keyboard

The tabs are one tab stop: ← and → (or Home and End) show the next bank as they move. Find a sound and the walkthrough’s ? are the next stops, and the list is a single stop after them. In the list:

In PRESETS, Enter opens the preset under the cursor and p plays it. p is also a note (D♯), but not while the presets list has focus.

The save key is m rather than s because s is a note, and note letters get through even when a control has focus.

A screen reader hears each row’s whole state (name, saved, rating, and the model’s guess), because the row’s buttons sit outside the tab order.

What to try next

• Save the sounds you’d reach for again, before your next generation.
• Rate a few sounds you wouldn’t reach for: low stars teach too.
• Hold ⌥ and see which sounds the model rates highest, and how sure it is of each.
• What the model learns from says how stars, picks, and cuts differ.

A sound’s face

Every sound has a face: a small green shape beside its name, drawn from what the sound actually played. This page is about what a face shows, how to read one, and where you’ll see it.

What a face shows

A face is the sound’s spectrum, stood upright and compared with the rest of your bank.

• Height is pitch. The base is the lows (about 35 Hz), the top the highs (about 14 kHz).
• Width is “more than the bank”. At each height the face is wide where this sound has more there than the sounds in your bank have on average, and narrow where it has less. A sound exactly like the bank’s average is a straight column half as wide as its space.
• The outline is the whole phrase, the standard phrase every sound is played on (a held note, a high stab, a two-note chord, a low note and its tail).
• The faint layers inside are the phrase over time, cut into twelve slices, each as large and as bright as that slice is loud. A slice that is almost silent (a long tail’s end) draws no layer.

The face is drawn from the engine’s own render of the sound, the same render the model measures, so it is a picture of what you’d hear, not a guess.

Reading one

• Wide at the top: brighter than your bank; narrow at the top: darker.
• Wide at the base: more low end than your bank.
• A thin stem below: nothing under the sound’s lowest note. Most pitched sounds have one.
• Wide all the way up: more in every band than the bank’s sounds, which is what noise looks like.
• Layers spread wider than the outline at one height: that part of the phrase carries more there than the phrase does overall.

Two sounds with similar faces have similar spectra. That is not the same as sounding alike: how a sound moves and how its pitch behaves are mostly not in the face.

Where faces appear

• The menu bar, beside the name of the sound you’re playing, at every level: the face of what the keys play. A sound you open flies into it, or into PERFORM’s well, from its row or card, and it shows the new face as that one lands.
• The bank, on every row, in a column left of the row’s two lines. A preset’s face comes with the app, so a preset row never waits for a render of its own.
• EVOLVE, beside each card’s name.
• PATCH, at OUT past the amp (a click on it plays the sound), on A and B in TEACH at the well's foot, in a module's sheet on a touch screen, and beside the model’s guess for the next module: the patch as it is, and the patch with that module, from the render the guess made of it.
• PERFORM, beside the sound in your hands, and beside B once an offer has grown. B grows out of the face, and goes back into it. In stage mode (⇧F) the face fills the screen.
• AUDIO IN, in the square on the module in the rack: the face of your input as it plays, drawn from the last few hundredths of a second, before the patch. It is there only while the input carries a signal. See playing through Auracle.
• The warm start, on each of the nine cards.
• TASTE: each sound on the map is its face, sized by how unsure the model is about it.

A face sits in space its place always keeps, so a name never moves when the face arrives. Where a name could be cut short (the bank, A and B in PATCH's TEACH), the column is wider by the face; EVOLVE’s and PERFORM’s names wrap rather than cut.

An empty space means one of three things:

• The face is on its way. A sound from an earlier session is rendered for it once the bank has finished arriving, after anything else the engine has to do (at the start, that includes PERFORM’s measurement of the sound it opens with). One render serves every place that shows the same sound: its row in the bank and the sound you’re playing. Every preset’s face comes with the app, rendered ahead of time from the preset itself, so a preset doesn’t wait for one.
• The sound doesn’t play. An edit the instrument refuses to play has no render, so it has no face.
• There is nothing to compare with yet. A face is drawn against your bank, and needs at least four sounds there with faces.

When a face changes

A face changes only when something real does:

• its render changes. The header’s face is the sound as it stands, so an edit shows in it once the edit’s render lands. Turning a PERFORM control doesn’t change it: nothing is rendered until you keep or take.
• your bank changes. A face is drawn against the bank, so when sounds are added, replaced or cut, every face is drawn against the bank as it is now. A change too small to move a face by a pixel’s worth isn’t redrawn.

Faces are redrawn in place. Nothing in a face moves on its own.

While you play it

The face of a sound you’re playing answers what you hear. Over the face, what sounds now is drawn in the face’s own bands against the same bank: its outline lights up as loud as the sound is, and the outline of what you hear this moment is drawn over it and fades like phosphor. When the sound stops, it fades and is gone, and the face is as it was.

It happens wherever the face of what you’re playing is, at that face’s own size: PERFORM’s well, the face at OUT in PATCH, the face flying between the levels, the EVOLVE card whose PLAY you pressed, the sound’s mark on TASTE’s map and its ring on LEARNING’s, and the whole screen in stage mode. A small face, like a mark on the map, only brightens its outline.

Each face answers its own sound and nothing else. With an offer in B, PERFORM’s two faces each answer what you hear of their own sound: at BLEND’s home only yours, holding B only B’s, and both between. An EVOLVE card answers its own PLAY, not the other card’s.

With reduced motion set on your system, nothing is drawn over a face: it stays still while you play.

Share a sound as a card

1. Open the sound.
2. Choose Download as a picture… in ⌘K.
3. Set the first box to the sound’s card.
4. Press DOWNLOAD.

The card is the sound’s face, its name, and the line its bank row has: the seed it grew from and what changed, or where it came from (a hand-made preset). At 2× it is 1200 × 630, the size a link preview wants. Like every picture Auracle downloads, the card carries the patch: drop it on Auracle and the sound opens. While the sound’s face is on its way the dialog says so and waits. A sound with no face to draw downloads as a card without one, and the dialog says why: this edit doesn't play, so it has no face, or a face needs at least four sounds to compare with.

The reference has the measurement in full: the bands, the slices, and how a face is compared with the bank.

Reading and editing the rack

The rack in PATCH's well is the patch itself, in signal order. This page is about reading it, getting around it, turning its knobs, keeping an edit as a new sound, and locking what you like before you breed from it.

Reading it

Green is sound. Amber is modulation, and the model’s mind. That holds everywhere in the instrument.

• Modules each have a title, on the right of their head the setting that says which kind of it they are (saw, svf lp; a click changes it), and all their knobs. Under a knob, its value in its own units (840 Hz, 24 ms, −6.0 dB, +12 ¢, 8.23 Hz), never as a fraction of its range, then its name; its travel and value are arcs. A setting that is not a knob (an octave) prints its value in the knob's place, over a dotted rule, and a click changes it. The amp's head draws its envelope from its four knobs as set. The selected module (the one you pressed on, or the keyboard stands on) shows its ⋯ menu and its ▢ lock on its top edge, at the right; any module shows them under the pointer, and every module does on a touch screen.
• Jacks are small rings. Their color is the kind of signal they carry, and only matching kinds connect. A module with two inputs names them beside the jacks, outside the module, by the cables that arrive (a, b; carrier, mod).
• Audio cables are green, curve from one module's output to the next one's input, and run left to right through the signal chain. Place a module by hand anywhere but clear to the right of the module that feeds it, and the cable between them runs backwards, drawn that way on purpose: out of the output, down below both modules, back under them and up into the input, in straight lines with rounded corners. A curve bowed wide enough to go back would balloon with the distance; this run reads the same at any length, and says at a glance that the cable goes backwards. Each carries light by its level: once an edit settles, the engine renders the phrase once more and measures every audio cable, and the brighter the cable, the louder the signal on it. A mark on its middle lights one bar per third of the meter's range (−54 dB to 0 dB re 1 V); point at it for the number, measured at rest: −14 dB. Until a new structure is measured its cables sit dim and its marks hollow, and after a knob turn the marks go hollow until the change is measured. While notes sound, the cables move at the level the live voice measures instead.
• Modulation cables are dashed amber, and each one ends in a named destination under its module: PITCH, THRESHOLD, MORPH, DEPTH (one nothing is plugged into is drawn faintly until you point at the module). A modulation cable pulses at its modulator’s rate, so you can see a 0.2 Hz sweep before you hear it, and it says how far and how fast it moves the knob: depth 25% · 0.51 Hz, the module's mod depth and the modulator's rate as their knobs are set. It is not measured, so it has no level mark and carries no light.
• The last module is always ENV / OUT: the amp envelope. Every patch has one, with a limiter before it that you can’t remove. Its lead runs to OUT, and past OUT stands the sound's face, measured on its latest render; a click on it plays the sound.

The rack is fitted to its well when it opens, no larger than the size a four-module patch opens at on a 1440 px screen, where every name and value reads, and no smaller than the size each module's name reads at, as large as the app's smallest text: a patch too big for the well at that size shows where it starts, and the rest is a pan away (the well's edges count it, and MAP shows all of it). Drawn smaller than its own size (a wide patch, a narrow window, the catalog open beside it), detail: automatic prints each module's name larger, and its setting once the readouts go: it leaves off the values and labels that would print smaller than the rack's own smallest type; every knob is still a control. Zoomed out by hand past where a knob is big enough to grab, it leaves each module three of its knobs to read, not to grab, so a large patch still says what it is until you zoom in. AUDIO IN's and CAPTURE's buttons stay.

Getting around

The camera's controls sit quietly in the well's bottom-left corner: FIT, −, +, MAP, and the layout's ▾.

Zoom runs from 0.30× to 2.50× by hand, and the rack fits its well when it opens (from 0.65×, where a module's name reads at the app's smallest text, up to 1.25×), clear of the well's top line, its foot, and the catalog while it is open. Once you have moved the camera, by hand or with the keys (End, the arrows, .), an edit to a patch that is too big to fit whole leaves it where you put it; another sound opens where it starts.

With the keyboard

Tab into the patch, then:

Inside a module the arrows walk its knobs and buttons, ↑ / ↓ turn a knob, and Esc goes back to the module.

Turning knobs

1. Drag a knob up or down, or focus it and press ↑ and ↓. Hold Shift for fine.
2. Click a named setting (saw, square, −2 oct) to cycle it, or reach it with the keyboard and press Space or Enter (with Shift, it goes back).
3. Press ⌘Z (Ctrl Z) to undo, and ⇧⌘Z to redo.

While you drag, you hear every value the knob passes through. A step sequencer’s bars are knobs too: press one where you want the step and drag (the step sequencer).

A knob always shows the value you last set, and a mark where it was when the sound was kept, once you have turned it. Once you turn it here, PERFORM plays from your value too (opening the circuit).

Keep an edit as a new sound

1. Change the sound.
2. Press KEEP AS NEW.
3. On the card that opens, WHICH WOULD YOU REACH FOR?, play A and B with ▶ PLAY (or 1 and 2).
4. Press THIS ONE under the one you’d reach for (or ← or →).

The card holds your edit and the original in a random order, unlabeled. Either answer teaches the model, and picking the original teaches it most. The receipt names the new sound and says which side was yours: Kept Warm Wash 2 as new: A was your edit, and you picked it. The new sound is named for what it now is, so its name can differ from the original’s, and the original stays in the bank as it was. Nothing replaces the new sound until it has been in a pick after this one (the bank).

Pressed while your last turn of a knob is still on its way to the engine, KEEP AS NEW waits for it, so what is kept is what you hear: the job slot in the menu bar says keeping your edit first…, with the lamp lit, until the edit lands, and then KEEP AS NEW goes on as if you had pressed it then. ⚡ EVOLVE FROM THIS on an edited sound waits the same way, and says the same.

• CANCEL, or Esc, closes the card and keeps nothing. Your edit stays open.
• SKIP COMPARING keeps the edit as new and teaches nothing.
• PICK THE EDIT, ticked before you press KEEP AS NEW, skips the card once: it keeps the edit as new and tells the model you’d pick it, without hearing the two side by side. Then it unticks itself. LEARNING’s forecasts grades the edits you heard and the ones you asserted apart.

⚡ EVOLVE FROM THIS on an edited sound asks the same question before it breeds, and canceling it cancels the breeding too. With nothing changed, KEEP AS NEW stays disabled, and its tooltip says Nothing to keep yet: turn a knob first.

Layout

The layout's ▾, in the well's corner, names the layout you’re in and opens a menu:

snap and reset act only on a layout by hand. Positions are kept for each patch, survive a reload and a ⚡ generation, and travel in a downloaded patch file. If a hand layout has spread past what the frame can show, SNAP lays it out again from the signal chain instead.

Locks, and evolving from here

1. Lock what you like:
   • click a knob’s lock dot (it shows on hover and focus) to lock that knob, or press L on it;
   • select a module and press L, or click its ▢, to lock the whole module; a locked module's edge is solid amber;
   • in ⚡ EVOLVE FROM THIS's ▾, press LOCK KNOBS or LOCK WIRING to lock every knob, or the whole structure.
2. Press ⚡ EVOLVE FROM THIS.
3. Play the child when it lands at the top of the bank.

Breeding then changes everything except what you locked. CLEAR LOCKS, in the same ▾, releases them all.

The button reads ⚡ EVOLVING…, and the job slot in the menu bar shows ⚡ evolving Soft Pad with STOP, which drops the walk and adds nothing; ⚡'s ▾ has STOP EVOLVING too. The rack, the bank, and the pairs go on answering while it walks. When the child lands it becomes the sound you're playing by itself only if nothing has changed under your hands since the press: you're still on the sound ⚡ started from, unedited, you haven't opened another, and nothing is sounding (no notes held or latched by HOLD or the arp, no ▶ phrase playing, no input you're monitoring). Otherwise it waits at the top of the bank, and its toast says why (your edits are still open, Soft Pad is still the sound in hand, what you’re playing goes on) with an OPEN IT button.

⚡ and EVOLVE POOL take turns. While a generation breeds, ⚡ is disabled and its tooltip says why; while ⚡ walks, EVOLVE POOL waits the same way.

The ⋯ menu

The selected module’s ⋯ (or right-click any module, hold a finger on it, or press F2 on it). It opens inside the well, upward when there is no room below, so it never covers the readout at the well's foot. Taller than the well, it is cut to the well's height and its list scrolls:

replace with…, insert…, and modulate hand off to the catalog with the socket already chosen and lit, so there is one list of modules in one place. A modulator’s own ⋯ has three rows: replace with…, what goes here? (the guess for its module's slot) and unplug this modulator.

Anything you bypass or delete is set aside rather than disappearing (SET ASIDE n at the well's foot), and stays there across a reload.

Empty sockets

Unplug a cable, set a module aside, delete a source, or move a source into another socket, and the socket it leaves is empty. It shows as a small dashed module titled empty, it’s listed as empty under IN THIS PATCH, and it’s silent. On one side of a mix, only that side goes quiet.

If the empty socket was the patch’s only source, the whole patch is silent. The subtitle under its name says silent: nothing reaches the output, the face at OUT and KEEP AS NEW wait for a source, and the line above the well says nothing to rate: no source reaches the output.

1. Pick any source in the catalog. The empty socket is the one already chosen.
2. Place it, or press ⌘Z, and you hear the patch again.

The model hears an empty socket too: empty sockets is one of the qualities it weighs.

Downloading a patch

In ⌘K, Download this patch writes a patch file, and Download as a picture… draws the rack as a PNG or SVG, at a size and background you choose. The picture carries the patch inside it: open an Auracle PNG or SVG with Open a patch file…, or drop it on the window, and you get the same sound back.

What to try next

• Lock a module you like and press ⚡ EVOLVE FROM THIS a few times.
• Hold ⌥ (the model view), and see which kinds of module your taste leans toward.
• Wiring and the catalog: add a module, or rewire one.

Wiring and the catalog

PATCH's catalog holds all 45 modules. This page is about adding a module to a patch, rewiring it with cables, and reading what the model makes of each module.

Add a module

1. Press ADD MODULE in PATCH's head (or /). The catalog opens over the well's left.
2. Click a module. It is now in your hand, and the line along the well's top names it, with its price and ▶.
3. Every socket it can go into lights up and says what will happen there: green inserts it after what’s in the socket, and amber replaces it. Point at one and the module is drawn, gray and dashed, where it would go: on the cable when there is room, otherwise just above or below the modules it would cover, with a dashed lead to its place (a source is drawn over the module it replaces).
4. Click a lit ○ to place it. Esc, or ✕ on that line, puts it down.

The line stays one line. Beside the open catalog its price is the figure alone (+0.08 ± 0.18, or a guess and its figure; what it prices, and that it is the same at every socket, is its tooltip), and what happens at the socket and the preview's words are cut short before the price or ▶ are; in a narrow window the preview's trace and the count of lit sockets step out.

To hear a placement before you make it, rest the pointer on a lit ○ for a moment, or press ▶ on the line along the well's top. It renders two seconds of the patch with the module in it, shows them in that line's scope, and places nothing. Once the pointer leaves the socket, the line names the one it means (hear it after the filter) and that socket is ringed, so ▶ plays what the line shows.

Every placement is one undo step, and its toast offers TAKE IT OUT. Dragging a module from the catalog onto a socket works too, and a missed drop says so. The catalog closes with ✕ or Esc (after a module in hand is put down).

From the keyboard

The catalog

The catalog, headed ADD A MODULE, holds 45 modules in ten groups, in the order a signal meets them:

• the sound: SOURCES, SHAPE, FILTER, SPACE, MOTION, DYNAMICS, and COMBINE;
• then the modulators: MODULATION, SHAPE CV (what bends a modulator), and COMBINE CV (two modulators, one cable).

So “what goes after a filter” is a question the order answers.

Above the groups, SET ASIDE lists what you have set aside (to drag back onto a socket), and IN THIS PATCH the modules the patch is made of. Click one to jump to it in the rack.

Each module shows three things at rest:

• a glyph for what it does to a wave;
• the name a synthesist would use;
• its ports: what it takes, and what it gives.

Under the model view (hold ⌥), a fourth: a bar with a whisker, which way your taste leans on this kind of module, and how sure the model is. The model's guess for the next module has an amber dot beside its name.

The bar appears only once the model has been fitted and at least five sounds in the pool use the module or another of its family (a filter, an EQ, and a vocoder are one family to the model); until then it’s a dash. It is solid when the whisker clears zero, and hollow while it crosses it (still a guess), as LEARNING’s weights draw it. “The model barely leans on this” and “the model has never seen this” are different statements, and they don’t look alike.

Searching it

Press / to search. It finds a module by sound as well as by name: grit finds distortion and bitcrush, wander finds sample-and-hold random, and vowel finds the formant oscillator. A search for something Auracle doesn’t have says so, and says why.

The spec card

Point at a module and its description opens over the well's bottom edge, from the readout at its foot; focus it from the keyboard and a card opens beside the catalog:

1. One sentence on what it does to a sound.
2. Its ports.
3. The settings it arrives with.
4. What the model makes of it, under the model view only (hold ⌥, or press model), in one of five states, from Not a coordinate the taste model measures on its own. to you lean toward it. Reading what it learned quotes all five.
5. heard: what the model can and can’t hear of this module. The chorus card says the model hears it as comb filtering, not as width: the model hears left and right summed, so it learns the artifact rather than the effect.

That last line tells you when a taste of yours is real but out of the model’s hearing. Then starring sounds that use the module won’t teach the model what you mean.

Dragging cables

1. Drag from an out jack.
2. Every input it can go into lights up. The module’s own chain is left out, so you can’t make a loop.
3. Drop it on a lit jack. It snaps within a short distance.

Dropping into empty space opens the catalog with that socket already chosen, and a drop that can’t work says why. Clicking the source and then the target works too.

Drop an output onto a socket that already has something in it, and a small menu asks which you mean:

• move it here: the module leaves its old socket (which becomes empty), and what was here is set aside;
• branch here: a copy joins what is here through a mix, and nothing moves. It’s a copy because one output can’t feed two places.

Modulation chains

A modulation input takes a chain, not only one modulator: s&h rand → quantize → slew before it ever reaches a cutoff. The rack draws the whole chain in amber.

• Drop a SHAPE CV module (quantize, slew, rectify, hold) on a cable that already carries a modulator, and it takes that modulator as its input instead of replacing it.
• COMBINE CV takes two modulators and gives back one.
• The socket says which of fill, replace, or shape it’s about to do.
• How deep a modulation can go is bounded, so it can’t be wired to swamp its destination.

Nearly every module has a modulation input with a named destination. Among the sources, vco and supersaw take it as pitch, wavetable as morph, pluck as decay, and formant as vowel. The ones with nowhere sensible to send it go without: noise, whose only setting is a color switch, and mix and ring mod, whose two inputs are both audio.

The step sequencer

steps is the one modulator you draw rather than dial. Under its three knobs (rate, length, and glide) sits a row of eight bars, one per step.

1. Press a bar and drag up or down to set that step, or focus it and use ↑ and ↓ like any other knob.
2. Cable it to a cutoff, a wavefolder, or a wavetable’s morph, and the timbre plays a rhythm of its own.
3. Turn glide up to slide each step into the next; at zero the steps are hard.

The line through the middle is no push: a bar above it pushes the destination up, and a bar below pushes it down. length sets how many of the eight bars play. The ones past it are grayed but kept, and lengthening the pattern brings them back.

Breeding treats every bar as its own knob, so it can change one step without touching the others. Press L on a focused bar to lock that step while the rest evolve.

Two-input modules

Six modules take two inputs, and the difference matters when you wire them:

In the second group the second input is a control signal, not audio, and the rack won’t let you wire it as audio.

SET ASIDE

Anything you unplug, delete, or bypass is set aside, and stays across a reload. SET ASIDE n at the well's foot counts it and opens the shelf; the catalog lists it first too.

1. Drag a wired in jack off its socket to unplug it. The chain is set aside, and the socket it left is empty and silent.
2. Drag its ● back from the shelf (or the catalog) onto a lit ○ to put it in. ✕ discards it.

Which of the catalog's groups are open persists; the catalog itself opens when you ask for it.

What to try next

• Search the catalog for grit, and try each module it finds on the same sound.
• Drop a SHAPE CV module on an amber cable, and hear the modulation change shape.
• Reading what it learned: what the bars in the catalog can and can’t tell you.

Playing it

The sound you’re playing is always live, at every level. This page is about the three ways to play it, the controls on the keybed, the arpeggiator, and recording what you play.

The instrument has four voices. A new note past four takes the oldest one, and a voice whose tail has gone quiet is parked until it’s needed. Every edit you make on the rack changes the running instrument, so a held chord keeps sounding through it.

Three ways in

The keybed on screen

Click or touch a key, and slide across the keys for a glissando. The keybed shows the computer keyboard’s letters on the keys they play.

The computer keyboard

The home row plays the white keys, and the row above it the black keys:

white:  a  s  d  f  g  h  j  k  l  ;  '
black:   w  e     t  y  u     o  p

z and x shift the octave, so that a plays anything from C0 to C7. At the bottom, a plays C0; at the top, ' plays F8, five notes past an 88-key piano’s C8. The keybed on screen stops at C8, so the last few letters sound without a key lighting. The left of the keys bar always shows the note a plays (KEYS Z C4 X octave), and Z and X there are buttons too.

MIDI

Plug in a keyboard and it plays, with velocity, pitch bend, and the sustain pedal. The right end of the keys bar shows the MIDI state (midi ● with a device connected); click it for the mapping panel.

A controller with knobs works too, with nothing to set up. The first eight knobs you turn take the first eight of PERFORM’s controls (its panel, then BLEND and WANDER), in the order you turn them, and the panel’s LEARN remaps any of them. Channel pressure brightens the sound, the mod wheel drives MOTION, and incoming MIDI clock sets the tempo. The mapping is remembered for each device.

The sustain pedal sustains. A note you release while the pedal is down rings until the pedal lifts, and lifting it releases exactly those notes. Notes still under your fingers keep sounding, and a sustained note you strike again belongs to your finger again. The pedal is separate from HOLD, the keybed’s latch in KEYS ⋯.

Web MIDI works in Chrome, Edge, and the other Chromium browsers, and in Firefox, which asks the first time whether to add a site permission for it. Safari has none; there the other two ways in still play. When MIDI isn’t available the keys bar reads midi ?, and the panel says why, with CONNECT MIDI to ask again.

MIDI plays one tab. With Auracle open twice, the tab you used last plays MIDI, and the other reads midi ○. A click anywhere in it takes MIDI back.

Keyboard and MIDI has the whole map, including the bend range, endless encoders, and soft takeover.

The keybed’s controls

Three sit at the right end of the keys bar:

KEYS ⋯ beside them opens the rest. It is lit while HOLD, UNI, ARP or SYNC is on, and its tooltip names which:

KEYS ⋯ stays open while you play through it (the keybed, the octave, HOLD), and folds on a click outside the keys bar or Esc.

The keybed’s width starts at three octaves for a mouse and two for a finger. The narrow sizes center on the computer keyboard’s octave, so what you see matches what your keys play. The height and width persist.

The arpeggiator

1. Press ARP in KEYS ⋯. Its settings show there, under the four buttons.
2. Hold a chord, or latch one with HOLD.
3. Set the pattern and rate against it.

While ARP or SYNC runs, a chip at the head of the keys bar’s cluster says what it is set to (arp 1/8 · 120), and opens the settings again after KEYS ⋯ folds.

The arpeggiator runs inside the audio engine rather than on a page timer, so it doesn’t drift, and it doesn’t stutter when the screen is busy.

SYNC

SYNC puts the patch’s step sequencers on the arpeggiator’s tempo. Each plays the musical division nearest the speed it was bred at: a pattern that ran at 3.7 steps a second becomes eighths at 120 BPM. All of them restart together with the first key you press, on the same beat the arpeggiator starts.

A five-step pattern still cycles against the bar; that’s the point of it. Turning a sequencer’s rate knob with SYNC on moves it between divisions, and the knob reads the rate it plays (2.1 Hz sync). SYNC changes only what you hear: the model still hears every sound free-running.

Recording

1. Press ● REC.
2. Play.
3. Press it again to stop. The WAV downloads.

It records the real output, after the limiter, at the session’s sample rate. This records what you play, not the standard phrase, and it’s the way to capture a sound you like. The five-second phrase is there to make sounds comparable, not to show them off.

Every sound at one loudness

Every sound is normalized to −18 LUFS before you hear it, in its phrase and in what the model measures.

A louder sound reliably wins a comparison, so without that the model would learn “I like loud” and pass it off as a taste in timbre. If a sound seems quieter than you expect, that’s the normalization at work.

If it makes no sound

Check in this order:

1. The pool is still filling. The first pair is dealt at eight sounds.
2. No sound is open. Click a row in the bank.
3. The browser hasn’t allowed audio yet. Browsers need a gesture before they start audio. Click anywhere, or press a key.
4. The sound is muted because it failed its check. A pinned strip says so, and stays until it’s resolved.
5. Voices are stuck. Press ◼.

Troubleshooting has more.

What to try next

• Latch a chord with HOLD, turn ARP on, and set the rate against it.
• Turn SYNC on with a patch that has a step sequencer.
• Play a sound in PERFORM with the named controls.

Playing through Auracle

AUDIO IN brings your own signal into a patch: a microphone, a guitar through an interface, a drum machine’s line out. Patch it into a filter or a delay and play through it, or into a follower and let it move the knobs.

Add AUDIO IN

1. Open a sound in PATCH.
2. Press ADD MODULE and, in the catalog, under SOURCES, click audio in. Every socket it can take lights up.
3. Click a lit socket. AUDIO IN takes it, as any source does.
4. The browser asks for a microphone or an interface. Allow it.

The browser is asked only then: never when Auracle opens, and never when you open a sound that already has AUDIO IN. Once you’ve allowed an input, a sound with AUDIO IN opens it by itself wherever the browser says it remembers your answer (Chrome and Edge do). Otherwise its module shows ALLOW INPUT.

What AUDIO IN hears stays in this browser. Nothing is sent anywhere.

The module

AUDIO IN has three settings and a row under them:

Hear it: MONITOR

Monitoring starts off every time Auracle opens, and it turns off when you open a sound with no AUDIO IN. While it is off, your input moves the level and nothing else, and the keys play the sound with its AUDIO IN silent.

1. Put on headphones. A microphone near your speakers hears the sound it is making and feeds back.
2. Press MONITOR.
3. Play into your input. You don’t need to hold a key: the sound is held open for you.

The sound is held open as if C4 were held, so your input runs through the whole patch, the amp envelope included. It settles at the sustain level, as a held key does. The keys play over it.

Your inputs

The first time you allow an input, the microphone or interface the browser opens is input 1, and each other one it lists gets the next number. The number stays with what you plugged in: a sound saved on input 2 reads the same interface next time, and one you plug in later takes the next free number. There are eight.

To change a module’s input, click its input line and pick one. It is one undo step, like any setting.

One input, one stream. An input is opened once, however many modules read it, and every one of them shows its level.

The keys hear one input. The sound you play takes one input at a time: the first AUDIO IN’s, in the patch’s order. Another AUDIO IN set to a different input shows that input’s level, and its input line says meter only. In the sound, it hears the first one’s input.

Unplugged. If an input goes away, its modules say unplugged and go silent, and a toast says so. Plug it back in and it opens again by itself, and MONITOR picks up where it was.

Refused. If you refuse the browser’s question, AUDIO IN stays in the patch, silent, and its module says input refused. To allow it later, allow the microphone for this site in the browser’s settings, then press ASK AGAIN.

The clip: what the model hears

Your input is never the same twice, so the model can’t rate a sound by what it does to your input live. It hears a sound with AUDIO IN through a clip instead: six seconds of the input it reads, captured the first time that input carries a signal while a sound you’re playing or recording reads it. Until then, the model hears it through a built-in plucked phrase.

• Each input has a clip of its own. A sound that reads two inputs is heard through each one’s clip, and each input is captured the first time you play into it.
• A toast says when a capture starts (Capturing 6 s of …, naming the input), and when the model has the clip.
• The clips are saved with your session, in this browser. A session saved before inputs had clips of their own comes back with its one clip, and the model hears every input through it until that input has its own: each input is still captured the first time you play into it, the input the old clip came from too, and the sounds on it are rated again.
• NEW CLIP captures its module’s input again, even on a module whose input line says meter only. Play what you mean to play through the sound while it runs. Every sound with AUDIO IN on that input in the pool is rated again with the new clip.
• ▶ on a sound with AUDIO IN plays it through its inputs’ clips, as the model hears it. The keys and MONITOR play it with your input, live.

The reference has how the clip is made, stored, and measured.

Play it with your voice: TRACK

track, under DYNAMICS in the catalog, plays a chain from the pitch and the notes of what it listens to: sing, whistle, or play a line into an input, and the chain follows you.

1. Click track, then click a lit socket after the chain you want to play. The chain goes into TRACK’s first socket, and an AUDIO IN into its second (listen). Placing it asks for an input, as AUDIO IN does.
2. Put on headphones and press MONITOR on the AUDIO IN.
3. Sing or play into the input. The chain plays your notes.

There is one input and one pitch in it, so every note a chord plays inside TRACK’s chain is the note you sing. Keys still play over it: each key sounds the tracked note through the rest of the patch, and stops when you let it go.

Record into it: CAPTURE

capture, under SPACE, records what is patched into it, up to four seconds, and plays the take from the keys.

1. Click capture, then click a lit socket after the chain you want to record. Until you record, it is silent.
2. Patch an AUDIO IN into it to record your input, or leave the chain that was there to record that.
3. Press RECORD on the module and play. Press STOP to end it; it stops by itself at four seconds.

Each time you record, RECORD makes a new take. It goes into the sound as an edit: one undo step, and the module says how long it is (take · 2.4 s). PLAY sets how a key plays it: once to its end, while the key is held, or round and round. Recording doesn’t need MONITOR, and it doesn’t interrupt what the keys are playing.

The take is part of that edit, like a knob you turned. To keep the sound with it, press KEEP AS NEW (keeping an edit); until you do, the sound in the bank still holds the take it had. Moving to another sound while RECORD is lit stops it, and that recording is dropped: Recording stopped: you moved to another sound.

Kept safe. If a saved sound’s take can’t be read when Auracle opens, and the take was all it played, the sound is kept out of the pool and listed at the foot of POOL under KEPT SAFE. Press RECORD AGAIN on it and play into the input it reads: it gets a new take and joins the pool again.

Breeding it

A sound with AUDIO IN breeds like any other. ⚡ EVOLVE FROM THIS and a generation walk it through its inputs’ clips, and every child keeps its AUDIO IN on the input you set, while its gain, its channel, and everything around it can change. No generation adds AUDIO IN to a sound by itself: an input is in a sound only because you patched it in. A TRACK or a CAPTURE stays where you put it too, and a CAPTURE keeps its take.

What it doesn’t do yet

• One input for the keys (above). The model hears a sound that reads two inputs through each one’s clip, but the keys play it from the first one’s input.

What to try next

• Put a filter after AUDIO IN, then sweep the cutoff with MONITOR on.
• Patch a follower into that filter’s mod slot: the louder you play, the further it opens.
• Put AUDIO IN in a ducker’s key socket under a pad, or in a vocoder’s voice socket, and let your playing shape a sound the keys play.
• Read the PATCH guide for the rest of the rack.

What the model learns from

The model learns your taste from what you tell it: picks, stars, cuts, and the edits you keep. This page says what each one teaches, when it learns, and what it can’t learn at all.

What teaches it

Everything you tell Auracle goes into one log, and the model learns one thing from all of it: how much you’d like each sound. The kinds of answer differ only in what they say about that.

Picks teach the most. People compare two sounds reliably, and give one sound a number much less reliably, even against themselves an hour later. If you do one thing, pick between pairs.

About stars

A star rating isn’t read as the number three. It’s read as “this sound sits between two points on your scale”, and the model learns where those points are along with everything else. So if you go through a generous phase and then a harsh one, the model can move the points instead of deciding your taste changed.

Rate the sounds you wouldn’t reach for, too. A low star is information.

About cuts

A cut is read against a line the model also learns: how picky you are being today. A session where you cut almost everything reads as a strict session, not as a change in your taste.

A cut is recorded once its seven seconds to take it back have passed; take it back and nothing is recorded. The other half of that answer, a keep, has nothing in the app that records it yet.

What doesn’t teach it

Listening time, replays, downloads, and hovering aren’t recorded as answers. They are cheap to collect and hard to read right: a long listen can mean you love it or that you’re puzzled by it.

Saving a sound teaches nothing. See stars are not saves.

In PERFORM, only an answered offer teaches. KEEP, BACK, and control turns are logged with your session, and the model doesn’t learn from them. See what PERFORM teaches the model.

The warm start

On a first visit you pick three of nine presets, under PICK THE THREE YOU’D REACH FOR. That half minute teaches the model 18 picks: each of your three over each of the six you passed over. From nothing, the model needs hundreds of picks, and those 18 are the difference between a model that has a guess by the end of your first session and one that doesn’t.

The nine are drawn one per family first from the 62 presets, then filled from the rest, so the first half minute spans the range instead of one corner. Only those nine are loaded, which keeps most of the pool free for what breeding finds.

Your three are saved, so no generation replaces them: they take 3 of your 10 saves, and the toast that ends the warm start says so. The first of them opens in PERFORM, ready to play.

1. Open ⌘K.
2. Choose Re-run the three-pick warm start, any time, to teach it 18 more.

When it learns

It learns at two speeds.

After every pick, a little. Each answer is folded in at once, so the model’s next guess, and its guess about the sound you’re playing, answer your last pick. This costs almost nothing.

Every sixth pick, a refit. The model fits again from the whole log: a few seconds of work at most, off the audio thread. This is where it can change its mind, find a new style, or move the points on your star scale.

In EVOLVE, the teaching line counts down to the refit in six pips (3 more picks and it redraws your taste map.). A pick counts from EVOLVE, TEACH in PATCH, or an offer answered in PERFORM. Then:

1. On the sixth pick, the pips fill and the line reads ● learning from your last 6 picks…. The sixth pick keeps its seven seconds to be taken back like any other, and the refit goes out when they’re up, or at once if you pick again first.
2. The amber lamp after the wordmark lights while the refit runs.
3. When it lands, the TASTE map is redrawn, and the line reads ● it just learned: see what changed ▸ until your next pick.

While a generation or a ⚡ walk is breeding, the line reads ● it will learn from these 6 when breeding finishes instead, because the refit waits for it.

Recency

Old answers fade, so your taste is allowed to change. An answer from about 150 answers ago counts half as much as your latest. A model that weighed an answer from three sessions ago the same as one from a minute ago would fight you when your taste moved.

What moves the model most

Roughly in order:

1. Picks between sounds that differ a lot. The most information in one answer.
2. The warm start. Eighteen picks in half a minute. Running it again adds 18 more.
3. Picks it guessed wrong. A surprise moves the model further than a confirmation.
4. Stars, in volume. Each one says less, but they are quick, and they set the scale that picks alone can’t pin down.
5. Edits, kept as new. These carry a lot: a change to the patch, and your verdict on it. Answered on the WHICH WOULD YOU REACH FOR? card, the verdict is heard, and picking the original teaches the most. Ticked as PICK THE EDIT, it is a claim. LEARNING grades the two apart.

What it cannot learn

Worth knowing, so you don’t spend a session teaching something it can’t hear.

The model hears each sound through a fixed set of 44 measurements: 18 of the standard render’s sound, and 26 counts of how the patch is built. If a taste of yours doesn’t show in those, no number of picks will teach it. The clearest case is stereo width. The model hears left and right summed, so it will never learn that you like chorus for its width. The chorus module’s spec card says so on its heard line.

Tastes about playing are mostly out of its hearing too: how a sound answers velocity, or how it behaves in a fast run, because the phrase it hears is fixed and modest. The reference spells out what the phrase does and doesn’t reveal.

What to try next

• Rate a handful of sounds you wouldn’t reach for.
• Keep an edit as new, and pick the original when you prefer it: that teaches the most.
• Reading what it learned says how to read what all this taught it.

Reading what it learned

This page is about telling a real lean in your taste from a bar that happens to point somewhere. It covers the habits that read the model well, and what the app does to keep a guess looking like a guess.

TASTE and LEARNING say what they show. This page is about reading them well.

Five states, and what each means

The app tells five states apart, and never lets two of them look alike. A module’s spec card in PATCH's catalog says them in these words:

The count is of sounds, each once, that use the module or another of its family: a filter, an EQ, and a vocoder are one family to the model, so a filter’s card counts the sounds with any of the three.

A dash is not zero. “The model isn’t sure yet” and “the model has had no chance to form a view” are different statements, and one gray bar can’t say both.

In the catalog, under the model view (hold ⌥), still a guess is a hollow bar whose whisker crosses zero, and a lean it’s sure of is a solid bar. The three silences before them are a dash. LEARNING’s weights draw the same two marks.

Read the whisker, not the bar

This is the one habit worth keeping.

In LEARNING’s weights, every bar has a whisker for how far it could be off. If the whisker crosses the center line, the model hasn’t settled that lean. The bar is a guess that happens to point somewhere, and it will likely point elsewhere after ten more picks. The app draws such a bar hollow, with its whisker at full strength, and marks the row with a ? in the margin. Only a whisker clear of the center line gets a solid bar.

A short bar with a tight whisker is worth more than a long bar with a wide one. The first is a small lean the model is sure of; the second is noise drawn with confidence.

The catalog’s bars follow the same logic, which is why they draw a dash below five sounds that use the module or another of its family. A lean learned from three examples would otherwise look the same as one learned from three hundred.

On the map, size is doubt

On the TASTE map, glow is how much it guesses you’d like a sound, and size is how unsure it is. People read the glow and miss the size.

• Small and bright: it’s sure you’d like it. Play it.
• Big and bright: you might love it. This is where to look.
• Small and dim: it’s sure it isn’t for you.
• Big and dim: it has no guess. Also worth a look, for another reason.

Early in a session every dot is big. That is what a cold start looks like, and it’s why the first generation you breed isn’t very targeted.

Read the footer too (it shows 29% of how they differ). The two axes often hold a third or less of how the sounds differ, so two dots close together usually sound alike, and two far apart are probably different. It’s a flat picture of something with more sides.

Styles are leanings, not genres

A style is one direction your picks lean in. It isn’t a genre or a mood. Its name (analog sustain, driven sweeps) describes what it leans toward in the measurements, not the music.

Two things follow:

• A style claiming almost none of the pool is idle. The model has room for up to five and lets your answers decide how many it uses. Two live styles and three idle ones isn’t a fault: your taste, as these measurements hear it, has two sides.
• You can rename them, and it helps. Click a chip’s name in LEARNING and type. Once a style is called what you’d call it, every place it appears reads at a glance, and the name is kept.

The model view

Hold ⌥ (Alt off Apple platforms) for a moment, at any level, and what the model believes comes up over it; let go and it goes. Press and hold MODEL in the menu bar for the same, or tap it to keep the view up until you tap it again or press Esc with nothing nearer to close: a press closes the nearest thing first (a menu, a panel, PERFORM’s XY, a sound’s card on TASTE’s map, the module you selected in PATCH), and the view goes on the press after. A tapped view is still up after a reload. Its light is lit while the view is up, and a tag under the menu bar says what it is reading from: what it believes, from 18 picks, or still guessing · 4 more picks and it fits before its first fit. A key pressed while you hold ⌥ (a level key such as ⌥↑) is that key, and the view doesn’t come up; in a text field or under a dialog ⌥ is left alone.

It shows only what the engine has:

• The bank: each row’s guess, a percentage and a bar (below), and the pool in the order the model rates it, which the rows glide into and back out of.
• TASTE: the halos, and the map’s TASTE side, as if you had switched the toggle; dashed rings before the first fit, when there is no rating to draw.
• EVOLVE: its guess for the pair on the table before you pick, on the card it favours (it guesses this · 62% · leaning), and each card’s style. The guess is the same one the line after your pick reads, asked again if the model refits before you pick.
• PATCH: the belief line in place of the subtitle (it’d like this 62% · leaning · was 58% ▲), what adds up to it in the readout at the well's foot, what the model makes of the selected module's family, each module's edge tinted by which way your taste leans on its family, a chip per family with what one more is worth, and the guess's two runners-up with their lower bounds (the model view in PATCH).
• PERFORM: which way your taste leans along each control, from the sound in your hands: an amber arc toward the end it leans to, and it leans brighter under the control; dashed, with a ?, while it is still a guess (which way your taste leans). Nothing before the first fit.

The guess on a bank row

Under the model view, each bank row shows the model’s guess. The percentage is roughly how likely you are to pick this sound in a pair. On its own, a sure 80% and an unsure 80% print the same number.

The bar under the row tells them apart. Its bright tick is the same guess, and the dimmer block around it shows the doubt: a narrow block is a sure guess, a wide one an unsure guess. The map’s dot sizes say the same at more length. The row is a way to rank sounds, not a measurement.

Its forecasts, over time

LEARNING’s forecasts say whether the rest deserves belief. A realistic course:

Two shapes are worth recognizing:

• Expected well above was. It is overconfident: when it says 80%, it’s right less often than that. It has usually latched onto a quality that was a coincidence. More picks fix it, especially ones you expect to surprise it.
• Skill stuck near zero after many picks. Either your taste doesn’t show in what the model measures (see what it can’t learn), or your answers vary, which happens: some days you aren’t choosing on one quality.

The number to watch is the skill on fair-test picks, the line that ends the number to trust. Fair-test picks are the pairs dealt at random, which is every pair EVOLVE and PATCH deal you. The overall number also counts comparisons you chose yourself (an edit against its original, a PERFORM offer), and those aren’t a fair sample.

When it’s working

You’ll hear it before the numbers say so:

• More pairs hold two sounds you’d reach for. The pairs are still dealt at random; it’s the pool that has grown toward you.
• Generations bring children you want to keep, not ones you skip.
• The guess above the rack in PATCH names your own reason for liking a sound.
• A style’s name is one you’d have written yourself.

That last one is the real milestone.

What to try next

• Open LEARNING, and count the solid bars. Those are the leans the model is sure of.
• Open a big, bright dot from the map.
• Calibration in the reference has the scoring in full.

Your data

Your sounds and your taste stay in your browser, and they are yours. This page says where they live, how to download them, and how to start over.

Where it lives

Everything is in your browser’s storage (IndexedDB), under the address you opened the app from. There is no account, no server, and nothing to sign in to. The engine is WebAssembly running in your tab: no sound, patch, or pick is sent anywhere.

So:

• A different browser, or a different machine, is a different session.
• The hosted app and a copy you serve yourself are different addresses, so they don’t share a session.
• Clearing the site’s data clears your session. So does a browser cleanup that includes site storage.
• A private window gets a session that ends with the window.

What is kept

It is kept as you play:

AUDIO IN’s input is played and measured in the tab, and only the clips are kept. Monitoring is never kept: it starts off every time.

A session comes back one sound at a time, with the bar counting them. A sound the render workers measured as the app loaded, or that an earlier return measured, is read back rather than rendered again, so a return is usually quick. Your taste comes back as it was, so nothing is fitted while it loads. It is fitted again once, just after it loads and while you play, when what it was learned from came back changed: a session saved by an earlier version, or one whose last visit was too short to stand alone and was merged into the visit before it. A sound that joined while you played (a generation’s, an edit you kept, a patch file you opened) is rendered again on the next return; see Boot is slow, or stalls.

Download and open

Everything here is a command in ⌘K: type a word of it (download, open) and press ↵.

Your taste

1. Choose Download your taste.
2. Keep the file somewhere safe.

The file holds the log of everything you taught it, and the standardizer it was recorded under: both, always, together. What the model learned only means something relative to the scaling that produced it, so a log without its standardizer has lost its units. The log is the source; the model can be fitted again from it.

The job slot in the menu bar says Downloading your taste…, with the lamp lit, from the moment you choose it until the file is ready. Then a toast counts what it holds: Downloaded your taste (auracle-profile.json): 52 picks, 4 stars, and 2 cuts.

To bring it back, or to move a taught model to another machine:

1. Choose Open a taste file…, and pick the file.
2. If you have taught it anything yourself, it asks first: Replace your taste with auracle-profile.json? Your 52 picks, 4 stars, and 2 cuts are replaced by the file’s. Your taste now downloads first, so nothing is lost. Press REPLACE IT.

While the file is read the job slot says Opening auracle-profile.json…, with the lamp lit. Once it’s open, the model fits from the file: Opened that taste file: 52 picks, 4 stars, and 2 cuts. Redrawing your taste map… Until that fit lands there is no guess yet, and TASTE draws every glow as a dashed ring.

A patch

Download this patch writes the sound you’re playing as a patch file. Open a patch file… opens one, and accepts .json, .png, and .svg. You can also drop a file on the window. From the drop until the sound is in the pool the job slot says Opening Glass Pad…, with the lamp lit, by the name the file carries. The sound it opens joins the pool the way a sound you keep as new does, and is just as safe until it has been in a pick (the bank).

A patch as a picture

Download as a picture… draws the rack as a PNG or SVG, at a size and background you choose, or the sound’s card: its face, name and where it came from. The picture carries the patch: open an Auracle PNG and you get the same sound back, so a picture of a rack, or a card, posted in a chat is a patch someone else can play.

Recordings

● REC on the keybed records your playing to a WAV: an ordinary audio file, with nothing Auracle’s in it.

Start over

1. Choose Reset your taste… in ⌘K.
2. Read the question, which has your counts: Reset your taste? Your 52 picks, 4 stars, 2 cuts, and 4 generations are forgotten, with every sound you haven’t saved. Your 3 saved sounds stay. A copy of your taste downloads first.
3. Press DOWNLOAD & RESET to download auracle-profile-before-reset.json and reset, or KEEP IT to leave everything as it was.

A reset is the right move when you have been teaching it something it can’t hear, or want to start a different taste from your saved sounds. It doesn’t clear SAVED: saved sounds are storage, not evidence, and they stay, with their layouts. So do the modules you set aside and the keybed’s settings. Everything else in the pool is replaced by a fresh one, and the warm start runs again. An address with ?seed= in it loses it on the reset, so the fresh pool is a new one (Overrides).

To clear everything, clear the site’s data in your browser.

When the app updates

Auracle is pre-1.0, and the format it saves in may change between versions. Sessions saved by older builds are upgraded when they load. Picks recorded under an older audition phrase keep what they say about how the patch is built. Their old sound measurements are marked as no evidence, rather than mixed with ones they were never comparable with.

Upgrades are code, and code has bugs.

Keyboard and MIDI map

Every key and MIDI message Auracle answers to, in one place. In the app, ⌘K lists every command with its key beside it.

The keys below use the Mac’s ⌘ and ⌥. On Windows and Linux, use Ctrl where you see ⌘ and Alt where you see ⌥: ⌘Z is Ctrl Z and ⌥↑ is Alt ↑, and the app shows them that way there.

The levels

PERFORM, PATCH, EVOLVE, TASTE and LEARNING are levels of one space around the sound you’re playing: TASTE is zoomed out (the sound among all sounds), PATCH zoomed in (what it is made of), LEARNING past TASTE, and EVOLVE beside PERFORM. The levels at the right edge of the stage show where you are, and a click on a stop goes there. The app opens at PERFORM, or at the level you were at last time.

They work with a knob or a list focused. A held ⌥ shows the model view after a moment; a key pressed while it is down (⌥↑, say) is that key instead, and the model view doesn’t come up. In a text field they stay the field’s: on a Mac ⌥← there moves by a word, and on Windows and Linux Alt ← is the browser’s Back, so it can leave the page from a field (elsewhere the app takes it). With a modal dialog up (the warm start, ⌘K’s list, stage mode, a lesson) they do nothing; a panel that leaves the page usable (MIDI, KEYS ⋯, the scope’s settings, Compare) doesn’t stop them. Clicking a stop puts the keyboard in that level. If you reach the levels with Tab, the arrow keys walk them as they are drawn (↑ out, ↓ in, ← to EVOLVE, → back), and Home and End go to their ends.

A move carries the face of the sound you’re playing from where one level draws it to where the next does: PERFORM’s well, the face at OUT in PATCH, its mark on TASTE’s map, its ring on LEARNING’s, and the card in EVOLVE that holds it, if one does. Where a level doesn’t draw it (an edited sound has no mark on the map), the face fades instead of flying, and while the sound is still on its way to you (just opened, or an edit not yet rendered) one level simply fades into the next. With reduced motion set on your system every move is instant.

Notes

The home row plays the white keys, and the row above it the black keys:

black:    w  e     t  y  u     o  p
white:  a  s  d  f  g  h  j  k  l  ;  '

Everywhere

In ⌘K’s list

Everything else you press while it is open goes into its field: no note plays and no level moves. One space says what it lists.

In EVOLVE

PATCH's canvas

PATCH's modules

Tab reaches the patch as a single stop. On a module:

Inside a module:

Elsewhere on the page Space plays the sound, a knob or a module focused included. The menus in PATCH's head and corner (⚡'s ▾, the layout's ▾) walk with ↑ ↓ and close with Esc.

The bank

The bank’s tabs are one stop: ← and → (and Home, End) show the next one as they move. Find a sound is the next stop (Esc clears it, and nothing typed there is a note), then the walkthrough’s ?, and then the list, a single stop:

In PRESETS the cursor keys work the same, Home and End jump to the first and last row, Enter opens the preset, and p plays it.

The catalog

The search finds a module by sound as well as by name: grit, vowel, sidechain, wander.

Gestures

In PERFORM

The pads’ keys, printed on each pad:

None of them acts while you type in a field, while a dialog is open (the warm start, ⌘K’s list, stage mode, a lesson), or with ⌘, Ctrl or ⌥ held. With the sound at home, ↵ and ⇧⌫ say there is nothing to keep or go back to. PASS and freezing WANDER have no key: PASS is a pass without another, and a tap on WANDER freezes it.

A focused control (reach it with Tab):

A run of arrow presses is one turn. An amber search control, or one still listening…, springs back to the center about half a second after the last press. A search control turned past its notch then asks, as letting go of a drag does.

With the mouse: drag up or down, Shift for fine, double-click a named control to center it (BLEND and WANDER ignore a double-click), long-press to hear it, and tap WANDER to freeze it. See PERFORM.

MIDI

Plug in a keyboard and it plays, with nothing to set up. Plug in a controller with knobs, and they work too.

Web MIDI works in Chromium browsers and in Firefox, which asks once whether to add a site permission for it. Safari has none; there the computer keyboard and the keybed on screen still play. When MIDI isn’t available, the keys bar reads midi ?, and the panel says why and offers CONNECT MIDI to ask again.

With Auracle open in more than one tab, MIDI plays the tab you used last. The others read midi ○, and play nothing from MIDI until you click in one.

The MIDI panel

1. Click the MIDI state at the right of the keys bar (midi ● with a device connected).
2. Press LEARN on a row, then move a knob: that knob now drives the row’s control (CC 21 now moves Snap.). Any knob it replaces is unbound.
3. Press CLEAR to unbind a row. It shows only on a row with a knob bound.

The panel lists PERFORM’s first eight controls (the panel’s in its order, then BLEND and WANDER) and what drives each. A row is a place in that order: after you arrange PERFORM’s panel, a row names whatever sits there now. A row with no knob bound says what does drive it: mod wheel on MOTION, pressure on BRIGHT, and · elsewhere. Below the rows: a switch for first knobs you turn claim free controls, the bend range, and the incoming clock’s tempo.

Knobs you turn

With that switch on, the first eight different knobs you move take PERFORM’s controls in the order you move them, in that order: with the six, BRIGHT, SNAP, MOTION, BODY, GRIT, SPACE, BLEND, and WANDER. With seven on the panel, WANDER falls past the eighth, and with eight BLEND does too: MIDI doesn’t reach what falls past. Each is announced (CC 74 now moves Bright, the first free control.). The mod wheel is left out, because it already means something.

Some controllers are never taken, by the switch or by LEARN, because MIDI gives them a meaning of their own:

• bank select (CC 0 and 32);
• data entry and (N)RPN (CC 6, 38, and 96–101);
• the sustain, sostenuto, and soft pedals (CC 64, 66, and 67);
• the channel-mode messages (CC 120–127).

So a keyboard that sets its bend range over RPN can’t take a control that way.

A sound’s controls have to be measured before they turn anything. Moving a mapped knob measures the sound you’re playing if PERFORM hasn’t already, so the knobs work from any level.

Endless encoders

A relative encoder is recognized from what it sends, with nothing to set. An ordinary knob sends only when its value changes, so it rarely sends the same number twice in a row; an encoder sends the same small tick over and over. Once a CC has sent a few values that repeat like that, it is followed relatively, and a toast says so (CC 21 is an endless encoder, so it’s followed relatively.).

Both common encodings are recognized: two’s complement and offset around 64. One tick moves a control 1% of its travel.

When in doubt it treats a CC as an ordinary knob. A knob mistaken for an encoder would be unusable; an encoder mistaken for a knob is only jumpy.

Soft takeover

An ordinary knob does nothing until it passes through the control’s current position. Then it takes over. This is often called pickup.

It matters here more than on most instruments, because the controls move without the knob: you can turn a control with the mouse, the keys, or the XY pad. Without pickup, the first nudge of a knob left at three o’clock would jump a control that is now at nine. So whenever a control is set some other way, the knobs bound to it have to pick it up again.

PERFORM also re-centers its controls, after a KEEP, a TAKE, a fresh measurement, or a Wander glide, without moving the sound. A knob you’re using isn’t let go then: the control’s new center is where the knob is now. The knob’s next movement moves the control from there, scaled so each end of the knob still reaches the same end of the control. Once they agree again, the knob follows.

BLEND is different. When B empties (you pass on an offer, or take it), BLEND returns home, and a knob on BLEND is let go. It does nothing until you bring it back down to home, and then it follows again. Otherwise a knob left near the top would sweep the whole of BLEND in its last few steps, and the next nudge would pour the next offer over the sound you chose.

The mod wheel and channel pressure aren’t picked up, because they don’t set a control’s position. Unless you learn CC 1 onto a control, each adds to the control it drives, on top of wherever it sits. The wheel pushes MOTION toward restless, and pressure pushes BRIGHT toward bright.

At rest they add nothing, so letting go returns the sound to where the control is. They never count as touching the controls, so they don’t pause Wander.

Clock

MIDI clock sets the tempo, which the arpeggiator follows. It needs one full beat of ticks before it reads anything, updates when the tempo moves by more than 0.4 BPM, and stays within 30–300 BPM. A gap of more than a second reads as a stop, not a very slow tempo.

Start is a restart: a running arpeggio begins again from its first note if a chord is held, and with SYNC on the step sequencers go back to their first step. From a Start until a Stop, the clock also pulls the synced sequencers back onto its beat once a beat. Stop silences nothing, and Continue is ignored.

For each device

The mapping, the switch, and the bend range are remembered for each device, or combination of devices, in this browser. Plug the same controller in tomorrow, and its knobs mean what they meant today.

The keys bar

Not bound to keys, but this is where people look for them. At the left, KEYS and the octave (Z and X are buttons too). At the right end:

In KEYS ⋯:

It stays open while you play through it (the keybed, the octave, HOLD), and folds on a click outside the keys bar or Esc.

On a phone held upright the keys bar is out of the way until you ask for it: KEYS, at the end of the bar along the bottom, brings it up over that bar, the octave, the volume, REC (its dot) and KEYS ⋯ on one line (MIDI is a row inside KEYS ⋯ there) and the keybed under them, and KEYS again puts it away. It starts at one octave, a finger wide a key.

On a touch screen

What a key does, a finger does like this:

On a phone held upright a toast is a banner across the screen; swipe it up to put it away (on its side too).

Accessibility

What works from the keyboard, with a screen reader, by touch, and with reduced motion, and where Auracle still falls short. Coverage is uneven, and this page says where.

Keyboard

Everything about the patch can be reached from the keyboard, wiring included.

Each region is one tab stop, and the arrows move inside it. Tabbing through several hundred rack controls would be unusable, so the bank’s list is one stop, the patch is one stop (its modules walked with ← and → in signal order, Enter into one, Esc out), and the catalog is one stop per group. The bank’s three tabs are a tab list, one stop, whose ← and → show the next bank as they move; Find a sound and the walkthrough’s ? are a stop each between the tabs and the list.

The levels. ⌥↑ and ⌥↓ zoom out and in, ⌥← and ⌥→ go to EVOLVE and back, and ⌥1– ⌥5 go straight to a level, from anywhere but a text field or a modal dialog (Alt off Apple platforms; in a text field there, Alt ← is the browser’s Back). The levels at the stage’s right edge are a navigation landmark named Where you are: each stop is a button named for its level and what it is (Taste: the sound among all sounds), with its key in aria-keyshortcuts, and the one you’re at is aria-current="location". Reached with Tab, the arrow keys walk them as they are drawn. Clicking a stop moves focus into its level, so EVOLVE’s ← and → work at once. The menu bar names the level you’re at in a polite live region, so a level key is announced where it went.

The model view. Holding ⌥ (Alt) shows it, under the same rules; MODEL in the menu bar is a button whose Enter or Space keeps it up (aria-pressed, and remembered across a reload), and Esc ends it once nothing nearer takes the press. Its tag, saying what the model believes and from how many picks, is a status, read once as the view comes up. In PATCH, the belief line in the subtitle is a status too, and the readout at the well's foot (a polite live region) reads what the model makes of the selection; each worth chip names its family and figure in its text, and each of the guess's runners-up is an image named for its rank, its module and its lower bound. In PERFORM, each control's lean is its description while the view is up, read with the control (it leans brighter, with a ? while it is a guess).

⌘K. ⌘K (Ctrl K), Find or do anything in the menu bar, or ? away from PERFORM’s controls opens one list of every command, so nothing the app does is only a pointer’s. It is a modal dialog (role="dialog", aria-modal) holding a combobox: the focus stays in it (Tab walks its field and the two links at its foot, the author and the source), the field names the row ↑ and ↓ choose (aria-activedescendant over a listbox of options), ↵ does it, and Esc closes it and gives the focus back where it was (opened with a click on its button, it leaves none, so Space plays after it). Each row’s name is its words and the key that does the same, so the list reads the keys aloud as you walk it. While it is open the keys are its field’s: nothing behind it hears them.

PERFORM. Its pads have keys, printed on each and given in aria-keyshortcuts: n OFFER (NEXT), hold b PEEK, ⇧↵ TAKE, and, once the sound has moved, ↵ KEEP with nothing focused (a dial or BLEND turned with the mouse or a finger lets go of the focus; one reached with Tab keeps it, and its Enter) and ⇧⌫ BACK. They yield to a text field and a modal dialog. Each named control and WANDER is a slider (arrows turn it, Home centers it, Enter on a named control plays its sweep and on WANDER freezes it); WANDER’s value reads frozen while it is, since a slider cannot also be a toggle. BLEND is a native slider under the faces while B holds an offer. XY in the well’s corner is a toggle button (aria-pressed), and HOW IT WORKS a disclosure (aria-expanded); each fills the well, and Esc inside it hands focus back to the button. The moved bar’s KEEP and BACK leave the tab order while the sound is home. The first-steps pill’s step is a status, read once as each new step comes up, and its × is a button named Stop showing these (that level's steps). In PATCH, Home and End walk to the first and last module only from the canvas or with nothing in focus: on VOL, in a menu, in the catalog's rows or under a dialog they keep their own meaning. UNDO TO AS OPENED stays in the tab order when it can't go (aria-disabled), and pressing it says why. The dashed face at OUT for the selected module's absence is said in the readout (Dashed at OUT: the sound without it, measured, or silent without it). Closing the catalog or TEACH with the keyboard puts the focus back on the button that opened it; with the pointer, it lets the focus go, so Space plays.

To place a module without a mouse:

1. Press / (or ADD MODULE) to open the catalog, and Tab to its groups.
2. Press ↑ and ↓ to choose a module.
3. Press Enter to pick it up.
4. Press ↑ and ↓ to walk the sockets it can go into. Each one is announced.
5. Press Enter to place it.

A setting on the rack (a wave, a filter mode) is a button: reached with the keyboard, Space or Enter cycles it, and with Shift it goes back. A click leaves no focus on it, so Space after a click plays the sound you’re playing, as it does with a knob focused. Its name says what it is set to (VCO wave, sin), and each change is read out.

PATCH's modules are announced as you walk them (filter, module 3 of 5); the selected one's name and what it does are in the readout at the well's foot, a live region. Every control in PATCH is a button or a knob a keyboard reaches, the face at OUT included (it plays the sound), and on a touch screen each is 40 px or more: the head's acts, the camera's corner, the menus, and a module's sheet with its lane's buttons.

Focus is always visible when the keyboard moves it, and a dialog returns focus to whatever opened it. A PERFORM control or the XY pad pressed with the mouse or a finger takes the focus without a ring. Keyboard and MIDI has the full map.

Screen readers

• The bank announces its cursor. The list follows it with aria-activedescendant.
• A bank row says its whole state: its name, whether it’s saved, its rating, and the model’s guess (at rest too, though the guess is drawn only under the model view). The row’s buttons sit outside the tab order, so the label carries what they show, and 1–5, m and c reach what they do.
• The bank’s list is named by its tab (Pool, Saved, Presets), and the tabs control it.
• A socket says what will happen when you arrow onto it: whether placing the module there inserts it, replaces what’s there, or shapes it.
• Toasts are read from a live region.
• A lasting condition, such as a sound muted because it failed its check, or an engine that has stopped, goes to a pinned alert that stays until it’s resolved, rather than a toast that might vanish before it’s read.

Touch

Every rack gesture works under a finger on a tablet or a phone: knob drags, cable pulls, locks, and the ⋯ menus.

Two rules make that work. Controls that own a drag claim the gesture before the browser can, which leaves the rack’s frame its own panning. And whatever a mouse finds by hovering (knob lock dots, a bank row’s actions) is shown outright on a touch screen, because on a tablet, hover-to-reveal means never: every bank row shows its actions (and every preset its ▶) at rest, on a line under its name, so a sound can be heard, rated, saved or cut without opening it. On a phone a bank row is a list's row, as a phone's own are: its name and its ▶ at rest, and swiped left it slides out its other actions (★, save, cut) at its end, the name keeping the room to their left and ending in an ellipsis where it doesn’t fit; swipe it back, scroll the list or tap another row and they go. They are still there for a screen reader, a keyboard and a mouse: focus in the row slides them out as a swipe does. MODEL’s press and hold is the model view under a finger, and two fingers spread or pinched on the stage zoom between the levels (two that start on PATCH’s patch move no level); a tap on a stop in the levels does the same. The stage keeps a pinch for the levels, so the browser does not zoom the page there, by a pinch or by a double tap. A pinch still zooms the page over the bank, the menu bar and the keys, and your system’s own zoom works everywhere. Small glyphs get an invisible pad for a finger, only on touch screens, so the desktop is unchanged. A phone prints no keys: the key beside a button and the letters on the keybed are left off, and the keybed keeps each C's octave. A tablet keeps them, since it may have a keyboard.

Two gestures: swipe up to pick, long press to see what the model believes

• Swipe a card up to pick it. In EVOLVE, put a finger on a card's face and swipe up: the card follows. Let go past a third of its height, or swipe up fast, and it is picked exactly as its PICK would pick it, with the same moment to take it back. Let go short of that and it settles back, picking nothing. A drag down or sideways is not the card's, and on a phone nothing under it scrolls either: the level stands still. Under reduced motion the card still follows the finger, and settles back without a slide.
• Long press to see what the model believes. A long press (about half a second, without moving) on an EVOLVE card, a bank row or TASTE's map shows the model view for as long as the finger stays down, as holding ⌥ does on a keyboard. A ring fills under the finger while you press; moving the finger first makes it an ordinary touch. Lift it and the view goes, and the long press opens nothing. With the model view already up (a tap on MODEL keeps it), a long press changes nothing. A bank row's actions stay on the row at rest; a long press does not replace them. On PATCH's rack a long press on a module keeps its own meaning: it opens the module's menu.
• On PERFORM a long press on a control opens its figure (see Explain a control).

Nothing is selected and no callout or magnifier opens under a long press: on a phone no text in the app is selected by a finger, but in a field (a tablet's and a touch laptop's text still selects).

On a phone, a tablet and a narrow window

Every size starts the instrument. On a window under 1000 px wide (a tablet held upright, a narrow desktop window) the bank leaves its column: the button of three lines at the start of the menu bar opens it as a sheet over the stage, and a sound chosen in it, a tap beside it, Esc or that button again puts it away.

On a phone held upright:

• The levels are the bar along the bottom, each stop named under its icon: PERFORM (the sound under your hands) first, then PATCH, TASTE, LEARNING, then EVOLVE beside them. A tap goes there.
• KEYS at the bar's end brings the keys up over it: the octave, the volume, REC (its dot) and KEYS ⋯ on one row, MIDI a row inside KEYS ⋯, and one octave across the screen under them, each key a finger wide (span in KEYS ⋯ shows more). KEYS again puts them away.
• The bank rises from the bottom. Pull its handle down, or tap it, to put it away.
• Each level is one screen and stands still, as an app's view does, with the keys up or down: nothing in it scrolls, and what it is for (PERFORM's controls, EVOLVE's PLAY and PICK, the rack, the maps) is in sight. What says again what the bar says (a level's name over it) is left off, and with the keys up what is for looking at gives its room to what is for the hands: PERFORM's name and well (on a phone under 800 px tall), EVOLVE's map and the row under the pair, until the keys go down. Where a level holds more than one screen, a row of tabs under its head shows one part at a time: PERFORM's controls (with the pads) or under the hood, and LEARNING's where liking rises, what it weighs or its forecasts. A list scrolls, as a phone's own lists do: the bank's, the catalog's, the rows under the hood, and what LEARNING weighs. On a smaller phone, or with larger text, a level that cannot fit scrolls rather than cutting anything off. Nothing scrolls sideways.
• In the levels, the bank and the keys, every button, tab and field is at least 44 px each way, a finger's size. Two things are the exception: what is drawn on the rack at its zoom (a tapped module opens its settings in a sheet), and a bank row's actions and stars, which are 44 px tall and as wide as the row can share among them: down to 39 px for a row's four and 31 px for a bred sound's five on a tablet in its narrowest bank, and 32 px for a phone's five stars, so a name keeps some room. The octave's two keys are arrows (a phone has no Z and X to print).

On a phone on its side, the levels stay at the right edge with the keys' button (a small keybed) under them, and the keys come up from the bottom. Each level is one screen there too, LEARNING's map beside what it weighs and its forecasts. On any touch screen the levels' stops are a finger's size.

A toast keeps clear of every control and each level's heading, at every size but one: PERFORM with the keys up on a small phone (below). It stands nearest the stage's bottom right, in free space or over the level's picture (PERFORM's well, an EVOLVE card's, the rack, TASTE's map), and higher up the level when nothing lower is free. On a phone held upright it is a banner as wide as its words up to the screen's: one or two lines with its action beside them, one at a time, in the free band of the level nearest its foot (on PERFORM inside the well, over its floor under the sound's face; on EVOLVE under the cards' corners, away from the thumb that swipes a card up). Over PATCH's rack, when the patch is wider than the well, it is narrowed to stand beside the edges (n ›, ‹ n) rather than across them. On a phone on its side it stands where it is free, as on a wider screen. Where PERFORM has no other room (on a small phone, or with the XY pad or HOW IT WORKS filling the well), the first-steps pill steps aside while the toast stands in its place: unseen, its × out of reach until the toast goes, its step still read as it comes up. On a phone the banner then keeps to one row if two would not fit, its words beside its action. With the keys up on a small phone PERFORM has no room left even so, and a toast stands over the foot of its knobs for its moment, their middles still free to turn. Swipe it up to put it away (taking it back is its action's, as before).

Hit targets

Hit areas are measured, not eyeballed. A knob’s whole face is grabbable, including under its ticks, track, and value arc, and a jack answers across its whole ring rather than only where its outline is drawn.

On a touch screen, where the rack is drawn small, the ▶ on the face at OUT answers a finger 44 px across (not while sockets are lit, so it never stands over the one beside it). While sockets are lit (a module in hand, a cable being placed), a tap on bare panel goes to a lit socket when the finger plainly means it: within 22 px of its middle, with no other lit socket within one and a half times that distance. A cable let go on bare panel goes in the same way from within 12 px; let go on a control, between two sockets, or away from them, it does what it did before. With nothing lit, a tap within 22 px of an out ○ (the same way, plainly meaning it) picks its cable up, as a tap on it does, rather than opening that module's settings; a drag from there still pans. A module's ⋯ and its lock reach out the same way over the rack around them: a tap there within 22 px of either, plainly meaning it, opens the menu or locks the module, as a tap on it does. A tap anywhere else on a module's panel, or on its name, opens its settings, and one on a knob or a socket is that one's. An input that is not lit keeps its drawn size: a tap there does nothing, and a drag from it pulls its cable out. UNDER THE HOOD's rows are 44 px too, the hood showing three and scrolling on its own to the rest.

Color and contrast

Text meets 4.5:1 against its background. The palette has two tiers for this: a text tier that clears the ratio, and a stroke tier for cable glow and jack rings, where contrast rules don’t apply.

Color is never the only signal. Green and amber tell audio from modulation, but every modulation cable also ends in a named destination, and each jack is labeled as well as colored. The styles are colored on the taste map, and named in words everywhere they appear.

Type size

No text in the panels is smaller than 11 px, and none drawn on a canvas (the scopes, and TASTE’s map and tabs) is smaller than 12 px.

The rack is the exception, because it’s drawn to its zoom. Its labels are 9 to 13 px at 1×, and grow as you zoom in. A label that would print smaller than 9 px, the rack's smallest at 1×, is left off, unless detail is set to full. Under detail: automatic, a module's name prints larger wherever it would print under the panels' 11 px, and the rack's fit stops where that larger name is 11 px, so no name at the fit is smaller (a patch too big to fit at that size pans); under detail: full, every label prints at its own size. A glyph on a button (▶, ✓) is sized to its button.

Your browser’s own zoom (⌘+ and ⌘−; Ctrl + and Ctrl − off a Mac) scales the whole page. Over the stage, Ctrl and the wheel and a pinch don’t: they move between the levels there, and zoom the patch in PATCH.

Motion

The rack pulses modulation cables at their modulator’s rate. That pulse is information, not decoration.

Moving between the levels, the level you leave fades and the one you reach comes in from the other side while the face of the sound you’re playing travels between them, for about two thirds of a second, with a light along the levels from the stop you left to the one you reach.

Auracle follows your system’s reduced-motion setting, and follows it live if you change it with the app open. With it on, the cable pulses, glows, and transitions stop; a move between the levels is instant, with no face traveling and no light along the levels; the rack jumps to a new layout or view instead of gliding, and the bank’s rows jump to the model view’s order rather than glide; a card waiting for its sound stops sweeping; and nothing is drawn over a sound’s face while you play it, where it otherwise lights up with what you hear. The scope still moves, because what it shows is the sound, but it redraws ten times a second rather than every frame. The guide and the reference follow the setting too.

Known gaps

• A phone pays for its boot. A phone renders the same 40 sounds at boot as a desktop does, on a slower processor, so the first sound takes longer to be ready there.
• The taste map is mostly visual. Its sounds can be walked with the arrow keys, each card says the sound’s name and the model’s guess, and a pick is announced (You picked Glass Pad over Soft Wash. Every rating moved.). LEARNING’s weights carry the model’s leans as named qualities, each row read with its weight and whether it is still a guess. The map’s spatial reading has no other form.
• Screen-reader support is deepest where it was tested. The bank and the wiring path were built and checked with a screen reader. The scope’s settings and the picture download were not.
• No high-contrast theme. The palette clears AA, but there is no AAA mode and no way to raise contrast beyond it.

If you find something not listed here, an issue helps.

Troubleshooting

What to check when Auracle makes no sound, boots slowly, won’t breed, or seems not to learn, in the order the causes are most likely.

No sound

Check in this order:

1. The pool is still filling. Boot renders 40 sounds, and the first pair is dealt at eight; the rest arrive while you play.
2. No sound is open. The menu bar says no sound, and PATCH no sound open. Click a row in the bank.
3. The browser hasn’t allowed audio yet. Browsers need a gesture before they start audio. Click anywhere, or press a key.
4. The sound is muted because it failed its check. A pinned strip says so, and stays until it’s resolved. A render that came back broken, silent, or mostly DC offset is never played. Open another sound.
5. Voices are stuck. Press ◼ SILENCE in KEYS ⋯, at the right of the keys bar.
6. The level is down. Check VOL at the right of the keys bar.
7. The tab is muted, or your computer is sending sound somewhere else. Check both.

On a phone, the bank and the keys are missing

They are a press away. The button of three lines, at the start of the menu bar, opens the bank; KEYS, at the end of the bar along the bottom, brings the keys up (on a phone on its side, a small keybed under the levels at the right edge does). See phones and tablets.

Boot is slow, or stalls

• The first load compiles the engine. Once; later loads are much faster.

• Coming back to a session brings your sounds back one at a time, and the bar counts them: recalling 12 of 40 sounds…. A sound the render workers measured as the app loaded, or that an earlier return measured, is read back rather than rendered, so a return is usually quick. The rest is rendered again, across the render workers where there are some:

  • the sounds of a first visit that had no render workers;
  • a sound that joined while you played: a generation’s, ⚡’s, an edit you kept, a patch file you opened, a preset you picked or opened;
  • every sound, after an update that changes how sounds are measured, or once the stored measurements pass their limit and are cleared.

  With the render workers, the first eight sounds are always rendered, with their audio, so they play at once. On a slow machine with no workers, a return that renders everything can take a minute, with the bar moving all the way.

• Render workers slow to start hold the boot up for five seconds at most: the engine waits that long for the first to be ready, then starts on its own, and each worker joins the work once it’s ready.

• Safari limits the render workers, and boots more slowly than Chrome. That’s expected.

• A worker that fails hands its work to the engine, over the same draws, so it costs time and not sounds.

• A render that times out twice is dropped. That draw is skipped, which is the one way a boot can end with different sounds from a clean run. It is noted in window.__aurLog ([auracle] draw 12 retired after 2 attempts), not the console, because it is a sign of a busy machine rather than a fault.

Add ?farm=0 to the address to boot without the render workers.

Showing someone a problem

A bug that needs a particular pool or offer is easier to report when it can be dealt again. Open the instrument in a fresh profile (or a private window) with ?seed= and any whole number in the address, for example ?seed=42, and reproduce it there. The same address deals the same pool of sounds for whoever opens it, though a sound you haven't named can be named differently; the warm start's cards and which side of the table a sound stands on still shuffle, and what you do after that is yours to repeat (Overrides).

A rebuild changed nothing

You are almost certainly serving with a cache. Use make serve, which tells the browser not to cache, rather than python3 -m http.server. A browser’s cache will keep serving an old worker.js or .wasm, and changing the headers later doesn’t dislodge a module worker it has already cached.

Worse than “nothing changed”: you can end up with an engine and a page from two different builds.

Dropouts and clicks

The instrument runs on a real-time audio thread.

• Another tab doing heavy work can starve it. Close that tab.
• A refit is running. A few seconds of work at most, off the audio thread; it shouldn’t cause dropouts, and if it does, that’s worth reporting.
• A click when a sound changes shouldn’t happen. If you hear one, it’s a bug.
• UNI with the arpeggiator at a fast rate is the heaviest setting there is, and the first place to look.

A MIDI controller doesn’t play

The right of the keys bar reads midi ● when a device is connected. midi ? means the page can’t reach MIDI at all; click it, and the panel says why:

• Safari has no Web MIDI. Use Chrome, Edge, or Firefox.
• Firefox asks whether to add a site permission for MIDI. Answer it; if it never appeared, press CONNECT MIDI in the panel.
• You refused access earlier. Allow MIDI for the site in the browser’s site settings (the icon left of the address), then press CONNECT MIDI.

midi ○ means another Auracle tab is playing MIDI. Close it, or click anywhere in this one to play MIDI here.

midi · means MIDI works and the browser sees no device: plug it in again, and it appears without a reload. On Windows, a device another program has open can’t be opened by the browser too; close that program and plug it in again.

AUDIO IN is silent

Its input line says why:

• no input yet: the browser hasn’t been asked. Press ALLOW INPUT.
• input refused: you refused it earlier. Allow the microphone for the site in the browser’s site settings (the icon left of the address), then press ASK AGAIN.
• no input found or input didn’t open: plug in a microphone or an interface, close any other app holding it, then press ASK AGAIN.
• unplugged: the input went away. Plug it back in; it opens by itself.
• nothing plugged in: no microphone or interface has that number yet. Click the input line and pick one.
• The square shows a level but you hear nothing: MONITOR is off. It starts off every time. Put on headphones, then press it.
• meter only: the keys hear the first AUDIO IN’s input. See your inputs.

Evolution does nothing

While a generation breeds, EVOLVE POOL is its own progress bar, saying what each walk came back as (WALK 3 OF 10 rated below the pool), and when it ends, a toast says what happened.

Before the model has anything to aim at, the toast says Nothing to breed toward yet. Make a few picks first, then evolve. Make a few picks in EVOLVE, then press it again.

A generation can put no new sound in the pool, and its toast says why, from each walk’s outcome:

• Generation 4: every walk came back unchanged.
• Generation 4: 3 were bred, but none rated above the sounds they would replace. A child joins only if the model rates it above the lowest-rated sound it could replace (not saved, nor kept as new and still waiting for its first pick).
• A count of each, when the walks differ.

That happens now and then. When it keeps happening:

• The patch is at its ceilings (24/24 modules), with no room to grow. Check the budget beside the guess in PATCH.
• Everything is locked. Locks are exact, and locking every place in the patch leaves breeding nothing to change.
• The pool is nearly all saved. Saves are capped at a quarter of the pool, but it’s worth checking if you have been saving a lot.

When every sound the model chose to breed from is out of breeding’s reach, the toast is different:

Generation 4: nothing could be bred, because every seed it picked has a knob on its stop or is deeper than the model scores. Nudge those knobs off their stops.

More picks won’t fix that one; moving those knobs will.

An edit didn’t take

• KEEP AS NEW is disabled until you have changed something. Its tooltip says Nothing to keep yet: turn a knob first.
• The edit was refused, and the toast says why: That edit to Glass Pad didn’t happen, then the reason.
• The rack still shows the sound before. Reload, and report it.

The model isn’t learning

First check its forecasts, rather than your impression. Then:

• Fewer than about 20 picks. It is too early.
• Your taste may not show in what it measures. The clearest case is stereo width, which it can’t hear at all. Read the heard line on the modules involved; it will tell you. See what it cannot learn.
• You have been saving instead of starring. Saving teaches nothing.
• Watch the fair-test number. The line that ends the number to trust is the skill on the pairs dealt at random, which is every pair EVOLVE and PATCH deal. The overall number also counts comparisons you chose (edits, PERFORM offers).

If it has learned something you don’t mean, Reset your taste… in ⌘K downloads a copy of your taste, clears what it learned, and leaves your saved sounds alone.

The engine stopped

An engine that has stopped shows a pinned alert rather than a toast, and the alert stays until it’s resolved. Reload the page; your session is kept, and it comes back.

If it stops again on the same session, that is worth an issue. Include the console output.

I lost work

Your session is in your browser’s storage, and it’s kept as you play. It is gone if:

• the site’s data was cleared, by you or by a browser cleanup;
• it was a private window;
• you’re on a different browser, machine, or address. The hosted app and a copy you serve yourself don’t share storage.

There is no copy on a server, and nothing to recover from. The only backup is one you downloaded: see your data.

Reporting something

github.com/alexnodeland/auracle/issues.

Include your browser and its version, what you did, the console output, and the patch file if it’s about one sound. window.__aur and window.__aurLog hold what the app logs for debugging.

Glossary

The words the app uses, in the sense it uses them. The [reference](../reference/) defines the same things in full; this page is for reading the app.

AUDIO IN, input, MONITOR, clip

AUDIO IN is the module that brings your own signal into a patch. An input is a microphone or an interface the browser offers, numbered from 1. MONITOR plays your input through the sound at the speakers; it starts off every time. A clip is the seconds of your input the model hears a sound with AUDIO IN through. See playing through Auracle.

TRACK, CAPTURE, take, kept safe

TRACK plays a chain from the pitch and the notes of an input. CAPTURE records what is patched into it: each time you press RECORD it makes a new take, played from the keys, an edit you keep with KEEP AS NEW. A sound whose take couldn’t be read is kept safe, out of the pool, until you record it again. See playing through Auracle.

Bank

The rail on the left, with three tabs: POOL (the sounds the model weighs and breeds from), SAVED (what you saved), and PRESETS (the hand-made library), and Find a sound under them. See the bank.

Brier skill

How much better than a coin flip the model’s guesses have been. 0 is a coin flip, 1 is perfect, and below 0 is worse than guessing. Its forecasts in LEARNING show it (13% sharper than chance).

Budget

The ceilings breeding searches within: 24 modules, a depth of 6, and a modulation depth of 3. PATCH shows a ceiling only when the patch is one short of it or at it (23/24 modules). Show measurements, in ⌘K, shows all three (8/24 modules · 4/6 depth · 1/3 mod depth). A patch at a ceiling has no room to grow.

Card

The picture of a sound you download to share it: its face, its name and where it came from, with the patch inside. See sharing a sound as a card.

Child, NEW

A sound a generation bred. The children of the latest generation lead the POOL tab under NEW · GENERATION 3, each tagged NEW, with a green dot until you hear it. Under a child’s name, the bank says which seed it grew from and what changed; click that line to compare the two.

Control

One of PERFORM’s round controls: the named controls on your panel (the six to start, up to eight), and WANDER at the start of the pads. BLEND is a slider under the faces in the well while B holds an offer.

EVOLUTION, what each generation did

What each generation did, step by step, opened from WHAT EACH GENERATION DID under EVOLVE POOL, over the foot of EVOLVE’s cards. Each step names the seed and the child, what changed, and how much more the model guessed you’d like the child than its seed (liked +0.06). See what each generation did.

Face

A sound’s drawn shape, beside its name everywhere: its spectrum from its own render, low at the base, wide where it has more than the bank’s sounds and narrow where it has less. See a sound’s face.

Fair-test picks

The pairs dealt at random, which is every pair EVOLVE and PATCH deal you; the line beside ANOTHER PAIR says so (◇ random pair · a fair test). LEARNING grades the model on them apart, as the number to trust, because you didn’t choose them.

Generation

One round of breeding. EVOLVE POOL walks a short way from each of the ten sounds the model rates highest, and adds each child that rates above the sound it would replace. When the generation ends (or you stop it), it replaces the lowest-rated sounds it can (not saved, nor kept as new and still waiting for a pick), and the toast names them. There is no crossover: every child grows from one seed.

⚡ evolve from this is one walk from the sound you’re playing, and counts as a generation of its own. GENERATIONS at the top of EVOLVE counts them.

Guess

The model’s guess about a sound: roughly how likely you are to pick it in a pair. It is always a percentage and a word, from one scale: a hunch (46–54%), leaning (55–69%, or 31–45%), or fairly sure (70% and over, or 30% and under), as in 59% · leaning. Under the model view, a bank row draws it as a percentage and a bar, with a block around the guess for how unsure it is; in PATCH it is the belief line the subtitle becomes (it’d like this 59% · leaning), with the qualities that count most in the readout.

PATCH's module guess is the module the model guesses you'd add next, dashed amber at its place; what goes here? (a module's ⋯, or Q) asks it for that module's place, and under the model view its two runners-up show with their lower bounds.

Job slot

The place in the menu bar where long work shows while it runs, just left of the sound you’re playing: a generation (⚡ breeding 3/10 · about 40 s), ⚡ evolve from this, or a refit. It has STOP where the job can be stopped. The amber lamp after the wordmark is lit exactly while it shows.

Keep as new

PATCH’s way to keep an edit: it joins the pool as a new sound, and the original stays as it was. It asks first, WHICH WOULD YOU REACH FOR?, and your answer teaches the model. PICK THE EDIT skips the question once. The sound you keep isn’t replaced until it has been in a pick after that: a pair with it in EVOLVE, a PERFORM offer you heard and answered while playing it, keeping an edit of it as new with an answer (the card, or PICK THE EDIT), or a cut. Its own card doesn’t count, nor do stars (the bank).

⌘K

The one list of every command, with its key, and every sound, by its face: ⌘K (Ctrl K), Find or do anything in the menu bar, or ? away from PERFORM’s controls. Type part of what you want, choose with the arrows, and press ↵. It took in the old ⋯ menu; the old ? card’s key map is the keyboard page (one space).

KEYS ⋯

At the right end of the keys bar, beside VOL, MIDI and ● REC: the rest of what the keybed does, HOLD, UNI, ARP (and its settings), SYNC, GLIDE, ⇕ TALL, SPAN and ◼ SILENCE. It is lit while HOLD, UNI, ARP or SYNC is on. See the keyboard map.

Leans

Under the model view in PATCH, each module's edge is tinted by which way your taste leans on its kind: amber toward, red away, stronger where the model is surer. It was a toggle in the layout's ▾; holding ⌥ (or tapping MODEL, which stays up across a reload, as the toggle did) is its home now. In PERFORM, each control carries its lean: an amber arc toward the end your taste leans to, dashed while it is a guess (which way your taste leans).

Levels

PERFORM, PATCH, EVOLVE, TASTE and LEARNING are levels of one space around the sound you’re playing: zoom out to TASTE (the sound among all sounds) and LEARNING (how it learns), in to PATCH (what the sound is made of), and beside it to EVOLVE (what it could become). The cross at the stage’s right edge shows where you are; click a stop to go there, or use ⌥↑, ⌥↓, ⌥←, ⌥→ and ⌥1–⌥5, ⌥ and the wheel, or a pinch (the keyboard map, one space). The menu bar names the level you’re at, and a move carries the sound’s face from one level to the next.

Lock

Holding a knob, a module, or the whole wiring, so breeding can’t touch it. A locked place in the patch can’t be changed, deleted, or created.

LUFS

The loudness unit every sound is normalized to (−18 LUFS). A louder sound reliably wins a comparison, so without it the model would learn “I like loud” and pass it off as a taste in timbre.

Measurements (φ)

The 44 numbers the model hears each sound through: 18 of the standard render’s sound, and 26 counts of how the patch is built. If a taste of yours doesn’t show in these, it can’t be learned.

Menu bar

The row across the top: the wordmark and its lamp, the level you’re at and what it is, the film of that level, the job slot while long work runs, the sound you’re playing (its face, its name and ▶, which is Space), TAUGHT, MODEL (the model view), and Find or do anything ⌘K, the one list of every command and every sound (one space).

Model view

What holding ⌥ (or MODEL in the menu bar) shows: what the model believes, over whatever level is up. The bank’s guesses and the pool in the order the model rates it, TASTE’s halos, EVOLVE’s guess for the pair before you pick, in PATCH the belief line, the leans, a worth chip per kind and the guess's runners-up, and in PERFORM each control's lean. A tap on MODEL keeps it up, across a reload too. See reading what it learned.

Module, catalog

A module is one part of a patch: a VCO, a filter, a reverb. The catalog, headed ADD A MODULE, is the list you add them from: ADD MODULE (or /) opens it over the left of PATCH's well. See wiring and the catalog.

Named control

One of PERFORM’s controls named for what you hear: BRIGHT, SNAP, MOTION, BODY, GRIT, and SPACE to start, and any of the twelve more in the palette. Each has the same name and the same two end words on every sound. What it turns is measured for each sound: up to four of that patch’s knobs, the ones that move the sound most purely that way. Until it’s measured, it reads listening… and does nothing.

See the named controls.

Offer, B

A variant grown from the sound you’re playing, held in a second set of voices called B that plays every note you play. Its face stands in amber beside your sound’s in PERFORM’s well. You hear it with BLEND or PEEK, at matched loudness, and it becomes your sound only if you press TAKE; NEXT and PASS pass on it. An offer may add or change a module; Wander never does. See Blend, Peek, and B.

Palette, panel

PERFORM’s palette is the eighteen controls the instrument can measure, in six families. Your panel is the ones you place on PERFORM, up to eight, in your order; ARRANGE places, hides, and orders them. See the palette.

Pair

The two sounds you pick between, A and B. EVOLVE deals them, and so does the TEACH strip in PATCH. ANOTHER PAIR deals a new one without picking.

Patch, sound, preset

A sound is what you hear, pick, save, and breed. A patch is how it’s built: its modules, knobs, and cables. A preset is a sound from the library, made by hand. Open a sound in PATCH to see its patch.

Phrase, sample

The standard five seconds every sound is heard on: the same notes for every sound, so sounds can be compared. ▶ PLAY on an EVOLVE card plays it. It is a measuring instrument, not a demo: play the sound from the keybed to judge it.

Pick

Any choice between two sounds: an EVOLVE pair, a PERFORM take or pass of an offer you heard, the warm start, or keep as new. TAUGHT counts picks, stars, and cuts.

Pickup

Soft takeover for a MIDI knob: it does nothing until it passes through the control’s current position, and then follows your hand. See soft takeover.

Pool

The POOL tab: the 40 sounds the model weighs and breeds from. The engine’s own default is 48; the app asks for 40.

Quarantine

What happens to a sound that fails its check: it is never played or shown, and the search learns to avoid where it came from.

Rating…

What the guess above the rack in PATCH ends with while the model rates an edited sound again.

Refit

The model fitting again from everything you have taught it: a few seconds of work at most, off the audio thread, every sixth pick. Between refits each answer is folded in at once. The amber lamp after the wordmark lights while a refit runs, and EVOLVE’s line says ● learning from your last 6 picks… until it lands, then ● it just learned.

Replaced

What happens to the pool’s lowest-rated sounds when a generation ends, or when a preset joins the pool: the lowest it can replace, which leaves out a saved sound and one kept as new that hasn’t been in a pick yet. The toast names them, and REPLACED · GENERATION 3 at the foot of the pool lists what the latest generation replaced. Only their names are kept.

Search control

A named control drawn in amber with a dashed ring: this patch’s knobs can’t make the change it names. Turn it past the notch and let go. Either the patch gets something to turn (a tone EQ for BRIGHT and BODY, a longer release for SPACE turned up), or an offer grows in B, aimed the way you turned it. See search controls.

Seed

The sound a child grew from. A generation breeds from the ten the model rates highest; hover EVOLVE POOL and the bank marks them SEED. (A random number generator’s seed is always called a random seed.) Opened in PATCH as it was bred, a child's subtitle says from ‹seed› · 3 changes, a tick marks each module the generation changed, and a pale pointer on a knob shows the seed's value.

Set aside

Anything you unplug, delete, or bypass is set aside instead of vanishing, and stays across a reload: SET ASIDE n at the foot of PATCH's well opens the shelf you drag it back from, and the catalog lists it first.

Stage mode

⇧F in PERFORM (or ⇧F in the well’s corner): the sound you’re playing on the whole screen, drawn from what you hear. See stage mode.

Standardizer

The scaling that puts the 44 measurements on a common footing. It is saved with your taste, always, because what the model learned means nothing without it.

Style

One side of your taste, named for what it leans toward (analog sustain) until you name it. A sound is rated by the style that likes it most, which is how you can like several unrelated kinds of sound at once. Up to five; a style claiming almost none of the pool is idle.

TAUGHT

The counter in the menu bar: everything the model learned from. Its tooltip splits it (52 picks · 4 stars · 2 cuts).

Vetting

The check every sound passes before it can be heard or measured: finite samples, a peak under a ceiling, not silent, and not mostly DC offset. Breeding does produce screaming resonance and silent duds; this is why you never hear them.

Wander

PERFORM’s dial for how alive the sound is on its own: still, ideas (variants appear in B), drift (the knobs glide through nearby settings), and roam (bigger and faster). It never changes the patch’s structure, it pauses while your hands are on the other controls, and a tap (or Enter on it) freezes it. It leads PERFORM’s pads. See Wander.

Warm start

Picking three of nine presets on a first visit, under PICK THE THREE YOU’D REACH FOR. It teaches the model 18 picks in half a minute, and your three are saved. Run it again from ⌘K: Re-run the three-pick warm start.

Without this module

In PATCH, the dashed outline over the face at OUT while a module is selected: the face of the patch without it (a processor bypassed, a source's socket empty, a modulator unplugged), measured by rendering that patch. When the patch would be silent without it, the readout says silent without it.

Worth

Under the model view in PATCH, a chip for each kind of module the patch holds: what one more of that kind is worth to the model (filtering +0.12). The model counts how many of a kind a patch has, not which is where, so two filters share one figure (shared by 2). It is the price the catalog quotes for a module in your hand.

Your taste, the model

Your taste is what the model has learned; the model is what learns it. It guesses how much you’d like any sound, including ones it has never played you, and how sure it is of each guess. The reference has what the model holds in full.

Films

Short films about Auracle: what it is, how to play it, and how it works underneath. Captions are on by default, and every film's full transcript is printed under it.

Everything you hear in them is Auracle: the music is scored for its own voices and played by its engine. The narration is synthetic (Kokoro-82M, offline).

Start here

Auracle 2:03

1. 0:00 Knowing your circuit
2. 0:22 Auracle
3. 0:28 Two sounds, one pick
4. 0:35 Real circuits
5. 0:43 Playing it
6. 1:12 Offers
7. 1:30 Underneath
8. 1:45 Every note
9. 1:53 Play it

How it works

How Auracle learns what you like 1:49

1. 0:00 Choosing, not describing
2. 0:11 What it listens for
3. 0:28 A pick is evidence
4. 0:38 Every taste that still fits
5. 0:47 More than one taste
6. 0:58 Forecasts, scored
7. 1:11 The search
8. 1:24 Reading what it learned
9. 1:33 Learning while you play
10. 1:40 In the open

Under the hood 2:17

1. 0:00 Five crates
2. 0:11 The genome
3. 0:23 Compiling to DSP
4. 0:31 The audition
5. 0:40 Features
6. 0:55 Utility
7. 1:15 Calibration
8. 1:24 Search
9. 1:39 PERFORM's wiring
10. 1:56 The runtime
11. 2:06 Read it, run it

The math 2:46

1. 0:00 Intro
2. 0:06 Utility
3. 0:23 Likelihoods
4. 0:44 Posterior
5. 1:01 Calibration
6. 1:17 Acquisition
7. 1:31 Target
8. 1:49 Refine
9. 2:03 Locks
10. 2:14 Perform
11. 2:37 Outro

The sound engine 2:49

1. 0:00 Intro
2. 0:07 Graph
3. 0:23 Modules
4. 0:41 Compile
5. 0:54 Phrase
6. 1:12 Vetting
7. 1:23 Loudness
8. 1:39 Features
9. 2:10 Live
10. 2:29 Farm
11. 2:39 Outro