F · Live coding: music

A browser music sandbox lets first-contact learners hear a concept before any install or account

A live coding audience need not understand the code to appreciate the performance, just as guitar audiences need not know how to play

A programming language can become a musical instrument performed live in front of an audience

A regional Spanish-language live-coding collective sustains itself by bridging into TOPLAP's global infrastructure

Algorave and live coding are a genuinely global, internationally distributed practice, not a local scene

Algorave is a global movement, born in 2011, of live-coded electronic dance music with the code projected

Algorave musicians are live improvisers writing code, not DJs mixing recorded music

Algorave reframes live coding as a rave: bodies dancing to visibly-generated algorithms in a club

Algorithmic music is defined by the urge to explore musical thinking through formalized abstractions

An algorave is a dance event whose music is composed live as algorithms, with the code shown to the audience

An artist-programmer uses computer language as the medium of the artwork itself, not merely as a tool

Estuary runs a subset of Tidal (Mini-Tidal) in the browser with no installation

Estuary's entire interface, tutorials and help texts are translated into multiple natural languages

Glicol is designed for zero-knowledge beginners but scales to expert live-coding

Hydra is a browser-based, JavaScript live-coding language for networked video-synth visuals

In algorave, musicians take responsibility for the music — not the software

In live coding an error is material to work with, not a failure to hide

In live coding, programs are instruments that can change themselves — making the code itself a dynamic, performable medium

Live coding frames computer programming itself as a creative cultural activity

Live coding is improvisatory real-time composition where the writing of code itself is performed as a live event for an audience

Live coding is improvised real-time music-making, not DJing and not software engineering

Live coding performance projects the running code so the audience witnesses how the music is made

Live coding strips away GUIs to reveal the language underneath, treating the laptop as a language machine

Live coding treats algorithms as expressions of thought, not as tools — distinguishing it from tool-centric approaches to music technology

Live coding's defining conviction is that code is written and projected in front of the audience in real time

Music is made by mixing and matching small musical ideas, then changing those combinations over time

Projecting live code on screen provides an alternative perceptual channel for deaf audiences

Pure Data is a real-time visual dataflow language where connected boxes replace text code

Real-time computer control of sound synthesis dates to Max Mathews' GROOVE system (1968)

Removing cost, installation, and first-step difficulty is what makes a creative-coding tool usable by beginners

Renardo is the actively maintained successor to FoxDot for Python live coding over SuperCollider

Sonic Pi uses music to solve the engagement problem in teaching programming, not a technical one

Sonic Pi was built to teach programming to school children through music-making

Strudel is a browser-based JavaScript port of the TidalCycles pattern language

Strudel runs entirely in the browser at strudel.cc, requiring no install to start making sound

Strudel's MiniREPL is an inline interactive editor for running and editing code samples in the docs

The algorave moved live coding from experimental venues into clubs with dancefloors, first held in London in 2012

The Hacking Choreography manifesto applies live-coding transparency values to dance: code is visible on stage, and dancers can subvert the program

The laptop's portability and price point make it a more accessible instrument than a piano, democratising music production

The live-coding community values human struggle and failure over AI-generated output

The TOPLAP manifesto demands code visibility, algorithmic insight, and rejects obscurantism — and was always intended as a draft

The TOPLAP manifesto demands transparency — 'show us your screens' and 'obscurantism is dangerous'

There is no universal language or method for live coding — the practice is inherently pluriversal and resists easy classification

TidalCycles is split across two repos: the Tidal pattern language (Codeberg) and SuperDirt sound engine (GitHub)

TidalCycles learners use Tidal Club (forum), Discord, and the Codeberg repository as distinct support layers

TOPLAP is the international live coding arts organisation, founded in 2004, with local nodes and shared community channels

TOPLAP was founded at the 2004 Changing Grammars symposium in Hamburg, giving live coding a name and community

TOPLAP's core demand is screen transparency: the audience must see the code being written, not just hear its output

VJing is real-time selection and manipulation of visuals, the visual counterpart of DJing

Writing custom software enables artistic expression that commercial tools structurally prevent

Writing your own tools in free software reframes music-making as refusal of proprietary control

2-step garage removes kicks from a four-on-the-floor pattern to create a skipping, syncopated groove

A 4/4 bar divided into 16 sixteenth-notes is the working canvas for drum programming in most electronic genres

A 7th chord adds the 7th scale degree to a triad — major7 chords include the natural 7th, minor7 chords include the flattened 7th

A ChucK UGen only produces audio if it is chucked transitively to `dac`

A comma inside a mini-notation string stacks two voices simultaneously; it is not a rest

A drum kit's four functional slots each have a default placement: kick=pulse, snare=backbeat, hi-hat=subdivision, percussion=fill

A Glicol feedback bus with gain ≥ 1 explodes — keep loop gain below 1

A live coder is like an improvising composer: code is the score and the computer performs it while the audience watches it being written

A pattern is where we perceive the structure of its making in the structure of its outcome

A pitch class is one of the 12 chromatic notes named independently of octave

A quantizer snaps an incoming control voltage to the nearest note of a chosen scale, turning free-running CV into melody

A signal can be reconstructed only if sampled above twice its highest frequency

A Sonic Pi live_loop with no sleep and no sync throws a 'did not sleep' error and stops

A SuperCollider Array is a collection whose messages return transformed copies and whose arithmetic broadcasts element-wise

A SuperCollider pattern's degree defaults to C major unless a scale, root, and octave are given

A SuperDirt sample name must match a dirt-samples folder; sound "kick" is silent because the folder is bd

A tilde or hyphen in mini-notation inserts a silent step that preserves the grid

A trailing tilde marks Pd signal objects, distinguishing the audio level from the control level

A triad stacks root, third, and fifth of a scale degree; its quality is set by the semitone intervals

A Unit Generator (UGen) is an object that generates or processes signals entirely in the server

Additive synthesis builds complex timbres by summing many sine partials with individual amplitude envelopes

Algorave embraces alien, futuristic aesthetics as a deliberate departure from mainstream dance music

Algorave is a named live-coded dance music genre and social format that expanded live coding's audience beyond specialist contexts

Algorave is tool-agnostic: multiple live coding systems produce its music and visuals

All of Western music can be expressed with two Sonic Pi commands: play (pitch) and sleep (timing)

All Strudel voices default to orbit(0), so their reverb and delay sends share one bus — split voices with .orbit(n) for independent wet levels

An isochronous rhythm places its onsets at perfectly regular intervals — the trivial case where k divides n

Angle brackets in mini-notation advance one element per cycle, not per step

Angle brackets in mini-notation pick one value per cycle, rotating through the list

Asterisk in mini-notation speeds up a step, fitting n repetitions into its allotted time slot

bank() repoints a pattern's drum abbreviations at a named drum-machine sample set

Calling .asStream.next consumes a SuperCollider pattern's stream, which cannot be rewound

Changing a sample's playback rate simultaneously shifts its pitch and duration

chord() and scale() return rings of MIDI notes, making music-theory patterns directly executable

ChucK has no hot-reload path in this rig and runs as a separate process

ChucK STK instruments stay silent until `.noteOn()`, and an ADSR stays closed until `keyOn()`

ChucK sums every UGen chucked to `dac` with no master limiter, so stacked voices clip

ChucK UGen class names are CamelCase-exact and must be verified against `names/ugens.txt`

ChucK's `=>` operator means patch, control, or assign depending on the operand types

ChucK's `signal()` wakes one waiting shred while `broadcast()` wakes all

Comma in mini-notation stacks patterns to play simultaneously in parallel

Computer music programs route audio by connecting unit generators in a signal processing graph

Contemporary live coding sits in a continuous lineage of live-electronics performance practice

Creators need an immediate connection to what they are creating — any delay hides ideas

Different live-coding tools front different first skills, so tool choice sets your first learning curve

Doubling a frequency raises the pitch by exactly one octave

Editing a SynthDef without re-running .add spawns the old definition on the server silently

Electronic genres cluster around characteristic tempo ranges

Eulerroom is the live streaming platform and video archive for Algorave and live coding performances

Every Punctual audio or video statement must end with an output operator or its result goes nowhere

Feeding a control-rate .kr signal where audio-rate .ar is required errors or aliases audibly

Forward slash in mini-notation stretches a sequence over n cycles

Four-on-the-floor places a kick drum on every beat of a 4/4 bar

Fourier's theorem decomposes any periodic sound into sinusoidal partials, and their amplitudes fix its timbre

Generative art emphasises autonomous process and distance from the author; software art embeds the human in the code

Glicol BPM is set at launch with `-b` and cannot be changed in-file during a session

Glicol CLI has no embedded sample bank; samples must be placed in the `samples/` folder

Glicol CLI keeps the previous graph running on a parse error, reporting it in the TUI console

Glicol has no built-in limiter, so summed lines and high gains clip hard

Glicol has no mini-notation, Euclidean syntax, or per-step probability operators

Glicol has no note names, scales, or chord primitives — pitches are hand-coded as MIDI integers

Glicol parameters are safest written with a decimal point, as the grammar's float rule wants a `.`

Glicol synth and drum nodes are silent without an upstream trigger (`imp`, `seq`, or `speed`)

Glicol.org documents nodes that the CLI version 0.13.5 cannot parse

Glicol's `seq` outputs a pitch ratio, not a frequency — feeding it straight to `sin` gives ~1 Hz

Granular synthesis builds textures from clouds of short enveloped sound grains

Hardware cost and internet access are the first barrier to live coding, unevenly by region and income

In ChucK `dur`/`time` are typed and cannot mix with bare numbers — units need the `::` operator

In ChucK a raw MIDI integer sent to `.freq` plays that many Hz — use `Std.mtof` to convert

In ChucK, a loop with no `=> now` computes in zero logical time and emits no sound

In ChucK, dividing two integer literals gives integer division, truncating toward zero

In Glicol `seq`, top-level spaces divide the bar while adjacent digits subdivide a step

In Glicol a `~name` bus is silent until another chain references it

In Glicol, every line whose name lacks `~` is sent to the speakers and summed

In live coding the human is the unambiguous creative agent; in generative art authorship is shared with the autonomous process

In live coding, each code change affects the running output immediately

In minimalist process music the gradually unfolding, audible process itself is the music

In Punctual 0.5 osc is the sine oscillator and sin is the math sine function of its argument; old sin-as-oscillator code is wrong

In Sonic Pi, .tick mutates the ring counter while .look only reads it — calling .tick twice in one pass advances twice

In SuperCollider everything is an object, and behaviour is triggered by sending messages to receivers

In SuperDirt, reverb and delay are shared across all voices on the same orbit

In Tidal/Strudel mini-notation, * subdivides hits into one step while ! replicates a step across positions

Jazz swing is a musician's real-time feel convention while electronic swing is a fixed repeating timing offset

Larry Tesler's modelessness principle — no person should be trapped in a mode — led to cut/copy/paste

Live coding and modular synthesis share the same motivation: working with systems as musical material from the inside

Live coding elevates programming to a central performance act by modifying algorithms in real time in front of an audience

Live coding emerged from computer music history that begins with MUSIC-N and flows through Max, SuperCollider, and real-time audio in the 1990s

Live coding emerged from hacker culture and could not have developed in a commercial music industry context

Live coding is a community construction — performance implies an audience; the practice developed through communal venues and networks, not isolated invention

Live coding is improvisation with a map that generates the territory: you cannot read the code until you run it

Live coding is process-first: you start with something and follow where it leads rather than executing a fully-formed idea

Live coding languages are classified by target medium, host platform, and implementation language

Live coding makes private intellectual activity publicly visible, which can function as a political act

Live coding's hacker-derived 'what you do, not who you are' ethos supports an inclusive community

Live coding's legitimacy depends on building music from a blank slate in real time — not from pre-prepared patches or stems

Live hot-swap — replacing a running pattern or voice definition live without stopping audio — is the single most portable concept in the registry

LMMS composes repeating rhythms in the Beat+Bassline Editor and non-repeating lines in the Song Editor

Lofi hip hop is a 2010s downtempo derivative that became a major YouTube streaming genre

loop do ... end in Sonic Pi runs forever and prevents any code after it from executing

McLean's lens frames musical pattern as repetition, symmetry, interference, and deviation

MIDI is a 7-bit serial protocol sending note and control events on up to 16 channels, not audio

Mini-notation polymeter requires the {…}%n form; without %n it uses the first group's length

Mini-notation specifies patterns tersely inside a string, with events spaced evenly across one fixed-length cycle

Music code is a language, so its free/shareable nature is what gives it shared meaning

Musical patterns exist both as sonic sequences and as embodied physical actions in motor memory

N.times do ... end repeats a code block exactly N times then continues execution

Nesting passes the result of inner expressions as arguments to outer ones; indentation makes levels readable

Note-based music organizes discrete pitched events; sound-based music foregrounds spectral content with less pitch hierarchy

note() sets pitch as a MIDI number or a letter name with optional octave and accidental

Octaves, 5ths, and 4ths are stable consonances; 2nds, 7ths, and tritones are tense dissonances that want to move

Patterns recur at every level of live coding — from software architecture to music and visuals

Pd has object, message, and number boxes, with inlets always on top and outlets on bottom

play and sleep are the two primitives for pitch and timing in Sonic Pi

Pseq without an explicit repeats argument plays the list once then stops, silencing the voice

Punctual edits quantize to the next cycle boundary with a short crossfade by default, so a change can take up to one cycle to land

Punctual is not wired into this livecoding rig — no file hot-reload, no 4-bin a.fft shim; run it at its own URL or in Estuary

Punctual's [...] list is combinatorial (channel-count product) while {...} is pairwise; using [...] where {...} is intended silently multiplies channels

Punctual's $ makes everything to its right the final argument while & is reverse application; confusing them silently reorders the graph

Punctual's cps is fixed at 0.5 when run standalone; it only reflects the ensemble tempo inside Estuary

Punctual's three arrow operators have distinct roles: >> routes to output, <> sets crossfade duration, and << is assignment (synonym for =)

Pure Data patches run in realtime, so editing the patch changes the sound immediately

Re-evaluating an Ndef with a syntax error keeps the old graph running with no audible indication

Re-running a Sonic Pi buffer does not restart the piece; it swaps each live_loop body in at its next boundary and loops keep their .tick counters

Receiver notation (a.msg(b)) and functional notation (msg(a,b)) are interchangeable in SuperCollider

Renardo 1.0 replaces the legacy Tkinter editor with a browser-based Svelte web client as its default interface

Rings in Sonic Pi wrap around on any index access, enabling infinite cycling of sequences

s.freeAll (Cmd-.) frees every running node but leaves the server booted and SynthDefs loaded

SC uses four enclosure types with distinct purposes: parentheses, brackets, braces, and quotes

Secondary notation — whitespace, naming, colour — carries meaning for human programmers that the interpreter discards

Self-playing musical automata have a history of over a millennium, predating computers as models of algorithmic composition

setcpm() sets global tempo in cycles per minute; the default 30 cpm equals 2-second cycles

Several Tidal functions like rot, whenmod, and layer throw undefined in installed Strudel 1.2.6

Sonic Pi cannot feed the rig's 4-bin FFT bridge for audio-reactive visuals — it runs in its own IDE with a bundled SuperCollider server

Sonic Pi idiomatically uses symbols not strings for samples and notes — play :e3 or play 52 work but play "e3" does not

Sonic Pi is designed for school children to learn programming through live coding music, with pedagogical materials built in from the start

Sonic Pi synth opts (amp:, pan:) control per-note volume and stereo position

Sonic Pi synth, sample, and fx names must exist in the bundled set; names like :kick, :bass, :verb are errors — the real names are :bd_haus, :tb303, :reverb

Sonic Pi's (range 0, 8) excludes the end value (0..7) while (line 0, 8, steps: 9) includes it — a common off-by-one source

Sonic Pi's random functions are deterministic: the same run always produces the same sequence

Sonic Pi's sync waits for the next cue from that point, so a loop with sync at the top delays its first pass by up to one cue period

Sonic Pi's use_bpm is thread-local; setting it in one live_loop does not change the tempo in another

Sonic Pi's with_fx wraps a code block, not a voice; only play/sample calls inside the do…end block are processed through the effect

Sound waves are pressure variations in air that the cochlea decodes as electrical signals

Source waveform sets harmonic complexity in a ladder from sine (pure) to noise (harsh)

Sporked ChucK shreds die when their parent shred ends

Square brackets in mini-notation subdivide one step into a nested sub-sequence

Standard two-letter abbreviations map to drum kit sounds in Strudel's default sample set

Strudel audio effects are chainable methods that accept patterned values

Strudel gain stacks multiplicatively and clips — several loud voices distort, so keep per-voice gain well under 1

Strudel is a browser-native port of TidalCycles that requires no installation and runs on any device with a web browser

Strudel is a browser-native, Tidal-style pattern language that shares TidalCycles' syntax

Strudel mini-notation * speeds hits into one step's time while ! replicates across steps — mixing them changes the rhythm

Strudel mini-notation squishes a space-separated sequence of sounds into one cycle

Strudel mininotation is a mini-language inside pattern strings that expresses rhythmic structure

Strudel note values can be MIDI numbers or letter names with octave and accidental notation

Strudel patterns must include .analyze('hydra') for visuals to receive FFT data — an untagged pattern plays audio but the visuals see a.fft = 0

Strudel polymeter with {…} requires the %n step-count suffix; without it the first group's length sets the step count for all groups

Strudel produces no sound until the first user click unlocks the browser AudioContext — silence at startup is autoplay policy, not a bug

Strudel re-evaluates on save without cutting audio — a syntax error keeps the previous pattern playing while the edit is not applied

Strudel sample names must match folders in the loaded bank — s("kick"), s("clap"), s("snare") are silent because the real folder names are bd, cp, sd

Strudel spaces every element of a pattern evenly within one fixed-length cycle

Strudel takes patterns/signals as arguments (not thunks like Hydra) — .lpf(sine.range(200,2000)) is correct; .lpf(() => ...) is a cross-DSL mistake

Strudel's crush takes a bit-depth (1–16), not a 0–1 knob — crush(4) is heavy, crush(16) is nearly clean

Strudel's setcpm is cycles-per-minute not BPM — setcpm(120) is very fast; use setcpm(BPM/4) for the standard 4-beats-per-cycle feel

SuperCollider 2's proxy system enabled true live coding by making it possible to rewrite any component of a running program at runtime

SuperCollider audio-analysis UGens are not wired to this rig's AV bridge and cannot drive its visuals

SuperCollider class names are capitalized and methods lowercase; misspelling a UGen name fails outright

SuperCollider conditionals use if(cond, {true}, {false}) and case tests condition/action pairs in order

SuperCollider distinguishes local variables (var), single-letter globals (a-z), and environment variables (~name)

SuperCollider evaluates binary operators strictly left-to-right, ignoring conventional arithmetic precedence

SuperCollider exists as two separate networked programs: sclang and scsynth

SuperCollider functions are curly-brace blocks that run only when sent .value and return their last expression

SuperCollider has no global output limiter, so summed voices and feedback can clip or blow up

SuperCollider is two separate processes: a language client and a sound server

SuperCollider patterns started without .play(quant:) begin immediately and drift out of phase

SuperCollider produces no sound until the audio server is explicitly booted with s.boot

SuperCollider records the server's live audio output to a sound file with record and stopRecording

SuperCollider scopes variables three ways: local (var) vanish with their block; single-letter and environment (~) names persist across the session

SuperCollider serves both as a standalone live-coding environment and as the audio back-end for many front-end languages

SuperCollider UGens run at audio rate (ar), control rate (kr), or initialization rate (ir)

SuperCollider's 2002 release as free software made it the foundational audio engine for live coding

Swing delays every other 16th note by a set proportion, with 50% meaning straight timing

Teaching algorithms through music engages students in computational thinking — describing, designing, and executing step-by-step processes — in a naturally motivating context

The $: prefix declares an independent pattern that plays simultaneously with other $: patterns

The 16-step drum machine grid represents two bars of 4/4 time as sixteen eighth notes

The ars combinatoria tradition treats music composition as combinatorial permutation of formal elements, predating computers by centuries

The crash is a celebrated moment in live coding performance — silence followed by sound returning always earns a cheer

The first generation of live coders came from art schools where tutors taught them code as creative material — not from computer science departments

The four basic filter types are defined by which frequency region they pass or attenuate

The pentatonic scale omits the 4th and 7th degrees of the major scale, creating a five-note, dissonance-free set

The Post window is SuperCollider's primary feedback channel for results, warnings, and errors

The sound() function plays a named sample and accepts colon notation to select sample variants

The TOPLAP Manifesto and 'Live Coding: A User's Manual' are the canonical texts for the field

The tresillo is a one-bar 3+3+2 rhythm that loops the first half of son clave and recurs across many genres

Tidal * and / operators speed up or slow down pattern steps multiplicatively

Tidal # keeps the left structure and takes the right value; |+| combines both structures and does arithmetic

Tidal combines patterns with operators; Strudel chains methods, so pasting Tidal operator syntax into Strudel throws

Tidal d1-d9, hush, solo, and mute manage multiple simultaneous patterns live

Tidal does not run in this rig; every Tidal pattern must be compiled to Strudel to be heard

Tidal evaluates a block on the editor's eval keystroke, not on file-save like the rig hot-reload

Tidal names a scale with a space-separated root — scale "c minor" — not Strudel's colon form

Tidal run and .. generate sequential integer patterns compactly

Tidal sets tempo with setcps (cycles per second); passing a raw BPM to setcps is absurdly fast

Tidal slow, fast, and hurry change pattern duration relative to the cycle

Tidal uses (k,n) notation inside a pattern to generate Euclidean rhythms — evenly distributing k onsets over n steps

Tidal writes chords with the apostrophe form n "c'min7" and has no separate .voicing() step

Tidal's d1..d16 channels and p come from BootTidal.hs and have no Strudel equivalent

Tidal's fundamental time unit is the cycle, not the beat, so adding events packs them tighter rather than lengthening the bar

TidalCycles emerged from the need to make live music without minutes of dead air — Perl was too slow for real-time performance

TidalCycles is a live coding environment designed for exploring musical pattern

TidalCycles is a pattern language that makes no sound; it delegates audio to a separate engine (SuperDirt/SuperCollider)

TidalCycles was designed to be immediate, so a code change is audible within a few seconds

To learn a live-coding language faster, imagine the sound before pressing Run, then diagnose the difference

To modulate a running Sonic Pi effect or synth you must capture its block-argument handle and call control on it

Two Sonic Pi live_loops with the same name are not independent — the second replaces the first

UGen .range and .exprange map a -1 to 1 signal to a custom output range (linear or exponential)

UGens are either unipolar (0 to 1) or bipolar (-1 to +1); knowing which is essential before routing their output

UGens run at audio rate (.ar) or control rate (.kr), trading CPU for update resolution; only .ar signals reach the speakers

use_bpm sets the tempo so sleep, envelopes, and FX phases all scale accordingly

Using an audio-only function in a visual context (or vice versa) in Punctual silently returns 0 rather than an error

Visual dataflow patching (Max/Pd) builds instruments by wiring boxes, distinct from text-based live coding

Web Audio API, WebMIDI, and Tone.js are the browser-native stack for interactive music apps

WebChucK runs ChucK in the browser via WebAssembly and the Web Audio AudioWorklet

Wrapping SuperCollider lines in outer parentheses makes a code block that evaluates as one unit on a single keypress

! in mini-notation replicates a step n times at equal duration

@ in mini-notation elongates a step proportionally, weighting its duration relative to neighbours

7th extensions are the most useful chord color in electronic music; minor-7 and major-9 define the deep-house/dub-techno pad sound

A chord-stab sounds all tones together with a tight envelope; an arpeggio plays them sequentially, turning harmony into rhythm

A counter-melody moves against the main line, filling space via call-and-response without adding density

A mix is a finite budget — spectrum, stereo width, and headroom shared between all voices

A Pd object only fires from its leftmost (hot) inlet; other inlets are cold and merely store

A pedal-tone holds one pitch while chords change above it, anchoring ambiguous harmony and adding tension

A random-walk melody uses small steps through scale degrees so stepwise motion reads as a tune

A ratchet-retrigger subdivides a single step into a fast burst while a drum roll retriggers across multiple steps

A rhythm necklace is an equivalence class of cyclic rhythms that disregards the starting point

A rhythmic motive is a short, identifiable rhythmic cell that can be repeated and varied to drive a groove

A rising audio energy arc can be mapped to rising visual motion rate or scale so that both domains accelerate together during a build

A semi-looping random CV source (Turing-Machine style) balances a repeating loop against occasional new random values

A sequential voltage source steps through programmed voltages, driving pitch, amplitude and duration at once

A shift-register sequencer like the Turing Machine generates evolving CV by looping a window of random bits, steered rather than programmed

A Strudel voice must be tagged `.analyze('hydra')` to contribute to the FFT — an untagged voice is inaudible to the visuals even if loud in the speakers

A swing setting of 60–65% produces the rolling feel characteristic of UK garage

A SynthDef is a reusable named synth recipe; a Synth is a running instance of it

A SynthDef is a reusable recipe for sound; a Synth is one execution of that recipe

A Tidal pattern is a function from a time arc to a list of events, not a stored sequence

A TidalCycles pattern is built in two layers: a mini-notation sequence as source material, then transformations applied to it

A tool's affordances and omissions silently shape the musical ideas a performer can conceive

A walking bass outlines the harmony by passing through chord tones and chromatic approach notes between roots

add() transposes pattern notes by a numeric amount, treating letter names as numbers

Additive rhythm builds unusual time signatures by combining groups of 2 and 3 eighth-note cells

Additive synthesis builds complex timbres by summing sine waves at chosen frequencies and amplitudes

Additive synthesis in SuperCollider stacks SinOsc UGens with harmonic ratios and independent amplitude envelopes

ADSR envelope in Strudel shapes each note's amplitude over four stages: attack, decay, sustain, release

ADSR envelopes in Sonic Pi shape both amplitude and duration of each triggered note

ADSR envelopes require a gate argument; trigger arguments cause immediate release on ADSR

Algorithmic pattern transformations (transposition, reversal, rotation, phase offset, etc.) are the compositional vocabulary of live coding

Almost any timbral intent reduces to five axes: spectral tilt, harmonic complexity, amplitude envelope, modulation movement, and space/width

Alternating phrases between two voices fills space and creates dialogue without adding density

Ambient melody, if present, is a sparse motif or scale-constrained random walk drifting high above the pad

Ambient music prioritizes timbre, space, and evolution over rhythm and progression

An algorithm's affordances are the musical actions it suggests or enables to its user

An arrangement is organized into named sections, each carrying a density/energy target and a structural function

Angle brackets in Tidal mini-notation select one element per cycle, creating slow-cycling pattern variation

Applying a transform only every nth cycle keeps a steady section alive without changing sections

Arpeggiation breaks chord notes into a melodic sequence, creating motion within a static harmonic field

Automating filter cutoff over time is the fundamental build and breakdown gesture across electronic genres

Baroque fugue applies deterministic transformations (stretto, inversion, augmentation, diminution, retrograde) that map directly onto code operations

beat_stretch: maps a sample to a specified beat count at the current BPM

Bitcrushing reduces bit depth or sample rate for digital lo-fi grit, distinct from analog saturation

Bjorklund's pulse-distribution algorithm has the same structure as the Euclidean algorithm

Buildup, breakdown, and drop create formal structure in electronic music through textural density rather than sectional contrast

Calling .play on a Pbind returns an EventStreamPlayer, and only that stored player can be stopped or resumed

cat plays patterns one per cycle, seq crams them into one cycle, stack plays them together

Cellular automata generate emergent global patterns from cells that update on local neighbour rules

Choose the scale, chord, and grid first, then let chance fill them; never randomize constraints and content at once

Choosing a scale is the single highest-leverage harmonic decision — it sets mood before any chord is played

Chopping and re-sequencing a sample turns any audio into a rhythmic-melodic instrument — timbre and rhythm at once

Chords in a Pbind are written as nested lists inside the pitch key

Chosen subdivision sets a genre's speed feel independently of tempo

ChucK is strongly-timed: advancing 'now' drives synthesis with sample-accurate control

ChucK wires Unit Generators into a signal chain with the ChucK operator =>

chunk applies a transformation to a different Nth of the cycle each cycle, rotating the window

chunk divides a pattern into n parts and transforms a different part each cycle

Close voicings (within one octave) are dense and mid-heavy; open voicings (spread across octaves) are spacious with a cleaner low end

Collaborative live coding platforms let multiple performers share a live code environment in real time

Comma-separated note values in Strudel produce chords; interval notation builds chord types

Comma-separated patterns inside square brackets create polyrhythms in Tidal

Control buses route modulation signals between synths so one modulator can drive many

Convolution applies an impulse response to a signal, enabling realistic room reverb simulation

cue broadcasts a named event and sync blocks until the next occurrence of that event

Curly-brace patterns in Strudel combine sequences of different step counts polymetrically

cut stops the current sample as soon as the next event in its group is triggered

Deep house and tech-house are opposite ends of a harmonic-density spectrum within house

define :name do ... end creates reusable code blocks that persist and can be redefined between runs

degrade and degradeBy randomly drop events from a pattern with a given probability

degradeBy removes events by probability; sometimesBy applies a function by probability

Delay and comb UGens allocate memory dynamically; increase s.options.memSize to avoid allocation failures

delay() adds echo repeats, with optional arguments for echo time and feedback

DnB creates a two-speed illusion: fast drums at ~174 BPM over a half-time-feel bass at ~87 BPM

doneAction: 2 tells a UGen to free its enclosing synth node when it finishes, preventing silent zombie synths

Dropping or adding a full layer on a bar line is an instant, effective transition natural to live coding

Each frequency band of an electronic mix has designated owners; the low-mid 250-500 Hz 'mud zone' is easiest to overfill

Each timbre intent adjective maps to a specific direction on the synthesis parameters, and combined tags stack additively

Effective generative music constrains the output space first so every random result is musically acceptable

Electronic music leans on a handful of workhorse chord progressions, each with a genre home

Encoding structure as an algorithm lets a whole arrangement be produced and restructured in one move

Env.new specifies an envelope as arrays of levels, times, and per-segment curvatures

EnvGen's doneAction argument controls what happens when a finite envelope finishes

Euclidean rhythm notation is a first-class idiom in TidalCycles/Strudel, compressing a groove to two integers

Event-driven sync lets a concurrent voice block on a named cue and be woken by a broadcast — distinct from time-grid quantization

every applies a transformation to a pattern on every nth cycle, leaving other cycles unchanged

Every Pd message is a selector plus arguments, built from float, symbol, and pointer atoms

Every running synth is a node in the server's Node Tree; .free removes one node, ctrl+. frees them all

Every Strudel mini-notation pattern has an equivalent JS function form, but mini-notation has only a handful of modifiers

every turns a static pattern into an evolving one by transforming it on every Nth cycle

fast(n) and slow(n) scale a whole pattern's tempo, the function forms of * and / in mini-notation

Filter automation controls perceived energy without adding notes: opening a lowpass raises energy, closing thins for a breakdown

Flashing each pattern element as it becomes active gives a live coder direct visual feedback on timing

Flok enables multiple live coders to share and edit a single browser interface in real time

FM synthesis builds complex spectra by using one oscillator's frequency to modulate another's

FM synthesis with integer modulator-to-carrier ratios produces harmonic tones; non-integer ratios produce inharmonic metallic tones

fork schedules time-ordered Pbind launches using .wait calls inside a Routine running on a TempoClock

FoxDot and its fork Renardo live-code music in Python using SuperCollider as the audio engine

Freesound API enforces per-minute and per-day rate limits that are stricter for write operations

Frequency modulation drives a carrier oscillator's frequency with a modulator, generating sidebands at C±kM

From-scratch live coding starts with a blank file; prepared-set coding edits pre-written code — each suits different contexts

gain() controls amplitude and can be patterned to create dynamic accent patterns within a rhythm

Generative music apps (Bloom, Scape) blur composer and listener; reactive apps use sensors (GPS, microphone) to make music responsive to physical context

Generative mutation drifts a pattern imperceptibly moment-to-moment but completely over minutes

Ghost notes are very quiet unaccented hits that add groove without changing the overt pattern

Glicol builds sound by chaining named audio nodes in a directed graph

Glicol compiles to WebAssembly for garbage-collection-free real-time audio in the browser

Glicol suits ambient drones because its modular graph natively sustains and slowly modulates signals

Glicol's seq node divides a bar by spaces and sub-divides each beat with concatenated MIDI numbers

Hard-coding the kick/bass/backbeat while making ornaments probabilistic gives a pattern both stability and life

Hardware modules like Stoicheia make Euclidean rhythm distribution tangible and patchable as a form of live coding

House is the most harmonic four-on-the-floor genre, with 7th/9th chord-stabs as its hook

Hydra is a browser-based live coding environment for visual synthesis, enabling collaborative networked visual performance

In a Tidal # combination, the left-hand pattern determines the rhythmic structure

In ambient, generative mutation replaces arrangement: parameters drift over minutes, not bars

In DnB the backbeat snare on 2 and 4 anchors the half-time feel against busy hats and ghost notes

In imperative engines, clock-quantized launch must be explicitly coded; Strudel/Tidal get it implicitly from the global cycle clock

In live coding the arrangement is enacted as a real-time sequence of code edits, not planned on a timeline

In loop-based rigs the tension arc is a staircase of discrete section states, not a continuous automation curve

In Strudel the tempo is set as cps (cycles per second), where bpm = cps × 60 × beats per cycle

In SuperCollider, always plot an unfamiliar UGen before playing it to avoid dangerous amplitude spikes

In SuperCollider's audio server, Synths are processed head-to-tail, so effects must appear after sources

In the imperative sequencing paradigm time only advances when you explicitly move it forward — nothing sounds until you advance time

In this rig frequency-budgeting and masking-avoidance are predictive — no framework surfaces a wired metering or perception bridge

In Tidal mini-notation, [] stacks subsequences into one cycle (polyrhythm) while {} aligns them step-for-step (polymetre)

In Tidal, $ is a low-priority function application operator that avoids wrapping the final argument in parentheses

in_thread do ... end launches a concurrent execution path while the main thread continues

Integer.do inside a SynthDef creates that many UGen instances and accumulates them into a sum

Isolating and looping a track's most compelling section creates a hypnotic transporting effect

iter n rotates a pattern's starting point forward by one subdivision each cycle

Jitter adds controlled timing randomness to a clock, from subtle humanization to complete chaos

Jungle producers built a new genre by slicing the Amen break into individual hits and rearranging them at high speed

jux applies a transformation to only one stereo channel, splitting a mono pattern into a hard stereo image

Karplus-Strong synthesizes a plucked string by recirculating a noise burst through a delay line and a lowpass averaging filter

Keep the sub-bass mono and singular — one bass note at a time, because chords in the sub range turn to mud

Keeping code and output permanently synchronized eliminates the mental model gap that causes creative blindness

Klank implements a bank of resonant filters excited by an impulse to model acoustic resonators in SuperCollider

knit creates a ring by repeating each value a specified number of times

Language-side random functions in a SynthDef choose values at compile time, not at Synth creation

lastOf and firstOf apply a transform on one specific cycle out of every n

Layering multiple simultaneous entropy sources yields mush; add one knob of chaos at a time

line generates a ring that linearly interpolates from start to finish across N steps

Live coding aligns with open-source, hacker ethics of sharing, transparency, and DIY access — especially enabling participation in communities with fewer resources

Live coding feels like an instrument rather than a DAW because evaluation is immediate and the feedback loop closes in milliseconds

Live coding is a feedback loop of writing code, running it, perceiving the result, and letting that drive the next change

Live coding is simultaneously notation and execution — the code notates and performs the work at the same time

Live coding makes the process of thinking visible — including errors, trial and error, and self-reflexive annotation — as part of the performance

Live performance involves three feedback loops: code/programmer, sound/programmer, and audience/programmer

Loading custom sample packs into SuperDirt requires adding a loadSoundFiles path to the SuperCollider startup file

Locking the bass to the current chord's root (or root/5th) is the safe default that ties harmony and rhythm together

Logging every keystroke with a timestamp lets a live-coded performance be regenerated exactly from text

Logic/MPC and FL Studio/Cubase use opposite swing scales — 0% in FL Studio equals 50% in Logic

loopAt syncs a long audio sample to a given number of Strudel cycles

lpf() applies a low-pass filter; lower cutoff values muffle sound, higher values let high frequencies through

Mapping time to space allows designers of time-based systems to see their entire history at once

Masking is fixed in priority order: arrange apart in time first, then EQ carve, then pan, then change register

Melodic contour (the shape of rising and falling) is what a listener remembers more than the exact notes

Melodies are built from motives (short rhythmic/melodic cells) grouped into phrases

Microtiming — small per-hit push/pull offsets of a few milliseconds — is what separates a sampled break from a programmed one

Mid-to-late 1990s software democratised music production and enabled laptop performance and live coding as new techno practices

Mix collapses an array of signals to mono; Splay spreads them across stereo

Mix folds a multichannel array to mono; Splay spreads it evenly across a stereo field

Mixolydian mode is a major scale with a flattened 7th degree, giving it a folk-rock character and removing the leading-tone tension

Motif development turns one short idea into a whole track's melody via transpose, invert, retrograde, augment, and fragment

MouseX and MouseY turn cursor position into live control signals, making a synth playable in real time

Moving chord tones across octaves (octave displacement) improves voice leading and creates stepwise melodies from otherwise static chords

Musical patterns gain complexity from interference between simple layers — not from the complexity of individual layers

Musical structure operates across multiple nested timescales from microsound through the perceptual present to formal sections

Muted-kit and rhythmic variations drive a track's build-ups and breakdowns

Named threads in Sonic Pi prevent duplicate instances when Run is pressed multiple times

Nested SC expressions evaluate inside-out; proper indentation makes nesting depth visually explicit

octs generates a ring of the same note across multiple consecutive octaves

off delays a transformed copy of a pattern by a fraction of a cycle and layers it over the original

Offsetting loop lengths in polymeter yields minutes of non-repeating combination from short loops with zero randomness

Onset/voice density over time is the most reliable lever for controlling perceived energy in an arrangement

Orbital used MMT-8 hardware sequencers in a loop-switching live setup that performed music by swapping patterns rather than triggering samples

Orca encodes values 0–35 in base-36 using digits 0–9 and letters A–Z

Orca is a 2D grid where every alphabet letter is a live operator

ORCA is a grid-based live-coding environment where single-letter instructions form music machines by spatial adjacency

Orca variables store and retrieve single characters via V, enabling cross-grid wiring

Orca's C clock outputs a counting value while D delay emits a bang on the modulo

Orca's colon operator sends MIDI notes with channel, octave, and note arguments

Orca's R operator outputs a random value between min and max each frame

Orca's T (track) operator sequences melody by indexing into a character string

OSC (Open Sound Control) is a network-based messaging protocol for real-time musical control, designed to supersede MIDI's limitations

OSCdef registers a named function to respond to incoming OSC messages by address

pan() positions each event in the stereo field, from full left at 0 to full right at 1

Pan2 places a mono signal in a stereo field; its pos argument ranges from -1 (left) to +1 (right)

Pan2 places a mono signal in the stereo field: -1 hard left, 0 center, +1 hard right

Passing an array to a UGen argument duplicates the whole signal graph, one copy per array element

Patcher languages like Max and Pure Data are visually rich but their primary syntax ignores spatial position

Pbind can drive any custom SynthDef by naming it with \instrument; SynthDef argument names become Pbind keys

Pbind durations are in beats; a TempoClock sets BPM, defaulting to 60 BPM if none is provided

Pbind has a built-in pitch hierarchy: midinote, note, degree all resolve to freq if the SynthDef uses 'freq'

Pbind maps keyword-value pairs into a timed stream of playable musical events

Pbind maps symbol-value pairs to a SynthDef's arguments, creating a timed stream of Synths

Pbind plays named SynthDefs via \instrument; SynthDef args become Pbind keys; freq and gate must be spelled exactly

Pbind rests are written as Rest(duration) and can appear in any parameter stream

Pbind specifies pitch four mutually exclusive ways: \degree, ote, \midinote, and req

Pbind supports named scales via \scale and chords via nested lists in pitch keywords

Pbind's stretch key converts rhythmic fractions to absolute seconds; quant locks changes to a grid

Pbrown implements a bounded random walk that moves musical parameters in small steps

Pd's trigger object splits one input into typed outputs fired right to left

Per-step firing probabilities create a living sequence with a fixed skeleton and flickering ornaments

PGroups in Renardo trigger multiple notes simultaneously on a single beat as a chord

Pinning a free-running audio tremolo and a visual brightness-pulse to the same rate value makes them move in lockstep without a shared transport

Placing individual hits off the grid by hand creates groove that uniform swing quantize cannot

PlayBuf plays a Buffer at a controllable rate, with optional looping and a trigger to jump to startPos

PlayBuf.ar loads an audio buffer and plays it back with variable speed, direction, and looping

PlayBuf.ar plays back audio files loaded into server buffers; rate controls speed and direction

Playing the same melody an octave higher reads as brighter and more intense — register is an arrangement lever

ply(n) speeds up each individual event n times within its own time slot, adding rhythmic density

Polymeter and every-n-transform generate long-form evolution in techno without changing the core pulse

Polymeter is the cheapest way to make a loop evolve without writing more notes

Polymeter, polyrhythm, and counter-melody are realized in imperative engines as genuinely separate concurrent timelines that can drift

Polyrhythm sounds two conflicting subdivisions at once, creating a rolling tension that resolves periodically

Post-war composition split between total pre-determination and deliberate abdication of control

Prand picks a random item from a list on each event, constrained to list members

Pre-gramming is the preparatory language and code design a live coder does before performing, which merges composition with language design

Pressing Run in Sonic Pi adds a new concurrent thread without stopping existing threads

Probabilistic variation at low amounts humanizes a pattern; at high amounts it thins or breaks it up

Probabilistically ratcheting a step into a 2/3/4-hit burst adds unpredictable rolls and stutters

Programmers use both discrete linguistic symbols and analogue mental imagery simultaneously when reading and writing code

Pseq plays items from a list in order for a given number of repetitions

Pseq, Prand, and Pwhite are three core Pattern generators with distinct selection behaviors

Punctual uses a normalised -1 to 1 coordinate space with (0,0) at the centre of the screen

Punctual uses the same signal notation for audio and visuals, routed by the >> target

Pwhite generates uniformly-distributed random numbers across a continuous range

Reason in scale degrees and resolve to pitch class late so an arrangement transposes by changing one number

Reich's phasing runs two identical loops at slightly different speeds to generate emergent shifting patterns

Relative keys share notes with a different tonic; parallel keys share a tonic with different notes, and swapping between parallels is modal interchange

Renardo Patterns are cyclic sequences that support arithmetic, slicing, and algorithmic manipulation

Renardo player attributes (`dur`, `amp`, `pan`, `sus`, `oct`) control timing and expression per note

Renardo players receive SynthDef instructions via the `>>` operator and play patterns continuously

Renardo pre-defines Roman numeral chord constants I–VII as PGroups for quick chord progressions

Renardo requires SuperCollider installed and bootable separately before it can produce sound

Renardo ships a large built-in scale library covering modes, bebop, world, and symmetric scales

Renardo startup files run automatically on launch to pre-configure the session environment

Renardo supports SuperCollider, REAPER, Ableton Live, and MIDI as swappable audio backends

Renardo uses scale degree integers (not MIDI notes) as pitch values, converted via `Scale.default`

Renardo's `.fadein(n)` method ramps amplitude from 0 to full over n beats

Renardo's `lpf` and `hpf` attributes apply per-note low-pass and high-pass filters directly on players

Renardo's `play()` instrument uses a string of characters to define a rhythmic sample pattern

Renardo's gatherer module enables downloading sample packs and instrument chains from a community server

rev() reverses the time direction of a pattern's events within each cycle

Reverb and delay create front-to-back depth — the mix's third dimension beyond frequency and stereo

Riley's In C structures a piece as ordered phrase cells each performer repeats and advances at will, blending determinism with indeterminacy

room() adds reverberation to a pattern, from dry at 0 to increasingly wet at higher values

Rotating the tonic of the pentatonic scale produces 5 distinct modes, each with a different emotional character

rpitch: shifts a sample's pitch by semitones without manually calculating the equivalent rate

Sample envelopes auto-set sustain to remaining sample length unless overridden

Sardine Players (Pa–PZ) are the core scheduling unit: each holds a looping pattern that runs against the global clock

Sardine turns Python into a time-aware live coding instrument by making function evaluation immediate and hot-reloadable

Sardine's live coding relies on a REPL: evaluate-and-update any code while the scheduler keeps running

SC server executes synth nodes top-to-bottom in the Node Tree; source synths must precede effect synths or no audio flows

scale() interprets n() numbers as degrees within a named musical scale

Sending set to a Group broadcasts the message to all contained Synths simultaneously

Separating s (sample folder) and n (index) in Tidal enables independent patterning of name and index

Session View enables nonlinear clip-based performance by launching clips in any order

Set the kick as the loudest reference and build every level relative to it, leaving master headroom, before reaching for EQ/compression

Setting an arpeggiator's gate low turns held notes into a short-gated step-sequenced bassline

Setting doneAction:2 in an envelope automatically frees a Synth when the envelope finishes

Sharing mutable variables across Sonic Pi threads causes non-deterministic race conditions

Showing concrete runtime values alongside abstract code eliminates the need to mentally simulate execution

Shuffle rhythm replaces straight eighth pairs with the first and third of a triplet, creating a swinging feel

Sidechain-pump has two roles: functional masking-avoidance between kick and bass, and aesthetic pump as a genre signature

Sidechaining a sustained sound to a muted kick creates rhythmic pumping without an audible drum

Slightly off-grid drum timing creates human groove that fully quantized patterns lack

slow and fast scale a Tidal pattern's time by a factor, changing its speed without altering its structure

sometimes/often/every apply transformations probabilistically or periodically in Strudel

Sonic Pi is a strongly-timed language where sleep controls when events occur rather than pausing execution

Sonic Pi plays external audio files by passing a file path string to sample

Sonic Pi ring chain methods transform rings immutably, returning a new ring without modifying the original

Sonic Pi, SuperCollider, Strudel, and Tidal are theory-native for harmony; Glicol, ChucK, and Punctual require hand-spelling frequencies

Sonic Pi's live_loop runs each named loop as a concurrent thread you can edit while it plays

Sonic Pi's onset: option indexes a sample's drum hits like a list, so you can play individual hits by number

Sonic Pi's start: and finish: opts play arbitrary sub-sections of a sample

Sonification maps data to sound to convey scientific meaning; music creates self-contained meaning in form — the same audio can be both

Sound reaches Hydra through exactly one path: a 4-element FFT array filled from Strudel's Web-Audio analyser — no MIDI, OSC, or per-instrument bus exists

SoundIn reads from hardware audio input buses; use headphones to prevent feedback

SoundIn.ar reads from the sound card's input buses; use headphones to prevent feedback

Spectral tilt (filter cutoff) is the single most expressive timbral move and the primary brightness control

speed() changes sample playback rate; negative values reverse the audio waveform

Spiegel's 1981 taxonomy of twelve pattern-transformation classes underpins algorithmic pattern libraries

splice time-stretches each chopped segment to its event duration; chop does not

spread() generates a Euclidean boolean ring for rhythmic hit placement in Sonic Pi

Square brackets in Tidal mini-notation create sub-patterns that fit multiple events into a single step

stack() layers multiple independent patterns into one simultaneous polyphonic output

Stepwise melodic motion sounds smooth while leaps sound dramatic and should resolve back by step

Strudel and Hydra have no shared clock — Hydra's bpm and Strudel's transport are independent and will drift

Strudel samples may not sound on the first play until you stop and restart

Strudel signals are continuous time functions that drive parameters smoothly between values

Strudel's built-in signals (sine, saw, square, rand, perlin) continuously modulate effect parameters

Subtractive synthesis sculpts a complex source by filtering away unwanted frequencies

SuperCollider has four enclosure types: () for argument lists and code blocks, [] for arrays, {} for functions, and "" for strings

SuperCollider IDE workflow requires Shift-Cmd-B to select a code block and Shift-Enter to evaluate it

SuperCollider Patterns are lazy descriptions of streams; asStream materialises them one value at a time

SuperCollider Pbind's pitch hierarchy supports alternative tunings via stepsPerOctave and scale

SuperCollider responds to incoming MIDI by registering callback functions on MIDI message types

SuperCollider routes audio between synths on numbered buses; Out.ar writes, In.ar reads, and Bus.audio allocates free buses

SuperCollider Routines and Tasks are coroutines that yield time to the clock between musical events

SuperCollider sends and receives OSC messages over UDP, enabling integration with other software and hardware

SuperCollider sounds are built from networks of Unit Generators (UGens) wired by nesting

SuperCollider's cross-platform GUI builds windows, sliders, and views by composing View objects in layout managers

SuperCollider's Env class defines a breakpoint envelope that EnvGen (or the .kr shortcut) plays back as a control signal

SuperCollider's Event system dispatches sound by type, making note, rest, group, and bus events uniform

SuperCollider’s GUI redirect system returns the active kit’s class when you request a generic Window

SuperCollider's Out UGen writes a signal to a numbered audio bus, not directly to hardware

SuperCollider's PMOsc implements phase modulation synthesis, producing FM-like timbres with modulator-as-ratio control

Sustained (ADSR/ASR) envelopes require a gate argument: gate=1 opens the envelope, gate=0 triggers release

Sweeping a high-resonance (high-Q) filter is the acid-line's whole sonic identity

Swing is only audible when notes land on the delayed off-beat steps — a pattern with only on-beat hits is unaffected

SynthDef names and stores a reusable synth recipe in the server; Synth instantiates it with specific argument values

t_gate arguments in SuperCollider automatically reset to zero after one control cycle, enabling clean re-triggering

Techno composition is loop-based: overdub successive layers over a repeating sequence, then shape structure by adding and removing elements

Techno's aesthetic is harmonic stasis: one chord, drone, or none for the whole track, never a progression

Techno's near-zero swing and mechanical straight grid are an intentional aesthetic, not a production failure

TempoClock schedules functions in beats, re-running them whenever they return a number

The .range(lo, hi) method rescales any UGen's output to a desired numeric range; mul/add provide equivalent lower-level control

The .set message changes a running synth's arguments in real time while the synth continues playing

The * and / operators in Tidal mini-notation speed up or slow down individual events and groups

The $ operator in Tidal applies a function to everything to its right, replacing wrapping parentheses

The 2nd, 4th, 6th, and 7th scale degrees pull toward chord tones — landing on one creates suspense, resolving releases it

The 4-bin layout is the shared surface between music frequency-budgeting and visual spectral-band-split: a well-budgeted mix yields a legible band-split visual for free

The 7 diatonic modes are rotations of the major scale, each with a unique interval structure and characteristic mood

The 808's 8-bar pattern constraint pushed producers to think in repeating loops rather than linear song structures

The cut effect assigns samples to choke groups so a new hit stops previous overlapping hits from the same group

The Freesound APIv2 exposes the CC-licensed sound library over HTTP for programmatic search and retrieval

The Gaussian (normal) distribution provides a symmetric bell-curve probability shape useful for generating clustered musical choices

The house bass sits between the kicks as a syncopated offbeat line locked to the chord roots

The Lag UGen smooths abrupt parameter changes by creating a linear ramp over a specified duration

The most powerful drop is a beat or half-bar of near-silence immediately before everything hits on the downbeat

The recommended path into SuperCollider + synthesis is: SC environment tutorial → synthesis cookbook → custom projects

The run function generates sequential integer patterns for automatically stepping through sample indices or pitch values

The SC Pattern library includes Pser, Pxrand, Pshuf, Pslide, Pseries, Pgeom, and Pn for diverse sequence generation

The seed mapping uses bass for brightness, high-mid for rotation speed, and low-mid for warp depth — three of four bands are assigned, highs are unused

The speed control in Tidal changes sample playback rate and thus pitch; negative values reverse the sample

The STFT slides a Fourier analysis window along a signal to create a time-frequency spectrogram

The techno kick is harder and often longer or more distorted than a house kick

The TR-808 introduced full-song percussion programming via a step sequencer — not just preset patterns

tick advances a beat counter per live_loop and returns the current ring element; look reads without advancing

Tidal chop, striate, cut, and loopAt turn long samples into granular and looping textures

Tidal controls global tempo with setcps, and individual pattern speed with fast and slow functions

Tidal Cycles treats music as infinite cycles of patterns in a terse mini-notation manipulated live

Tidal effect parameters are control patterns, combined with sound patterns using the # operator

Tidal filters cutoff, hcutoff, and djf shape a sound's frequency content

Tidal functions can be partially applied (curried) to produce new functions that accept remaining arguments

Tidal mini-notation uses *, /, !, and <> to speed up, slow down, repeat, and rotate steps within a cycle

Tidal mini-notation uses | to randomly pick between subsequences, and ? to randomly drop events

Tidal oscillators with range modulate parameters as LFOs, smoothed via control busses

Tidal sometimes, degradeBy, irand, and rand add controlled randomness to patterns

Tidal transformations chain with the . operator to combine into one function

Tidal users without functional programming background can make music with it, showing DSL usability decouples from host language difficulty

Tidal's ? and degrade functions randomly remove pattern events to introduce controlled probabilistic variation

Tidal's continuous oscillator patterns (sine, saw, tri, square) modulate control values smoothly over time

Tidal's mini-notation parses polymetric rhythms from strings using square and curly bracket operators

Tidal's n selects a sample by index while note pitches a sample up or down

Tidal's rand emits a continuous stream of random floats 0-1 and irand n emits random integers 0 to n-1, both deterministic in time

Tidal's randomness is seeded by cycle count, so resetCycles restarts the same random sequence

Tidal's tempo is set in cycles per second (cps), not BPM; converting requires choosing beats per cycle

TidalCycles `chop N` divides each sample event into N equal, individually addressable slices

TidalCycles `while` applies a function only when a binary pattern is true, gating transformations per cycle

TidalCycles can pick one of several patterns at random each cycle to add variation

TidalCycles euclid k n places k onsets Euclideanly across n steps, the function form of the (k,n) mini-notation

TidalCycles is designed exclusively for live coding algorithmic patterns, with a mini-notation for rhythms and an extensive combinator library for pattern manipulation

TidalCycles is oriented around cycles rather than beats, so mixing fractional steps yields cross-rhythms easily

TidalCycles parenthesis notation (k,n) generates Euclidean rhythms directly in mini-notation

TidalCycles step builds a pattern from a step-sequencer string, mapping x to a hit and digits to sample indices

TidalCycles' pattern model originates from Indian tabla rhythm analysis via Bernard Bel's Bol Processor syntax

Timbre is a multi-dimensional percept that requires a feature list rather than a single number to describe

Transient-shaping boosts a sound's attack for punch or softens it to sit back in the mix

True voice-leading (guaranteed minimal motion) requires explicit note lists; Strudel's voicing() is only a heuristic

Two infinite loops written in sequence can never both run, because the first loops forever and the second is never reached

UGen output is scaled to useful ranges using .range, mul/add arguments, or linlin/linexp methods

Unit generators are the building blocks of digital synthesis: generators and modifiers wired into a patch

Uplifting trance pushes arpeggios to the background during breakdowns while harmonic wash effects (synth strings/choir) move to the fore

Use Bus.audio to allocate private buses safely, avoiding conflicts with hardware I/O buses

use_random_seed resets Sonic Pi's random stream so a live_loop produces a repeatable random pattern

use_synth switches the active synthesiser for subsequent play calls in the current thread

Using .plot() before .play() lets you see a waveform before committing to audio output

Using one_in(N) in a live_loop creates probabilistic drum patterns with adjustable density

Varying the k parameter of a euclidean rhythm live smoothly morphs the groove without changing the step count

Varying velocity per hit is what turns a flat, robotic drum pattern into a human-feeling groove

VJing is embodied: it requires physical gesture and controller movement and cannot occur without an improvising performer

vowel() applies a formant filter that colours a sound with a spoken-vowel timbre

Weighted random choice picks among options by probability so the common case dominates and surprises stay rare

with_fx wraps code in an audio effect that processes all sounds generated inside the block

Wrapping array indexes with wrapAt lets SC sequences cycle through parameter arrays of different lengths

A 3- or 5-step hat loop against a 16-step pattern creates an evolving polyrhythmic feel

A breakdown must drop energy to a genuine low so the following build has real contrast

A browser Sonic Pi can drive collaborative jamming by streaming server events to each client's Web Audio synth

A build must keep at least one voice in reserve to subtract at the drop

A descriptive score documents what was heard; a prescriptive score directs a performer

A drop is one cycle of near-silence followed immediately by the full groove returning

A fill applied only on the turnaround cycle is self-clearing and requires no follow-up save

A first-order Ambisonic B-format signal carries full-sphere spatial information in four channels: W, X, Y, Z

A groove must be stated for a full phrase before it is developed

A GrooveTransformer ML model can predict a full drum pattern from a sparse hit/velocity/offset input vector

A high-pass sweep removes low-end weight from the full stack without removing the pattern

A highly constrained live coding language reduces cognitive load and enables musical output within seconds, at the cost of expressive range

A Hydra sketch with no .out() is guaranteed blank, so .out() presence is the [NOW] proxy for a black-frame check

A Hydra sketch with no time or reactive term is static by construction, the [NOW] proxy for a frozen-frame check

A JITLib proxy is a placeholder defined by its valid sources, its contexts of use, and a default source

A live-coding community's code of conduct names domain-specific failure modes beyond generic anti-harassment rules

A live-coding setup file pre-loads server memory, sample dictionaries, SynthDefs, a clock and a safety limiter before the set

A live-coding SynthDef names its frequency arg 'freq', exposes an 'out' arg, and self-frees via doneAction

A livecoding agent must not claim to hear or see its output when no perception bridge exists

A low-pass cutoff ramped upward over a phrase opens the groove without adding voices

A pattern must be tagged .analyze('hydra') to be visible to the audio-visual bridge

A sample-and-hold random voltage source injects controlled randomness into pitch, amplitude or timing

A satisfying live set has an energy arc of contrast over time, not sustained maximum

A Strudel Hap has an onset when its whole timespan begins at the same time as its part timespan

A SuperCollider pattern is a factory for a stream, with Pseq and Prand giving ordered and random values

A wholesale section rewrite is only warranted when at a section boundary, the target shares few voices, and a patch would cost more edits

Adding a feedback delay on a voice's final cycle lets its echo tail carry the transition

Additive synthesis in Sonic Pi layers multiple synth voices at different pitches and amplitudes to create new timbres

Adopting free/open-source tools is framed as feminist praxis against gatekeeping in music tech

Algorithmic composition creates rule systems that generate musical output rather than specifying individual notes directly

Algorithmic composition strategies range from pure randomness to Markov chains and constrained search

Algorithmic notation turns score-writing from description of intent into a process of live exploration

Algorithmic spatialization places sounds in virtual acoustic space using channel-based diffusion, object-based rendering (VBAP/Ambisonics/WFS), or binaural techniques

Algorithms extend compositional cognition by executing implications the composer cannot fully predict

An agent without the L3 perception bridge must not claim to have evaluated perceived audio or visual output

An autonomous live edit should carry exactly one concept-id and never bundle two ideas into one save

An edit is only sonically effective if its diff touched a sound-producing token, not just a comment or whitespace

Applying rhythmic tools to wrong materials or at wrong settings produces useful unexpected results

ATK decoders output channels in counter-clockwise order starting from front-center; call .directions to verify routing

Audible generative processes should change gradually so listeners can track the transformation

Autonomous livecoding agents must apply stricter cadence discipline than copilot mode, defaulting one tier smaller

Autonomous livecoding mode uses a priority-ordered if-then table where the first matching row fires

Autonomous mode risks over-acting while copilot mode risks displacing the human performer

Breaking things and recovering fast is core livecoding practice, not a failure to hide

Bricolage programming is a creative feedback loop of making a code change, perceiving the output, and reacting — without forward planning

BufRd reads a Buffer at any frame index, enabling sinusoidal, noise-driven, and custom playback paths

Chaining single-change mutations creates descendants that diverge progressively from an ancestor idea

chop and striate slice a sample into n pieces; striate interleaves slices from multiple samples where chop plays each sample's slices sequentially

Chopping a sample into equal slices and playing them in random order creates beat-slicing effects

ChucK shreds are sample-synchronous concurrent processes spawned with spork ~

ChucK Unit Analyzers extract audio features from a signal for real-time analysis

CLiC models a live-coding collective as horizontal and adhocratic — no owners, directors, or teachers

Combining X-write with a movement operator animates a self-propelled operator across the grid

Commenting a voice out or in is the most legible and reversible layer transition

Concatenative synthesis drives resynthesis by selecting and joining database sound segments whose features best match a target

const replaces the entire playing pattern with another one

Continuous random patterns must be sampled by a discrete structure to produce events

Copilot mode follows a propose-explain-wait loop and never saves without human acceptance

Creating many one-change variants of a seed idea generates a sibling pool of musically related material

CTK objects populate a Score-like structure that plays in both real-time and non-real-time synthesis

Curly brace syntax in Tidal creates polymeter patterns where sequences of different lengths share the same pulse

Data sonification requires inference-preserving mappings: conclusions drawable from the sound must correspond to conclusions about the source data

Designing a live-performance interface is instrument building — the mapping shapes what music is possible

Different live coding systems model time differently: metric cycles (Tidal), coroutines with explicit waits (ChucK), and temporal recursion (Extempore)

Dilla time layers multiple simultaneous rhythmic feels — straight, swung, and displaced — within one track

Divisive rhythm subdivides a fixed cycle; additive rhythm builds sequences by adding or removing beats

Driving percussion above 0 dB into StageLimiter compresses the whole mix on each hit for a sidechain-style pump

Each arc should reserve its single highest-energy move for one boundary it has built toward

Each livecoding edit should introduce or retire exactly one concept-id so the diff is legible and attributable

Estuary terminal commands add custom sample banks to an ensemble session

Estuary's Metre widget visualises cycle subdivisions and Euclidean/Bjorklund patterns against the live tempo

Euclidean rhythms are exactly the maximally even rhythms — those maximizing pairwise inter-onset distance on the circle of time

Every evaluation heuristic is either a static [NOW] check or a [L3] check blocked on a perception bridge that does not yet exist

Exotic scales (Neapolitan, Middle Eastern, Hungarian, whole tone) extend the palette beyond major/minor

Exposing a WebSockets and OSC interface lets any UI — web page, hardware controller, script — control an audio plugin at runtime

fastcat and cat concatenate patterns in series, differing only in whether they compress to one cycle

Feeding the previous frame back with an FFT-driven amount makes visual trails grow with the audio build

filterHaps tests the whole Hap (with timing) while filterValues tests only the value

FOA transformations warp the whole B-format soundfield and are not commutative

FoaPanB encodes a mono signal to FOA B-format with a dynamically modulatable azimuth and elevation

Footwork producers typically build a track by cutting up samples first and working the beat around them, at very high output rates

For time-based arts, the most useful definition of 'declarative' is closeness of mapping between notation and target domain

Freesound's API supports content-based search filtering by automatically extracted audio descriptors

From-scratch live coding starts from an empty editor and builds the whole piece live before an audience

Generative composition means defining a rule-system and running it, not fixing every note

Glicol uses the LCS algorithm to update only changed nodes when code is re-evaluated

glicol_synth is a standalone graph-based Rust audio DSP library usable outside Glicol

Glicol's JavaScript API embeds the audio engine in any browser app via CDN or NPM

Glicol's meta node allows inline Rust DSP code inside a live session

Grains shorter than about 50 ms transition from perceived pitch to timbre or click as duration decreases

Granular synthesis constructs sounds from thousands of short grains (10–100 ms) with independent parameters

Granular time-pitch changing in SuperCollider decouples playback speed from pitch by varying grain rate and position

High-level abstractions reduce cognitive load in live coding but may constrain musical affordances; some practitioners prefer lower-level control

Hocket distributes a single melodic line across two or more instruments to create timbral variety and rhythmic texture

House uses long DJ-friendly phrase forms: filtered intros, additive builds, chord/vocal breakdowns, kick+bass drops

Imperative engines can express tension arcs as continuous automation; cyclic engines can only produce section-quantized staircases

In ixi lang musical phrases are named agents you manipulate by name with verb-noun-adjective actions

In SuperCollider, effects buses require correct node ordering so the effect Synth reads the source Synth's output

In techno a lowpass filter opening over 32 bars is itself the arrangement, replacing chord changes

In this livecoding rig a file save is the performance action: Strudel hot-swaps gaplessly and Hydra re-evals on the same GL context

In Tidal each sound parameter is patterned independently, so timbre aspects can carry their own polyrhythms

Interactive music systems react to performer input in real time, ranging from deterministic score-following to autonomous improvising agents

Interference patterns in live coding produce outcomes that exceed the coder's prior imagination

ixi lang encodes rhythm as monospaced text agents where horizontal position of characters marks timing

ixi lang operates as a 'parasite' on SuperCollider — adding a constrained high-level syntax that coexists with full SC access in the same document

ixi lang organises musical notation into three real-time-synchronised modes — melodic, percussive, and concrète — each with its own bracket syntax

ixi lang represents music as agents performing scores that rewrite themselves in real time when transformed by code

ixi lang rewrites an agent's score in the editor when it is transformed, keeping the code a live view of current state

ixi lang's 'coder' mode removes the latency between typing and sound by mapping keystrokes directly to audio in real time

JITLib can crossfade a proxy's source when it is redefined instead of cutting abruptly

JITLib treats a running SuperCollider program as an ongoing construction rather than a compile-then-run tool

Key modulation is a section-level event; treat a key change as structural, not a bar-to-bar move

Laptop music inherits acousmatic listening without solving the agency-perception problem that acousmatic music raised

Layering material at half and double the track tempo creates rhythmic complexity within a single key

Linear drumming — no two drums play simultaneously — creates melodic-sounding beats and forces democratic instrument weighting

Live coders find ensemble performance easier because performers can cover each other's gaps, reducing the solo exposure problem

Live coders work at least one level of abstraction above individual sound events, manipulating compositional structure rather than note-by-note detail

Live coding deautomatizes algorithmic processes for audiences by making the generating code visible

Live coding exists on a spectrum from fully improvised to largely pre-composed, and performers position themselves on it

Live coding intervenes in an ongoing process by modifying its laws (the program text), not its immediate state

Live coding makes software strange (defamiliarization), letting us see beyond routine practices and assumptions of computational culture

Live coding produces multiple overlapping kinds of liveness — machine liveness, embodied human liveness, and relational audience liveness — not one single kind

Live coding systems achieve progressive evaluation through external grounding, internal grounding, temporal recursion, or hybrid state management

Live coding's real-time loop between coder and machine is itself a creative method, not just a format

live_audio creates a persistent named audio input stream that can be moved between FX contexts dynamically

live_loops auto-generate cue events that other live_loops can sync on for phase alignment

Live-coding pattern languages are composable: any two transformations combine into a new one without extending the language

Livecoding edit cadence should be anchored to the musical grid, not wall-clock time

Livecoding edits span a four-tier diff-size ladder from micro param changes (1 line) to section rewrites (whole file)

Livecoding requires changes to happen live in the running file, not staged offline and dumped in as a batch

Locking a TidalCycles delay sets its time in cycles so echoes stay in phase with the tempo

Markov chains model context-dependent musical choices by making each event depend probabilistically on prior states

Melody on chord tones sounds resolved; on tensions it pulls — good lines put tension on weak beats and resolution on strong beats

MIDIOut sends MIDI from SuperCollider to a DAW via the macOS IAC Driver virtual MIDI bus

Minimal techno layers 'rhythms inside rhythms' so sustained listening reveals hidden structure

MiniTidal's continuous signals (sine, saw, tri, square, rand) can modulate any control parameter

Minor ninth chords (m9) add a major ninth above a minor-seventh chord, producing a beautiful mellow sound used in deep house and ambient

MIR uses content-based audio feature extraction and machine learning to automate musical analysis and similarity search

Mirror neurons fire both when performing and when observing an action, enabling embodied perception of musical effort

Multichannel reverb mix modulated by source-to-speaker distance models sound spatialization in SuperCollider

Music-centred design extends user-centred design to privilege the needs of performers, audiences, and musical flow — not just usability metrics

Naming a pattern-transformation function adds it to a system's compositional vocabulary and shapes what music is possible

Network latency above 20-30 ms disrupts tight rhythmic ensemble playing but can be worked around with free improvisation or asynchronous structures

Network music performance has latency thresholds: below 10ms is unnoticed; 10-40ms requires tempo negotiation; above 40ms demands independent tempi

NodeProxy and Ndef are SuperCollider's server-side placeholders whose synthesis source can be swapped while playing

NodeProxy.map connects a running control proxy to a synth argument without stopping synthesis

Note FX process MIDI note data before the instrument, so a fixed clip can vary at performance time without editing it

On a broken or silent output the agent must recover to a known-good state before adding new ideas

One borrowed chord from a parallel mode in an otherwise diatonic loop is a cheap, strong hook

One-time events — sounds, gestures, or processing applied exactly once — prevent loop-based music from feeling predictable

Only MIT/BSD/Apache/CC0/CC-BY non-NC code may be emitted verbatim into committed jam files; gray-licensed snippets are local-reference only

onset: pick in Sonic Pi selects a random transient event from a sample for instant hit variation

Orca's O and X operators read and write cells at an (x,y) offset from themselves

OSC lets SuperCollider send and receive timestamped musical messages over a network

Overlaying a structural pattern and a material (colour) pattern produces an interference result you cannot read off the code

Parallel harmony transposes a fixed voicing by the same interval for each chord, producing the signature sound of house and electronic music

Partial quantization, selective instrument quantization, and manual velocity editing create human feel in programmed drums

Pbindef modifies individual keys of a running Pbind without restarting the stream

Pbjorklund2(k,n) emits Euclidean duration patterns that can be modulated by nesting other pattern classes

Pchain and Ppar compose event patterns by layering key sources or running multiple patterns in parallel

Pdef and Tdef are SuperCollider's client-side proxies for live-replacing running patterns and scheduled tasks

Pdefn holds a named pattern value that can be derived and reused across multiple running streams in SuperCollider

Perceived loudness comes from arrangement space and saturation — a mix with gaps sounds louder than a full, crushed one

Performing live coding requires accepting public errors and resisting the pressure to meet conventional definitions of music

perlin produces smooth cycle-to-cycle random modulation unlike the per-event jitter of rand

Pfunc generates pattern values by calling a function, and Pkey cross-references values from an earlier key

Physical modelling synthesis uses an excitation signal driving a resonant body model

Pink (1/f) noise has equal energy per octave and models the long-range correlations found in many natural signals including music

Placing with_fx inside a loop creates one FX instance per iteration, wasting CPU

play, synth, and sample return a SynthNode reference that enables post-trigger parameter changes

ply n repeats each event in a pattern n times within the event's original time slot

ply subdivides each event into n repeats; segment resamples the whole pattern at n events per cycle

polymeter aligns patterns by step so patterns of different lengths phase against each other

Polyphonic MIDI in SuperCollider uses an array of 128 Synths indexed by note number

ProxySpace NodeProxies let you rewrite a running synthesis graph mid-performance with an automatic crossfade

ProxySpace turns the SuperCollider environment into a namespace of live-redefinable audio proxies

Pure algorithmic generation tends toward uniformity unless counteracted by entropy variation, interactivity, or inherent structure

pure() lifts a value into a pattern that emits it once per cycle

Quarks extend SC's language with community-contributed classes; UGen plugins extend the audio server with new signal processors

Raising degradeBy over successive cycles thins a voice while preserving its timing grid

Ramping brightness down and blending toward a solid empties the canvas gracefully instead of a hard hush cut

randcat plays patterns from a list in random order; wrandcat adds probability weights to the selection

Randomisation tools require active curation — the producer remains responsible for every moment of the output

randrun emits a shuffled run of the integers below n, one distinct value per step

Redefining a named function while a named thread loops is the foundational Sonic Pi live-coding pattern

Renardo defines audio effects as SC SynthDefs in Python using an `effect_manager` DSL, then exposes them as player attributes

Renardo supports just intonation as an alternative tuning system via `Tuning.just` on any scale

Renardo supports microtonal pitches as floating-point scale degrees interpolated between semitones

Renardo's `.eclipse(dur, every, offset)` periodically silences a player for automatic arrangement breaks

Renardo's `linvar()` interpolates values linearly across its duration, unlike the step-wise `var()`

Renardo's `Pvar` makes entire Patterns switch over time, enabling structural variation between cycles

Renardo's `Ring` cycles through its elements indefinitely when called, unlike a one-shot list

Renardo's `var()` creates a time-varying value that switches between states at bar-aligned boundaries

Renardo's Ableton backend can automate parameters with TimeVar at up to 300Hz via AbletonOSC

Renardo's PRand, PChoice and PWhite generate stochastic values that re-roll each cycle

Renardo's REAPER backend controls instruments via OSC, enabling DAW-quality effects without SuperCollider

Renardo's TempoClock pre-queues events 0.25 seconds early to compensate for processing latency

Renardo's VRender extension converts note sequences and lyrics into a vocal WAV via sinsy.jp singing synthesis

Repeating a progressively shorter sub-loop of closing material creates a sense of acceleration that drives a track to a convincing end

Reusing drum pattern MIDI as pitched material and vice versa creates rhythmically related harmonic and melodic parts

Sardine embeds three distinct pattern mini-languages (Sardine PL, Ziffers, Vortex) selectable per player

SC Groups organize synth nodes into named sections that can be targeted for routing and order-of-execution control

SC receives MIDI via MIDIIn.connectAll and MIDIdef callbacks; ADSR gate management requires per-note synth node tracking

SC receives MIDI via MIDIIn.connectAll and MIDIdef, and tracks note on/off pairs using arrays indexed by MIDI note number

ServerBoot and ServerTree callbacks ensure SynthDefs and resources load in the correct order after server boot

Short looped fragments of any audio reveal implied rhythms through pattern-finding perception

Silence and restraint in a well-grooved set are active arrangement choices, not absence of ideas

Simultaneously triggering an instrument with loops of different lengths creates a self-evolving composite pattern

Slight pitch offset between two identical synth voices creates beating and perceptual thickness

Slow coding is a live coding variant where extended periods of silence or stasis are made compositionally meaningful through visible anticipation

Some quality checks are permanently not-possible on this rig because the 4-bin FFT cannot supply the required feature

Sonic Pi _slide: opts cause synth parameters to glide smoothly between values over time

Sonic Pi auto-inserts incoming MIDI events into Time State, enabling sync and get on them

Sonic Pi filters sample packs by substring, regex, or symbol before selecting by index

Sonic Pi listens on port 4560 for OSC messages and routes them into Time State automatically

Sonic Pi sends MIDI messages in sync with music via midi, midi_note_on, and related functions

Sonic Pi's :tb303 synth emulates the Roland TB-303 with a dedicated cutoff envelope and resonance

Sonic Pi's randomness is deterministic so a 'random' pattern you like can be reproduced and performed

Sonic Pi's Time State (get/set) provides deterministic shared state across live_loops

Sonic Pi's Time State paths support OSC-style wildcard pattern matching for sync and get

Sonification maps non-audio data to sound parameters to convey information through the ear in SuperCollider

Sound motion is organized as simple, complex, and compound processes that evolve spectrum, space, or both

stack layers a list of patterns to play simultaneously so one transformation can shape them all

Staggering clip boundaries across tracks softens section transitions and avoids abrupt formal cuts

Staying 'in time' with the audience's phrase structure is the central discipline of live-coded dance music

Step-function automation envelopes with sharp edges create an additional rhythmic layer independent of note events

Stepping kaleidoscope symmetry up on a downbeat gives a visual drop paired with an audio peak

Stochastic music controls broad statistical properties of a piece rather than specifying individual events exactly

striate cuts each sample into n equal grains, reorganising them for granular-texture effects

struct imposes a new rhythmic grid on a pattern while mask only silences it where the mask is 0

Subtractive synthesis removes frequencies from a rich source using resonant low-pass or high-pass filters

Sufficient repetition makes almost any pattern feel musical regardless of its harmonic content

SuperCollider allows adding new methods to existing classes via extension files placed in the Extensions folder

SuperCollider can generate a complete 12-tone row matrix using nested iteration over a scrambled pitch-class array

SuperCollider classes and events both support object modeling: classes via inheritance, events via prototype chains

SuperCollider methods do not auto-return their last expression; the caret (^) designates the return value

SuperCollider Patterns schedule streams of synthesis events algorithmically using Pbind and combinators

SuperCollider's FFT UGens enable real-time spectral processing in the frequency domain

SuperCollider's functionality is extended via Quarks (language packages) and UGen plugins (server extensions)

SuperCollider's GrainSin, GrainFM, and GrainBuf UGens generate individual grains at a specified density

SuperCollider's Pbind pattern system is comprehensive but hard to read and manipulate live, motivating constrained live-coding languages

SuperCollider's Pitch and Amplitude UGens extract frequency and loudness from audio input in real time

SuperCollider's RandSeed and RandID make stochastic synthesis reproducible from a given seed

SuperCollider's SynthDef and Pbind together create a patterned synthesizer: SynthDef defines the voice, Pbind sequences it

Swapping the FFT index driving a visual parameter aligns the visual energy with the new section's audio driver

Swinging a bassline or melodic layer against straight drums generates groove without touching the drums

sync in Sonic Pi always blocks until a future Time State event is inserted

Techno's tension arcs span dozens of bars, driven by filter opening and layer subtraction rather than drops

Temporal recursion — a function calling itself with a time delay — is a core live coding time-representation technique (as in Extempore/Impromptu)

Tension is built by ramping one or two dimensions over a phrase then resolving on a boundary

The :slicer FX modulates amplitude rhythmically using a control wave at a configurable phase duration

The :slicer FX's probability: opt gates each phase on or off deterministically for random-sounding rhythms

The ~> and <~ operators shift a Tidal pattern forward or backward in time by a fraction of a cycle

The apparently simple 'reversal' operation has multiple non-equivalent implementations depending on assumptions about rests, events, and scale

The ATK provides two toolsets: FOA (first-order, 4-channel) and HOA (higher-order, (n+1)² channels)

The ATK uses a right-hand coordinate system: azimuth 0°=front, positive=counter-clockwise, elevation 0°=horizon

The ATK workflow is encode → transform → decode, each stage operating on B-format

The Cognitive Dimensions of Notation framework describes trade-offs in programming language design using named dimensions

The complement of a Euclidean rhythm is also Euclidean

The default livecoding agent mode is copilot: the human leads, the agent proposes and waits rather than acting autonomously

The halting problem means no algorithm can decide whether another will terminate, making perfect global repetition a sign of failure

The International Conference on Live Coding (ICLC) has been live coding's primary academic and community venue since 2015

The ixi lang matrix hybridises declarative score notation with full SuperCollider code per cell, enabling grid-based algorithmic navigation

The Mexican live-coding scene grew from a 2006–2014 institutional hub into a geographically dispersed network

The overarching taste check compares each intended intent-vector field against a perceived estimate within tolerance

The strongest section changes fire an audio and a visual transition on the same downbeat

The TOPLAP 'show us your screens' principle requires every livecoding change to land as a legible diff in the visible file

Tidal loops the current command until a new one compiles, with a completion rule ensuring musical continuity

Tidal pattern combinators transform time — not just events — enabling rotation, reversal, and every-nth-cycle transformations

Tidal provides continuous waveform functions (sine, tri, saw, square) that return smoothly varying values for use as effect parameters

Tidal represents time as rational numbers so musical subdivisions are stored exactly as fractions without floating-point error

Tidal schedules OSC messages to an external synthesiser, separating pattern logic from sound synthesis

Tidal's |>, <|, |<, >|, |+| operators combine two patterns by separately controlling which side provides structure vs. values

Tidal's begin and end play only part of a sample, and unit "c" makes speed stretch playback to fit the cycle

Tidal's cut stops any other sound using the same cut group, while legato controls how long a sound plays before the next one starts

Tidal's higher-order pattern transformations compose freely because they operate on functions, not on stored event lists

Tidal's pipe arithmetic operators (|+, |-, |*, |/) modify control values relative to an existing pattern value

Tidal's shuffle plays a random permutation of a pattern's parts (without replacement); scramble picks parts with replacement

Tidal's slice and splice chop a looping sample into n equal slices for rearrangement; splice also pitch-adjusts each slice to fit its step duration

Tidal's sometimes applies a function to random individual events; somecycles applies it to entire random cycles

Tidal's stripe repeats a pattern n times per cycle but with random sub-cycle durations that still fill the cycle

Tidal's wchoose picks from a list with weighted probabilities, unlike choose which weights all options equally

Tidal's weave function offsets multiple patterns in time while applying a shared effect pattern, creating canonic and spatial structures as side effects

TidalCycles `@N` sets an event's duration to N steps, enabling non-isochronous rhythms

TidalCycles `off` overlays a time-offset, transformed copy of a pattern to build canons

TidalCycles ascii, binary, and binaryN turn strings or integers into boolean rhythm patterns via their binary representation

TidalCycles bite slices a pattern cycle into equal-sized pieces and addresses them by index, enabling arbitrary reordering of pattern sections

TidalCycles can trigger custom SuperCollider synths using n with note names or midinote with MIDI numbers

TidalCycles choose emits continuous random values from a list; wchoose adds probability weights to make some values more likely

TidalCycles chunk divides a pattern into n sections and applies a transform to each in turn, one per cycle

TidalCycles degrade and degradeBy randomly remove events from a pattern at a controllable probability

TidalCycles euclidInv and euclidFull produce the rhythmic complement or dual-voice Euclidean pattern

TidalCycles loopFirst repeats only the first cycle of a pattern, freezing later cycles' content

TidalCycles mask gates a pattern with a boolean mask, letting events through only where the mask is true

TidalCycles necklace generates boolean rhythmic patterns from a list of inter-onset intervals rather than onset/total-steps parameters

TidalCycles palindrome alternates a pattern between forward and backward playback every other cycle

TidalCycles ply repeats each event in a pattern n times within its original time slot

TidalCycles range rescales a 0–1 continuous pattern to any numeric interval

TidalCycles ribbon cuts a fixed window from a pattern's timeline and loops that window

TidalCycles rot rotates the values of a pattern leftward while preserving the original rhythmic structure

TidalCycles spread applies a function with each of a list of parameter values in turn, cycling one value per cycle

TidalCycles stripe repeats a pattern n times at random speeds while keeping total duration constant

TidalCycles struct imposes a boolean rhythmic structure on any pattern, enabling Euclidean and binary rhythm shapes

TidalCycles stutter repeats each event n times separated by a fixed time offset, creating manual echo-style delays

TidalCycles timeLoop t loops a pattern's cycle sequence every t cycles, like a modulo on cycle number

TidalCycles trunc cuts a pattern short while linger repeats the kept fraction to fill the cycle

TidalCycles uses Ableton Link by default for BPM synchronization with other performers and applications

TidalCycles when and whenmod apply transforms based on a predicate or modular arithmetic test on the cycle number

TidalCycles' 'iter' rotates a pattern by a fraction each cycle, and the rotation amount is itself patternable

Toggling a color inversion or hard posterize on the drop downbeat is a single-frame visual hit

Transposition, inversion, retrograde, and pitch rotation are rule-based transformations that generate new patterns from existing material

Two live_loops with slightly different sleep times produce Steve Reich-style phasing

Two pattern-transforming functions can be composed into one and applied together in TidalCycles

Tying scroll or scale speed to a rising FFT band accelerates the visual motion through a build

use_real_time removes Sonic Pi's scheduling look-ahead for MIDI and OSC-driven live loops

Vary the type of energy (density, brightness, space) not only the loudness level

Visual live-coding work is routinely under-credited relative to audio, and the gap tracks gender

When a craft choice conflicts with the livecoding ethos, the ethos wins — it is an operating constraint, not a footnote

When in doubt, an autonomous livecoding agent should wait rather than act

withValue (alias fmap) applies a function to every Hap's value without changing timing

Wrapping a Pbind in Pdef allows live re-evaluation of patterns without stopping the stream

A composer can encode their own decision-making as an algorithm, automating it to free attention for intuitive aspects

A live coder's personal pattern space is a strict subset of the language's full possibility space; creativity means expanding toward the system's edges

A Markov chain trained on pitch and rhythm sequences generates new music with the same statistical patterns

A SuperCollider performance piece uses ServerBoot/Tree, Pdefs, and Groups to create a hot-swappable live structure

A SuperCollider startup file auto-loads SynthDefs and buffers on server boot for live-coding readiness

A tendency mask shapes a stochastic parameter by making its random bounds move over time

Algorave requires the algorithmic process to be visible — not necessarily live-coded

Algorithmic music faces a process-product tension: system elegance does not guarantee musical result, and the ear must ultimately arbitrate

An overdriven DFM1 filter self-oscillates into a warm drone that layers across the harmonic series

appLeft/appRight/appBoth choose which pattern donates structure when a pattern of functions meets a pattern of values

Building constrained sub-languages inside SuperCollider creates composition environments with intentional expressive limits

Computer improvisers produce 'virtual sociality' that reveals as much about human interaction as about machines

Correct Ambisonic format conversion requires matching four parameters: order, component ordering, normalization, and reference radius

Crashes and errors in live coding are perceived as humanizing and authentic by audiences, making risk integral to the aesthetic

Daily live coding practice builds a fluent repertoire of low-level activities that frees attention for structural thinking during performance

Each NodeProxy can act as a module patched into others at audio (.ar) or control (.kr) rate

Economy of selection — picking the salient few from a vast field — is the irreducibly human element in generative composition

Elegant formal rules do not guarantee compelling music because music works through perception, not logical consistency

Ergodynamics is an instrument's latent expressive potential and discoverability

Estuary is a zero-install browser platform for collaborative live coding in networked ensembles

Estuary maintains a single shared tempo (CPS/BPM) that all languages and ensemble members follow

Estuary's Timer widget structures live-coding sets into named timed sections visible to the whole ensemble

Estuary's view DSL lets performers define and share named workspace layouts via terminal commands

Fell's Multistability uses independent percussion and chord layers, no fixed grid, and velocity/speed/duration focus to generate emergent rhythmic complexity

First-order Ambisonics encodes a 3D soundfield as four channels (W, X, Y, Z) decoded for any speaker layout

Heuristic algorithms pair computational power with expert judgment to guide composition, unlike borrowed formal models

In higher-order live coding, code becomes physical material sculpted in real time through sensory feedback

Interference — where combined patterns yield features present in neither — may lie at the heart of algorithmic music

JITLib NodeProxies can run on remote servers for collaborative live coding over a network

Live coding at an algorave produces creative flow because abstract code structures are directly experienced as sound by a responsive dancing crowd

Live coding can be performed by geographically distributed musicians sharing code over networks, challenging the conventional requirement for co-presence

Live coding involves tacit knowledge — knowing how that cannot be fully articulated — alongside explicit computational knowledge

Live coding is a kairotic practice: intervening at the opportune moment (kairos) rather than executing planned time (chronos)

Live coding lacks the DJ's ability to preview material before presenting it, so submitted code goes straight to the audience

Live coding treats the programming language itself as a real-time musical notation

Live granulation requires recording to a looping buffer first, then running GrainBuf on the buffer with a trailing pointer

markovPat generates sequences driven by a probability transition matrix rather than a fixed pattern

MFCC UGen extracts 13 spectral shape coefficients from an FFT frame for timbre classification in SuperCollider

Music games can be 'ecooperatic' — governed by ecological forces and cooperative social dynamics rather than economistic competition and correct/incorrect evaluation

Music technology falls into three epistemes: acoustic, electronic, and digital

New digital instruments borrow work-processes and gestures from older ones (ergomimesis)

OSCdef triggers a function on incoming OSC and can be re-evaluated live to remap external data to sound

Placing algorithms in physical robotic devices introduces real-world complexity that enriches the musical result beyond simulation

Prewrite expands an axiom by production rules to generate self-similar, non-random rhythmic sequences

Projecting code reveals process but does not by itself make a performance legible to a non-programmer audience

Projecting the code makes live coding an honest, transparent mapping from instruction to sound

Pulsar synthesis generates pitched textures by combining a waveform table with a duty-cycle envelope repeated at audio rate

Purpose-built live-coding systems gain performance power from deliberate constraint, and their vocabulary becomes a 'technology for thinking'

register() adds a new method to Strudel's Pattern class and returns it as a standalone function

SCTweets are complete SuperCollider pieces in 140 characters that exploit syntax shortcuts for extreme concision

set_mixer_control! applies global LPF, HPF, and amplitude adjustments to all Sonic Pi output

Some live coding systems fold machine learning and machine listening into the performance, letting the coder train and steer models live

splitQueries breaks multi-cycle queries into per-cycle sub-queries

SuperCollider classes encapsulate reusable synthesis behaviour and extend the language

Texture uses Euclidean distance to automatically wire typed values to functions, making visuospatial layout syntactically significant

The :sound_out FX routes audio to both its outer FX context and a specific hardware output channel

The Creative Systems Framework analyses creativity as search space, traversal strategy, and evaluation — with bricolage externalising traversal into the computer

The TOPLAP manifesto prioritizes algorithm transparency over tool materiality as a performance ethic

Tidal embeds in Haskell to exploit its type system and applicative functor abstractions for pattern composition

TidalCycles fix and contrast apply transforms only to events matching a ControlPattern test, leaving others unchanged

TidalCycles inhabit maps string names to patterns, allowing a pattern of strings to select and play named sub-patterns

TidalCycles lindenmayer generates L-system strings that can be converted to playable patterns via step functions

TidalCycles patterning stacks four levels: sequence, symmetry, deviation, and composition/interference

TidalCycles select and pickF use a numeric pattern to switch between whole sub-patterns or transforming functions

TidalCycles sew switches between two patterns using a boolean pattern for structure; stitch uses the boolean's own structure rather than the source patterns'

TidalCycles snowball applies a transform iteratively to accumulate layers, like a feedback-processed delay

TidalCycles soak applies a transform repeatedly and concatenates all versions, creating an accelerating or evolving sequence

TidalCycles' weave produces an unplanned canon when sound and effect patterns are swapped, illustrating discovery through generalization

Time is warped either on the query span (before) or on the hap spans (after) a pattern is queried

TOPLAP prefers live coding without safety nets — no backup tracks, no pre-rendered fallback — because risk is part of the performance value

Transition functions like xfadeIn and anticipate swap patterns gradually instead of instantly

Vocable synthesis maps written phonetic symbols to physical model parameters so short words describe complex instrumental articulations

Waveset manipulation treats individual waveform cycles as grains for extreme time-stretching and morphing in SuperCollider

When two Tidal patterns are combined applicatively, the left pattern's structure is preserved and its events are matched with co-occurring right-hand events

A bounded self-analysing drone with non-zero-base colour and a short crossfade is the safe Punctual recovery program

A ChucK ADSR envelope or STK instrument stays silent until its gate is opened with keyOn/noteOn

A ChucK voice that never reaches dac produces silence with no error

A ChucK while-loop without a time-advance silently hangs the VM at 100% CPU with no audio

A failed Strudel evaluate leaves the previously running pattern playing rather than stopping audio

A Glicol file with no out: line produces silence with no error message

A Glicol node name not in the reference is a parse error that leaves the graph unswapped

A large mul or an unattenuated feedback bus in Glicol clips loudly with no error

A minimal ChucK panic patch uses SinOsc-to-dac with a timed while-loop and no sample files

A minimal groove using only bundled synths and samples with a sleep in every loop is the safe Sonic Pi recovery

A Punctual parse or compile error leaves the previous working program running rather than tearing it down

A Sonic Pi live_loop automatically cues its own name each cycle, making sync :loop_name safe without explicit cue calls

A Sonic Pi sync on a non-existent cue tag blocks the loop forever without throwing any error

A Sonic Pi syntax error aborts the run but all currently running live_loops keep playing

A SuperCollider \degree pattern with no \scale defaults to C major and plays wrong pitches without error

A SuperCollider autonomous panic recovery is s.freeAll followed by a single inline graph needing no SynthDef, sample, pattern, or scale

A SuperCollider synth without doneAction:2 leaks nodes silently until CPU overload crackles

A SuperCollider SynthDef must be re-added after every edit or Synth plays the old cached graph

A SuperCollider UGen name that is miscased or not installed posts 'not understood' rather than playing

Adding .analyze('hydra') to a Strudel voice feeds it to the a.fft array that Hydra's audio-reactive mapping reads

Algorhythms are the microrhythmical structures underlying digital computation — making inaudible electromagnetic signals audible as political-aesthetic act

An unknown sample name in Tidal produces no GHCi error but silences that voice via a SuperCollider post warning

An unknown Sonic Pi synth, sample, or fx name usually errors, though a bad sample name can just fall silent

An unknown Strudel sample name produces silence with no exception rather than an error

ChucK compile errors block shred addition while runtime errors remove only the offending shred

ChucK has no default master limiter, so many voices summed to dac clip unless gain is kept low

ChucK has no native scale, chord, or euclidean primitive; these must be hand-rolled from arrays and Std.mtof

ChucK sporked child shreds are killed the moment their parent shred exits

ChucK UGen names are exact CamelCase and must be verified against the rig's ugens list

Defining two Sonic Pi live_loops with the same name does not create two voices — the second silently replaces the first

Each independent Strudel voice in a multi-pattern session must be on its own $: prefixed line

Estuary's ExoLang interface lets external JavaScript live-coding languages be loaded at runtime

Estuary's visual theme is controlled by a CSS file defining four core colour variables

Every >> in Glicol must sit between two nodes; a trailing or orphaned >> is a syntax error

Every Sonic Pi live_loop body must call sleep or sync or it stops with a runtime error

Free/open-source live-coding tools are an ethical stance about craft and collective ownership, not just a pragmatic choice

Glicol has no native scale or chord primitive; pitches must be hand-listed as frequencies or seq integers

Glicol keeps the last valid graph playing when a save introduces a parse error

Glicol requires exactly one named chain per line; multiple chains on one line cause a parse error

Glicol's sp sample set is separate from Strudel's dirt-samples and requires its own samples folder

hush() immediately silences every Strudel voice — it is the first step of autonomous recovery from a broken mix

Integer division in ChucK silently truncates: 1/2 evaluates to 0, not 0.5

Live coding performances arc from empty to complex and back to silence, suggesting cyclic rather than linear revision control

Making algorithmic music is following the material (code as medium) rather than imposing form — discovering music that could not be imagined before hearing it

Mixing audio-rate and control-rate UGens in SuperCollider fails the SynthDef build with a 'not audio rate' post message

Most Punctual bugs produce no error — a wrong-domain function silently returns 0 and missing >> yields no output

Playing a SuperCollider synth before s.boot produces silence and a 'Server not running' post message

Punctual 0.5 removed the 0.4 output operators >> video, >> hsv, >> red, and >> left; old code silently fails or parse-errors

Punctual changes take effect at the next cycle boundary by default — use <> 0 for near-immediate switching

Punctual uses three distinct arrows: << (define), >> (output), and <> (crossfade) — mixing them causes errors or wrong behavior

Punctual's lo/mid/hi analyse the program's own audio output — they are zero if no audio statement is running

Referencing a Glicol bus before it is defined on its own line causes an unresolved-reference error

Slub's practice establishes that source code can be simultaneously the score, the instrument, and the performance

Sonic Pi control on a synth node requires capturing its handle and setting *_slide before calling control

Sonic Pi has no clip protection — high echo/reverb feedback or stacked loud amp: causes distortion with no error

Sonic Pi sleep arguments are in beats, not seconds — use use_bpm to set the tempo that determines their duration

Square brackets in Punctual create combinatorial expansion — use curly braces or colon-ops for pairwise behavior

Stacked loud Strudel voices or high delay feedback cause clipping — lower .gain toward 0.6-0.8 and reduce feedback

Strudel audio requires a user gesture to unlock the AudioContext — code cannot force it

Strudel method parameters accept patterns and signals, not JavaScript arrow functions — use sine/saw/rand for movement

Strudel's setcpm takes cycles per minute, not BPM — use setcpm(bpm/4) for 4-beat cycles

SuperCollider errors surface in the post window while the booted server keeps playing the last good nodes

SuperCollider gain and feedback runaway throws no error — only rising volume, clipping, or DC blowup signals it

SuperCollider JITLib's Ndef replaces a running graph on re-eval while ProxySpace requires push before tilde-name access

SuperCollider Pseq without 'inf' repeats plays once then stops silently

The Glicol panic patch is a single out: line with an oscillator, LPF, and no sample references

Tidal parse and type errors appear in GHCi while sound problems appear in the SuperCollider post window

Tidal uses prefix functions rather than method-chaining, so Strudel-isms cause GHCi scope or parse errors

Tidal's # operator applies a named control to a pattern; its right side must be a control name, not a bare string

Tidal's hush command silences all channels immediately and is the primary panic-stop for gain runaway

Unbalanced brackets in Tidal mini-notation produce a GHCi parse error, leaving the old pattern playing

Unbalanced mini-notation brackets in Strudel throw a parse error that shows in #err while keeping the old pattern playing

Weaving and live coding share deep structural analogies — computational bit operations are recognizable in loom operations, and handweaving embodies forms of tacit knowledge relevant to live coding

When Tidal cannot run in a rig, the operative recovery is to emit equivalent Strudel code that produces sound immediately