N · Tools & free/open software stack

Always run a short test recording or stream before going live to catch setup issues

Blender is a free, open-source 3D suite spanning modeling, animation, rendering, compositing, and scripting

Drum programming sequences rhythmic patterns using electronic or digital sounds instead of a live kit

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

OBS captures desktop audio and microphone by default; a wrong device selection yields a silent stream

OBS composits a scene from stackable sources such as display, window, and webcam capture

OBS's Auto-Configuration Wizard picks encoding settings from your intent, hardware, and network

Open-source DIY Eurorack modules can be built for around $20 and an hour each, making modular affordable

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

A community Google Colab notebook enables RAVE training without local GPU hardware

A DAW that matches your mental model removes the technical bottleneck between idea and recording

A drum pattern sets the groove by placing kick, snare, and hi-hat on specific beats in a bar

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

An Ardour session is a folder containing all project data: audio, MIDI, routing, and snapshots

An electronic instrument's interface can be analysed as a layered model from sound through control and layout to concept and time

An OSC message has two parts: an address pattern (the parameter name) and one or more typed arguments (the values)

Audacity Macros chain effects into a reusable sequence for batch-processing multiple audio files

Audacity's Spectrogram view shows frequency content over time, enabling spectral selection and editing

Cheap PC software instead of pro studios pushed early dubstep toward its twisted-bass sound

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

Constrained instruments with few controls can be more creatively productive than instruments with unlimited options

Csound is a text-based software sound synthesis system, created by Barry Vercoe in 1985

Daft Punk's Homework was tracked entirely in hardware with DAT as both recording medium and source

DAW scale-snap tools correct out-of-key notes without requiring theory knowledge

Early Grime producers made instrumentals on FL Studio (Fruity Loops) on basic home computers, treating software limitations as aesthetic constraints

Electronic instrument development is a conversation between designers, engineers, users, and competitors across brands

Every Pure Data object has an interactive helpfile opened by right-clicking it and choosing Help

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

Grime's canonical 140 BPM tempo originated partly because FL Studio's default tempo is 140 BPM

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

iO-808 auto-persists progress across sessions while an explicit JSON save/load is used for sharing patterns

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

LMMS volume lives at three tiers, and each tier is meant for a different job

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

Mixing a signal with a slightly delayed copy of itself produces comb filtering

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

Open Sound Control is a transport-independent network protocol carrying typed, address-patterned messages between devices

OSC connections require both a destination IP address and a port number to route messages to the correct application

OSC's 32-bit float arguments provide far higher control resolution than MIDI's 7-bit (0–127) integer range

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

Pre-trained RAVE streaming models are available for immediate use without training

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

Quantization snaps notes to the time grid; humanization reintroduces small timing deviations for feel

RAVE requires a CUDA GPU with 5–32 GB VRAM depending on config, and hours of audio

RAVE training requires CUDA verified via nvidia-smi and a dedicated conda environment

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

Roland TR-808 and cheap Japanese synths democratised studio production for Chicago house DJs

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

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

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

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

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

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

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

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

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

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 decibel formula changes from 10·log to 20·log when comparing voltages instead of powers

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

The shift from analog to digital production lowered the financial barrier for resource-constrained producers

The TR-808 programs beats by selecting a drum voice then toggling 16 step buttons to place hits

The TR-808's sounds are fully synthesized via Web Audio API — no samples are used

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

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

VCV Rack is a free, near-limitless software modular synthesizer that closely approximates hardware Eurorack for learning and planning

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

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

0 dBm is 1 milliwatt; it implies an impedance context unlike dBu

32/64-bit floating-point arithmetic in DAWs provides vast internal headroom but does not protect against plug-in overloading

A condenser microphone uses a charged capacitor whose capacitance varies with diaphragm movement

A custom DAW template eliminates friction between inspiration and capture

A drum fill is a brief deviation from the groove at a phrase end that signals a structural transition

A dynamic microphone uses electromagnetic induction — a coil moving in a magnetic field generates voltage

A GPLv3+ VCV plugin requires its derivative works to also be GPLv3+

A live performance patch should prioritise the most-used controls as always-visible with less-used controls accessible but hidden

A mic preamp must boost mic-level signals (–70 to –50 dBu) to line level without adding audible noise

A microphone's polar pattern defines how its sensitivity varies with the direction of incoming sound

A nn~ model's methods each define a distinct processing pipeline with its own inlet/outlet count

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

A Pure Data object's creation argument only sets an initial value; incoming signal or messages override it

A slow phasor~ scaled and passed through mtof~ produces a repeating one-octave pitch sweep

A spectroscope displays a signal's spectral content — amplitude vs. frequency — in real time

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

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

Ableton Link synchronizes tempo across apps by group adoption rather than a central master clock

Ableton's Slice to New MIDI Track converts a break into a drum rack of individually triggerable slices

AbletonOSC is installed as a MIDI remote script that exposes Live's full API over OSC

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

An Ardour track/bus type is chosen by its signal source and routing role, not just its name

An endless encoder needs an external value display because, unlike a fixed-range pot, its position carries no value

Ardour snapshots save alternate versions of a session within the same folder without overwriting the current state

Ardour's processor box is the per-strip plugin chain where signal passes pre- or post-fader

Arrangement View is a linear timeline where clips are fixed in time and automation is written globally

Audacity's Nyquist prompt lets you write Lisp code to synthesise, analyse, and process audio

Balanced connections use two out-of-phase signal conductors to reject common-mode noise

Beat alignment means any integral beat value on one Link participant maps to an integral beat on all others

Before MIDI, electro producers synced drum machines and sequencers using clock/trigger pulses and Roland Sync cables

Bitwig runs a linear Arranger and a non-linear Clip Launcher together, so improvisation and fixed arrangement share one session

Bitwig's Unified Modulation System lets any modulator device control any parameter at every level of the signal chain

Cable shielding intercepts electrostatic interference; balanced twisted pairs cancel electromagnetic interference

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

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

Consumer gear operates at –10 dBV; professional gear at +4 dBu — an ~12 dB gap

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

CV/Gate controls analogue instruments with voltages: a gate switches notes on/off, CV sets a parameter such as pitch

DAW faders give finer gain control near unity, so mixes should be built with faders resting around unity

DAWs apply swing as extractable groove templates dialed in per clip

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

EEVEE is Blender's real-time renderer that uses rasterization, trading physical accuracy for speed

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

Filtering an LFO with a lowpass filter smooths abrupt transitions and removes click artifacts

Finger-drumming captures natural timing and velocity variation that is hard to draw in manually

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

Footwork producers favor the hardware MPC over software for its analog outputs, tight timing, and tactile feel

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

Freesound's APIv2 lets you filter sounds by perceptual qualities like brightness, hardness and depth — not just text

Freesound's content-based similarity search returns sounds that are acoustically alike, not just similarly tagged

Frequency response is measured within a stated tolerance window, not a single curve

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

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

Glitch production migrated from damaged hardware into software simulation of failure states

In a DAWless setup one device acts as MIDI clock master to synchronise start, stop, and tempo across all machines

In an open-architecture patch, objects are wired with cords carrying the video signal, and any break stops the output

In LMMS, anything you want to reuse across projects must be saved with the instrument preset, not the project

In Logic, Option-clicking with the Scissor tool slices a MIDI region into equal grid divisions instantly

In Max the [route] object both separates OSC messages by address pattern and strips that pattern off, dispatching each to its handler

In Max/MSP, the leftmost inlet is 'hot' (triggers output) and other inlets are 'cold' (store values only)

In Pure Data, tilde-suffixed objects (osc~, *~, dac~) are the ones that generate and process audio signals

Layering multiple drum sounds triggered simultaneously creates fuller, richer textures than any single sample

LMMS ships LB-302, a built-in monophonic synth that imitates the Roland TB-303 acid architecture

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

Many synth and plug-in presets ship at full scale; their output levels should be reduced before feeding an effects chain

Max executes right-to-left so cold inlets are initialized before the hot inlet fires, avoiding stale-value bugs

Max/MSP is a graphical dataflow language whose objects are wired with virtual patch cords, like a modular synthesizer

Max/MSP's cycle~ object generates a continuous cosine wave at a specified frequency

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

MIDI carries digital performance data — notes, tempo, position — over one cable across up to 16 channels

Modulargrid is the standard tool for planning a Eurorack system — it tracks cost, power draw, HP, and module placement before purchase

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

Network jitter in OSC streams can be mitigated by buffering, rate-limiting, or smoothing incoming values

New modules are added in VCV Rack by right-clicking an empty rack space to launch the Module Browser

nn~ exposes RAVE encode, decode, and forward as Max/MSP or Pure Data audio-rate methods

nn~ is a translation layer that runs any TorchScript (.ts) model as a live Max/MSP or Pure Data object

nn~ model attributes are model-defined, live-controllable parameters set via 'set NAME VALUE' messages

nn~'s circular buffer amortizes neural model compute across time, at the cost of added latency

On Maschine, tempo-matching must be done before chopping because its Sampler cannot warp in real time

One-shot mode plays a drum sample to its full decay; gate mode ties sample length to note length

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

Partial quantization moves notes toward the grid by a percentage, preserving human timing

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 maps keyword-value pairs into a timed stream of playable musical events

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

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

Phantom power delivers DC polarizing voltage to a condenser mic over the two balanced signal conductors

play~ is chosen over groove~ for granular synthesis because its triggering allows efficient per-grain enveloping

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

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

Publishing an SDK as open source accelerates adoption of a protocol across diverse software

Pure Data connections run from an outlet (object bottom) to an inlet (object top), never the reverse

Pure Data has two modes — Edit Mode for building patches and Run Mode for playing them

Pure Data opens with DSP off, so no audio is produced until DSP is explicitly turned on

Pure Data's auto-patching creates each new object already connected to the previous one

Quantized launch makes apps wait for the next quantum boundary before starting, enabling tight ensemble starts

Quintuplet, sextuplet, and septuplet grids place hits between 16th notes without manual millisecond nudging

RAVE models must be exported with --streaming to avoid click artifacts in realtime hosts

RAVE uses gin-config to define and override model hyperparameters without modifying code

RAVE's lazy dataset mode avoids disk conversion by loading raw audio files at training time

Re-Pitch warp mode maintains the original character of a breakbeat by changing pitch with tempo

ReBirth RB-338 (1997) was an early software emulation of the TB-303 and TR-808/909, democratising the classic techno sound

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

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

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

Rendering a looping animation to video: save each frame and call exit() at a target frameCount

Return tracks and sends enable shared effects processing across multiple tracks simultaneously

Samplers can map multiple sounds to MIDI notes in contiguous (melodic) or interleaved (drum-pad) layouts

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

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

Shelving EQ affects all frequencies above (or below) a hinge point; peaking EQ affects a band around a center frequency

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

Sound pressure drops 6 dB for every doubling of distance from a point source in free field

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

SOURCE automatically logs every used sound to a dated file, creating a ready-made CC attribution record

SOURCE treats a CC-licensed sound library as a live instrument rather than a static sample bank

Speaker cable must be large-gauge to minimize resistance and preserve amplifier damping factor

Step sequencing builds patterns fast but its dead-on-grid timing must be loosened for feel-driven genres

Summing N oscillators multiplies amplitude by N; dividing by N after summing prevents clipping

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 sends and receives OSC messages over UDP, enabling integration with other software and hardware

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

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

The 808's DIN sync port was a hardware synchronization standard that preceded MIDI

The Akai MPC can mark slice points live while a sample is still recording

The budget Alesis 3630 compressor became a defining piece of 1990s French touch production

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

The Live Object Model organises Live's entire state as a tree: Song > Tracks > Clips/Devices > Parameters

The next generation of Chicago footwork producers worked primarily in Fruity Loops rather than hardware drum machines and samplers

The RAVE VST loads a .ts model in any DAW as an audio effect that re-timbres incoming audio

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

The VCV Library prohibits cloning another product's brand, panel, or component layout without permission

TorchScript (.ts) files are the portable, runtime-independent format for deploying PyTorch models without Python

Touchstrips offer space-saving continuous control with unipolar, bipolar, stepped, and pressure-sensitive modes

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

Use gear you know well rather than chasing the newest tools to make music

VCV Rack plugins take one of three licensing paths: GPLv3+, free-of-charge under any license, or commercial royalty

Video must be compressed to appropriate codecs before a live performance to enable real-time processing

VU meters track average level (close to perceived loudness); peak meters track instantaneous peaks, 10–25 dB higher

Waveform-to-waveform nn~ models have equal in_ratio and out_ratio and pass audio through uncompressed

'Ringing out' a monitor system identifies feedback frequencies with EQ to maximize gain before feedback

A 1/3-octave graphic EQ provides enough resolution to notch room resonances without disturbing adjacent frequencies

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

A clipped amplifier outputs approximately double its rated continuous power, threatening loudspeaker voice coils

A DAW's internal musical state, not just its audio, can drive visuals when exposed over OSC

A driver computes a property's value from other properties via a function or Python expression

A groove template is a timing and velocity map applied to shift any pattern toward a reference feel

A ground loop forms when two pieces of equipment share multiple ground paths, creating a hum-inducing loop antenna

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 MIDI 2.0 device must implement MIDI-CI-with-discovery plus a feature, or UMP-with-discovery plus a feature

A MIDI-CI Profile is a published set of messages and required responses that devices can advertise and negotiate

A parametric equalizer allows independent control of center frequency, gain, and bandwidth (Q) for each band

A software emulation reduces an instrument's many possible sounds to a small labelled subset

A stage monitor system is a separate sound system pointed at performers, providing individualized mixes

Ableton's Echo is the closest built-in device to a hardware dub delay; slight L/R timing error adds character

Ableton's warp modes use different algorithms matched to the audio material being time-stretched

AbletonOSC implements OSC wildcard dispatch by converting * to a [^/]+ regex and matching all registered handlers

AbletonOSC's OSC server uses a non-blocking UDP socket to drain all queued messages per tick without blocking Live

AbletonOSC's property listener uses Live's add_<prop>_listener API and immediately sends the current value on subscribe

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

An active crossover placed before power amplifiers increases headroom, damping, and reduces distortion versus passive crossovers

An audio transformer provides galvanic isolation and common-mode rejection to break ground loops

Analogue-modelling plug-ins degrade outside their intended operating range because they don't fully model extreme non-linearities

Any PyTorch model can become a nn~ object by subclassing nn_tilde.Module and registering methods and attributes

Ardour's Cue window enables clip-launching and non-linear performance workflow alongside the timeline

Ardour's Strict I/O mode enforces matching channel counts through the plugin chain; Flexible I/O allows width changes

Audio plugin parameters can be defined in a CSV schema and the parameter boilerplate auto-generated to reduce repetition

Automation and Clip Envelopes in Ableton Live can generate discrete visual output cues without audio processing

Bidirectional communication is the core innovation of MIDI 2.0, letting devices discover and auto-configure for each other

Bridging a stereo amplifier combines both channels in mono to roughly double the power output

Clip envelopes automate parameters only within their clip while track automation applies across the full arrangement

Constant-voltage (70V) distribution allows many loudspeakers to share one amplifier using impedance-transforming taps

Constrained, primitive gear setups can lend a charm that more capable technology removes

Critical distance is where direct sound energy equals reverberant sound energy in a room

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

DAW groove extraction captures a live break's exact timing and velocity offsets and transfers them to a MIDI clip

Deep tool familiarity can trap you in the music your tools suggest rather than the music you want

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)

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

Each polyphonic grain in Max/MSP needs a unique instance ID to avoid shared-state collisions

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

Focusrite Scarlett XLR inputs cannot take line-level signals; line sources must use the combo TRS input instead

Geometry Nodes builds geometry procedurally as a node tree flowing from Group Input to Group Output

Group humanization plugins link multiple tracks so instruments respond to each other's timing, mimicking an ensemble

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

in_ratio and out_ratio in nn~ method registration define the temporal compression between audio and model outputs

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

JUCE's ValueTree structure can serve as a single source of truth for a plugin's complete state, driving all object creation

Link keeps apps in time by relating independent timelines, not by forcing one shared timeline

Link start/stop synchronization only follows explicit user actions and is not auto-applied when joining a session

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

Live's embedded Python cannot use threads; AbletonOSC polls the OSC socket once per 100ms tick using Live's scheduler

Loudspeaker polarity reversal is not the same as phase — polarity is frequency-independent

Loudspeaker sensitivity (dB SPL / 1W / 1m) plus power ratio in dB gives maximum SPL at 1m

mc.nn~ processes multiple audio channels through one RAVE model instance to cut CPU and RAM

mc.nn~ runs several audio streams through one model as a batch, saving CPU and RAM versus duplicating nn~

mcs.nn~ packs all of one instance's inlets/outlets into a single multi-channel connection, enabling per-batch latent operations

MIDI 2.0 extends MIDI 1.0 rather than replacing it, so existing devices and messages stay valid

MIDI-CI is MIDI 2.0's discovery-and-negotiation layer, delivering profiles, property exchange, and process inquiry

MIDI-CI Property Exchange uses JSON over SysEx to get and set device data with no bespoke software

MIDI-CI runs over any MIDI 1.0 transport because it is carried in System Exclusive messages

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 music performance has latency thresholds: below 10ms is unnoticed; 10-40ms requires tempo negotiation; above 40ms demands independent tempi

nn~ is a Max/PureData external that bridges trained neural audio models (RAVE, vschaos2) into a patching environment

nn~'s void/lazy mode lets you fix inlet/outlet count before attaching a model

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

Operate a live sound system 6 dB below the feedback threshold to maintain stable gain

Pbjorklund2(k,n) emits Euclidean duration patterns that can be modulated by nesting other pattern classes

ProxySpace NodeProxies let you rewrite a running synthesis graph mid-performance with an automatic crossfade

Pure Data is extended with community externals installed via the Deken package manager

Quantizing kick and snare hard while leaving hats loose gives metric stability with textural feel

Quarks extend SC's language with community-contributed classes; UGen plugins extend the audio server with new signal processors

RAVE can be exported to ONNX format for deployment in environments that do not support TorchScript

Renardo's Ableton backend can automate parameters with TimeVar at up to 300Hz via AbletonOSC

Renardo's REAPER backend controls instruments via OSC, enabling DAW-quality effects without SuperCollider

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, and tracks note on/off pairs using arrays indexed by MIDI note number

Single-encoder interfaces trade immediacy for preset recall accuracy by eliminating pot-position mismatch

Sonic Pi's randomness is deterministic so a 'random' pattern you like can be reproduced and performed

SOURCE presets are XML files where PRESET > SOUND > SOUND_SAMPLE hierarchy mirrors the sampler's class structure

SOURCE separates audio engine, sensor I/O, and API communication into three independent processes connected by OSC/WebSockets

Speech reinforcement needs 70–80 dBA; music reinforcement requires 85–100 dBA with 10–20 dB headroom

Speeding up a loop to resample it then returning to the original tempo adds authentic grit

Standing waves form when a sound's wavelength matches a room dimension, creating fixed nodes and antinodes

Summing bus overdrive occurs before the master fader — pulling master fader down does not fix it

SuperCollider's functionality is extended via Quarks (language packages) and UGen plugins (server extensions)

SuperCollider's Pbind pattern system is comprehensive but hard to read and manipulate live, motivating constrained live-coding languages

Technology lowers the barrier to making sound but raises the risk of producing without musical development

The AbletonOSC Python client uses a threading.Event to block on an OSC reply, creating a synchronous query interface

The Cognitive Dimensions of Notation framework describes trade-offs in programming language design using named dimensions

The Grid is Bitwig's patchable modular environment for building custom synths and effects inside the DAW

The Link quantum value sets the loop length for phase synchronization, aligning loop boundaries across apps

The MIDI 2.0 Protocol raises resolution on all Channel Voice Messages and adds per-note expression

The track_data handler uses a dot-namespace format to query track, clip, clip_slot, or device properties in a single call

The Universal MIDI Packet is one container for all MIDI, adding 16 Groups of 16 channels (256 total) and jitter-reduction timestamps

Thru playback continues past a triggered slice into the rest of the sample for natural breakbeats

Tidal loops the current command until a new one compiles, with a completion rule ensuring musical continuity

Tidal schedules OSC messages to an external synthesiser, separating pattern logic from sound synthesis

Tidal's weave function offsets multiple patterns in time while applying a shared effect pattern, creating canonic and spatial structures as side effects

TidalCycles uses Ableton Link by default for BPM synchronization with other performers and applications

Troubleshoot 'no signal' by tracing from source to output; troubleshoot 'unwanted signal' by tracing from output to source

Two MIDI 2.0 devices reach full communication through an ordered discovery sequence ending in normal MIDI use

Ableton Link synchronizes beat, tempo, and phase across multiple apps or devices over a local network without a master clock

AbletonOSC supports hot-reloading its own handler code by sending /live/api/reload, avoiding a full Live restart during development

An overdriven DFM1 filter self-oscillates into a warm drone that layers across the harmonic series

Delayed fill speakers must be time-aligned electronically so their sound arrives no earlier than the main cluster's sound

Each NodeProxy can act as a module patched into others at audio (.ar) or control (.kr) rate

Link Audio channels are demand-driven: a sink only transmits when at least one source subscribes

Link Audio shares named audio streams (channels) between peers aligned to the shared Link timeline

Link session state modifications should only happen on the audio thread to achieve sample-accurate timing

Link session state must be captured before reading and committed after writing to ensure consistency

OBS noise suppression filters garble music and must be removed when streaming DJ sets or live instruments

OSCdef triggers a function on incoming OSC and can be re-evaluated live to remap external data to sound

Prewrite expands an axiom by production rules to generate self-similar, non-random rhythmic sequences

Rendering instruments to audio early in the process forces completion by removing the option to keep editing the source

Splitting mic signals to separate house and monitor consoles requires isolation transformers to prevent ground loops

Stage monitors are placed in the rear null of the vocal mic's polar pattern to maximize gain before feedback

The :sound_out FX routes audio to both its outer FX context and a specific hardware output channel

Tidal embeds in Haskell to exploit its type system and applicative functor abstractions for pattern composition

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

Multiple remote DJs can be brought into one OBS scene by popping each Jitsi Meet stream into its own window and window-capturing it