Generative & evolving sounds

MIDI Generators: Seed, Rhythm, Shape, Stacks, Euclidean

Generators live in the clip's Generate tab and write notes into the selected clip region when you press Generate (or every time you change a parameter with auto-apply). Each is a different idea of what a phrase is; chaining them with transformations is the sequencer.

1. Seed: random notes within a pitch range and a density, scale-aware when the clip's scale is on. Density 30–50%, note range two octaves, note length 1/16, velocity range 60–110. Press Generate repeatedly until one pass has a shape you like; Seed is a dice roll, so roll often.
2. Rhythm: a drum pattern generator with density and variation per lane; use it on Drum Rack clips for hats and percussion, keep the kick drawn by hand (the anchor). It can write accents and ghost notes with a sensible velocity spread.
3. Shape: draws a melodic contour (arc, ramp, zigzag) across the clip and places notes along it in the scale; the most "composed" of the four. Set the step grid to 1/8 and the contour to a rising arc for a 4-bar phrase that peaks on bar 3.
4. Stacks: generates chords: chord size, interval choices, voicing spread, in the scale. Combined with Shape (Shape the top line, Stacks under it) you have a chord progression generator.
5. Euclidean Sequencer (pack device in the generator list or as a Max for Live sequencer): distributes k hits across n steps as evenly as possible; 5 in 16 and 7 in 16 on two percussion lanes produce the polyrhythms minimal techno is built on. Rotate the pattern per bar with a mapped macro.
6. Set the clip to Scale mode (the key and scale at the top of the clip editor) before generating: every generator respects it, which is what keeps generative output musical.

Variations: Seed with density 10% on a 16-bar clip, note length 1 bar, range one octave: a slow generative bassline. Stacks with 2-note chords at 1/2-bar: dub techno stabs. See MIDI tools.

Transformations: Recombine, Connect, Time Warp, Ornament, Strum, Quantize, Velocity Shaper

Transformations act on existing notes (selected or whole clip). Applied in sequence, with a duplicate clip per stage, they turn one generated phrase into a family of related ones — the generative equivalent of a theme and variations.

1. Recombine: shuffles pitches, rhythms or both among the selected notes (modes to rotate, mirror or shuffle). Shuffle pitches only: the rhythm you liked stays, the melody is new each press. The lowest-risk variation tool.
2. Connect: fills the gaps between selected notes with passing notes in the scale. Apply at 30–50% to a sparse Seed phrase to make it a run; apply at 100% to get a continuous 1/16 line for an arpeggiated feel without an Arpeggiator.
3. Ornament: adds grace notes, flams or trills before notes with a chance and a length. 15–25% chance, 1/32 length: the human decoration a sequencer never has.
4. Time Warp: redistributes note timing across the selection with a curve (accelerate, decelerate, custom). A gentle decelerate across a 4-bar phrase makes the end breathe; applied to drums it is a controlled ritardando.
5. Strum: spreads chord notes in time (up/down, ms or grid): guitar strums on Stacks output, or at 1/16 spacing a rolled-chord arp.
6. Quantize with a strength below 100% (60–80%) after any generator: keeps generated looseness but pulls it toward the grid; Velocity Shaper draws a velocity curve across the selection (arc, ramp, random with range) so the phrase has dynamics the generator did not give it.
7. Workflow: duplicate the clip before each transformation (Cmd+D) so Session view holds the whole lineage: clip 1 raw Seed, clip 2 recombined, clip 3 connected, and so on. Follow Actions between them (next recipe) play the lineage as a piece.

Variations: Arpeggiate (transformation) on Stacks chords with a rate and style for arps baked into the clip, then Glissando (12.1) to glide between them — see MPE & expressive sounds.

Follow Actions, note probability and velocity ranges

Per-note Chance (0–100%) and Velocity Range (a random deviation per note) are in every MIDI clip since Live 11; Follow Actions decide which clip plays next with a probability between two choices. Together they are a Markov-chain arranger with no extra devices.

1. In the clip editor, show the Chance lane: set the main notes to 100% and the fills, ghosts and ornaments to 30–70%. A hat clip with 1/16 ghosts at 50% chance never plays the same bar twice and never loses its downbeats.
2. Velocity Range lane: ±15–25 on hats and percussion, ±10 on bass; each trigger picks a random velocity within the range, which through velocity→filter in the instrument is also timbral variation.
3. Follow Actions (clip Launch section): Action A and B with a probability slider; trigger after N bars (or use Linked to the clip length). Clip A: 70% Next, 30% Any. Clip B: 50% Previous, 50% Other. A short Clip C with 100% First is a reset that keeps the chain from wandering forever.
4. Scenes have Follow Actions too (Live 11+): a scene-level chain that moves whole sections with probability while the clip chains run inside them.
5. Make the chain legible: colour clips by role, keep 3–5 clips per track, and give each a distinct feel so the listener hears the decisions.
6. Record the Session output to Arrangement (global record) for 10–20 minutes, then arrange from the recording (last recipe).

LFO, Shaper, Envelope Follower and Expression Control on macros

The M4L modulators map to any parameter (several each, since Live 12) and are the slow and the reactive timescales of a generative patch. Point them at Rack macros rather than raw parameters so one modulator moves ten things in a designed way.

1. LFO 1: Random shape, Smooth 0 (sample-and-hold), Rate 1 bar synced, Depth 40% → Macro "Timbre" (which maps Wavetable position, filter res and Roar drive). A new timbre every bar, within a range you chose.
2. LFO 2: Sine, unsynced, 0.017 Hz (≈ 1 minute), Depth 60% → Macro "Open" (filter freq, reverb send). The arc nobody notices as periodic.
3. Shaper: draw a 64-bar curve (slow rise, dip at bar 40, peak at 56) → Macro "Density" mapped to Note Length gate, Velocity device Random amount and hat chain volume: the number of events grows across the phrase. Set Shaper to loop or to one-shot with a Push button retrigger.
4. Envelope Follower on the kick → Macro "Duck" inverted (bass filter, pad volume) with Rise 2 ms, Fall 250 ms. Reactive, not random: the generative layers answer the drums.
5. Expression Control's Random source → Macro "Scatter" per note (it fires a new random value on each note) mapped to Drift Fine ±8 ct and Echo feedback ±10%: per-note imperfection on an otherwise static patch.
6. Depths are ranges: set the macro's own min/max mapping ranges to musical limits so the modulators cannot push a parameter somewhere ugly.

Variations: LFO on Sample & Hold mapped to the rate of a second LFO: random-rate wobble. See Modulation & M4L and Automation & modulation.

Random, Velocity and Note Length as live chance devices

The MIDI effects run live, so unlike clip note probability they also apply to generated clips, arps and Push performances. A chain of Random → Scale → Pitch → Velocity → Note Length is a constrained chance machine on any input.

1. Random: Chance 40–70% (the probability a note is altered), Choices 4–8 (how many possible offsets), Scale 1–3 (the interval step between choices: 1 = semitones, 2 = whole tones before the Scale device fixes them), Mode Add (upwards), Sub, Bi (both) or Alt (alternating, which is a deterministic pattern, useful for "generated" sequences that repeat).
2. Scale after it (never before): every random pitch is snapped to the key. Pitch device with Range limits the register: generative sounds that wander below C2 become mud.
3. Velocity device: Random 20–40 for a velocity scatter, Out Low/High to clamp; through velocity → filter on the instrument this is the timbral randomness.
4. Note Length: with the Gate percentage mapped to the Density macro, short notes = sparse feel, long = legato wash, from the same stream.
5. Feed a single repeated note (1/16 clip with one pitch): the chain generates the melody live; feed a Seed clip: two levels of chance stack and the output is wilder.

Operator loop envelopes as internal sequencers

Operator's envelopes have Loop modes: Loop (free-running at a time), Beat and Sync (tempo-locked, retriggering at a division) and Trigger. Four oscillators with four differently timed looping envelopes make a one-note patch that rhythmically modulates itself — a sequencer with no clip.

1. Algorithm: the serial one (D→C→B→A). Osc A sine (carrier), B Coarse 2, C Coarse 3, D Coarse 1 with Fine +3.
2. Osc A envelope: Loop mode Sync at 1/4: the amplitude retriggers every quarter note (Attack 2 ms, Decay 180 ms, Sustain −inf) — the pulse.
3. Osc B envelope: Beat at 1/8T, Decay 90 ms: FM index pulses in triplets against the quarter pulse. Osc C: Loop (free) with a 0.7 s period: the second modulator drifts across the grid. Osc D: Sync 1 bar, slow attack: a once-per-bar swell of the deepest FM.
4. Operator LFO: Sync 1/16, Square or S&H shape → Filter Freq 20%, filter LP 12 at 1.5 kHz: a stepped filter in 16ths.
5. Pitch Envelope: Loop at 1/2 bar, Amount 10% → Osc D only: the top partial sweeps every half bar.
6. Hold one note for 32 bars: the result is a polyrhythm of 4 against 3 against free against 1 bar. Change the held note on the 8-bar and it is a track.

Variations: Osc B set to Noise with a Beat 1/16 loop: a built-in hat. Swap Sync for Loop (free time) on two envelopes: the pattern slowly phases against the grid, Reich-style. See Operator.

Wavetable Random Note unison and Meld Scrambler

Two instrument-level chance sources. Wavetable's Random Note unison mode gives each unison voice a different random pitch offset per note so every chord is a fresh cluster; Meld's Scrambler (12.2) is a stepped random modulation source inside the synth, so a static note gets a jittering timbre with no external device.

1. Wavetable: Unison mode Random Note, 4 voices, Amount 20–40%. The amount sets how far from the note the random voices land (it scales toward semitone offsets, so at 30% expect something between chorus and a cluster). Each new note draws new offsets.
2. Keep Osc 1 on a Harmonics table and the filter LP at 1 kHz: random clusters are tolerable when dark. Amp attack 300 ms so the cluster blooms rather than stabs.
3. Meld: Engine A Chord (12.2) for built-in intervals, Engine B Reed. In the modulation matrix, Scrambler → Engine A filter 25%, Scrambler → Engine B main amount 20%, Scrambler → LFO 1 rate 15%. Set the Scrambler's rate to a synced division (1/8) for a grid-locked jitter, or free for a drift.
4. Meld LFO 1 (slow sine) → Scrambler depth: the amount of randomness itself waves over a minute.
5. Reverb Prism after: random clusters through a long bright reverb are a cinematic bed; through a dry chain they are IDM.

Variations: Wavetable Unison Random Note at 100% on a noise-table pluck: every hit is a different metallic chord. Meld Scrambler → Engine A pitch at a small amount with the Chord engine: the voicing re-rolls each step. See Meld.

Macro randomization and Macro Variations as structure

Every Rack has a randomize button for its macros (with per-macro exclusion) and Macro Variations that store and recall whole macro states. Randomize is the dice; Variations are the sections. Launched from Push or by an LFO, they are the form of the piece.

1. Build the rack with 8 macros whose mapping ranges are musical limits: Filter 200 Hz–4 kHz (never fully closed), Drive 0–30%, Density 20–80%, Reverb 10–50%. Randomize only works well if every extreme of every macro is acceptable.
2. Exclude from randomization the macros that define the sound (Chain selector, Sub level, Tune): right-click the macro and exclude. Randomize now re-rolls the texture, never the identity.
3. Hit Randomize until a state is good; store it as a Macro Variation. Collect five: Intro, Build, Peak, Break, Outro. Each is a found object, not a design.
4. Launch Variations from Push (they appear as buttons in the device view) or map the variation launch to a MIDI note and sequence variation changes from a clip, with Follow Actions choosing which clip (and so which variation) comes next.
5. Morph between variations with the variation morph control where available, or map an LFO (1 bar, smooth) to one or two macros on top of the recalled state for motion inside each section.
6. Audio Effect Racks do the same on the master chain: randomize a Beat Repeat + Grain Delay + Redux rack every 8 bars for the glitch layer.

Variations: Macro snapshots in a chain of racks: outer rack's Variations recall inner racks' Variations for hierarchical form. See Racks & macros.

Self-playing techno patch recipe

A set that runs for 20 minutes without a hand on it and does not get boring: fixed kick and sub, Euclidean percussion with chance, a Seed bassline re-rolled every 16 bars, a chord stab on Follow Actions, and three slow modulators on the mix. 128 BPM.

1. Anchor: kick 4/4 drawn by hand, sub on the root with a 1/8 off pattern, both fixed, sidechain from kick on everything else. No generation touches them.
2. Percussion: Drum Rack, Rhythm generator for a base, then Euclidean 5/16 (rim) and 7/16 (clave) lanes; ghost notes at 50% chance, velocity range ±20. Clip Follow Action: 80% itself, 20% a variant with the Euclid lanes rotated by one step.
3. Bass: 16-bar clip, Seed density 25%, one octave C1–C2, 1/8 notes; MIDI chain Random 30% → Scale → Pitch range → Note Length (gate from a Density macro). Scene Follow Action every 32 bars re-launches a scene whose bass clip was regenerated (keep 4 pre-generated bass clips and let Follow Actions pick).
4. Stab: Stacks on 2 notes, 4 clips of different voicings, Follow Actions 60% Next / 40% Any, 8 bars. Dub chord rack with Echo send; the "Dub" macro is on a 60 s LFO.
5. Texture: the Operator loop-envelope patch on the root, −18 dB, HP 400; Auto Filter LFO at 0.03 Hz.
6. Mix motion: LFO 0.017 Hz → "Open" macro (hat chain filter, stab reverb); Shaper 64 bars one-shot retriggered by a scene → "Density" (ghost chance via Velocity device, Note Length gate); Envelope Follower from the kick → "Duck".
7. Press play, record 20 minutes to Arrangement, go make coffee. Then the last recipe.

Variations: Replace the bass with the TD-3 driven by a Seed clip via External Instrument: random 303 lines with Accent from velocity range. See Deep techno and MIDI generator rack.

Ambient generator recipe

No tempo to speak of: long Seed notes at low density in a just-intoned scale, Stacks chords every 2–4 minutes via Follow Actions, Granulator III and Spectral Time doing the sustain, and all motion on unsynced LFOs. The piece plays itself for an hour and never repeats.

1. Set tempo 60 BPM (only so bar lengths are long). Set tuning to a just-intonation scale on the root; Scale mode on all clips with a pentatonic or a 5-note subset so any two generated notes consonate.
2. Notes: 32-bar clip, Seed density 5–10%, note lengths 2–8 bars, range C2–C4, velocity 40–90. Note Echo after (1 bar, 3 repeats, feedback −6 dB) so each note echoes itself at a lower velocity: a built-in canon. Four such clips with Follow Actions 50/50 Next/Any after 32 bars.
3. Voice: Wavetable, Harmonics table, Unison Random Note 20% (JI makes the random offsets less offensive, though still not scale-locked), Attack 4 s, Release 10 s, Velocity → filter 40% so loud generated notes are bright.
4. Sustain layer: Granulator III frozen on a chord recording; M4L LFO 0.011 Hz → File Position 10% range; 0.023 Hz → Spray; Spectral Time on the Wavetable bus with Freeze toggled by a Follow-Action-launched clip that sends a MIDI-mapped note every 4–8 minutes (a dummy clip on a track whose only job is to send that note).
5. Chords: Stacks 3-note voicings on a separate track, 1 note per 2-minute clip, 4 clips with Follow Actions Any: the harmony changes rarely and unpredictably.
6. Motion: three LFOs at 0.011, 0.023 and 0.041 Hz on three macros (Open, Space, Width); Shaper one-shot 20 minutes long on Density if you want the piece to have a shape; nothing synced to the bar.
7. Reverb Dark Hall 14 s, Low Cut 200, on a return; send automation is on the Space macro.

Variations: Replace Wavetable with a Sampler of a real piano in JI (the Live 12 tuning system re-pitches samples per note). See Ambient, Drones.

CV Tools with the modular: CV Instrument, Triggers, Clock, Envelope Follower

Everything above generates MIDI and modulation inside Live; CV Tools sends it out as voltage through a DC-coupled interface and brings the modular's own randomness back in. The eurorack becomes a voice and a chaos source for Live's generators, with Live's Follow Actions as the macro-structure the modular lacks.

1. CV Instrument on the generated MIDI track: calibrate against the VCO (the device plays a test sweep and builds a tuning table), set Pitch and Gate outputs to DC-coupled interface channels. Generated notes now play the modular voice; Live's tuning system is honoured because CV Instrument outputs the actual pitch as voltage.
2. CV Triggers: on a Drum Rack-style MIDI track, each note number → a trigger output: the Euclidean lanes fire eurorack drum modules or envelopes. Trigger length and polarity per output.
3. CV Clock Out: clock (1/16 or 1/8) and reset/run outputs to a hardware sequencer, so the modular's own sequencer runs in time with Live's Follow Actions and re-syncs on every scene launch.
4. CV Envelope Follower (and CV In): patch a modular random source (sample-and-hold, a chaotic LFO, Wogglebug-type) into an audio input; the device turns it into a modulation signal mapped to Live macros. Analogue randomness now moves Live's filters and the Density macro.
5. CV LFO / CV Shaper out: Live's slow modulators as voltage into VCF cutoff and VCA — the 60 s sine from the techno recipe, in hardware.
6. Return the modular audio on an audio track with Monitor In, Resample constantly: the hardware state is unrecoverable.

Variations: TD-3: send it MIDI from the Seed chain through External Instrument and take its audio back; its own sequencer synced from CV Clock Out while Live randomises its filter via CC. See Hardware & modular integration and Modular hybrid rack.

Resampling generative output and curating

The generator is a source, not a track. Record long, listen once with a marker key, keep the fragments that are better than what you would have written, and throw the rest away. The ratio is usually 10:1.

1. Record the whole system to Arrangement (global record with Session clips playing) so you keep MIDI, note expression and automation, plus a Resampling audio track for the master as insurance.
2. Listening pass at normal speed, no editing: add a locator (Cmd+Shift+L or the Set button) every time something good starts, a second when it ends. Do not stop the transport.
3. Second pass: for each pair of locators, Consolidate the MIDI and audio (Cmd+J) into clips, name them by what they are ("bass 3 good turn", "stab chain 2 peak"), drag to Session view into a new "Keepers" scene group.
4. Hits and glitches: resampled audio into Simpler Slice mode (Transient) → Slice to New MIDI Track: the generative run becomes a kit.
5. Bounce Group (12.3) or Bounce in Place (12.2) the kept sections as stems with their automation. Freeze the generators' tracks, then Flatten, so the set no longer depends on chance.
6. Delete the rest. Keeping everything is how generative projects die.

Variations: Run the same system three times at different seeds and tempos, keep the best 2 minutes of each, and compose from those. See Resampling workflow, Resampling rack.

Arrangement from a generative session

The kept fragments are not in order and do not know about each other. Arrangement is the step where you impose the form the generator could not: entrances, a peak, a break, an ending. Most of the work is deletion and gain staging.

1. Sort keepers by energy, not by when they happened: the generator's bar 400 might be your intro.
2. Lay the fixed anchor first (kick and sub) across the sections you want; everything else is placed against it.
3. Place one keeper per lane per section; keep gaps. A generative track's strength is variety, so never loop one keeper for more than 32 bars — use the next keeper instead.
4. Fills: the glitch rack randomized output, cropped to the last bar before each section. Peak material only in the peak.
5. Automate what the system automated, by hand this time: HP on the texture rising into the break, reverb up on the solo stab, the Open macro drawn as a line rather than an LFO.
6. Ending: the generator never ended; you do. Remove layers in reverse order of entry over 16 bars, texture last.