LabHub

Blog

Live Coding Music & Visuals in 2026 — Sonic Pi / TidalCycles / Strudel / Hydra / TouchDesigner / SuperCollider Deep-Dive

2026-05-16 · 21 min read · #live-coding#algorave#sonic-pi#tidalcycles#strudel#estuary#orca#foxdot#supercollider#pure-data#max-msp#hydra#punctual#p5-js#openframeworks#cinder#touchdesigner#notch#resolume#vvvv#renoise#toplap#nime#deep-dive#english

한국어English日本語

Prologue — When code climbed onto the stage

In 2010, a small club night in Sheffield, England held the first party called "Algorave". In the DJ booth sat a laptop, and on the screen — the source code was projected in plain view. The audience danced to the beats, but what they were actually watching was Alex McLean typing Haskell code in real time.

Fifteen years later, in 2026, that scene is no longer experimental.

This article draws a single map of the live-coding landscape as of May 2026: what it means to "perform with code", which tools live where, and where students, musicians, VJs, and media artists should each start.

1. The 2026 live-coding map

Live coding splits into three broad camps.

[Music live coding]
    Sonic Pi   — Ruby DSL, education + concerts
    TidalCycles — Haskell, algorave home turf
    Strudel    — JS, browser-only (TidalCycles port)
    FoxDot     — Python, SuperCollider backend
    SuperCollider — sclang, 35-year-old standard
    Pure Data  — visual patcher, Miller Puckette
    Max/MSP    — commercial visual patcher (Cycling '74)

[Visual live coding]
    Hydra      — JS, browser, Olivia Jack
    Punctual   — functional shader DSL, David Ogborn
    p5.js      — Processing for the Web
    openFrameworks / Cinder — C++

[Visual programming (node-based)]
    TouchDesigner — node graph, GPU-accelerated
    Notch       — motion design + media-server
    vvvv        — node-based, Windows-centric
    Resolume    — VJ software

[Other]
    ORCA       — esoteric sequencer (Hundredrabbits)
    Renoise    — tracker (scriptable)

These three camps are typically used together on stage. You write beats in TidalCycles, paint visuals in Hydra, and sync them with OSC/MIDI/Ableton Link. A "live-coding set" usually means a music + visual duo or solo multitasker.

Three core concepts before diving in.

2. Sonic Pi — between the classroom and the concert hall

Sam Aaron built Sonic Pi at the Cambridge Computer Lab as "an instrument for teaching children to code". That decision happened to produce, in 2026, the friendliest live-coding tool around.

The core: Ruby DSL + SuperCollider sound engine. The syntax is Ruby-friendly, but the sound is in fact rendered by 35-year-old SuperCollider underneath.

The smallest possible set. One line.

play 60

MIDI 60 (C4) sounds once. To make a pattern:

live_loop :kick do
  sample :bd_haus
  sleep 0.5
end

live_loop :bass do
  use_synth :tb303
  play chord(:E2, :minor).choose, release: 0.3
  sleep 0.25
end

A live_loop with the same name is seamlessly replaced by new code. Change the chord in :bass mid-show, hit Run, and from the next cycle the new chord flows in naturally.

What Sonic Pi does well:

Limitations:

Who uses it: music teachers, students, musicians who want "one more instrument I can touch even without coding", Raspberry-Pi cafe installations.

Sam Aaron's TED talk "Programming as Performance" remains the best-known introduction to live coding.

3. TidalCycles — home of the algorave

Alex McLean has been building TidalCycles since 2009. It is a Haskell library, and it is the closest thing to a lingua franca in the music live-coding scene. About 70% of performers on algorave stages play Tidal.

Core idea: every pattern is a function, and time flows in cycles.

d1 $ s "bd*4 [~ sn] cp hh*8"

Unpacking that one line:

That is the basic mini-notation. The real power comes from transformation functions.

d1 $ fast 2 $ rev $ every 4 (# speed 2) $ s "bd*4 sn cp hh*8"

fast 2 doubles the speed, rev reverses, every 4 applies speed 2 (pitch up) every fourth cycle — all expressed via function composition. The Haskell operators $ and . happen to fit live coding beautifully.

Why TidalCycles is strong:

Weaknesses:

Who uses it: nearly everyone on an algorave stage. About half of ICLC (International Conference on Live Coding) presenters.

If installation is a problem, jump to the next chapter — Strudel — and use the same mini-notation in the browser.

4. Strudel — TidalCycles in the browser

Strudel (https://strudel.cc/) is the JavaScript port of TidalCycles, started by Felix Roos in 2022, with the single goal of "TidalCycles in the browser, with zero install".

In 2026 you just open strudel.cc and start playing. No installation, no dependencies, no compiler.

stack(
  s("bd*4 sn cp hh*8"),
  note("c2 eb2 g2 bb2").s("sawtooth").lpf(800),
  s("rim*8").gain(0.6)
).cpm(140)

Syntactically almost identical to TidalCycles. Same s (sample), same note, same mini-notation, same transformation functions. The only difference is that Haskell's $ is replaced by method chaining (.lpf(800)).

Why Strudel matters:

Limitations:

Who uses it: newcomers to live coding, classrooms (students without install permissions), spontaneous jam sessions, social-media-first live coders sharing patterns on Twitter/Mastodon.

In 2026, if someone says "I want to try live coding once", Strudel is the first tool to suggest.

5. Estuary — collaborative live coding

David Ogborn (McMaster University) and his team built Estuary (https://estuary.mcmaster.ca/), a live-coding environment where multiple people code on the same screen simultaneously. Think of it as Google Docs for live coding.

The twist: a single environment hosts multiple languages at once. Each panel runs a different language.

Several people each take a panel and, locked to the same BPM, build a stage together. Estuary caught widespread attention during the pandemic for remote algoraves and has stayed a regular at LiveCodeFest ever since.

What makes Estuary special:

Limitations:

Who uses it: live-coding workshop instructors, remote jam sessions, school clubs, algorave ensembles.

6. ORCA — the esoteric sequencer

Hundredrabbits (Devine Lu Linvega and Rek Bell) built ORCA (https://hundredrabbits.itch.io/orca), an esoteric live-coding environment made of three-character cells. It looks like an alien language, and in some sense it really is.

.A.....
.0A8...
.......
.D8....

Each letter is an operator. A adds, B subtracts, D divides, T is track, * is a bang. Cells signal their neighbours every frame, producing a kind of 2D cellular automaton + sequencer + visual programming hybrid.

Orca itself produces no sound. It emits MIDI/OSC, which is then routed into SuperCollider, Renoise, Ableton, or Reaper to make audio. It works purely as a "timing engine + visual sequencer".

Why Orca is a cult favourite:

Limitations:

Who uses it: noise and experimental electronic musicians, generative artists, live coders who specifically want to be different.

7. FoxDot — Python live coding

Ryan Kirkbride (University of Leeds) built FoxDot, which pairs Python with SuperCollider. It is the Python alternative for people who find Haskell too heavy for TidalCycles.

p1 >> pluck([0,2,4,3], dur=1/2, amp=0.8)
p2 >> bass([0,0,3,4], dur=2)

p1 and p2 are player objects. The >> operator assigns an instrument and a pattern. SuperCollider is the backend, so the timbres are essentially the same as SuperDirt.

FoxDot's niche:

Limitations:

Who uses it: Python developers, data artists, anyone crossing over between machine-learning code and live music.

8. SuperCollider / Pure Data / Max-MSP — the classics

These three environments are the infrastructure of live coding. TidalCycles, FoxDot, and Sonic Pi above all use SuperCollider as a sound engine. Pure Data and Max-MSP are the two standards of visual patching.

SuperCollider

The sclang plus scsynth architecture, started by James McCartney in 1996. The language (sclang) and the synth (scsynth) are decoupled and communicate over OSC.

{ SinOsc.ar(440) * 0.2 }.play

That one line emits a 440Hz sine. SuperCollider's real power lies in SynthDef — reusable synthesizer definitions.

SynthDef(\bass, { |freq=110, amp=0.5|
    var sig = LFSaw.ar(freq) * LFPulse.kr(2);
    sig = RLPF.ar(sig, freq * 4, 0.3);
    Out.ar(0, sig * amp)
}).add;

Even in 2026 SuperCollider is the standard. Half of NIME papers and roughly 70% of live-coding sound engines are SuperCollider-based.

Pure Data (Pd)

Miller Puckette rewrote his own Max (built at IRCAM) as open source and called it Pure Data. Signal flow is drawn as nodes and cables.

Max-MSP (Cycling '74, a subsidiary of Ableton)

Max is the commercial elder sibling of Pd. The three share one root (Max at IRCAM, then Pd, then Max-MSP).

Classics versus live coding: SuperCollider, Pd, and Max can all be used for live coding, but they are fundamentally environments. If your aesthetic is typing code on stage, TidalCycles, Sonic Pi, and FoxDot sit on top of them. If your main job is bringing a finished studio patch to stage, you use Max-MSP as-is.

9. Hydra — the most popular video synth

Olivia Jack's Hydra (https://hydra.ojack.xyz/) appeared in 2018 and in five years became the standard of live-coded visuals. Some 70–80% of algorave back-projection visuals run on Hydra.

The core: a functional JavaScript DSL on top of WebGL shaders. One browser tab and you are done.

osc(20, 0.1, 0.8)
  .kaleid(4)
  .color(2, 0.5, 1)
  .modulate(noise(3, 0.5))
  .out()

Line by line:

Hydra's core idea is function chaining as video composition. osc, noise, voronoi, shape, gradient are sources, and .kaleid, .modulate, .rotate, .scale, .colorama are transforms.

Why Hydra is decisive:

Limitations:

Who uses it: algorave VJs, live-coding duos (music + visuals), club visualists.

In 2026 Hydra is the only tool that gets you from zero to stage-grade visuals in an hour.

10. Punctual / p5.js — code and visuals

Punctual

David Ogborn (the Estuary person) also built Punctual, a functional shader DSL. Similar to Hydra, but sound is treated equally.

saw [220,330,440] >> centre;
fb sin saw 0.1 >> rgb;

Audio and video flow out of the same functional expression. Academic, minimalist aesthetic.

p5.js

Lauren McCarthy's p5.js is Processing for the Web. It is not specifically a live-coding tool, but as "drawing pictures with code" it has trained a new generation of media artists every year.

function setup() { createCanvas(800, 800); }
function draw() {
  background(0);
  for (let i = 0; i < 100; i++) {
    let x = noise(i, frameCount * 0.01) * width;
    let y = noise(i + 100, frameCount * 0.01) * height;
    circle(x, y, 5);
  }
}

Less common on stage than Hydra, more common as the default tool of Instagram and media-art galleries. If Hydra is strong live, p5.js is strong in generative art.

Limitations:

Who uses it: media-art students, Instagram and social artists, generative NFT creators, educators.

11. openFrameworks / Cinder — the C++ camp

The heavyweight side of visual coding. The workflow is write, compile, run — different in feel from typing on stage, but the standard in installation work and concert visuals.

openFrameworks (oF)

Zach Lieberman, Theo Watson, and Arturo Castro built openFrameworks as a C++ creative-coding toolkit. It brings the Processing/p5 spirit to C++.

void ofApp::draw() {
    ofBackground(0);
    for (int i = 0; i < 1000; i++) {
        float x = ofNoise(i, ofGetFrameNum() * 0.01) * ofGetWidth();
        float y = ofNoise(i + 100, ofGetFrameNum() * 0.01) * ofGetHeight();
        ofDrawCircle(x, y, 5);
    }
}

The code corresponds almost line-by-line to p5.js. The difference is speed: 4K at 60fps, hundreds of thousands of particles, multi-GPU output — all feasible.

Cinder

Andrew Bell (Barbarian Group) built Cinder as a C++ creative-coding framework. More "professional" than oF — stricter API, more OOP.

oF versus Cinder: schools and open source tend to use oF; ad agencies, installations, and museums lean Cinder. Both are heavyweight.

Who uses it: installation studios (teamLab, Random International, Nexus Interactive Arts), broadcast and ad visuals studios, museum media content.

12. TouchDesigner / Notch / Resolume / vvvv

The four giants of node-based visual programming. Different aesthetic from typing live, but they dominate stage visuals and media-art productions.

TouchDesigner (Derivative)

Derivative's TouchDesigner is a node graph plus Python plus GLSL. The standard in media-art studios.

In Korea, roughly 90% of media-art studios (D'STRICT, a'strict, KOOO, Studio Locus Solus) use TouchDesigner. COEX K-Wave, the Myeong-dong light festivals, the DDP media facade — all TouchDesigner.

Notch

UK-based Notch makes Notch, a tool for realtime motion design and LED-wall content. Think of it as a live version of After Effects.

Resolume Avenue / Arena

Netherlands-based Resolume makes Avenue and Arena, the standard VJ software. Clip-based live video mixing.

It is not itself a live-coding tool, but the workflow Hydra to Spout/Syphon to Resolume is standard for compositing live-coded output into a club VJ set.

vvvv

German vvvv group builds vvvv, a Windows-centric node-based visual programming tool. vvvv gamma (2020 onward) is a .NET rewrite.

13. Renoise — the tracker is back

Renoise is a descendant of the 1980s–90s tracker tradition (Amiga's ProTracker). Notes are written into cells flowing vertically.

| 00 | C-4 01 .. .... |
| 01 | --- .. .. .... |
| 02 | E-4 01 .. .... |
| 03 | --- .. .. .... |
| 04 | G-4 01 .. .... |
| 05 | --- .. .. .... |

Each row is a sixteenth-note (or finer) slot. One line carries note, instrument number, volume, and an effect command.

Renoise's niche:

Connection to live coding:

Who uses it: demoscene composers, chiptune artists, indie game-music writers, classic tracker users.

14. TOPLAP / Algorave / LiveCodeFest / NIME / ICLI

A map of the live-coding community and conferences.

TOPLAP

TOPLAP (http://toplap.org/) was formed in Hamburg in 2004. The name is a tongue-in-cheek expansion of "Temporal Organisation for the Permanence/Proliferation/Promotion of Live Algorithm Programming".

Algorave

Algorave = algorithm + rave. Started by Alex McLean and Nick Collins in Sheffield in 2012. The definition is simple.

In 2026, regular algoraves run in Tokyo, Berlin, Mexico City, Buenos Aires, Seoul, and Sydney.

LiveCodeFest

LiveCodeFest (http://livecodefest.toplap.org/ and similar) is a 24–48 hour live-coding festival, hosted in multiple cities each year with online streaming. The 2025–2026 season includes lineups in Berlin, Tokyo, Seoul, and Mexico City.

NIME — New Interfaces for Musical Expression

NIME (https://www.nime.org/) is a conference series founded in 2001. As the name says, it covers new interfaces, instruments, and systems for musical expression.

ICLI — International Conference on Live Interfaces

ICLI is more performance-oriented. Where NIME focuses on the interface, ICLI focuses on "the interface as live performance".

15. Korea and Japan — East Asian live-coding scenes

Korea

The Korean live-coding scene broke through publicly in 2024–2025.

Traits of the Korean scene:

Japan

Tokyo is the Asian hub of algorave.

Tokyo and Osaka have a robust demoscene plus live coding plus chiptune triangle. Renoise usage is also relatively high.

16. Who should learn live coding

An entry-route table by audience.

+-------------------+----------------------------------------+
| Student (school)  | Sonic Pi -> Strudel -> Hydra           |
|                   | (browser-only path, zero install)      |
+-------------------+----------------------------------------+
| Musician          | Sonic Pi -> TidalCycles -> SuperColl.  |
|                   | (Ableton Link to sync to current rig)  |
+-------------------+----------------------------------------+
| Python developer  | FoxDot -> Strudel -> TidalCycles       |
+-------------------+----------------------------------------+
| JS developer      | Strudel -> Hydra -> Punctual           |
+-------------------+----------------------------------------+
| VJ / visualist    | Hydra -> TouchDesigner -> Resolume     |
+-------------------+----------------------------------------+
| Media artist      | TouchDesigner -> openFrameworks -> Notch |
+-------------------+----------------------------------------+
| Demoscene / chip  | Renoise -> ORCA -> SuperCollider       |
+-------------------+----------------------------------------+
| Academic          | SuperCollider -> Max-MSP -> NIME paper |
+-------------------+----------------------------------------+

For complete beginners, the recommended 90-day course.

Week 1–2: Sonic Pi. Five-minute install at home or school. Beats from day one. Sam Aaron's official tutorial alone runs 30 chapters.

Week 3–4: Strudel. Open strudel.cc in a browser and have a first set in 30 minutes. Learn mini-notation.

Week 5–6: Hydra. Five minutes to your first visual at hydra.ojack.xyz. Start from osc().out().

Week 7–8: Strudel + Hydra together. Sync both in a single browser tab. Minimum viable algorave solo set.

Week 9–12: choose TidalCycles or TouchDesigner. Go deep on music (TidalCycles) or expand into media art (TouchDesigner).

By the end of this course, you can comfortably play a 5-minute slot at a local algorave open stage.

17. Closing — code as stage costume

The live-coding scene has a long-standing slogan: "Show us your screens" — don't hide the code, show it. The audience has to be able to read along; that is what makes it live coding.

That single line carries two meanings.

In 2026 live coding is no longer fringe. Sonic Pi runs in a classroom. TidalCycles runs in a club on a Saturday night. TouchDesigner runs in a media-art studio on a Tuesday. And in between, a small movement called algorave has been shouting the same slogan for fifteen years.

Code is stage costume. Wear it well.

References

Comments

No comments yet.

Sign in to leave a comment