Manual

Getting started

Press play. Browsers keep audio muted until you have interacted with the page, so the first press is really just permission. If you hear nothing, press it again.

A new session opens with a few drum tracks already running. Click any cell in a track's row of squares to add or remove a hit. After that:

• The instrument button next to a track's name changes what it sounds like: it opens a searchable picker of every engine and preset.
• + add track at the bottom gets you another instrument.
• The numbered buttons above the tracks are 32 pattern slots.
• Right-click anything you don't recognise (long-press on a touchscreen). You get what it does and whatever movement is on it.

Transport

The bar across the top runs playback for everything.

The second row is the keyboard strip: scale, octave, chord and arp, covered under playing from your keyboard. The status line at its right end reports what just happened.

Above the transport sit new, share, and, once you are signed in, save and songs. See saving and sharing.

Knobs

Nearly every parameter is a knob, and they all behave the same way.

On a phone the same controls draw as vertical sliders and the thumb follows your finger. Two rows stay sliders everywhere: the wavetable editor's harmonic bars and the chance generator's pitch faders.

Patterns

Every session has 32 pattern slots. Click a number to switch to it; the one you are editing is outlined. Empty slots are blank, so one slot per section is an easy way to build an arrangement.

Clips and the arrangement

One song, three pictures of it. The switcher in the transport (or tab, with nothing focused) moves between the groove view, the step grids you know; the clips view, every track's 32 patterns laid out as clips to launch one track at a time; and the arrange view, a timeline of pattern blocks per track. Play plays what the open view shows: the arrangement in the arrange view, the clips in the clips view, and whatever the pattern bar says in the groove view. Switching views while playing takes effect at the next bar line. Desktop only for now.

Clips

The arrangement

Tracks

A track is one instrument plus its pattern. The header row has its name, its engine, the pattern length and the mixer controls.

The last row of buttons (roll, filter, env, fx, eq, comp, mod, aut) opens the panels described under filter, effects and dynamics and modulation and automation.

A button wears a dot with a count when something inside it is switched on, and hovering it names what. Whatever is on also shows on the track itself: engaged effects, enabled LFO rows, a filter you have closed, an eq band you have moved. Open the panel and you get all of it again.

The step grid

The row of squares is the pattern. A filled square is a note, and every fourth one is marked so you can find the beat.

• Click an empty square to add a note, or a filled one to take it away.
• Drag right from a note to make it longer.
• Drag up or down on a note to change its pitch.
• Double-click to set a note to full velocity.
• Right-click, or press and hold on a touchscreen, for the step editor.

On drum tracks the pitch hardly matters, so the grid is usually all you need. Melodies are easier in the piano roll.

The piano roll

roll opens the piano roll on that track, on the pattern it is playing: a keyboard up the side, bars across, the notes as bars you draw, drag, stretch and paint. It is the same editor as the piano view, so everything below is true there too, and it works with a finger on a phone. It is the best place to write a melody, and the only place to stack notes into a chord you voice by hand.

The tools along the top decide what a drag does: pan scrolls, draw places and moves notes, paint lays a note every length as you sweep, erase deletes what you sweep over and select boxes notes to move or delete together. snap is the grid notes land on.

The lane underneath is velocity: drag across the stalks to make steps harder or softer. With notes selected, the arrow keys move them (shift: an octave, or a bar), nudge pushes them off the grid, and delete removes them. The pattern's header above the grid makes it a bar shorter or longer, doubles it, or sets its time signature; in key folds the rows to the scale when one is on, and hear sounds the notes as you place them.

The step editor

Right-click any step for everything it can do beyond pitch and length.

The three generators

Three buttons on the track row fill the grid for you: the dice rolls a part, the ring divides the bar evenly, the die throws odds. All three can print a result into the grid as ordinary steps you can then edit. The ring and the die also run live, generating as the track plays without writing anything, so their controls can take an LFO, an automation lane or a macro pad; switch live off and the pattern is exactly as you left it. While live is on the grid shows what is playing and goes read-only. A track has one rhythm at a time, so turning one of those two on turns the other off.

The dice: roll a part

One press replaces the pattern with a new one, rhythm and pitches both. Keep pressing until something sticks; nothing is held, so each roll starts from scratch. What lands in the grid is ordinary steps, yours to edit afterwards.

Drag the dice up or down to set how full the rolls come out, drawn as the fill behind the icon. All the way down is empty, all the way up is every step, and downbeats stay likelier than the steps between them.

On a drum-kit track every hit sits on C2 and only the rhythm changes. Anywhere else it walks a melody in the session's key, mostly a step or two at a time with the occasional octave leap, starting from the last note you used on that track. It follows the root and mode even when scale quantize is off. It leaves the sound alone; rand beside the four knobs is the one that rolls that.

The ring: euclidean rhythms

A number of hits spread as evenly as possible over a cycle, which covers a lot of the world's drumming. Set the hits, the cycle length and a rotation, and the cycle tiles across the track. It decides only when notes happen; the pitches stay whatever the pattern already had.

The die: chance

Chance decides the pitches as well. You write the odds of notes rather than the notes, and it plays something that fits them. Two sections, each with its own dice.

Rhythm. note value is the base rhythm, from 1/1 down to 1/32 by way of the triplets, and nothing random happens to it on its own. variation is off in the middle: turn it left for longer note values, right for shorter, and how far you turn it is both how often another value turns up and how far from the base it strays. legato is how likely a note is to be tied to the one before instead of gating again; all the way up you get a single held note. rest is how likely a note is to be dropped. Two checkboxes let variation reach the triplets and the 1/32s, which are off to start with.

Melody. The twelve faders are the probability of each semitone, not a switch on each: one at half height turns up half as often as one at full, and a single raised fader is certain wherever it sits. That is how you write a scale here, or a scale with a bias. Until you move a fader they are the session's scale, when one is switched on (and follow it when you change key), and a minor pentatonic when not. from scale writes the active scale into them as faders of the track's own, so a later key change leaves the part where it is. Generated notes are not snapped to the session scale, because these faders are the scale. low note and high note set the range, up to five octaves; a semitone raised outside it can't play, and its label greys out to say so.

The dice. Each section's roll takes a new throw. A throw is held, so the part repeats and you can play against it. The new throw dropdown beside each roll says how long for: hold keeps it until you roll again, every pass takes a fresh throw every time the window comes round, so that section never repeats, and every 4 passes lets a phrase play four times and then move on. Rolling a section twice always changes something; if a throw can't change anything, the button says which knob to turn instead.

The window is the first and last step it generates over, and it tiles across the track like the ring's cycle. Until you turn last step it is the whole track, so a 32-step track gets a 32-step window. Moving first step slides the window without changing its length.

Six controls can be modulated while live is on: the four rhythm knobs and the two range knobs. An LFO on rest breathes the part in and out; a lane on low note walks it up the register over a bar. The picture at the top of the panel is the part it is playing now: height is pitch, width is how long a note is held, and a note in the second colour is struck more than once, which is how the triplets and the 1/32s fit a grid of sixteenths.

Playing from your keyboard

On a desktop machine your computer keyboard always plays the active track, which is the last one you clicked and the one with the outline. Typing in a text box is safe: note keys only fire when no text field has focus.

The layout is a piano on the top two rows: the letter row is the white keys, the number row above it the black keys. That leaves the home row free for moving around in vim mode.

• White keys: q w e r t y u i o p [ ]
• Black keys: 2 3 5 6 7 9 0 =
• z and x drop and raise the octave.

Two ways to get what you play into a pattern.

• Record. Switch on record, start playback, and notes land on whichever step is passing underneath.
• Capture. Play freely, stopped or running, then press capture. Your last phrase is written into the track with its timing and note lengths, and the pattern is sized to fit it.

To move around, edit and turn knobs from the keyboard too, switch on vim mode.

Vim mode

Vim mode turns the whole studio into something you can drive without the mouse, in the manner of the vim text editor. Press ` (the backquote key, top left) or vim in the transport to switch it on, and the same again to switch it off. Your browser remembers the choice. With it off, the keyboard is just the piano described above.

In vim mode the letters stop playing notes and become commands, until you ask to play. A box in the bottom corner says which mode you are in, and a cursor on the active track's step grid shows where the next edit lands.

Moving around

Most moves take a count typed first: 4l moves four steps, a beat.

Editing

Every command is its own undo step, however fast you type. A whole stretch in insert mode undoes as one, the way it does in vim.

In insert mode with the sequencer stopped, h and l (or ← and →) move the cursor, l while you hold a note makes that note a step longer, Enter switches the cursor's step on or off with the track's usual note (C2 on a drum track) and Backspace clears the step behind the cursor. j and k change track, playing or stopped, so you can record one part and move straight on to the next.

Visual mode selects steps on one track: move with the same keys, then press y to copy, d to delete (which copies too), p to paste over the selection, > < to transpose it, or [ ] to nudge it. A copy carries everything on a step: chords, arps, ratchets, sample regions.

Knobs

One knob at a time can be picked, which draws a bright outline round it. Scroll on the trackpad to turn it (hold shift for finer steps), or press - and = to move it 1% at a time, with a count for bigger jumps: 10= is 10%. hjkl move to the knob next to it, as drawn on screen, and Esc lets go.

Commands

The command line lists what could come next as you type: every command on an empty line, the effects after :fx, and the active track's knobs after :k, each with where it is set now. Tab takes the next match into the line and shift Tab the one before (the arrow keys do the same), or click one. Enter runs whatever the line says.

Scale and chords

Tick scale, pick a root and a mode, and your playing is locked to that key. The white keys all belong to the scale and the black keys go quiet, so there are no wrong notes. There are major and minor modes, pentatonics, blues, some exotic scales and a few microtonal tunings.

The palette button next to it colours notes by pitch across the roll and the grid, which makes repeated shapes jump out.

Chord mode

With chord on, each key plays a whole chord instead of a single note. Pick the chord type and a voicing. If a scale is active the choice collapses to on or off, because the chord gets built from the scale itself: each degree gets the quality it should have and everything stays in key.

Chords you record or capture are stored as chords rather than loose notes, so the roll shows one labelled note you can retune or move in a single go.

Arp

The arp box sits next to the chord picker. Switch it on and a held key arpeggiates as you play, at the rate, octave range and direction you choose. Anything you then record or capture carries those arp settings into the pattern.

Sound engines

The instrument button beside a track's name picks its instrument, from a searchable picker. They come in groups:

The four knobs under the name are that instrument's main tone controls: harm, timb, morph and decay on a Plaits model, something else on the next engine. The labels change with the engine, and hovering one says what it does on the instrument you have loaded.

The silverbox

An acid box modelled from its circuits, so it answers a pattern the way the original does. Its four knobs are the panel: cutoff, reso, env mod and decay. Next to them are the waveform switch, the accent depth and tuning.

Three behaviours are how you play it:

• Accent comes from step velocity. Push a step past about two-thirds and it accents: louder, brighter, filter decay forced short. With the resonance up, consecutive accents stack into a rising squelch rather than resetting, and that pile-up is the sound of an acid line.
• Slide comes from note length. Draw a step longer than one cell and the note after it slides out of it: the pitch glides across and the envelopes never retrigger.
• Plain steps get clipped short, a little over half the step, which is what makes a silverbox part drive instead of running together. Lengthen a note if you want it to hold.

The filter thins out as you wind the resonance up, same as the real one. That is why acid records run a silverbox into a distortion pedal, and you can do the same from the track's fx panel.

The contagion

A big polyphonic synth built for movement. Its four knobs are cutoff, reso, shape and decay. The four beside them are the levels of osc 1, osc 2, the sub and the noise. Everything else lives in the rows underneath.

• Shape is one continuous morph from sine through triangle and saw to pulse, and at the top the pulse width knob takes over. Sweep it and the tone changes character, not just brightness. It is osc 1's; osc 2 has its own, shape 2 and pw 2.
• Unison is the supersaw. Each note plays up to eight detuned copies of the whole oscillator section, spread across the stereo field. Two or three thickens things up; eight with the detune wound on is the wide trance sound.
• Two filters, not one. Each can be a low pass, high pass, band pass or notch, and you choose how they connect: in series, in parallel, or split so filter 1 plays the left ear and filter 2 the right. A low pass into a high pass gives you a band pass you can sweep from both ends. Filter 1 takes the reso knob and filter 2 has its own, reso 2; the last tenth of either makes the filter whistle on its own.
• Saturation sits between them, so filter 2 gets to tidy up whatever the saturator did. It runs from a gentle warmth through hard clipping to a bit reducer and a rate reducer, plus a one-pole low pass and high pass. The follow versions track the note you play.

With sync on, osc 2 is forced to osc 1's pitch, so dragging or automating the semi knob gives you the classic tearing sync lead. fm works the same way round: osc 1 modulates osc 2.

The amp and the filter each have an envelope. The track's decay knob is the amp's; the filter's has its own attack, decay, sustain and release, so a short filter decay over a long amp sustain is a pluck that keeps ringing. env amt is how far it moves the cutoff. Each envelope also has a slope: in the middle the sustain holds, to the right it fades while you hold the note, to the left it swells.

The hexop

Six sine waves. That is the whole instrument: no filter, no sub oscillator, nothing else. What comes out depends on which sines are wired into which, and how hard. The panel is the same six rows whatever you are building, one per operator, each with its level, its frequency as a ratio of the note, and its own envelope.

• The algorithm is the wiring. There are 32 of them and you can't make your own. The dropdown draws each one, so 1←2 means operator 2 modulates operator 1. The panel marks the carriers, the operators that reach your ears, whose level is volume. Everything else is a modulator, and its level is how hard it bends the operator below it.
• Level is exponential. A modulator at half its knob is a sixteenth of full scale, so nearly all the useful range lives in the top quarter. Nudging one modulator level is how you program this thing.
• Every operator has its own envelope, so the timbre has an envelope. A modulator that decays fast under a carrier that doesn't is a struck sound. That is the trick behind an FM electric piano.
• Feedback is the only source of harmonics here that isn't another operator. Wind fbk up and it stops being a tone and turns into noise, which is where the breaths and cymbals come from. Which operator carries it depends on the algorithm, and the panel says which.

The four track knobs ride all six operators at once. bright raises every modulator's level together, which is the fastest way to hear what a patch can do. fbk is the feedback, mod dec scales how fast the timbre falls away, and decay how fast the note does.

Start from the voice dropdown rather than from silence: an electric piano, a bass, a bell, brass, a marimba, an organ and a pad. Load one and change a single operator level. vel makes playing harder raise the modulation index, so hard notes come out brighter and not just louder, and key scale pulls the modulators back as you play up the keyboard. Without it the top octave screams.

The guitar and the bass

Each models the whole chain a real one goes through: the string, the pickup reading it, the amp it runs into and the speaker in front of the mic.

Both start from a tone dropdown of famous rigs. Load the nearest one, move a control, hear what that control is for. Loading a tone replaces everything including the four track knobs.

The guitar

The string has the losses of a real one: the highs die before the fundamental does, so a note gets duller as it rings rather than just quieter. Where you pick notches harmonics out of it, bridge thin and cutting, over the neck round and full, and the pickup notches it again on the way out. Choosing a pickup is choosing where its resonance sits. A single coil peaks high and glassy, a humbucker low and fat.

The four knobs are drive (how hard the amp is hit, on a log taper like the real pot), tone (the knob on the guitar itself, not the amp; roll it down with a neck humbucker for the darkest sound the instrument has), bloom and sustain.

bloom is feedback. The speaker is coupled back into the strings, so past a certain point the energy coming back beats the string's own losses and the note stops decaying and starts growing. It needs volume: a clean amp barely blooms, a cranked one sings. It stops when the note ends, the same way taking your hand off the string does. Hold a long step on a high setting and listen to it climb.

The bass

Same string, wound and stiffer. Its harmonics sit noticeably sharp of where the arithmetic says they should, and that disagreement between the pitch and the clank is most of what a bass sounds like. Flatwounds take it away along with the high end, which is why records made before about 1970 sound the way they do. That is the roundwound / flatwound select.

fret is how hard the string is allowed to clatter against the fretboard; wound up with the hand control at the top, that clatter is slap. grind is distortion, but only above the xover frequency, with the clean low end put back underneath. Distort a bass whole and the bottom vanishes, which is why every bass overdrive worth owning works this way.

The knobs are drive, tone, comp and sustain. Wind comp up and the part sits perfectly still under everything else.

Subby

A monosynth for the bottom two octaves and nothing else. Two notes a third apart at 40Hz beat at a rate you feel as lumpiness rather than hear as harmony. Last note wins, and glide slides into it, either always or only when a note arrives while another is still sounding, which is the 808 slide.

Most people cannot hear a 35Hz sine. A phone speaker starts around 500Hz and a laptop around 180Hz. The fix is harmonics: generate them and the ear rebuilds the fundamental it cannot hear. drive is that path. At zero you get a genuinely pure sine, which is the right choice when something else in the mix is already carrying the note.

• The shaping is parallel and high-passed. xover is where it starts; nothing below it is ever distorted, so the bottom stays clean however hard you drive.
• edge biases the signal before the drive, which makes the clipped pulse uneven, and an uneven pulse is the even harmonics. Four shapers: tube, fold, fuzz and rect.
• drop is the pitch envelope, the 808 beater. It spans 40 semitones and lands exactly on the note. click adds the band of noise that is often the only part of the note a small speaker reproduces.
• reso hangs the silverbox's ladder filter above the crossover, with its own envelope and its own accent. The acid never reaches the fundamental. At zero the whole stage is bypassed.

The four knobs are drive, tone, shape and decay. The tone dropdown loads a complete patch: the trap 808, a distorted one, a pure sine, a reese, an acid sub and a dub sub.

Vox

A singing voice, built the way a voice works: the vocal folds make a train of pulses, and the throat and mouth are resonances (formants) that the pulses ring. The pulses are the pitch and the effort; the resonances are the vowel. A note can start with a consonant, and a choir of up to eight sings each note.

• The four knobs are vowel (u, o, a, e, i across the knob), size (soprano at the bottom, then alto, tenor, bass), breath (air in the voice; the top quarter fades to a whisper) and release. An automation lane on the vowel sings a different vowel on each step.
• sings picks a phrase (doo wop, la la, shoo bee, hallelujah ...): every note sings the next syllable, a chord on one step shares one, and the phrase starts over when you press stop. With the phrase off, every note starts with the consonant beside it. The consonant goes before the step, so the vowel lands on the beat, the way a singer places a word. bite is how loud the consonants are. Or type your own lyric in the field beside it, one syllable a note: twin kel twin kel lit tel star. A syllable is a consonant, a vowel and a consonant; the last one is sung as the note ends. Two vowels glide from one to the other (ai for "eye", ow for "now"), oo is u, ee is i, and mmm is a hum. Spell it as it sounds: one consonant each side of the vowel. Or tick phonetic and type plain English: each word is looked up in a pronouncing dictionary and split into its syllables, one a note, and the line under the row shows what it will sing (the night is young is sung da nait iz yan). The dictionary is fetched the first time you tick the box, and a word it does not know is guessed from its letters.
• The vibrato comes in late, after delay, and fades in. drift is the wander in pitch and the scoop up into each note that make it a person; at zero it sings like a machine. growl is the rasp of a pushed or chanting voice.
• voices is the choir: copies of the voice per note, detuned and spread across the stereo field. mono is a lead singer instead: last note wins, and a note arriving while another sounds slides into it.

The voice dropdown loads a complete setup: a choir on aah, angels on ooh, a basso, a soul lead, doo wop backing, a robot choir, a monk chant, a whisper and a hallelujah.

Lancet

A snare drum synthesizer with seven ways of making a snare, picked with the model dropdown: analog (sine shells and noise, the early drum machines), slap (sines through a waveshaper under a bright clipped noise), modal (a drum head's own partials plus noise), physical (an exciter through resonant delay lines, with wires), fm (a carrier under two modulators and noise), granular (a snare under a cloud of grains from a rattle, a chain, paper, a coin or sand) and blend (layered high and body layers, through an old sampler).

• The four knobs are timbre, color, fx and decay. What timbre and color do changes with the model (the status line says, when you pick one): on most, timbre is the noise and color the body. fx is each model's own effect, clean at the bottom: a clipper, a multiband drive, a fold, a compressor, a lo-fi sampler. The step's note is the pitch, C2 the middle of a two-octave range, and tune trims it.
• velocity is how much a step's velocity does: the level, and a little of the brightness and the length with it, so a ghost note is a ghost note.
• The random row throws a knob on every hit: decay, timbre, color, pitch, fx, level, and the chance of a different model. A little on timbre and level is a drummer; model at half is a different snare every hit.

The strike dropdown loads a complete setup: a tight or fat analog snare, a slap crack, a wood or piccolo modal, a tin head, an fm clap, a metal fm, coins on the head, boom bap, dusty funk, and one that rolls the dice.

Halo

A cymbal synthesizer: hats, rides, crashes, chinas, splashes and a gong from one instrument, four ways, picked with the model dropdown: metal (the 808's six square waves through two bandpasses, the drum machine hat), fm (inharmonic carrier and modulator pairs, the digital cymbal), modal (forty partials on a plate's series, each dying faster the higher it sits, the acoustic one) and noise (two bands of noise, a shaker or a trashy splash).

• The four knobs are tone, size, spread and decay. Tone is dark to bright, and it is read while a cymbal rings, so a lane on it opens a crash that is already sounding. Size scales every partial together: small is a hat, big a crash, the bottom a gong. Spread is each model's own character (the status line says, when you pick one). The step's note is the pitch, and tune trims it.
• trig or choke. Trig lets hits ring over each other, as crashes do. Choke makes it a hi-hat: a hit is cut when its step ends and the next hit cuts the one before, so a short step is a closed hat and a tied one is open, on one track.
• stick is the tick of the strike, bloom the swell a crash makes after the hit (all the way up, a cymbal that rises into the beat), width the stereo spread (it still sums to the cymbal on a mono speaker) and vary how much every hit differs, so a ride pattern is not one sample eight times.

The cymbal dropdown loads a complete setup: 808 closed and open hats, a pedal hat, an fm hat, a ride and its bell, a crash, a china, a splash, a gong, an fm crash, a shaker, trash, and a reverse swell.

Siege

A bass drum synth, a siege engine for the low end: a sine under a pitch envelope, an amplitude envelope, and a drive that comes after the envelope. That order is the sound. A drive in front of an envelope distorts the whole note the same amount; behind it, it crushes the loud start, leaves the quiet tail a clean sub, and lifts that tail up to twelve times, so a driven kick reads longer and a long one turns into a rumble.

• The four knobs are drive, click (how far above the note the pitch starts, up to six octaves), depth (how long it takes to fall onto the note: a millisecond is a tick, a quarter second is the 909's sweep) and decay (the body, 50ms to four seconds).
• Two drives. fold is a two-stage wavefolder: it reflects the wave instead of flattening it, so it keeps making new harmonics as it is driven, then a soft knee squashes the peaks. More compression than distortion. clip is a clipper: odd harmonics, a square almost at once, the harshest and the loudest.
• The note is the pitch, an octave either way with tune. lock keeps the tuning you set and lets a note only move the kick by whole octaves, so a sequence that wanders never detunes the drum.
• trig ignores the step's length, as a drum does. gate holds the body for as long as the step is held and lets it decay when the step ends: write notes, ties and a little glide and it is a bassline.
• low cut is a third-order 30Hz filter that takes the infrasound a driven sub makes and leaves a C1 alone. floor is the level a step at velocity 0 plays at; a full-velocity step always plays at full.

The kick dropdown loads a complete setup: an 808, a 909, a techno kick, a rumble, a tick, a gabber kick, a sub drum, a hard trance kick and a bassline.

Ladder

The transistor-ladder monosynth, after the Minimoog: three oscillators and noise into a mixer, the mixer into the four-pole ladder filter, the filter into the amplifier, with a contour on each. The things that make it sound like itself are all in the details: the mixer overloads the filter's input stage when the levels are up, the filter thins out as the emphasis climbs and whistles on its own past three quarters of the knob, and the oscillators drift a little against each other.

• The four knobs are the filter's: cutoff, emph (the emphasis, or resonance), contour (how far the filter contour opens the filter, up to five octaves) and decay (the loudness contour's decay). The rest of the front plate is in the panel.
• The oscillator bank. Each oscillator has a range (lo, the LFO range, then 32' to 2') and one of the machine's six waves: triangle, shark (the triangle-saw), saw, square, wide and narrow pulse. Osc 2 and osc 3 tune seven semitones either way, continuously; a few hundredths of a semitone is the detune. Osc 3 can be taken off the keyboard, which is how it becomes a fixed-rate LFO.
• The mixer is the overdrive. One oscillator at its usual level arrives clean; push all three up and the filter's input saturates. That is most of what fat means on this machine.
• Two contours, attack, decay and sustain each, and the decay switch: on, a note releases at its decay time; off, it stops as soon as the step ends. kbd is how much of the keyboard the cutoff follows; at full, a whistling filter plays in tune.
• The mod wheel carries osc 3 or noise (mix between them) to the oscillators, for vibrato, or to the filter, each behind its own switch. Drop osc 3 to lo, take it out of the mix, and turn the wheel up.
• Mono is the machine: the lowest held note wins, a note arriving while one is held changes the pitch without restarting the contours, and the track's glide is the glide knob. Poly plays six at once, for chords.
• Eight patches in the panel's dropdown, from a bass and a funk lead to the filter whistling by itself.

Samples

Choose sampler as a track's engine and it asks for a source: a file from your machine, or one of the bundled drum kits. After that the waveform button in the track header opens the sample editor.

Three of the kits are real drums, recorded with real mics: Salamander (a punchy garage rock kit), Virtuosity (a dry jazz club kit) and DRS (a big multi-mic rock kit). Each has a kick, snare, rim, closed and open hat, a high and a floor tom, a ride and a crash. Put each piece on its own track, and keep the whole part on one kit so it sounds like one room.

• Trim the start and end, and fade either edge.
• Slice a loop and play the slices from the grid, one per note.
• Fit a loop to the tempo, or leave it at its natural speed.
• Keep pitch locked so a tempo-fitted loop stays in tune, or unlock it and play the sample melodically.

Files you load stay in your browser. They only go anywhere if you save the session to an account or make a share link.

The wavetable editor

With the wavetable engine selected, the waveform button opens an editor where you draw the sound. A wavetable is a series of frames, each a single cycle of a waveform, and the wave knob sweeps between them.

• Draw straight onto the canvas, or build the shape with the harmonic sliders underneath.
• Load a starting point: basic shapes, or any of the bundled waveforms.
• Add frames and the wave knob morphs smoothly between them.
• Unison stacks up to 7 copies of the voice per note, spread apart by the track's detune knob.
• Wave scan sweeps through the frames on its own. Set the speed (free, or in time with the tempo), the direction, and how much of the table it covers. Retrigger restarts the sweep on every note.

Filter, effects and dynamics

Each track has its own chain, opened from the buttons under its name.

The effects chain

Effects run in the order they appear in the panel, starting with amp. drive pushes the signal into everything that follows, so fuzz, the wave shaper, tape saturation and the crusher all bite harder, and out trims the level back afterwards. Both sit at unity in the middle.

Then come vinyl and cassette (wear, warble and noise), fuzz, ring modulation, a wave shaper, a bit crusher, auto-wah, chorus, phaser, flanger, pitch shift, delay and reverb. Each has a wet or amount control that does nothing at zero, so you can poke around the panel safely. The vinyl crackle and cassette hiss only sound while the track is playing, so a muted or stopped track is silent.

The bit crusher has a rate as well as bits: the sample rate it runs at, from 48k down to 250Hz. Bits alone is a noise floor under the sound; rate is where the sampler grit comes from, because anything above half of it folds back down out of tune with the track.

glide lives here too. It slides the pitch between notes instead of jumping, for portamento leads and basses.

Fx buses

Everything in the panels above belongs to one track. So does the mod matrix, and so do the automation lanes. An fx bus is how several tracks come to share them: a track with no instrument, that other tracks are routed through on the way to the master.

Press + add fx bus under the tracks, or pick fx bus from any track's engine dropdown. An out control then appears on every track: point it at the bus and that track arrives there with its own sound intact, like an output assignment on a mixer.

In every other respect the bus is an ordinary track. Its filter, effects, eq and compressor act on everything feeding it at once. Its mod panel sweeps the whole group with one LFO, its aut lanes draw per-step movement across all of it, and it can be p-locked, so the group is drenched in one pattern and dry in the next. A bus can feed another bus. Sends that would loop back on themselves are refused.

A bus plays no notes, so its step grid and roll are gone. mute on a bus cuts the audio passing through it, and solo on a bus keeps whatever feeds it.

p-lock

A track normally has one sound and 32 patterns of notes. Move its filter and it moves everywhere, because the sound belongs to the track and only the notes belong to the pattern.

The p-lock button changes that for the pattern you are on. Locked, that pattern keeps a sound of its own; every pattern you leave unlocked carries on sharing the track's. So the bass can be bright and drenched in delay for the chorus while the verse and the middle eight are left alone, and those two still move together when you tweak them.

It is per pattern, so the button changes as you move around, lighting up on the patterns you have locked. In chain mode the sound changes arrive with the arrangement, on the bar.

Everything about the sound comes along:

• the engine's own controls, meaning the four knobs and whatever panel it has
• the filter and its envelope
• the effects rack, the eq and the compressor
• the modulation assignments in the mod panel

What stays put is the instrument: the engine, and any sample loaded into it. A locked pattern is one instrument played differently, not a different instrument. Routing, macro pads and the generator settings stay put too.

Modulation and automation

Two ways to make a sound move, both per track.

mod: continuous

Assign an LFO to a parameter and it sweeps on its own. Pick the target, a shape, an amount, and either a free speed in hertz or, with sync on, a length: how long one cycle takes in sequencer steps, from half a step up to 64. Filter cutoff is the obvious target, but effect amounts and the instrument's own tone controls work just as well.

The ± switch beside the amount says where that movement sits. On, the modulation swings either side of wherever the knob is. Off, it only lifts the parameter above the knob and lets it fall back: the same amount of movement, all on one side. Use that for anything that should idle where you left it and only open up.

phase is where in the cycle the shape starts. A quarter turn between two LFOs at the same rate gives you a circular pan.

Two of the six shapes are not waveforms. rnd square holds a fresh random value for a whole cycle and then jumps to another, which is sample and hold. euclid taps the parameter in a euclidean rhythm instead of sweeping it. Its length is the step length, so “1 step” means one ring step per sixteenth, and you set the pulses, the cycle length and a rotation the way you would on a track. decay at zero holds each tap for its whole step, which is a gate; turn it up and each tap falls away, which is a pluck. It locks to the transport, so the rhythm it plays is the rhythm the sequencer is playing. Put it on a filter for a gated sweep, on reverb for throws that land on the offbeats, or on a live euclid track's rotate and have one euclidean pattern turn another.

aut: per step

Automation draws a value for each step of the pattern instead. Choose a parameter and you get a lane under the grid where every step holds its own value: a filter that opens over 16 steps, a delay that only shows up on the last beat. Lanes belong to the pattern, so each pattern can move differently.

Right-click any parameter

To see what is moving one control, right-click the knob, the switch or its label. It works anywhere: the instrument row, the filter, effects, eq and comp panels, the sample and wavetable editors. You get a small window for that one parameter, holding what it does, whatever LFO or automation is on it, its macro assignment, and a button to add any of them.

A parameter with something on it wears a dot next to its label: green for an LFO, blue for an automation lane, grey for a lane you have switched off.

A knob being driven grows a second needle in that same colour, at wherever the LFO or the lane has pushed the parameter right now, while the knob itself stays where you left it. The two needles together tell you how far it is travelling and where it comes back to.

Macro pads

macro in the transport opens a set of XY pads. Each axis drives a list of parameters, and that list can span tracks: one thumb opening the bass filter while ducking the lead's reverb.

Two ways to assign a parameter to an axis:

• Learn. Press learn on an axis, then touch any control anywhere in the app. The panel gets out of the way while an axis is armed.
• The parameter menu. Right-click a control and assign it there, next to its LFO and its lane.

Each assignment has a from and a to, so one axis can open one filter across its whole range while barely moving another, and flip reverses it.

The assigned knobs move as you play the pad. By default the move is momentary: let go and everything ramps back to where it was, so nothing is committed. latch instead leaves the parameters where you put them, exactly as if you had moved the knobs yourself, so they go into the patch and into a save.

Pads are global rather than per track, and they don't follow p-lock. They are saved with the session.

Live coding with Strudel

code in the transport opens a drawer under the tracks with your song written as Strudel code. Change it and press Ctrl/⌘ Enter: the song takes the change while it plays, without the beat stopping. Ctrl/⌘ . stops. While it plays, the words in the code that wrote the sounding notes light up.

Whatever the code makes are ordinary tracks. The grid shows them, you can turn their knobs by hand, and a save keeps them. The code isn't a second copy of the song. While the drawer is open it follows the song: change a step, a knob or anything else in the studio, and the code is written again to match. Once you've typed in it, your code is left alone, and from song lights up with a dot to say the song has moved on. The bar also has examples, from song (write the song out again), copy, and strudel.cc, which opens the code on the Strudel site.

How code becomes tracks

• Each sound is a track. A seqbaby track is one instrument, so $: s("bd*4, ~ cp, hh*8") is three tracks: bd, cp and hh.
• A track is named by its label. bass: is the track called bass; an unlabelled $: takes the sound's name, and .p("my name") names it outright. A label playing several sounds makes several tracks (drums bd, drums sd). If a track of that name is already in the song, the code takes it over.
• One cycle is one bar. A pattern gets as many bars as its part takes to come round again, so <c2 eb2 g2> is three bars. Each pattern keeps its own length, so the same track can be one bar in one section and four in the next.
• Sixteen steps a bar, doubled up to 64 when notes are closer together than a sixteenth. A note between steps (a triplet) is written as a nudge on the nearest step, so it lands exactly where the code puts it.
• Notes at the same moment are one step with the extras stacked on it, and a chord symbol from chord() becomes a root and a chord type.
• Running again updates, it doesn't start over. Tracks you didn't touch keep playing. Delete a line and run, and its track goes. Delete a setting and run, and it goes back to its default. A knob you turned by hand that the code never mentions stays where you left it. Each run is one undo step, and in a jam everyone hears it.

The notation

All of Strudel's mini-notation works inside the quotes:

And these functions: s, sound, note, n, chord with .voicing(), .scale("C4:minor"), stack, cat, seq, arrange, fast, slow, rev, ply, euclid, degradeBy, struct, mask, off, superimpose, add / transpose, early / late, segment, the signals sine saw tri square cosine rand perlin with .range(), const variables, and setcpm / setcps for the tempo.

How sounds map

seqbaby has no sample library behind these names: each sound plays on the nearest seqbaby instrument.

General MIDI names (gm_epiano1, gm_electric_bass_finger and so on) go through the same rules. To pick a seqbaby instrument exactly, name it: s("silverbox"), s("subby"), s("electric_guitar"), s("plaits:virtual_analog"), or its key, s("dm:contagion"). Its name as the engine menu shows it, with underscores for spaces.

How controls and effects map

A value that is the same on every note sets the knob. One that changes from note to note becomes an automation lane. A signal such as sine.range(300, 2000).slow(4) becomes an LFO, synced to the bar, with the knob parked in the middle of the range.

For everything Strudel has no name for, seqbaby adds its own methods:

Every name and value is checked against the instrument's own controls, so a typo comes back as a note under the code rather than a broken track.

Patterns and the arrangement

A song that uses more than one pattern is written in sections. pattern(2) starts one, and the lines after it write pattern 2. .repeat(4) is how many bars it plays in chain mode (leave it off and it plays as long as its longest part), .meter("7/8") its time signature, and chain() at the top turns chain mode on.

• A track shares one sound across its patterns, as it does in the studio. .lock() gives that pattern a sound of its own (p-lock).
• Code with no pattern() writes the pattern the drawer was opened on, shown in the bar as pattern 1. If you are looking at another one it says writes pattern 1 (showing 3). Until you edit the code, it follows you from pattern to pattern.
• Strudel's own arrange([4, a], [8, b]) fills patterns 1, 2 and so on, each playing that many bars, in chain mode.
• Take a section out of the code and run, and that pattern is cleared for the code's tracks. Patterns the code never mentions are left alone.

Opening it on strudel.cc

strudel.cc opens the code on the Strudel site. When it uses seqbaby's own names, which strudel.cc doesn't know, it opens a version Strudel can play instead: seqbaby's instruments as the nearest stock sounds, only the effects Strudel has, a chained song as arrange(), and a list of what was left out.

What doesn't translate

• Things that change the pattern while it plays: every, sometimes, often, rarely, jux, firstOf, lastOf. seqbaby plays a written pattern, so the pattern plays unchanged and the run says it left them out.
• Randomness is frozen. ?, |, degradeBy and rand are rolled once when you run, and a pattern that never repeats is written as its first four bars, looped. Run again for a new roll.
• Samples. There is no sample library behind the names, so samples() is ignored, bd:3 plays the same as bd, and n on a drum doesn't choose a sample. Sampler and granular tracks need their sample picked in the studio, so code can't make one.
• Controls with no seqbaby equivalent: pan, vowel, speed, begin / end, orbit, the amplitude envelope (attack, release and friends; use .knob() on the instrument's own envelope instead) and hpq / bpq.
• Size. A track holds up to 64 steps. A pattern that only comes round every 8 bars gets a coarser grid to fit, and one past 16 bars is cut short. Each pattern has its own length, but the grid (steps per bar) is the track's, so a track that needs 32nds in one section has them in all of them.
• One filter a track. Use lpf, hpf or bpf, not two of them.
• One instrument a track. A track that plays a different sound in another pattern keeps the first.
• Chord symbols fold to the chords a step can hold (maj, min, sus2, sus4, dim, aug, maj7, min7, dom7, m7b5, add9): a C9 plays as a C7.
• A number that changes each bar in .fast("<1 2>"), .ply() and the like takes its first value.
• A sidechain belongs to the track, not to one pattern, so a locked pattern can't have its own.
• Tracks the code can't hold stay as they are. A track with arps, chord inversions, nudged steps or sample regions, and a sample, granular, MIDI, fx bus or live euclid / chance track, appears as a comment. Running the code leaves it exactly as it was; edit it in the studio.
• Only Strudel. TidalCycles' Haskell isn't read.
• The code runs here, not in Strudel. It is read rather than executed, so only the functions above exist, and anything else is left out with a note, never run.

Undo

Ctrl/⌘ Z steps back, Ctrl/⌘ shift Z steps forward, and the two arrows in the transport do the same. It covers the whole session, not just the grid: notes, knobs, tracks added and removed, generator settings, a pattern you cleared, a session you loaded by accident.

A drag counts as one step, so a knob moved in three goes comes back in one. Which pattern you are looking at is not part of it, so an undo changes the song and never the view. Text fields keep the browser's own undo: retyping a track name is the field's history, not the song's.

Jamming with other people

jam in the top bar starts a room from the song that is open and gives you a link. Everyone who opens it edits the same song with you, live: steps, knobs, tracks added and removed, generators, undo. Nobody needs an account, only the link. Opening a different song, or pressing new, leaves the jam: the song you open is yours, not the room's.

Each of you plays it on your own machine, so press play wherever you are. Play and stop are yours alone, but a start lands on the room's beat, so two people pressing play hear the same step. Which pattern you are looking at is not shared. Everything else is one song. Undo steps back over the others' edits as well as your own, and an undo goes out to the room like any other edit.

Saving, sharing and export

Leave the name field blank and the song gets named after what is in it, something like basement squelch or soft vapour. The adjective comes from the tempo and the key, the noun from whichever engine the song is mostly made of. The name appears in the field when the save box opens, so you can read it and type over it.

A saved song is a tree, not a file that gets overwritten. Every save hangs off the version you are working from, so the history keeps a straight line while you go forward and branches the moment you open an older version and carry on. Remixing leaves the tree and starts a new song. Sharing a song shares the state you saved, never the versions behind it.

Without an account everything lives in the tab, which means a reload or a clearing of site data takes it with it. An account is the way to keep it.

Letting an AI agent write a song

seqbaby ships an MCP server, which is the plug that lets an AI agent such as Claude use a tool. Connected, the agent can start a song, add tracks, write their rhythms and notes, shape their sound, put movement on them, and hand you a share link. It writes the same session the studio saves, so whatever it makes opens here like any other song, and you carry on by hand from there.

The agent works in the same vocabulary as this manual. A rhythm is a step string, so x..x..x. is a hit on steps 1, 4 and 7; X is an accent,_ a tie; a string shorter than the pattern repeats across it. Notes are names like C2. Every engine, every panel control with its range, every preset and every modulation target is served to the agent as reference, and each value it sends is checked against the engine's own tables, so a wrong engine name or a control outside its range comes back as a correction rather than a silent track. A guide tells it which engine suits which job and how each one likes to be played: that a silverbox accent is a hard hit and a slide is a tie, that subby needs drive to be heard on a phone, that a reverb belongs on a bus.

Connecting it

In Claude Code, register the server once. It runs straight from the repository; the first start installs it, later starts are instant.

Claude Desktop and other MCP clients take the same command in their configuration file:

Working inside a checkout of the repository needs no registration at all: Claude Code finds the server in the project and the composing guide with it.

Asking for a song

Say what you want in plain words, and ask for a link at the end:

The reply is a link that opens the song here. Keep talking to change it: busier hats, a different bass preset, a filter sweep across four bars. Each request edits the same song and each share is a fresh link. If you would rather nothing was published, ask for the song as a file instead and load it from the session menu's import.

If something sounds wrong

• No sound at all. Press play once more, since browsers hold audio back until you interact with the page. Then check that nothing else is soloed and that the track's volume is up.
• One track is silent. Look for a soloed track elsewhere, a muted one here, or a filter cutoff closed all the way down.
• Playback stutters. Reverb, granular and pitch shift are the expensive ones, and a lot of them at once on a slow machine will do it. Closing other tabs helps more than you would think.
• The playhead looks out of time with what you hear. Safari can't report its audio delay, so the display works from an estimate. Add ?vlat=0.2 to the address to tune it.
• An arp isn't audible. The note is probably too short to fit more than one arp note in. Lengthen it, or choose a faster arp rate.
• A knob moves but nothing happens. Check whether an LFO or an automation lane owns it. A driven knob is the base the movement swings around, and a lane rewrites it every step.
• Sound cut out after switching apps. Click anywhere on the page. The audio engine reconnects on your next interaction.

Credits and licences

seqbaby is built on other people's work. Thank you to everyone below, and if you use the sounds in something you release, these are the licences that travel with them.

The emulator engines are original models of those instruments rather than recordings of them, and the trademarks belong to their owners.