petri

what it is

Point petri at your sample folders and every sound becomes a cell on one living map — clustered by how it sounds, coloured by family. From there the environment does three things, and each feeds the next: map, generate, play.

• map — browse by ear, not by filename: sweep the field to audition, search it in plain words, and let similar sounds sit next to each other.
• generate — four engines make new samples from what's already there: spawn breeds two or three sounds into one, grow evolves a synth voice toward a target, mill grinds a neighbourhood into a texture, and stack prints a sound together with its relatives as one layered hit. Since 1.2 design sits beside them for the times you'd rather shape one sound by hand than roll for it.
• play — a keyboard instrument, two sequencers, a recorder, and a concatenative rail that answers audio you play into petri with your own library — so what you make is playable the moment it exists, and drags into your DAW as a file.

new in 1.2

1.2 gives petri a hand. Until now every new sound arrived from a roll — breed it, evolve it, grind it, layer it, re-roll until it lands. The design rail is the deliberate route: pick a sound off the map and shape it in place, with sample studio+'s effect blocks drawn straight onto its waveform. Beside it, tiles turns the field into a strategic grid, and the map now opens at twice the size it used to.

The rest of the release, briefly:

• shift-click your parents. A selection of two or three dots was drawn on the map long before anything read it. Now it is the contract: with a selection standing, spawn, mill and stack use exactly the dots you named instead of rolling the neighbourhood — and shift-clicking auditions each dot as it joins, so you pick by ear rather than by colour.
• the tempo comes from your DAW. Audition quantise, mill loops and both sequencers now read one clock, and in a host that clock is the project's. The settings row says which tempo is driving them; turn from DAW off (or drag the number) to set it yourself.
• tempo is a number you can actually set. The settings row used to cycle eleven preset bpms, so 137 was unreachable. It is a drag-number now — 40–240, live under the drag, double-click back to 120.
• hold a dot to loop it. A new loop word on the audition rail: hold a dot and the preview retriggers, on the quantise grid if one is set, re-rolling the per-hit dice every pass. Hold one sample and farm variations of it straight into the recorder.
• fixed: silent previews. A host automation lane (or a restored project) could mute every preview while the settings row still showed it unmuted — clicks did nothing, the sequencer still spoke, and only a restart fixed it. The mute state is mirrored back into the UI now, so it can be seen and undone with one click.
• honest sequencer readouts. Both sequencers used to draw a closed padlock and a host tempo whether or not a transport existed to follow. With nothing to follow they read free — and the link choice is remembered between sessions.
• fixed: tiles floating off the grid. On very large libraries some tiles ended up parked between lattice lines, overlapping their neighbours, instead of taking a square of their own. Every tile gets a cell now, audited to zero on a 31,000-sound corpus.
• 1.2 is a free update for everyone who owns petri, on Apple silicon and Intel.

new in 1.1

1.1 gives petri an ear. It can listen to audio you play into it and answer, in real time, with sounds from your own library; it prints a pinned sound and its relatives as one layered hit; and it hands back the last minute of anything you played, whether or not you were recording.

The rest of the release, briefly:

• level is measured. The matcher's loudness axis had been a placeholder since the first scan. It is read from the audio now — on the library you already have, with no re-analysis pass — so matches account for how loud a sound actually is.
• keys and the concatenative rail moved to the left side, so either can play while the recorder works on the right. Old projects reopen on the new side.
• the concat rail remembers itself — approach and every cell come back with the project instead of resetting.
• generated files sign their names. Everything petri makes now saves as lux_petri_<WORD>_<kind>_<nn>.wav, so it identifies itself in any folder listing. Files made before the update keep their old names and still work.
• confirm marks are a quarter bigger, the interface scales to the window rather than to a fixed size, and labels, states and handles were tightened across the board.
• an Intel macOS installer joins the Apple silicon one, and the map takes libraries from a few hundred sounds to tens of thousands.

install & requirements

• macOS (Apple silicon or Intel) — Standalone app + VST3 + AU. Signed & notarised installer, one per architecture — 1.1 adds the Intel build.
• Windows (64-bit) — Standalone app + VST3.
• One licence covers up to three machines; the demo is free and has no time limit.

1. Download the installer from luxcache.com → account → downloads (the demo download lives on the product page — it's the same app, running in demo state until activated).
2. macOS: run the .pkg. It installs the app to /Applications, the plugins to /Library/Audio/Plug-Ins/VST3 and …/Components, and the free sample set once, machine-wide.
3. Windows: run the .exe. The VST3 lands in C:\Program Files\Common Files\VST3, the standalone in C:\Program Files\petri by Lux Cache.
4. Open the standalone, or rescan plugins in your DAW and load petri by Lux Cache as an instrument.

petri is an instrument plugin (MIDI in, audio out) — in your DAW it lives on an instrument track, not an audio insert. Standalone and plugin share the same library, the same analysis and the same generated sounds: anything you make in one is there in the other.

first run — import

The first launch opens one modal: import your samples to petri. Pick the library you want mapped, untick any subfolders you don't, press import to petri, and the map starts building while you watch.

• Analysis streams in the background. Dots appear grey and colour in as each sound is read — you can browse, audition and even generate while it works.
• Unchanged files restore instantly. petri remembers what it has already read, so a reopen of the same library is browsable in about a second — no re-scan, no re-analysis.
• More ways in later: drop audio files anywhere on the window (they're copied to a dropped/ folder and mapped once analysed), add folders from the file browser's +, or from settings → library.
• Formats: wav · aif/aiff · flac · mp3 · ogg.
• One library per map. The libraries pane is a choice, not a set to combine — picking a root opens that map. samples by Lux Cache is the one exception: the full and free sets ride together as a single map, and they no longer tag along behind your own roots. To map several folders as one, use + add a root folder and stage them together.

the window

Three tabs — map · list · settings — under one top bar, over one footer. The map is home; everything else opens as a rail on top of it.

The footer's hint line never goes blank — with nothing under the cursor it reads "drag across the field to audition · click a dot to pin", and hovering any control replaces it with that control's explanation. The window opens at 1120×710, resizes freely and remembers its size.

how you touch it

Five gestures cover the whole map. Learn these once and every rail follows the same grammar: click a word to toggle or cycle it, drag a number to scrub it.

• zoom — pinch, or ⌘/Ctrl+scroll (0.3×–8×). pan — two-finger scroll, or grab empty space with the hand tool.
• double-click empty background — reset to the whole-field view.
• arrow keys — walk the map by ear: the pin steps to the adjacent dot in that direction, auditioning as it goes.
• hover is silent by design — it moves the highlight and readout, but only a press or drag makes sound. The headphones toolbar icon silences auditioning entirely.

Lowercase labels, one accent colour, no bordered buttons — words are the buttons. Whatever is under your cursor, the footer explains it.

the field

Every sample is one dot. Position comes from a similarity layout over each sound's analysed character — brightness, noisiness, motion, density, attack, harmonicity — so colonies of alike sounds form on their own. Colour is the sound's family.

the analysis readout

Pin a dot and the bottom of the left control rail reads its analysis:

There is a fourth axis the readout doesn't print: level. Until 1.1 it was a placeholder, which made loudness dead weight in every match; it is measured from the audio itself now — and libraries analysed before the update settle up quietly, off the back of decodes petri was doing anyway, with no re-analysis pass to sit through. It is what stops find by example and the concatenative rail from treating a whisper and a wall as the same sound.

the toolbar

The floating palette above the field is the whole environment in one strip: three panels, two tools, five makers, five players.

One rail per side at a time — opening a second closes the first. Every open rail grows a small chevron on its map-facing edge to collapse it. Since 1.1 keys and the concatenative rail live on the left with the engines, because both make sound against live input: either can run while the recorder works on the right. Projects saved before the update reopen on the new side.

arrange & display

The control rail (hamburger icon) decides how the field is laid out and drawn, and reads out the analysis of whatever is pinned. Two philosophies up top: let the map cluster itself, or steer the axes by hand.

dots

• style — one ring of curated looks rather than two raw dials: default · compact · broad · squeeze · pangea · stars, each a size-and-spacing pair, plus tiles since 1.2 — which is not a size and spacing at all but the square grid. The map re-fits live, ⇧§ steps the ring from the keyboard, and v jumps straight to tiles and back.
• reset gaps — re-packs the map from scratch. Generating leaves marks in the layout — channels carved around vines and stalks that have since gone — and this erases the leftovers while the sounds you made keep their ground. It also unpins a saved view.

projection

• x: default · y: default — the similarity layout: sounds cluster purely by how they sound. Set either axis to a real dimension — brightness, noisiness, density, motion, attack, harmonic, length — and the map tweens into a compass where that axis means what you chose (dark ↔ bright, tonal ↔ noisy, snappy ↔ slow…).
• family pull — how hard family tags tug the clustering (0 = purely acoustic; default 0.20; all the way up gives you proper family islands).

filters

• max length — sounds longer than this stay off the map (default 1.5 s: a one-shot-first field out of the box; raise it to map textures and loops).
• max dots — plot cap, default 10,000 since 1.2 (it was 5,000), up to 50,000. The old cap was a performance floor rather than a legibility one; the dense-map work in 1.2 moved it. The footer count tells you when it's biting.
• family key — the legend, collapsed by default. Open it and click a family row to solo that family on the map; click again to clear.

colour by (type · certainty · character) lives on the settings page rather than here.

tiles — the grid view

The same library, dealt onto a lattice. Every sample claims one square, samples that sound alike claim neighbouring squares, and the shape the collection makes becomes a coastline you can read at a glance. Press v to switch, v again to come back — or pick tiles on the control rail's style ring.

• it is the same library. Tiles is a way of drawing the field, not a different set of sounds — the filters, the family key, the radar, the pin and every gesture work exactly as they do on the map. Sweep to audition, click to pin, shift-click to select.
• neighbours stay neighbours. Each square is dealt from the same similarity layout the dots use, so what sat together as a colony sits together as a block. What you lose is the density signal — a crowd and a couple both become one square each — and what you gain is every sample being equally visible.
• nothing drifts and nothing overlaps. There is no relax pass and no bob: the grid is the solve. Anything you generate and keep takes the nearest free square to where it was standing, so a brood lands beside its parents rather than on top of them.
• the grid remembers. Tiles is a style like any other, so it comes back with your settings on the next launch.

On very large libraries, 1.2 also fixed the dealer: tiles could end up parked between lattice lines instead of taking a square, which read as a broken grid. The land now grows until it holds everyone.

find by example

Heard something close-but-not-quite? Three ways to ask for its neighbours, all ranked most-similar-first with a match percentage.

• the similar rail (ear icon, or t) — follows whatever you last pinned or previewed: the forty nearest sounds, each with its waveform and a similarity %. ↑/↓ step and audition the ranking.
• similar from the list — the ear button on any list row ranks the whole catalogue against it. The reference row reads ref; everything else carries its percentage.
• drop a file on the search box — "find me something like this": petri reads the file, imports it to dropped/, and lights the map with the two hundred closest sounds you own.

find by description

Type what you're after in plain words — "dark evolving drone", "punchy metallic snare" — and matching sounds stay lit while the rest of the map fades back. No tagging, no naming, no folders required.

• The search understands descriptions, not just filenames — it listens with the same ears the map uses, so "warped tape choir" works on a folder full of AUDIO_017.wav.
• While the radar is live, sweeps, clicks and arrow-walks only touch matches — the dimmed field stays silent. The list tab filters to the same ranked results.
• It's honest about weak results: a query nothing matches says so ("nothing in your library reads as … yet") rather than pretending.
• ⌘F focuses the field from anywhere; Esc or the × clears it.

the list

The same library as a searchable, sortable table — for when you know what it's called, want to work a pack, or need to tidy.

• Every row plays on click. ↑/↓ step and audition; ⏎ flips to the map with that dot pinned; typing anywhere becomes a search.
• Row buttons: ear = similar-to-this · pack = show this pack · star = like it · map-pin = show on the map. The pack name is a click too.
• Detected key rides the row. A pitched one-shot wears its root; a harmonic loop wears maj or min. The key chip filters the list down to one of them.
• Multi-select with ⇧/⌘-click (⌘A for all), then drag the selection straight out to your DAW or Finder as files — or use the banner's spawn from these to send them to the breeding dock.
• tidy — duplicates finds exact copies (same name, same duration); twins finds sounds so alike your library doesn't need both. Folding hides the copies for this session — nothing is deleted from disk.

the brood — keep or discard

The engines all work the same way: they make a candidate — an unsaved sound that lives on the map, in the culture, waiting for a verdict. Until you keep it, nothing is written to your library.

• ✓ keep — bakes the candidate into a real 24-bit WAV inside your library, plants its dot where it was born, and stamps its full parentage into the file itself.
• ✗ discard — the branch withers; nothing is written.
• ↻ re-roll — same recipe, fresh dice: replaces the candidate with another take from the same parents (spawn, stack) or the same target and mode (mill). Grow strands evolve instead of re-rolling, so they don't carry ↻.

Kept sounds join the library in their own folders inside your library root — lux_petri_spawned/, lux_petri_grown/, lux_petri_milled/, lux_petri_layered/ — and their dots stay planted where they were made, wearing their engine's mark. They're ordinary WAVs: drag them out, breed from them, sequence them. Since 1.1 every one of them is named lux_petri_<WORD>_<kind>_<nn>.wav, so a generated sound announces itself wherever it ends up.

spawn — breed

spawn crosses two or three samples into one new sound that inherits from each. Keep what works, breed from the children, and sounds develop across generations — the rail draws the whole lineage as it grows.

breeding a child

Two gestures actually breed. Both land two candidates — the same roll thrown twice, so there's a choice rather than a verdict. Only the first plays as it bakes; click the other to hear it.

• pin a dot, then press the popped-up spawn button. One press rolls partners from that dot's nearest neighbours and breeds them immediately. Let the cursor rest on the button for a beat before you click — the pop-up arms after a sixth of a second, and a faster click falls through to the map and just re-pins.
• hold ⇧X and click a dot. The same roll, with no pin and no waiting for the button to arm — the quickest way to run a room.

Once a family exists, breed on any of its rows starts the next generation from that sound. That is how a lineage gets past generation one.

the parents dock

• shift-click 2–3 dots on the map — they land in the dock (a fourth swaps the oldest out), and each one auditions as it joins. You can also drag dots into the rail from the map.
• The × beside a name drops that parent; the × on the parents label clears all of them.
• Every parent gets an equal share of the child. There is no mix to set — the character comes from the genes and from re-rolling, not from a balance.

the family

Several families can be on the go at once. The active one is unfolded; the rest collapse to one summary row under the braid — click one to bring it forward. A child that is still baking wears baking… and takes its colour when it lands.

the genes

Every child rolls its own character. Select a child and four cells appear in the rail's head — drag a value and the child rebakes on release:

Spawn breeds by morph: it blends the parents' actual audio — attacks are protected, timing is reconciled, and the child's body is painted from its parents' own material. Nothing is synthesised. (For a synth take of a sound rather than a blend, that is grow.)

Kept children are named by family: each family grows a two-syllable word from its roots, so a lineage reads as lux_petri_FUVOLA_spawn_01-m.wav, lux_petri_FUVOLA_spawn_02-m.wav… in lux_petri_spawned/.

grow — evolve

Point grow at any sound and it evolves a fresh synth voice toward it — listening, mutating, and getting measurably closer the longer it runs. The result is a playable synth cousin of the original, never a copy of the sample.

how a run behaves

• It hears, then guesses, then climbs. The run starts from what it heard — pitch, envelope, texture — then evolves generation after generation, judging every attempt by ear against the target and audibly checking in as it improves.
• The takes have personalities. Two strands stay close (faithful), one drifts, and one goes wild — as close as it can get while being as different as it dares. The saved filename tells you which one you kept.
• Stuck strands start over on their own with a fresh guess; strands still improving earn extra generations. You never babysit a dead end.
• On the map, four vines wander out of the target as the strands evolve — checkpoints drop seeds along them, and a finished garden replants itself next session.
• Nothing touches disk until you save. Checkpoints and finals stay weightless until you keep one; save renders the 24-bit WAV to lux_petri_grown/ and plants the dot at the vine's tip.

mill — grind

mill fuses a cluster of samples into one continuously shifting texture. Nothing is synthesised — every grain in the render is the members' own audio, chosen and placed by the mill.

the grist

By default the mill grinds the pinned sound plus its twelve nearest neighbours — the neighbourhood you can see — pin a sound and the mill takes the colony around it.

three characters

A take is repeatable — the same grist and the same recipe give the same result, and ↻ throws fresh dice for another one. Saves land in lux_petri_milled/, and the take plants a spiky dot at its wheat-stalk's tip on the map.

stack — layer

Layering a hit with a few similar hits — each nudged in pitch, pan, tone and level — is the oldest trick in sound design, and normally ten minutes of dragging in a DAW. The map already knows which sounds are relatives, so stack does it in one click and prints the result as a single sample.

rolling one

• Pin a dot and press stack — the fourth button in the pin's pop-up quartet (spawn · grow · mill · stack). The rail opens with it, or from the layers icon in the toolbar.
• One click lands two orbs: the same relatives given two different treatments, so there's a choice rather than a verdict. Only the first plays as it bakes — click the other to hear it.
• ↻ re-roll keeps the parents and rolls fresh dice; reroll in the rail does the same to the last stack — and since 1.1.4 it keeps working after you save, so printing a take is no longer the end of asking those sounds for another treatment. The chip beside it retires to a grey saved: done · go again.
• Nothing is written until the map's ✓ confirm mark says so, you press save, or you drag the orb out.

what a layer is

• 2 to 7 layers, three by default. The base is the sound you pinned and it keeps its identity; the relatives are the chorus.
• Relatives come from the map, not the family. Strict nearest-neighbours stacked five of the same kick, because the embedding carries the family tag; stack uses spawn's own dice instead — map-space proximity, where cluster borders live.
• Each relative rolls its own detune, pan, filter and trim, ducks 25% under the base, and the sum is peak-normalised to −1 dB. A stack lands at a usable level, not a hot one.

the treatment ranges

The seven bars are ranges, not values — each layer rolls its own number inside them. Drag a bar to widen or narrow the roll; reset returns them all to the defaults. They persist between sessions.

Kept stacks land in lux_petri_layered/ as lux_petri_<WORD>_layer_01.wav, and their dots plant on the map like any other generated sound — a stack can be a parent, a key, a sequencer lane.

design — one sound, shaped in place

Every other engine in petri rolls: you ask for a child and re-roll until one lands. The design rail is the opposite move. Pick a sound off the map, place up to three effect regions on its waveform, hear it, and export the result into your library as a child. It is sample studio+'s sound design, living inside petri and pointed at the sample under your cursor. Open it with d, or the brush in the toolbar.

the rail, top to bottom

• the head — rand all throws a fresh sound and a fresh chain in one go; pick arms the field, so clicking any dot brings it onto the rail through the chain you already built.
• the sound — the sample on the rail, with a small dice beside it to shuffle in a random one. Click the name to hear the original: the library file with the chain and every edit bypassed, which is the A/B.
• gain · vari · width · rev — whole-sample controls, drag-numbered like everything else. vari is tape varispeed (±100% = ±2 octaves) and changes the length; rev flips the sample and the blocks on it together.
• play · loop | render · reset — space is rebound to the rail while it is open, so it previews the designed sound rather than the map.
• the wave — the designed sample, with each block drawn as a wash across the region it covers, its automation over the top and its edge fades at the shoulders.
• the chain — fx1 → fx3 and the dice. Click an empty slot to choose an effect, the chevron to swap one, the × to clear it.
• the curve — the selected block's automation at full rail width. The wave shows; the curve edits.
• export as child — the only thing here that writes to your library. Under it, the sounds you exported this session; click one to hear it.

the ten effects

Each slot holds one effect, and the same ten are available in every slot. Their order is their signal chain: fx1 into fx2 into fx3.

sub, sweep, filter and ring are frequency blocks: their curves draw and render on a log axis, so an exponential sweep is a straight line. The rest are linear. The curve panel says which, and it is fixed per effect.

a block is a region you draw

Nothing here is a knob with one value. Every effect is placed on a stretch of the sample and shaped across it:

• move it — drag the block's grip band.
• resize it — drag its dashed edges. The cursor tells you when an edge is under the hand.
• fade its edges — the small dots at the block's top corners ramp it in and out, and those ramps bend too.
• bend its curve — in the curve panel, click to add a node, drag to move one, double-click to remove it, and grab the midpoint between two nodes to bend the segment.

Hovering a block on the wave reveals its handles without selecting it, so you can see what you are about to grab. There is no trim: petri is not a chopper, and every pixel of the wave box is audio.

rolling, rendering, exporting

• the dice reroll the chain — one to three effects, fresh regions, curves and fades, with fx1 always playing. shuffle (beside the sound) brings up a random sample through the chain you built; rand all does both at once. Every roll sounds itself, so a throw you can't hear is never one you go looking for.
• render flattens the chain into the sample and frees all three slots, so you can build the next three on top of what you just made. The generation counter climbs; nothing is written to disk.
• reset clears the slots and the gain/vari/width/rev row. Rendered generations stay.
• export as child writes a new sound into your library beside its parent, with its parentage stamped in the file like everything else petri makes — or drag the export block straight into your DAW, which writes nothing to the library at all.

lineage & undo

Generation compounds — so petri keeps the receipts.

• Lineage travels with the file. Every kept sound carries its recipe and parentage inside the WAV itself (in the file's metadata — the audio is untouched). Rename it, move it, re-import it years later: petri still knows its parents, its engine, and where it lived on the map.
• The map remembers. Kept sounds replant at their birthplace every session, wearing their engine's mark; spawn children keep visible threads to their parents. A tidy after save setting retires the lineage furniture if you'd rather keep just the dot.
• Undo is generative history. ⌘Z steps back through spawns, mills, discards and re-rolls — up to 64 actions, each named in the top bar (undo · spawn a child). Saves are deliberately excluded: a file you kept stays kept.
• Or keep it all inside petri. keep generated in petri (settings · map) saves everything you spawn, mill, grow and layer into the plugin's own home instead of into lux_petri_* folders beside your samples — so nothing appears in your library until you drag a sound out. Off by default. Everything else is unchanged: the sounds still carry their lineage, still replant on the map, and the clean-slate wipe still reaches them.
• The one hard reset lives in settings → about → clear all generated samples: it wipes every spawned / milled / grown / layered file from your folders and rescans. Two clicks, clearly armed, no accidents.

the audition rail

One set of controls shapes every preview — map sweeps, list rows, similar-rail auditions, replayed recents. Open it with a, or click the pointer tool a second time.

loop — hold a dot and it goes again

New in 1.2, and it sits on the preview row beside reset. With loop on, holding a dot retriggers its preview for as long as you hold:

• with quantise set it is a ratchet — one hit per gridline, at the session tempo. Hold with 1/16 and the dot plays a sixteenth pattern in your project's time.
• with quantise off the voice simply goes again each time it ends.
• every pass re-rolls the dice — pitch, pan, start point, filter, reverse, all of it. That is the point: hold one sample and farm variations of it straight into the recorder.

It composes with a scrub rather than fighting it — come to rest at the end of a sweep and the dot you stopped on is the one that ratchets. Holds that already mean something (a grab, or the step rail's drag-out arm) win. The setting is remembered between sessions.

With dice on start and reverse plus a scale lock, sweeping one colony becomes an instrument in itself — the same dots, never the same phrase twice.

keys

The keys rail maps your library across a MIDI keyboard four different ways. Every key wears a sample; click a key or play your controller.

• octaves 2–4 · start rotates the picks · voices mono/poly · dice: roll re-deals everything unlocked. Each key also has its own tiny dice.
• hand picks: drag a key's note dot onto any sample on the map to re-point that key yourself. There's no mode to enter, and the pick holds like a lock does — it survives a rescan, and roll re-deals around it.
• kits save: the + freezes the whole keyboard — mode, picks, locks — as a named kit; in drums mode collect copies the twelve files into a kits/ folder for use anywhere.
• collect drags too (1.1): press collect and drag instead of clicking, and the whole kit rides out as one multi-file drag — drop it on a Live drum rack and every pad lands. Same cell, two physics: a plain click still files the kit.
• MIDI just works: any octave of any controller reaches the map — notes wrap onto the keyboard. Drag across the keys for a glissando. Velocity sensitivity is a settings toggle.

the concatenative rail

Play audio into petri and it answers, in real time, with sounds from your own library. Feed it a drum loop and the library re-lays that loop as a mosaic of your samples; feed it a bassline and the library sings it back in its own voice. Nothing is pre-rendered — petri matches what it hears against your corpus as it arrives.

getting audio in

petri is an instrument, so until 1.1 it had no audio input at all. It has two now, and neither of them asks you to think about routing for long:

• sidechain — a stereo sidechain input on the plugin, and since 1.1.4 it arrives switched on, so a host with no per-bus routing UI can still feed it. petri only ever listens to that bus; it never passes it through, so it stays an instrument. The standalone deliberately keeps the bus off — an active input there would open a recording device and ask for your microphone at launch, for a rail you may never open. Use audio in there instead.
• a device, directly — the audio in row opens an input itself: your mic, an aggregate, BlackHole or similar. Click it for the list (sidechain first, then every input device, a tick on the current one). No routing, no host quirks.

AU cannot receive audio

That's an Apple rule for instrument plugins, not a petri choice — in the AU the rail says so itself. Use the audio in row, which opens a device directly, or load the VST3 and feed its sidechain.

the four approaches

The word row across the top is the instrument. Each word is a complete recipe — trigger model, gate and balance — named for the relationship between what you play and what comes back. The engine boots into mosaic.

An approach is a starting point, not a lock: every cell stays live afterwards, and pulling one away from its preset is how you find your own. The whole distance between answer and bloom, for instance, lives in the ring cell.

the cells

Twelve cells in three rows, all drag-numbered like everything else in petri — drag a value to scrub it, click a word to cycle it.

listen — whole, or inside

By default the matcher works with whole samples. Press listen and petri cuts every sample at its own onsets and measures each slice on its own: a 2,352-sound corpus becomes 71,675 units, and its tonal units go from 219 to 2,542. Short percussive material gains the most — the four approaches only really separate from each other once petri is matching slices.

• It is never automatic and never up front, because it is heavy. whole stays playable the whole time the pass runs.
• It runs once per map and caches. A fresh install mostly reads its slices from a bake that ships with petri rather than computing them.
• It cancels. While it runs, the pool line becomes an analysis row — count on the left, progress bar, cancel on the right — and the listen cell counts up in per cent. Cancelling drops back to whole; progress isn't kept, because the cache only writes at the end.

the pool, and the lasso

Above roughly 2,500 sounds a corpus is mostly descriptor duplicates: thirteen times the sounds moved the match score by 0.02. So petri selects at most 2,500 for the matcher — by coverage quotas across the matcher's own space, with your own fingerprints (generated sounds, anything you've used three times or more) force-included, and no single family allowed over 35%. Measured on a 31,265-sound corpus, the curated 2,500 beat the full table on every column: taking the junk out of the neighbourhood makes every neighbour better.

• The pool line says so out loud — 2500 of 31265 · curated — because a silent cap is a lie. Its left half, N ready, is how many of the pool are decoded and warm.
• scope is the manual version: arm it and a transparent overlay drops over the field. One freehand stroke closes into a region and every visible dot inside it becomes the corpus — whole and sliced alike. The pool count shrinks to the scoped set as you draw. Disarm to clear it.

Scope is the answer to the junkyard problem: a corpus you can see is a corpus you can curate. Circle one colony and the rail can only answer in that voice.

reading what it's doing

• the ribbon — input level along the top, the grains that answered it below, each in its sample's dot colour, newest on the right.
• the strip — the sample sounding right now, and an honest input state: no input · warming N · listening.
• the grain history — the sounds that just answered, in order, the way the audition rail lists what you recently heard. Every one is a file you own.
• the tutorial wash — after two seconds with no audio arriving, the display explains the routing instead of sitting empty, because a rail that is working perfectly and hearing nothing looks broken.

sequence on the map

Draw paths across the field and they play: each route steps through its dots to its own rhythm, locked to tempo. Six lanes, twenty-six rhythms, and polyrhythm falls out naturally.

• Every onset steps the route to its next dot — a route needs at least two dots to play.
• direction per lane: forward, backward, pendulum, or random walk. The lane's dice picks it a different rhythm bed.
• Long-press a lane's grip and drag — an eight-bar loop of just that lane bounces straight into your DAW as a WAV.
• collect bounces every playing lane to its own loop WAV in one folder (~/Music/petri/petri collected/) and opens it — a groove kit from one click. Collected loops never re-enter the library pool.

sequence on a grid

The step sequencer is the conventional counterpart: five lanes of sixteen steps, one sample per lane, with the same dials and the same collect.

• link runs every lane on one shared playhead; unlink and each lane takes its own rate and direction — instant polyrhythm.
• The lane × clears its steps but keeps the sound; the lane dice writes a fresh sparse pattern.
• Long-press + drag a grip for a four-bar bounce of that lane; collect writes all of them to petri collected/.
• space plays and stops whichever sequencer is open; closing the rail stops it.

record & drag out

The recorder catches everything the environment puts out — sweeps, keys, both sequencers, the concatenative rail's answers, engine auditions — as a single WAV take. Since 1.1 it catches them whether you armed it or not.

keep last 60 s

petri heard it anyway. The recorder keeps a rolling 60-second stereo ring of every block it produces — auditions, keys jams, concat answers, sequencer runs — armed or not. Press keep last 60 s and that minute unrolls into a numbered take, after the fact. The jam you didn't record is no longer gone.

• The word counts what's actually in the buffer, so it reads keep last 12 s twelve seconds after a cold start and settles at 60.
• A successful keep flashes saved for a beat, and the take appears in recent below.
• Nothing to keep yet? It says so rather than writing an empty file.

• Takes are 24-bit stereo WAVs, named take_001.wav onward, saved to ~/Music/petri by default.
• pause holds the take open — press again to keep recording into the same file.
• The ring costs you nothing to leave running — it is the recorder's own memory, not a file. Only keep or record writes to disk.
• Recording is one of many ways out. Everything drags: list rows (and whole selections), the player bar's grip, sequencer lane grips (rendered loops), engine takes and children (dragging out saves them first), and recorder takes. If you can hear it, you can drop it on a DAW track as a file.
• drag out with fx (settings · audition, off by default) exports what you actually heard: the player bar's grip renders the sound with the armed audition treatment baked in — envelope, pitch, filter and the dice as they rolled. Off, and the grip gives you the raw file; on, but a sound you never previewed treated still comes out raw, because there's no performance to bake. List rows always drag raw — they audition dry, so a treated export there would be a sound you never heard.

settings

One scrolling page, six sections — library · scanning + analysis · map · audition · shortcuts · about. Changes apply live and are remembered.

themes

Eight worlds: four dot palettes on a light sheet, the same four on dark. The § key steps the ring from anywhere.

The palette changes what the dots mean visually; the sheet flips the whole UI between paper and near-black. Dark mode is a choice, not a system follow — step past the four light worlds and you're in the dark four.

activation & the demo

No serial numbers. Activation is a short sign-in tied to your Lux Cache account: the app shows a code, your browser approves it, done.

1. In the app, choose log in. petri shows a short pairing code and opens luxcache.com/activate in your browser.
2. Sign in (or sign up) and enter the code. The page names the machine you're approving, so you always know what you're activating.
3. The app notices within moments — registered to you — and the full sample library starts downloading in-app.

• Three seats. A licence covers up to three machines at once. Free a seat any time — from settings → about → sign out this device, or from your account's devices page if the machine is gone.
• Offline is fine. petri verifies its licence locally and runs fully offline for months at a stretch; any launch with network quietly refreshes the lease.
• The demo is the whole environment — unlimited time, every feature, limited to the free sample set. Generating, saving and playing all work; importing your own folders (and saved maps) unlock with the licence. One installer serves both: buy, sign in, and the demo becomes the full app.
• Updates are free, forever. petri checks once a day; when a new build exists you'll see a quiet notice — downloads come from your account page, never auto-installed.

walkthroughs

Seven end-to-end recipes. Each starts at the map and ends with files — kept, collected, or dropped on a DAW track.

keyboard

The map is wired to the keyboard — tools, rails, walking, undo — without reaching for the toolbar.

Two rails have no letter of their own: stack and the concatenative rail — open them from the toolbar, or stack from a pinned dot. (The concatenative icon's tooltip mentions c; that key is still not bound.)

In the list: ↑/↓ audition-step, ⏎ shows the row on the map, ⌘A selects all, and typing becomes a search.

the rhythm alphabet

Twenty-six rhythm beds, a–z, shared by the route player and mill's loop mode. Every bed is a four-bar phrase; the letters make lanes readable at a glance (lane 3 · J swing).

Most beds are one-bar grooves tiled over the phrase; clave, broken, build, amen and chaos genuinely change across their four bars.

families & colours

Thirteen families, tagged automatically as each sound is analysed. In the krayon theme the dots wear exactly these hues; the other palettes re-tint the same families, and colour always means the same thing everywhere — map, list, keys, sequencers.

kick snare cl hat clap perc bass synth pad loop fx tom op hat cymbal

Family tags come from listening to the sound itself, with filename hints as a tie-break — the analysis readout tells you whether a tag was analysed or guessed, and how sure it is. The engines wear family colours too: spawn's violet, grow's green and mill's gold are the synth, loop and perc-adjacent hues you see above.

tips & gotchas

• Hover is silent on purpose. Press or drag to hear — bare hover only moves the readout. If nothing ever sounds, check the headphones toggle in the toolbar.
• The map is one-shot-first out of the box. max length defaults to 1.5 s, so pads and loops may be invisible until you raise it. The footer's visible of scanned count is the tell.
• Quantise changes what the map is. With 1/16 on, sweeping is playing — every scrub lands on the grid at your session tempo (the host's tempo inside a DAW).
• Confirm before you breed on. An unconfirmed candidate can't parent the next generation — ✓ it first. And a library rescan clears unsaved spawn history: keep the children you care about before you reorganise folders.
• Re-roll beats regret. ↻ is cheaper than tweaking a mediocre candidate — same recipe, fresh dice. Verdict-chips first, gene-surgery second.
• Dragging out is keeping. Pulling an unsaved child or take into your DAW saves it to its engine folder first — so the file your project references is real and permanent.
• Everything generated lives in four folders — lux_petri_spawned/, lux_petri_grown/, lux_petri_milled/, lux_petri_layered/ inside your library root — and every file carries its parentage internally. Safe to browse, rename, back up. Prefer your library untouched? keep generated in petri (settings · map) keeps them inside the plugin until you drag one out.
• tonal keys refusing a sound is correct behaviour. Only confidently pitched material is allowed to be an instrument; everything else still lives in bright / family / drums modes.
• Big libraries are fine. The field calms its animations as it gets crowded, and the plot caps at 10,000 dots by default since 1.2 (raisable to 50,000) — filters and radar are how you carve a huge corpus, not scrolling. tiles is the other answer to a crowd: every sample equally visible, nothing hidden under anything else. Quitting mid-scan is safe too: petri abandons the import immediately rather than making your DAW wait the rest of it out, and picks the scan up next launch.
• Low cpu mode (settings) is the one switch for gigs and old laptops: still map, paused analysis, full function.
• Scope before you play into it. The concatenative rail answers from up to 2,500 sounds; lassoing one colony with scope first is the difference between "my library" and "this voice". It's the fastest control on the rail.
• listen (inside) is a one-time cost, per map. Start it before you make coffee, not mid-take — whole keeps playing while it runs, it caches when it finishes, and cancelling throws the progress away.
• Play the rail, don't set it. An approach is a starting point; ring, density and spread are where the performance is. hold freezes an answer you like so you can play over it.
• Forget to hit record. That's what keep last 60 s is for — the ring is always running, so the take you didn't arm for is still there for a minute.
• A stack is a hit, not a patch. Two orbs land per click so you can choose; neither survives a restart, so keep the one you want before you close.
• Name your parents rather than hoping. Shift-click two or three dots and the gen buttons pop beside the last one — spawn, mill and stack then use exactly those. It is the difference between "something around here" and "these three".
• Render is free; export is the commitment. In the design rail, render only flattens the chain in memory so the slots free up — nothing reaches your library until you press export as child or drag the block out. Stack renders as far as you like before deciding.
• Previews gone silent? Check the mute word on the audition rail's level first. A host automation lane can reach the preview level, and until 1.2 it could do so without the row ever showing it.

troubleshooting

The DAW doesn't list the plugin.

Rescan plugins in the DAW's preferences. petri is an instrument (VST3, plus AU on macOS) — look under instruments, not effects. On Windows the VST3 lives in C:\Program Files\Common Files\VST3.

The map is mostly grey.

Grey dots are sounds not yet analysed — petri is still reading them. They colour in as it goes (the settings progress line counts them). If it never advances, check background analysis or low cpu mode hasn't paused it.

A pack I imported isn't on the map.

Check the footer count and the causes it names: the max length filter (1.5 s default), the max dots cap, or the pack unticked in the file browser. A radar search also hides non-matches until cleared with Esc.

Search finds nothing sensible.

The radar searches analysed sounds — a fresh import needs a moment before it's searchable. Weak queries say so honestly; try describing character ("soft sub with a long tail") rather than pack names.

A sample won't land on a drum key.

By design — drums mode only deals sounds under 1.5 s, and tonal mode only takes confidently pitched material. Check the sound's length and detected key in the analysis readout.

petri isn't hearing my audio.

In the AU, it can't: Apple's instrument format has no audio input at all. Use the audio in row at the top of the concatenative rail — it opens a mic, aggregate or loopback device directly — or load the VST3 and feed its sidechain (switched on by default since 1.1.4). In the standalone, pick the device in audio in. The rail's own display tells you which case you're in after two silent seconds.

The concat pool says "2500 of 31265".

Working as intended. Past roughly 2,500 sounds a corpus is mostly duplicates in the matcher's terms, so petri curates the pool for coverage rather than feeding it everything — it measured better than the full library on every axis. Use scope to say which part of the map the answers should come from.

Slicing (listen · inside) is taking a while.

It's a real analysis pass, and it's why it's never automatic. whole stays playable throughout, the result caches per map so you pay once, and you can cancel from the analysis row — though a cancelled pass starts over, since the cache only writes at the end.

"All your device seats are in use."

The licence covers three machines. Free one from settings → about → sign out this device on any active machine, or from your account's devices page at luxcache.com if the machine is gone.

Windows blocked the installer.

SmartScreen flags the unsigned installer: choose More info → Run anyway.

Where is everything on disk?

Your samples stay where they are. petri's own state lives in ~/Library/Application Support/Lux Cache/petri by Lux Cache/ (macOS) or %APPDATA%\Lux Cache\petri by Lux Cache\ (Windows); generated sounds in lux_petri_* folders inside your library root; recordings in ~/Music/petri; collected loops in ~/Music/petri/petri collected/. With keep generated in petri switched on, generated sounds live in that same state folder instead of in your library — dragging one out is what puts a file somewhere you chose.

I have a feature idea.

We'd love to hear it — hello@luxcache.com.