petri

what it is

Point petri at your sample folders and every sound becomes a dot on one map. Dots are grouped by how they sound and coloured by family. From there petri does three things, and each feeds the next: map, generate, play.

• map: browse by ear, with no need to read filenames. Sweep the map to audition, search it in plain words, and find similar sounds next to each other.
• generate: four engines make new samples from the sounds you already have. 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 when you want to shape one sound by hand.
• play: a keyboard instrument, two sequencers, a recorder, and a concatenative rail that answers audio you play into petri with sounds from your own library. You can play what you make as soon as it exists, and drag it into your DAW as a file.

new in 1.5

1.5 lets you play the map without the mouse. A pointer on the audition rail follows an XY controller or your DAW's automation, and it keeps playing when petri's window is closed. 1.5 and 1.4.3 also make very large libraries quicker to import and quicker to open. This manual describes 1.5.1.

The rest of these releases in brief:

• hold. A new word on the audition rail's preview row. With hold on, the map acts as if you are pressing it, so every dot the mouse moves over plays. A sustain pedal (CC 64) or the map hold parameter does the same. See hold.
• very large libraries stay playable. Opening a big library no longer leaves the map silent while petri checks your files. Sounds petri has not read yet join the map as it reads them (1.5).
• check on launch. petri looks through your folders each time it opens. If your library is huge, turn check on launch off in settings and press rescan library when you add samples (1.5).
• big imports no longer look frozen. While petri opens each file it now counts up (reading sounds · 3,412 of 20,000). It no longer stops on the number it found. That step is also about twice as fast for FLAC files (1.4.3).
• the mill and grow rails have their settings back. In 1.4.2 their cells were grey readouts. Now the mill cells and grow's branches cell set up the next take you make on the map. The stack rail loses its reroll and save buttons, so you keep and re-roll a stack on the map, as with the other engines (1.4.3).
• fixed: children you can't hear. Sweeping across generated sounds on the map sometimes skipped them, and the arrow keys stepped past them. Both now reach every dot (1.5).
• a lighter map on Retina screens. The map uses less CPU when idle and when you hover, and a moving pointer draws about twice as smoothly (1.5).
• fixed: dragging settings in the audition rail is smooth again. Dragging level, width, pitch, the envelope or the dice had become laggy, because petri saved your settings to disk on every small movement. It now saves once, when you let go. The drag controls on the settings page, such as tempo, work the same way (1.5.1).
• 1.5.1 is a free update for everyone who owns petri. It needs macOS 11 or later (Apple silicon or Intel) or 64-bit Windows.

new in 1.2

1.2 adds a way to shape a sound by hand. Until now every new sound came from a roll. You bred, evolved, ground or layered, then re-rolled until it worked. With the design rail you pick a sound from the map and shape it in place, drawing sample studio+'s effect blocks onto its waveform. 1.2 also adds tiles, which turns the map into a square grid, and the map now opens at twice the size it used to.

The rest of the release in brief:

• shift-click your parents. petri has long drawn a selection of two or three dots on the map, but nothing used it. Now, while a selection is active, spawn, mill and stack use exactly the dots you chose. Without a selection they roll from the neighbourhood as before. Shift-clicking also auditions each dot as it joins, so you can choose by ear.
• the tempo comes from your DAW. Audition quantise, mill loops and both sequencers now read one clock. In a host, that clock is the project's. The settings row shows which tempo is driving them. To set it yourself, turn from DAW off or drag the number.
• you can set any tempo. The settings row used to cycle through eleven preset bpms, so you could not reach 137. Now it is a number you drag, 40–240. It updates live as you drag, and a double-click returns it to 120.
• hold a dot to loop it. The audition rail has a new loop word. Hold a dot and the preview retriggers, on the quantise grid if one is set. Each pass re-rolls the per-hit dice. Hold one sample and you can capture variations of it straight in 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 played, and only a restart fixed it. The UI now shows the real mute state, so you can see it and undo it with one click.
• accurate sequencer readouts. Both sequencers used to show a closed padlock and a host tempo even when there was no transport to follow. With nothing to follow they now read free, and petri remembers the link choice between sessions.
• fixed: tiles floating off the grid. On the largest libraries some tiles ended up between grid lines and overlapped their neighbours. Every tile now gets a square of its own. A test on a 31,000-sound library found no tiles off the grid.
• 1.2 is a free update for everyone who owns petri, on Apple silicon and Intel.

new in 1.1

1.1 adds three main things. petri 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. It also gives you back the last minute of anything you played, whether or not you were recording.

The rest of the release in brief:

• level is measured. The matcher's loudness axis had been a placeholder since the first scan. petri now reads it from the audio, so matches account for how loud a sound is. This works on the library you already have, with no re-analysis pass.
• 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 its settings. The approach and every cell now come back with the project. Before, they reset.
• generated files name themselves. Everything petri makes now saves as lux_petri_<WORD>_<kind>_<nn>.wav, so you can recognise it in any folder listing. Files made before the update keep their old names and still work.
• confirm marks are a quarter bigger. The interface now scales to the window, where before it had a fixed size. Labels, states and handles were tightened throughout.
• an Intel macOS installer joins the Apple silicon one. The map now handles libraries from a few hundred sounds to tens of thousands.

install & requirements

• macOS 11 or later (Apple silicon or Intel): Standalone app + VST3 + AU. One signed & notarised installer covers both kinds of Mac.
• 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 is on the product page. It is the same app, and it runs 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, for the whole machine.
3. Windows: run the .exe. The VST3 goes to C:\Program Files\Common Files\VST3, and the standalone goes to 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, load it on an instrument track, not as an audio insert. The standalone and the plugin share the same library, the same analysis and the same generated sounds, so anything you make in one appears in the other.

first run — import

The first launch opens one modal, import your samples to petri. Pick the library you want mapped and untick any subfolders you want left out. Press import to petri and the map starts building while you watch.

• Analysis streams in the background. Dots appear grey and take their colour as petri reads each sound. You can browse, audition and generate while it works.
• Unchanged files restore instantly. petri remembers what it has already read. When you reopen the same library you can browse it in about a second, with no re-scan and no re-analysis. New files you have added join the map as petri reads them, and you can play the map meanwhile. To skip that check on a huge library, turn off check on launch in settings.
• More ways in later: drop audio files anywhere on the window (petri copies them to a dropped/ folder and maps them once analysed), add folders from the file browser's +, or add them from settings → library.
• Formats: wav · aif/aiff · flac · mp3 · ogg.
• One library per map. In the libraries pane you choose one library root, and petri opens that map. It does not combine them. samples by Lux Cache is the one exception. Its full and free sets open together as a single map, and they are no longer added to the maps of your own library roots. To map several folders as one, use + add a root folder and stage them together.

import filters — for very large libraries (1.4.3)

A library of 100,000 sounds or more used to take hours to import, and the map only shows 10,000 dots anyway. So petri now decides what to import before it opens a single file. The import group on the card holds the filters. They are on by default, for new and existing users. Each filter shows on its right how many sounds it will leave out, for example − 31,120.

• Exact copies are always skipped. Two files with the same name and the same size are one sound, so petri imports the first and leaves out the rest. There is no switch for this. The subfolders heading shows the count, for example subfolders · found 184,302 · 26,411 copies.
• Select or clear every subfolder at once. The box at the top of the subfolders' tick column ticks them all. If they are all ticked, it clears them all. When only some are ticked, it shows a dash.
• The Lux Cache sets and your generated sounds are never filtered. Everything in the factory sets and in petri's own lux_petri_* folders always comes in.
• Filters apply on the next import. If you change them for a library you have already mapped, press rescan library. A map can shrink when the filters are on. petri keeps the analysis of sounds it leaves out, so turning a filter off again does not mean waiting for them to be read a second time.
• The map's own filters are separate. The max length filter on the map hides sounds you have imported. The import filters decide what petri imports in the first place.

the window

The window has three tabs, map · list · settings, under one top bar and above one footer. The map is the home view, and everything else opens as a rail on top of it.

The footer's hint line always shows something. With nothing under the cursor it reads "drag across the field to audition · click a dot to pin". Hover any control and the line explains that control. The window opens at 1120×710, resizes freely and remembers its size.

how you touch it

Five gestures cover the whole map. Every rail then works the same way: click a word to toggle or cycle it, and 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: resets the view to the whole map.
• arrow keys: move around the map by ear. The pin steps to the adjacent dot in that direction and auditions it.
• hover is silent by design. It moves the highlight and the readout, but only a press or a drag makes sound. The one exception is hold on the audition rail: with it on, the map plays as if pressed, so hovering plays too. The headphones icon in the toolbar turns auditioning off completely.

Labels are lowercase, there is one accent colour, and buttons have no borders, because the words are the buttons. The footer explains whatever is under your cursor.

the field

Every sample is one dot on the map. Each dot's position comes from a similarity layout, which uses the sound's analysed character: brightness, noisiness, motion, density, attack and harmonicity. Sounds that are alike form groups on their own. A dot's colour shows the sound's family.

the analysis readout

Pin a dot to see its analysis at the bottom of the left control rail:

There is a fourth axis that the readout does not show, level. Until 1.1 it was a placeholder, so loudness did not help any match. petri now measures level from the audio itself. Libraries analysed before the update catch up in the background, using decodes petri was already doing, so you do not wait for a re-analysis pass. Level lets find by example and the concatenative rail tell a quiet sound from a loud one.

the toolbar

The floating palette above the map holds everything in one strip: three panels, two tools, five makers and five players.

Only one rail can be open on each side. Opening a second rail on a side closes the first. Every open rail shows a small chevron on the edge that faces the map, which collapses the rail. Since 1.1, keys and the concatenative rail sit on the left with the engines, because both make sound from live input. Either can run while the recorder works on the right. Projects saved before the update reopen with these rails on the new side.

arrange & display

The control rail (hamburger icon) sets how the map is laid out and drawn. It also shows the analysis of the pinned sound. At the top you choose between two approaches: let the map cluster itself, or set the axes by hand.

dots

• style — one ring of preset looks in place of separate size and spacing dials: default · compact · broad · squeeze · pangea · stars. Each look is a size-and-spacing pair. Since 1.2 the ring also has tiles, which is the square grid and has no size or spacing. The map re-fits live. ⇧§ steps through the ring from the keyboard, and v switches to tiles and back.
• reset gaps — packs the map again from scratch. Generating sounds leaves marks in the layout, such as channels carved around vines and stalks that have since gone. This removes those leftovers, and the sounds you made keep their places. It also unpins a saved view.

projection

• x: default · y: default is the similarity layout, where sounds cluster only by how they sound. You can set either axis to one measured dimension: brightness, noisiness, density, motion, attack, harmonic, length. The map then animates into a compass where that axis means what you chose (dark ↔ bright, tonal ↔ noisy, snappy ↔ slow…).
• family pull — how strongly family tags pull the clustering. 0 is purely acoustic, the default is 0.20, and the maximum gives you distinct family islands.

filters

• max length — sounds longer than this stay off the map. The default is 1.5 s, so the map starts with one-shots. Raise it to map textures and loops.
• max dots — the most dots the map will plot, default 10,000 since 1.2 (it was 5,000), up to 50,000. The old cap was there for performance reasons only, and the dense-map work in 1.2 raised it. The footer count tells you when the cap is limiting the map.
• 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.

You will find colour by (type · certainty · character) on the settings page.

tiles — the grid view

Tiles shows the same library on a square grid. Every sample takes one square, and samples that sound alike take neighbouring squares. Together the squares form an outline, like a coastline, that you can read at a glance. Press v to switch to tiles and v again to come back. You can also pick tiles on the control rail's style ring.

• it is the same library. Tiles is a way of drawing the map, and the sounds are the same. The filters, the family key, the radar, the pin and every gesture work as they do with dots. Sweep to audition, click to pin, shift-click to select.
• neighbours stay neighbours. Each square is placed using the same similarity layout the dots use, so sounds that sat together as a group sit together as a block. You lose the density signal, because a crowded area and a sparse one look the same when each sample is one square. In return, every sample is equally visible.
• nothing drifts and nothing overlaps. The squares do not settle or bob as dots do, because the grid is the layout. Anything you generate and keep takes the nearest free square to where it stood, so a brood lands beside its parents and never on top of them.
• the grid remembers. Tiles is a style like any other, so petri restores it with your settings at the next launch.

On very large libraries, 1.2 also fixed how squares are placed. Tiles could end up between grid lines without taking a square, which looked like a broken grid. The grid now grows until it holds every sample.

find by example

When a sound is close to what you want, you can ask for its neighbours in three ways. Each way ranks the results from most to least similar and shows a match percentage.

• the similar rail (ear icon, or t) — follows the sound you last pinned or previewed. It lists the forty nearest sounds, each with its waveform and a similarity %. ↑/↓ step through the ranking and audition each sound.
• similar from the list — the ear button on any list row ranks the whole library against that row. The reference row reads ref, and every other row shows its percentage.
• drop a file on the search box — this asks petri to find sounds like the file. petri reads the file, imports it to dropped/, and lights the two hundred closest sounds you own on the map.

find by description

Type what you want in plain words, such as "dark evolving drone" or "punchy metallic snare". Matching sounds stay lit and the rest of the map fades back. You do not need tags, names or folders.

• The search understands descriptions as well as filenames. It listens to the sounds in the same way the map does, so "warped tape choir" works on a folder full of AUDIO_017.wav.
• While the radar is on, sweeps, clicks and arrow-key steps only touch matches, and the dimmed dots stay silent. The list tab filters to the same ranked results.
• petri tells you when results are weak. A query that nothing matches gets the message "nothing in your library reads as … yet".
• ⌘F moves the cursor to the search box from anywhere. Esc or the × clears it.

the list

The list shows the same library as a table you can search and sort. Use it when you know a sound's name, want to work through a pack, or need to tidy.

• Every row plays on click. ↑/↓ step through the rows and audition them. ⏎ switches to the map with that dot pinned. Typing anywhere starts a search.
• Row buttons: ear = similar-to-this · pack = show this pack · star = like it · map-pin = show on the map. You can click the pack name too.
• Each row shows the detected key. A pitched one-shot shows its root, and a harmonic loop shows maj or min. The key chip filters the list to one key.
• Multi-select with ⇧/⌘-click (⌘A for all). Then drag the selection straight out to your DAW or Finder as files. Or press the banner's spawn from these. petri jumps to the map with those rows selected, and the spawn button beside the last dot breeds exactly those sounds.
• tidy — duplicates finds exact copies (same name, same duration). twins finds sounds so alike that your library doesn't need both. Folding hides the copies for this session, and nothing is deleted from disk.

the brood — keep or discard

The engines all work the same way. Each one makes a candidate, an unsaved sound that waits on the map until you keep or discard it. Nothing is written to your library until you keep it.

• ✓ keep writes the candidate to your library as a real 24-bit WAV. Its dot stays where the candidate was made, and the file itself records all of its parents.
• ✗ discard removes the candidate. Nothing is written. To clear the whole brood at once, right-click anywhere on the map and choose discard all takes (n). It discards every waiting candidate as one undo step. ⇧Esc does the same from the keyboard (1.2.1).
• ↻ re-roll replaces the candidate with another one made from the same recipe and new dice (a new set of random choices). spawn and stack use the same parents. mill uses the same target and mode. 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/ and lux_petri_layered/. Their dots stay where they were made and carry their engine's mark. They are ordinary WAVs, so you can drag them out, breed from them and sequence them. Since 1.1 each one is named lux_petri_<WORD>_<kind>_<nn>.wav, so you can recognise a generated sound wherever it ends up.

spawn — breed

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

breeding a child

You breed on the map. Every method below gives you two candidates, the same roll made twice, so you have a choice. Only the first plays while it bakes. Click the other to hear it.

• pin a dot, then press the spawn button that pops up. One press rolls partners from that dot's nearest neighbours and breeds them straight away. Rest the cursor on the button for a moment before you click. The pop-up arms after a sixth of a second, and a faster click falls through to the map and re-pins the dot.
• click a child, then press its spawn button. Any candidate on the map, kept or not, shows the same button when you click it. The button appears on its own, because grow, mill and stack need a real file and spawn is the one action a child can take. One press crosses the child with a rolled neighbour. Use this to take a lineage past generation one: click the child you like and breed more from it.
• shift-click 2–3 sounds, then press spawn. They can be dots, children or a mix. The button by the last one breeds exactly those sounds, and petri does not roll any other partners.
• hold ⇧X and click a dot. This does the neighbourhood roll with no pin and no wait for the button to arm. It is the quickest way to run a room.

Every parent gets an equal share of the child. There is no mix to set. The character comes from the mode, the dice and re-rolling.

four modes (1.4)

A row of four words sits at the top of the rail: morph · graft · cast · ring. The word in the accent colour is the mode every spawn uses, whichever way you start it on the map. Click another word to switch. Each child keeps the mode that made it, so one family can hold all four.

spawn's ring works like the design rail's ring block, with one difference. There the oscillator is a frequency you set on the block. Here it is the other parent.

the family

Several families can be in progress at once, and they share the one braid. The active lineage is lit and the others sit dimmed beside it. Click any of their dots to bring that family forward. A child that is still baking is grey and takes its colour when it is ready. A kept child stays in the tree with a small white heart, and you can breed from it like any other.

the genes

Every child rolls its own character. The four cells at the foot of the rail show the picked child's genes. They are readouts, so they are grey and you cannot edit them. To change a child's character, ↻ it for new dice, or breed again in another mode.

That table describes morph. In the other three modes tilt and width mean the same thing, applied after the bake. The attack and dice cells read that mode's own two values:

The cells keep their morph names and hover text in every mode (1.4), so the readout says attack and dice while it shows the values above.

morph blends the parents' actual audio. Attacks are protected, timing is reconciled, and the child's body is painted from its parents' own material. graft cuts that same audio at its seams, and cast convolves it. None of these three synthesises anything. ring can: when its dice choose a sine, that oscillator is new, tuned to the pitch it heard in the partner. (For a synth take of a sound, use grow.)

Kept children are named by family. Each family grows a two-syllable word from its roots, so a lineage reads as lux_petri_GORKIN_spawn_01-m.wav, lux_petri_GORKIN_spawn_02-m.wav… in lux_petri_spawned/. The letter before .wav is the mode that made it: -m morph, -g graft, -c cast, -r ring. -s marks children of the retired synth mode, which still restore.

grow — evolve

Point grow at any sound and it evolves a new synth voice towards it. It listens, mutates and gets 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

• A run listens first, then guesses, then improves. It starts from what it heard (pitch, envelope and texture). Then it evolves generation after generation and judges every attempt by ear against the target. You hear it check in as it improves.
• Each take has its own character. Two strands stay close (faithful), one drifts, and one goes wild, which means 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 again by themselves with a new guess, and strands that are still improving get extra generations. You do not need to watch for dead ends.
• On the map, four vines grow out of the target as the strands evolve. Checkpoints drop seeds along them, and a finished garden comes back in your next session.
• Nothing is written to disk until you keep a take. Checkpoints and finals use no disk space until then. ✓ at a vine's tip renders the 24-bit WAV to lux_petri_grown/ and plants the dot there. (Dragging a take out to your DAW keeps it too.)

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, which is the neighbourhood you can see. Pin a sound and the mill takes the sounds around it.

three characters

In the rail you choose the mode word. The cells under the lanes are the settings for the next take you make on the map with wheat. Drag a number up or down to change it. In loop mode, click rhythm to step from random through the beds, and click bars to cycle 1 · 2 · 4. With the rhythm on random, every ↻ rolls a new one. (In 1.4.2 these cells were grey readouts. 1.4.3 made them settings again.)

The rail shows the four cells of the active mode, and the table above covers all three. A take is repeatable. The same grist and the same recipe give the same result, and ↻ rolls new dice for another one. Kept takes go to lux_petri_milled/, and each take plants a spiky dot at the tip of its wheat stalk on the map.

stack — layer

Layering a hit with a few similar hits, each nudged in pitch, pan, tone and level, is a long-established sound-design technique. It normally takes 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 pinned dot's button row (spawn · grow · mill · stack). The rail opens when you press it. You can also open the rail from the layers icon in the toolbar.
• One click gives you two takes, which appear on the map as orbs. They are the same relatives given two different treatments, so you have a choice. Only the first plays while it bakes. Click the other to hear it.
• ↻ re-roll on the map keeps the parents and rolls new dice.
• Nothing is written until you press the map's ✓ or 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 layered around it.
• Relatives come from the map, not the family. A strict nearest-neighbour search stacked five of the same kick, because the embedding carries the family tag. So stack uses spawn's own dice: map-space proximity, where cluster borders live.
• Each relative rolls its own detune, pan, filter and trim, and ducks 25% under the base. The sum is peak-normalised to −1 dB, so a stack comes out at a usable level and not a hot one.

the treatment ranges

The seven bars set ranges, and each layer rolls its own number inside them. Drag a bar to widen or narrow the roll. reset returns them all to the defaults. The ranges persist between sessions.

Kept stacks go to lux_petri_layered/ as lux_petri_<WORD>_layer_01.wav. Their dots plant on the map like any other generated sound, so a stack can be a parent, a key or a sequencer lane.

design — one sound, shaped in place

The design rail lets you shape one sound by hand. Pick a sound from the map, place up to three effect regions on its waveform, listen, and export the result into your library as a child. Every other engine in petri works by chance: you ask for a candidate and re-roll until you like one. The design rail uses the sound design tools from sample studio+, and it works on the sample you pick. Open it with d, or with the brush in the toolbar.

the rail, top to bottom

• the head: rand all rolls a random sound and a random chain in one go. pick arms the map, so the next dot you click comes onto the rail and plays through the chain you already built.
• the sound: the sample on the rail. Use the small dice beside it to shuffle in a random one. Click the name to hear the original, which is the library file with the chain and every edit bypassed. Use this to compare A/B.
• gain · vari · width · rev: whole-sample controls. Drag the numbers to change them, as everywhere else in petri. vari is tape varispeed (±100% = ±2 octaves), and it changes the length. rev reverses the sample and the blocks on it together.
• play · loop | render · reset: while the rail is open, space belongs to the rail, so it previews the designed sound and not the map.
• the wave: the designed sample. Each block is drawn as a wash across the region it covers, with 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, click the chevron to swap one, or click the × to clear it.
• the curve: the selected block's automation at full rail width. The wave shows the automation, and the curve edits it.
• export as child: the only control here that writes to your library. Under it is a list of the sounds you exported this session. Click one to hear it.

the ten effects

Each slot holds one effect, and every slot offers the same ten. The slots run in order as a 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 other effects are linear. The curve panel tells you which type you have, and the type is fixed for each effect.

a block is a region you draw

No effect here is a knob with a single value. You place each effect on a stretch of the sample and shape it across that stretch:

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

Hover over a block on the wave to show its handles without selecting it, so you can see what you are about to grab. There is no trim, because petri is not a chopper. Every pixel of the wave box is audio.

rolling, rendering, exporting

• the dice re-roll the chain. Each roll gives one to three effects with fresh regions, curves and fades, and fx1 always plays. shuffle (beside the sound) loads a random sample through the chain you built. rand all does both at once. Every roll plays automatically, so you always hear the result.
• render flattens the chain into the sample and frees all three slots, so you can build the next three effects on top of what you made. The generation counter goes up. 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. Its parentage is stored in the file, as with everything petri makes. You can also drag the export block straight into your DAW, which writes nothing to the library.

lineage & undo

Generated sounds build on each other, so petri records where each one came from.

• Lineage travels with the file. Every kept sound carries its recipe and parentage inside the WAV itself. They sit in the file's metadata, and the audio is untouched. You can rename the file, move it or re-import it years later, and petri still knows its parents, its engine and where it sat on the map.
• The map remembers. Each session, kept sounds return to the place on the map where they were made, and each one shows its engine's mark. Children made by spawn keep visible threads to their parents. The tidy after save setting removes these lineage markings if you want to keep only the dot.
• Undo is generative history. ⌘Z steps back through spawns, mills, discards and re-rolls. It holds up to 64 actions, and the top bar names each one (undo · spawn a child). Undo leaves kept sounds alone on purpose, so a file you kept stays kept.
• Choose where they are saved. save generated to (settings · map) decides where everything you spawn, mill, grow and layer goes. By default it is lux_petri_* folders beside your samples. inside petri keeps them in the plugin's own home, so nothing appears in your library until you drag a sound out. pick folder saves them to a folder you choose, such as your library drive. Wherever they go, nothing else changes. The sounds still carry their lineage, they still return to their place on the map, and the hard reset below still deletes them.
• The one hard reset is in settings → about → clear all generated samples. It deletes every spawned / milled / grown / layered file from your folders and rescans. It takes two clicks and shows clearly when it is armed, to prevent accidents.

the audition rail

One set of controls shapes every preview: map sweeps, list rows, similar-rail auditions and replayed recents. Open it with a, or click the pointer tool a second time. Since 1.5 it also holds the map pointer, which plays the map from a controller or your DAW.

loop — hold a dot and it goes again

New in 1.2. The control 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, with one hit per gridline at the session tempo. Hold a dot with 1/16 set and it plays a sixteenth-note pattern in time with your project.
• with quantise off the voice starts again each time it ends.
• every pass re-rolls the dice, so pitch, pan, start point, filter and reverse all change. Use this to hold one sample and record variations of it straight into the recorder.

loop works together with a scrub. When you come to rest at the end of a sweep, the dot you stopped on is the one that ratchets. A hold that already has a meaning takes priority, such as a grab or the step rail's drag-out arm. The setting is remembered between sessions.

hold — the map as if pressed

New in 1.5. hold sits on the preview row next to loop. With hold on, petri behaves as if you were pressing the map:

• with no pointer on, the mouse plays every dot it moves over. You do not need to press or drag.
• with a pointer on, the pointer plays every dot it crosses. The mouse goes back to normal: press or drag to hear a dot.
• with loop on as well, the dot under the held mouse or pointer keeps retriggering.

Click hold to turn it on and leave it on. It is then underlined. You can also hold from outside petri: press a sustain pedal (MIDI CC 64; any value of 64 or more counts as pressed), or automate the map hold parameter in your DAW. The word lights in the accent colour whenever hold is on, whichever way you turned it on.

Try the dice on start and reverse with a scale lock, then sweep one colony. The same dots play a different phrase each time, so the colony works as an instrument.

Dragging any number on this rail is smooth. petri saves your changes to disk once, when you let go. In 1.5.0 it saved on every small movement, which made dragging laggy. 1.5.1 fixes this here and on the settings page.

the map pointer

The pointer lets you play the map without the mouse. Move it with an XY controller, a pair of knobs or your DAW's automation. Every dot it crosses plays through the audition rail, as a mouse sweep does. It keeps playing when petri's window is closed.

The pointer section sits on the audition rail, between quantise and the envelope. Its label reads pointer · play the map from a controller. Choose one of three words:

• Choosing position or steer turns hold on, so the pointer plays straight away. Choosing off releases hold. Click hold to turn it off while the pointer stays on: the pointer then moves silently, and a sustain pedal plays only while it is down.
• steer has two more settings. speed (0.2–4×, default 1×) sets how far a full push moves the pointer. glide (0–95%, default 70%) sets how long it keeps moving after you let go. Drag either number.
• up is up. Pushing the controller up moves the pointer up the map, as on most XY controllers.
• Quantise and loop apply. With quantise set, the pointer plays on the grid, as a sweep does. With loop on, the dot under a resting pointer keeps retriggering.

the region

While a pointer is on, a frame appears on the map. The pointer only moves inside this region, so a controller's full travel covers the part of the map you care about. Drag any of its four corners to resize it, as you would crop a photo. The region starts as the middle half of the dots on screen. It belongs to the map, not to the screen, so it stays in place when you zoom or pan. The handles keep clear of any open rail.

MIDI CCs and DAW parameters

To use a different CC, drag the number beside x cc, y cc or hold cc up or down (0–127). There is no learn mode. If a CC and a DAW parameter both move, petri follows whichever moved last.

with the window closed

In a DAW, the pointer keeps playing after you close petri's window. It carries on from where it was, at the speed it was moving, with the same hold and the same dots. So you can record automation sweeps with the plugin window out of the way. Open the window again and the map picks up the pointer where it is.

keys

The keys rail maps your library across a MIDI keyboard in four different ways. Every key holds 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 small dice. At 3–4 octaves the rows are too thin for the per-key dice and lock, so both are hidden. Go back to 2 octaves to use them. The big roll still works, and locks you set at 2 octaves still hold.
• hand picks: drag a key's note dot onto any sample on the map to point that key at it yourself. You do not need to enter a mode. The pick holds like a lock, so it survives a rescan and roll re-deals around it.
• kits save: the + saves the whole keyboard (mode, picks and locks) as a named kit. In drums mode, collect copies the twelve files into a kits/ folder so you can use them anywhere.
• collect drags too (1.1): press collect and drag, and the whole kit comes out as one multi-file drag. Drop it on a Live drum rack and every pad is filled. A plain click still saves the kit to the folder.
• MIDI from any octave: any octave of any controller reaches the map, because notes wrap onto the keyboard. Drag across the keys for a glissando. Turn velocity sensitivity on or off in settings.

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 petri rebuilds that loop from small pieces of your samples. Feed it a bassline and the library plays it back in its own voice. Nothing is pre-rendered. petri matches what it hears against your library as the audio arrives.

getting audio in

petri is an instrument, so before 1.1 it had no audio input. It now has two, and neither needs much routing.

• sidechain: the plugin has a stereo sidechain input. Since 1.1.4 it arrives switched on, so a host with no per-bus routing controls can still feed it. petri only listens to that bus and never passes it through, so it stays an instrument. In the standalone app the bus stays off on purpose. An active input there would open a recording device and ask for your microphone at launch, for a rail you may never open. In the standalone, use audio in.
• a device, directly: the audio in row opens an input itself, such as your mic, an aggregate device, BlackHole or similar. Click the row for the list. It shows sidechain first, then every input device, with a tick on the current one. This way needs no routing and avoids host quirks.

AU cannot receive audio

Apple sets this rule for instrument plugins, and the rail in the AU tells you so. Use the audio in row, which opens a device directly, or load the VST3 and feed its sidechain.

the four approaches

The row of words across the top sets how petri answers. Each word is a complete recipe of trigger model, gate and balance. Its name describes the link between what you play and what comes back. The engine starts in mosaic.

An approach is a starting point. Every cell stays live afterwards, so you can pull any cell away from its preset to find your own sound. For example, the whole difference between answer and bloom is the setting of the ring cell.

the cells

There are twelve cells in three rows. They work like every other number 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 separately. A library of 2,352 sounds becomes 71,675 units, and its tonal units go from 219 to 2,542. Short percussive material gains the most. The four approaches only sound clearly different from each other once petri is matching slices.

• It runs only when you ask, because it is heavy. whole stays playable while the pass runs.
• It runs once per map, then caches the result. A fresh install mostly reads its slices from a pre-computed set that ships with petri, so it has little to compute.
• You can cancel it. While it runs, the pool line becomes an analysis row with a count on the left, a progress bar, and cancel on the right. The listen cell counts up in per cent. Cancelling returns you to whole. petri does not keep the progress, because the cache is written only at the end.

the pool, and the lasso

Above roughly 2,500 sounds, a library is mostly sounds whose descriptors duplicate each other. Thirteen times as many sounds moved the match score by only 0.02. So petri selects at most 2,500 for the matcher. It picks them by coverage quotas across the matcher's own space. It always includes your own fingerprints, which are generated sounds and anything you've used three times or more. No single family may take more than 35%. Measured on a library of 31,265 sounds, the curated 2,500 beat the full table on every column, because taking the junk out of the neighbourhood makes every neighbour better.

• The pool line shows the cap openly, for example 2500 of 31265 · curated. Its left half, N ready, shows how many sounds in the pool are decoded and ready.
• scope lets you set the pool by hand. Arm it and a transparent overlay drops over the map. Draw one freehand stroke and it closes into a region. Only the visible dots inside that region can then answer, whether listen is set to whole or inside. The pool count shrinks to the scoped set as you draw. Disarm scope to clear it.

Scope lets you curate the pool by eye. Circle one colony and the rail can only answer with those sounds.

reading what it's doing

• the ribbon shows input level along the top and the grains that answered it below. Each grain takes its sample's dot colour, and the newest is on the right.
• the strip shows the sample sounding now and the input state, which is one of no input · warming N · listening.
• the grain history lists the sounds that answered most recently, in order, in the same way the audition rail lists what you recently heard. Every one is a file you own.
• the tutorial wash appears after two seconds with no audio arriving. The display then explains the routing, because an empty display would make a working rail look broken.

sequence on the map

Draw paths across the map and they play. Each route steps through its dots to its own rhythm, locked to tempo. There are six lanes and twenty-six rhythms, so polyrhythm comes naturally.

• Every onset steps the route to its next dot, so a route needs at least two dots to play.
• direction is set 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 to bounce an eight-bar loop of that lane 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 the folder. One click gives you a groove kit. Collected loops never re-enter the library pool.

sequence on a grid

The step sequencer is the conventional grid version. It has five lanes of sixteen steps and 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, which gives you polyrhythm at once.
• 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 as a single WAV take. That covers sweeps, keys, both sequencers, the concatenative rail's answers and engine auditions. Since 1.1 it catches them whether you armed it or not.

keep last 60 s

The recorder keeps a rolling 60-second stereo ring of every block petri produces, whether armed or not. That includes auditions, keys jams, concat answers and sequencer runs. Press keep last 60 s and that minute becomes a numbered take, after the fact. You can recover a jam you didn't record.

• The label counts what is in the buffer. It reads keep last 12 s twelve seconds after a cold start and settles at 60.
• A successful keep flashes saved for a moment, and the take appears in recent below.
• If there is nothing to keep yet, it tells you and writes no file.

• Takes are 24-bit stereo WAVs, named take_001.wav onward, saved to ~/Music/petri by default.
• pause holds the take open. Press it again to keep recording into the same file.
• The ring costs you nothing to leave running. It is the recorder's own memory and no file is involved. Only keep or record writes to disk.
• Recording is one of many ways to get sound 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. Anything you can hear, you can drop on a DAW track as a file.
• drag out with fx (settings · audition, off by default) exports what you heard. When it is on, the player bar's grip renders the sound with the armed audition treatment baked in: envelope, pitch, filter and the dice as they rolled. When it is off, the grip gives you the raw file. When it is on but you never previewed the sound with the treatment, it still comes out raw, because there is 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

Settings is one scrolling page with six sections: library · scanning + analysis · map · audition · shortcuts · about. Changes apply live and petri remembers them.

themes

There are eight worlds: four dot palettes on a light sheet, and the same four on a dark sheet. The § key steps through them from anywhere.

The palette changes how the dots are coloured. The sheet switches the whole UI between paper and near-black. Dark mode is your choice and does not follow the system setting. Step past the four light worlds and you reach the four dark ones.

activation & the demo

petri uses no serial numbers. Activation is a short sign-in tied to your Lux Cache account. The app shows a code and your browser approves it.

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 and shows registered to you. The full sample library then 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 recipes, each from start to finish. Each one starts at the map and ends with files that you keep, collect or drop on a DAW track.

keyboard

You can work the map from the keyboard. Keys cover tools, rails, walking and undo, so you don't need to reach for the toolbar.

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

In the list, ↑/↓ step through the rows and audition them, ⏎ shows the row on the map, ⌘A selects all, and typing starts a search.

the rhythm alphabet

There are thirty-two rhythm beds, shared by the route player and mill's loop mode. Every bed fills the four-bar phrase. The letters (and, past Z, digits) let you read a lane at a glance (lane 3 · J waltz). 1.2.1 retuned the library: swing is now waltz, tresillo is now dancehall, jersey, amen and chaos are new versions of themselves, and six house beds join at the end.

Most beds are one- or two-bar grooves tiled over the phrase. clave, broken and build change across their four bars.

families & colours

petri tags each sound with one of thirteen families as it analyses the sound. In the krayon theme the dots use exactly these hues. The other palettes re-tint the same families. A colour always means the same family everywhere: map, list, keys and sequencers.

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

petri sets family tags by listening to the sound itself, and uses 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 use 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 a dot. Hovering alone only moves the readout, unless hold is on. If nothing ever sounds, check the headphones toggle in the toolbar. If everything sounds as you hover, turn hold off.
• The map shows one-shots first by default. max length defaults to 1.5 s, so pads and loops may be hidden until you raise it. The footer's visible of scanned count shows you when sounds are hidden.
• Quantise turns sweeping into playing. With 1/16 on, every scrub lands on the grid at your session tempo (the host's tempo inside a DAW).
• Keep before you reorganise. You can breed on from a candidate without keeping it, but a library rescan clears unsaved spawn history. Keep the children you care about before you reorganise folders.
• Re-roll before you tweak. ↻ costs less than tweaking a mediocre candidate, because it uses the same recipe with fresh dice. Use the ✓ ✗ ↻ chips first. If the rolls keep missing, change the rail's mode word and spawn again.
• Dragging out keeps the sound. When you pull an unsaved child or take into your DAW, petri saves it to its engine folder first. The file your project references is then real and permanent. The design rail's export block is the one exception: it hands your DAW a temporary file and writes nothing to your library.
• Everything generated lives in four folders, by default inside your library root: lux_petri_spawned/, lux_petri_grown/, lux_petri_milled/ and lux_petri_layered/. Every file carries its parentage internally. The folders are safe to browse, rename and back up. If you prefer your library untouched, set save generated to (settings · map) to inside petri, which keeps them inside the plugin until you drag one out. To keep your work with a portable library drive, pick a folder on that drive.
• tonal keys is right to refuse some sounds. Only confidently pitched material can become an instrument. Everything else still lives in bright / family / drums modes.
• Big libraries are fine. Since 1.4.3 the import filters keep a huge library to 20,000 sounds by default, chosen evenly across its folders, without loops, copies or long files. For a library that takes a while to check, turn off check on launch. The map calms its animations as it gets crowded, and since 1.2 the plot caps at 10,000 dots by default (you can raise it to 50,000). Narrow a huge library with filters and the radar, not by scrolling. tiles also helps with a crowd, because every sample is equally visible and nothing hides under anything else. Quitting mid-scan is safe too. petri abandons the import immediately, so your DAW doesn't wait for the rest of it, and picks the scan up at the next launch.
• Low cpu mode (settings) is the one switch for gigs and old laptops. The map holds still and analysis pauses, and everything still works.
• Set scope before you play into the rail. The concatenative rail answers from up to 2,500 sounds. Lasso one colony with scope first and the answers come from that one voice, not from your whole library. It's the fastest control on the rail.
• listen (inside) is a one-time cost, per map. Start it when you have time to wait, not mid-take. whole keeps playing while it runs. It caches when it finishes, and cancelling throws the progress away.
• Play the rail as you go. An approach is a starting point. The performance is in ring, density and spread. hold freezes an answer you like so you can play over it.
• If you forget to press record, use keep last 60 s. The ring is always running, so a take you didn't arm for is still there for a minute.
• A stack is a hit, not a patch. Two candidates land per click so you can choose. Neither survives a restart, so keep the one you want before you close.
• Choose your parents yourself. Shift-click two or three dots and the button row appears beside the last one. spawn, mill and stack then use exactly those dots.
• Render writes nothing. Export writes the file. 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. Render as many passes as you like before you decide.
• If previews go 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), so 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 that petri has not analysed yet. They colour in as it reads them (the settings progress line counts them). If the count never advances, check whether background analysis or low cpu mode has 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 you clear it with Esc.

If the sounds were never imported, the import filters may have left them out. skip loops leaves out loops and stems, skip files over leaves out long files, and cap max sounds takes only part of a very large library. Exact copies of a file are always left out. Change the filters on the import card, then press rescan library.

My huge library takes a long time to open.

You can play the map while petri checks your folders. To skip the check, turn off check on launch in settings → scanning + analysis, and press rescan library when you add samples. For the first import, keep the import filters on. With the cap at 20,000, petri reads 20,000 files, not all of them.

Moving the mouse plays everything.

hold is on. Click hold on the audition rail's preview row to turn it off, and check that no sustain pedal is held down and that the map hold parameter isn't automated in your DAW.

Search finds nothing sensible.

The radar searches only analysed sounds, so a fresh import needs a moment before you can search it. petri tells you when a query is weak. Try describing the character of the sound ("soft sub with a long tail") in place of pack names.

A sample won't land on a drum key.

This is 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, because Apple's instrument format has no audio input at all. Use the audio in row at the top of the concatenative rail, which 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. After two silent seconds, the rail's own display tells you which case you're in.

The concat pool says "2500 of 31265".

This is working as intended. Past roughly 2,500 sounds, a library is mostly duplicates in the matcher's terms. So petri curates the pool for coverage and leaves the rest out. The curated pool 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 is a full analysis pass, which is why it never runs automatically. whole stays playable throughout. The result caches per map, so you wait only once. You can cancel from the analysis row, but a cancelled pass starts over, because 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 keeps its own state in ~/Library/Application Support/Lux Cache/petri by Lux Cache/ (macOS) or %APPDATA%\Lux Cache\petri by Lux Cache\ (Windows). Generated sounds go in lux_petri_* folders inside your library root, recordings in ~/Music/petri, and collected loops in ~/Music/petri/petri collected/. save generated to in settings changes where generated sounds go. With inside petri, they live in that same state folder and stay out of your library. With a picked folder, they go in lux_petri_* folders inside it.

I have a feature idea.

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