Split View: 라이브 코딩 음악 2026 — Sonic Pi·TidalCycles·Strudel로 개발자가 뮤지션이 되는 법 (Algorave 심층 가이드)

Live Coding Music 2026 — How Developers Become Musicians with Sonic Pi, TidalCycles, and Strudel (Algorave Deep Dive)

Prologue — Developers can be musicians too

Late at night. Two monitors. Editor on one side, waveform on the other. You hit keys and bass pours out of the speakers. Change a line, hit Cmd+Enter, and from the next bar the beat is different.

This isn't magic. It's live coding music.

A backend developer who has never touched a DAW (Digital Audio Workstation) can make their first beat in 30 minutes — if they know how to type code. You don't need music theory. You don't need to learn an instrument. All you need is a text editor, speakers, and a bit of curiosity.

Live coding started in early-2000s Sheffield, UK. Alex McLean and friends asked, "Can you improvise music with code?" In 2004 the movement settled around a deliberately silly acronym, TOPLAP — The (Temporary | Transnational | Terrestrial | Transdimensional) Organisation for the (Promotion | Proliferation | Permanence | Purity) of Live Algorithm Programming. The core of the TOPLAP manifesto is simple: algorithms are thoughts, and thoughts should be visible. Live coders project their screens to the audience. The audience sees how the beat is built, where it broke, and how it recovered.

This article covers the three major live coding systems in one breath.

• Sonic Pi — Ruby-based, ideal for beginners, used in hundreds of UK classrooms.
• TidalCycles — A pattern language on top of Haskell, the heartland of techno, IDM, and breakcore.
• Strudel — A JavaScript port of TidalCycles that runs in the browser.

Plus the variants — FoxDot, Csound, ORCA — the Algorave scene, and a 30-minute first-beat tutorial.

1 · What "live coding" actually means

Live coding refers to two things at once.

(1) Live coding as a performance. Writing code in real time on stage to make music (or visuals). You stand on stage with an empty editor and build a beat over the next hour. The audience sees you mess up and recover. That's the point.

(2) Live coding as a tool. An environment for making music. Instead of a DAW GUI, you describe patterns as text. You run them, sound comes out, you fix them, and the next bar plays the updated sound.

The two come together but each can exist alone. You can use live coding tools without ever performing. You can also perform live coding without doing club music — there are classical live coders and there are noise live coders.

Algorave — algorithms walk into the club

Algorave is a portmanteau of "algorithm" and "rave." It started in the UK in 2012. Live coders go to clubs, project their code instead of DJ booths, and the audience dances in front of the screen.

The code being visible isn't a gimmick. The audience watches a line change and hears the beat shift. It's like an omakase where the kitchen is exposed — you don't just enjoy the result, you watch the cooking.

As of 2026, Algorave is a global recurring event. London, Berlin, Tokyo, Seoul, Mexico City, Sao Paulo, New York — dozens of events happen every year. Live coding is no longer an academic experiment; it's a genuine branch of the music scene.

The six principles of the TOPLAP manifesto

A summary of what live coders try to honor.

1. Show your screen (give us access to the performer's mind). Don't put a tarp over the laptop.
2. Algorithms are thoughts. Thought becomes music.
3. Code is both tool and instrument. Live coding includes building the tools.
4. Don't get stuck in a genre. Live coding is not only techno.
5. Code in front of people whether you're good or not. Mistakes are fine.
6. No mouse (half-joke). Do it with text only.

Point six is a joke, of course; OSC and MIDI controllers are used freely. The spirit is "text is a first-class citizen."

2 · Sonic Pi — Live coding starting from Ruby

Beginners often bounce off live coding at the words "Haskell?" That's why Sam Aaron picked Ruby.

What Sonic Pi is

Built by Sam Aaron (Cambridge Computer Lab) starting in 2012. A Ruby DSL for describing music, with SuperCollider (a C++ audio engine) as the backend. Runs on macOS, Windows, Linux, and Raspberry Pi.

Two things make Sonic Pi distinctive.

1. Education-friendly. BBC's micro:bit campaign, the Raspberry Pi Foundation's classroom coding initiative, and Aaron's own classroom tours have introduced tens of thousands of teenagers to coding via Sonic Pi.
2. Explicit timing model. A command like sleep 0.5 runs on "musical time," not wall-clock time. Heavy function calls don't delay the beat.

Install (30 seconds)

Go to https://sonic-pi.net/ and grab the installer for your OS. macOS: dmg. Windows: msi. Linux: AppImage. On Raspberry Pi just run sudo apt install sonic-pi.

Launch the app and you'll see the editor on the left, log on the right, and a track visualizer at the bottom. v5 shipped in late 2024 with a new synth engine, more accurate timing, and a native build for M-series Macs.

First beat — kick, snare, hat

Paste the following into the editor and hit Cmd+R (Run).

# Sonic Pi — 4-on-the-floor basic beat
use_bpm 120

live_loop :kick do
  sample :bd_haus
  sleep 1
end

live_loop :snare do
  sleep 1
  sample :sn_dolf
  sleep 1
end

live_loop :hat do
  16.times do
    sample :drum_cymbal_closed, amp: 0.4
    sleep 0.25
  end
end

Reading it.

• use_bpm 120 — 120 beats per minute. One beat is sleep 1.
• live_loop — The heart of live coding. An infinite loop, but when you edit the code and Run again, the new version is applied from the next cycle. Seamless.
• sample :bd_haus — A built-in sample. :bd_* are kicks, :sn_* snares, :drum_cymbal_* hi-hats.
• sleep — Musical-time wait until the next event.

Run it and a four-on-the-floor beat plays immediately. Now change the 0.25 in the hat loop to 0.125 and Run again. From the next bar the 16ths become 32nds. That's live coding.

Add one line of melody

live_loop :bass do
  use_synth :tb303
  play (ring :c2, :c2, :eb2, :g2).tick, release: 0.4, cutoff: rrand(70, 110)
  sleep 0.5
end

(ring :c2, :c2, :eb2, :g2) is a circular list of four notes. .tick pulls the next index on each call. rrand(70, 110) reseeds the filter cutoff at a random value between 70 and 110 every beat — so the pattern is the same but it sounds slightly different each time.

The charm of Sonic Pi is exactly this — building up line by line. It's not "composing music" so much as "sculpting a beat live."

Sonic Pi suits you if

• You are new to live coding.
• You know Ruby or any OOP language.
• You teach students or run classroom sessions.
• You want to integrate with SBCs like Raspberry Pi or micro:bit.

3 · TidalCycles — A pattern language grown on top of Haskell

TidalCycles is the heartland of the live coding world and the strongest argument for why live coding is more than a "fancy sequencer."

What Tidal is

A Haskell library built by Alex McLean (PhD in music and computer science, UK) starting in 2009. The backend is SuperDirt (a sample player on top of SuperCollider). It runs on macOS, Windows, and Linux — but the entry barrier is the highest. You need Haskell, SuperCollider, and an editor (VS Code, Pulsar, Atom, or Emacs).

People still use Tidal for one reason — the mini-notation pattern language.

Mini-notation — a language inside a language

Tidal runs inside Haskell, but you describe patterns in its own small language, not in Haskell. That little language is mini-notation.

-- TidalCycles — 4-on-the-floor basic beat
d1 $ s "bd bd bd bd"            -- kick, 4 times per cycle
d2 $ s "~ sd ~ sd"              -- snare on 2 and 4
d3 $ s "hh*16" # gain 0.6       -- hi-hat, divided 16 times

Reading it.

• d1, d2, d3 — Nine orchestra channels (streams). Each runs independently.
• s "..." — A sample pattern. The quoted string is mini-notation.
• "bd bd bd bd" — Divide the cycle into four equal parts and play bd in each.
• The tilde character means silence. So "silence sd silence sd" is a backbeat.
• The asterisk — hh*16 plays hh sixteen times.
• # gain 0.6 — Gain at 60%.

That short snippet is already a real beat. But mini-notation truly shines with expressions like the following.

-- Mini-notation with variations
d1 $ s "bd(3,8)"                -- 3 kicks across 8 steps, Euclidean
d2 $ s "[bd, ~ sd] [hh*4]"      -- simultaneous and nested patterns
d3 $ slow 2 $ s "rim*8"         -- slow the pattern by 2x
d4 $ every 4 (rev) $ s "cp*4"   -- every 4 cycles, reverse the pattern

• bd(3,8) — Euclidean rhythm. Distribute three pulses across eight steps as evenly as possible. Musically pleasing polyrhythms emerge for free.
• Brackets — Grouping and nesting patterns.
• slow, fast, rev, every — Functions that transform patterns along the time axis.

This is why mini-notation is "not just a sequencer notation." Patterns are first-class values, and functions transform them. That's why functional programmers fall hard for Tidal.

Install — the hardest part

Installing Tidal is the biggest hurdle in live coding. The steps go like this.

1. Install SuperCollider (audio engine).
2. Install SuperDirt (run Quarks.install("SuperDirt") inside SuperCollider).
3. Install Haskell with GHC (ghcup is recommended).
4. Install the Tidal package (cabal install tidal).
5. Install an editor plugin — the TidalCycles extension for VS Code is the realistic choice.

About 70 percent of first-time attempts get stuck somewhere in those five steps. That is why Strudel exists.

Why people still use Tidal

Despite the install pain, people stay with Tidal because its expressive ceiling is essentially unlimited. It sits on top of Haskell, so you can turn patterns into functions, compose those functions, and build your own libraries. And it sits on top of SuperDirt, so every SuperCollider synth and effect is reachable.

For techno, breakcore, IDM, and noise — for music that needs to be coded fast on stage — Tidal is the most powerful option.

4 · Strudel — TidalCycles moves to the browser

Strudel takes Tidal's install hell and erases it.

What Strudel is

A JavaScript port of TidalCycles led by Felix Roos since 2022. Go to https://strudel.cc/ and you can start coding immediately. No install, no SuperCollider, no Haskell.

Strudel inherited Tidal's mini-notation almost verbatim. If you know Tidal you'll adapt within minutes. The one big difference: because the host language is JavaScript, function composition is expressed via method chaining.

First beat — in the browser

Open https://strudel.cc/, paste this in, hit Ctrl+Enter.

// Strudel — 4-on-the-floor basic beat
stack(
  s("bd bd bd bd"),               // kick
  s("~ sd ~ sd"),                 // snare
  s("hh*16").gain(0.5),           // hi-hat
  note("c2 c2 eb2 g2").s("sawtooth").cutoff(800).resonance(15)
)

Reading it.

• stack(...) — Play multiple patterns simultaneously.
• s("...") — A sample pattern. Mini-notation syntax is identical to Tidal.
• .gain(0.5) — Adjust gain via method chaining.
• note("c2 c2 eb2 g2") — Note (MIDI) pitch pattern.
• .s("sawtooth") — Play with a sawtooth synth.
• .cutoff(800).resonance(15) — Low-pass filter.

That's it. No install, no signup. Open a URL and live coding begins.

What Strudel changed

Since 2022 Strudel has done three things.

1. Zero entry barrier. The five Tidal install steps became one — opening a URL. More than 80 percent of new Algorave participants now start with Strudel.
2. Easy sharing. The Strudel REPL encodes your code into a URL. You can drop a one-line beat as a link on Twitter.
3. Web audio plus visuals. Because everything runs in the browser, Canvas and WebGL combine naturally. Hydra (a live coding visuals tool) and Strudel happily share a page.

Strudel vs Tidal — what differs?

Almost the same, with these differences.

• Backend. Tidal uses SuperDirt (a desktop synth); Strudel uses Web Audio plus its own synths and samples.
• Expressivity. Tidal is slightly richer — full SuperCollider access. Strudel keeps closing the gap.
• Performance reliability. For stage gigs Tidal still dominates — better latency, richer synths. But between 2025 and 2026 Strudel-on-stage grew rapidly.
• OSC and MIDI. Tidal handles these freely. Strudel also drives external synths and drum machines via the Web MIDI API.

Start with Strudel, move to Tidal for serious stages — that's the common path.

5 · Variants — FoxDot, Csound, ORCA

The big three dominate, but several variants are interesting.

FoxDot — Python live coding

Built by Ryan Kirkbride (University of Leeds). A Python-based live coding environment with SuperCollider as the backend and a Python DSL on top.

# FoxDot — 4-on-the-floor
Clock.bpm = 120
d1 >> play("x x x x")        # kick
d2 >> play("  o   o")        # snare
d3 >> play("-" * 16, dur=0.25)  # hi-hat
b1 >> bass([0, 0, 3, 5], dur=0.5, oct=3)

The double right-arrow operator means "send this pattern into channel d1." Visually the flow reads well.

FoxDot is richer than Sonic Pi and lighter than Tidal. It plugs naturally into the Python ecosystem, so you can generate patterns with NumPy or SciPy and feed them in. The community is smaller than Tidal, Strudel, or Sonic Pi.

Csound — the grandparent of computer music

Built at MIT by Barry Vercoe in 1986. The ancestor of live coding, although it began as a text-based sound synthesis tool.

; Csound — a simple sine wave
instr 1
  asig oscili 0.5, 440, 1
  out asig
endin

i1 0 1

Csound is more a sound design tool than a live coding tool per se. To use it live you'd go through Cabbage or its live-coding mode. But if you want to build synths from scratch — or you're into classical/experimental music — Csound is still the most powerful.

ORCA — esoteric on a grid

Among these variants the weirdest and most charming is ORCA, built by Devine Lu Linvega of the nomadic art duo Hundred Rabbits.

ORCA is not a text editor — it is a 2D grid. You place single-character operators on the grid, and those operators exchange signals to emit MIDI, OSC, and UDP.

.....D8....
...........
.aT5...4Cc4
.....b.....
...........

Each glyph is an "operator." D is delay, C is counter, T is tracker, and a and b are variables. ORCA does not produce sound itself — it only sends MIDI to external synths.

ORCA is closer to a cellular automaton than a music tool. Live coders love it as an "esoteric" environment. Watch the grid for an hour and you can see it breathing.

6 · 30-minute first beat tutorial — fastest with Strudel

The fastest path to your first beat. Thirty minutes is enough.

0 to 5 minutes: open the environment

Go to https://strudel.cc/. The page opens with a code editor. Top-right Play button plays the default demo.

Stop the demo and clear all the code.

5 to 10 minutes: the first line

Type one line.

s("bd*4")

Ctrl+Enter (Cmd+Enter on Mac). The kick fires four times. First beat done.

10 to 15 minutes: add snare and hi-hat

stack(
  s("bd*4"),
  s("~ sd ~ sd"),
  s("hh*8").gain(0.5)
)

Ctrl+Enter. A four-on-the-floor beat is now complete.

15 to 20 minutes: bass line

stack(
  s("bd*4"),
  s("~ sd ~ sd"),
  s("hh*8").gain(0.5),
  note("c2 c2 eb2 g2").s("sawtooth").cutoff(800)
)

c2, eb2, g2 are the root, third, and fifth of a C-minor chord. Almost anything on top will sound reasonable.

20 to 25 minutes: variation

Add a touch of motion to the bass.

stack(
  s("bd*4"),
  s("~ sd ~ sd"),
  s("hh*8").gain(0.5).sometimes(x => x.fast(2)),
  note("c2 c2 eb2 g2")
    .s("sawtooth")
    .cutoff(sine.range(400, 1200).slow(8))
    .resonance(10)
)

• sometimes(x => x.fast(2)) — Roughly half the time, play the pattern twice as fast.
• sine.range(400, 1200).slow(8) — Modulate the filter cutoff between 400 and 1200 Hz over 8 cycles via a sine wave. The classic "filter sweep" cliche of club music.

25 to 30 minutes: share

The Strudel REPL has a Share button (top-left) that creates a URL with your code encoded into it. Drop the URL in Twitter or Discord and your friends can open it and hear the same beat.

Within 30 minutes you have made a beat, varied it, and shared it. This is why live coding is so strong as a developer hobby.

7 · The Algorave scene — joining the community

Solo beat-making is fun, but the real joy of live coding is the community.

Where to meet

• TOPLAP official channels — https://toplap.org/ and Discord. The global home for live coders.
• Algorave events — https://algorave.com/ lists the worldwide event calendar. As of 2026, an average of five to ten events run per month worldwide.
• Strudel Discord — Linked directly from the Strudel REPL. The liveliest live coding community right now.
• TidalCycles Club — The tidalcycles.org forum and Discord.
• Sonic Pi forum — https://in-thread.sonic-pi.net/. Heavy on educators and classroom users, so the tone is gentle.

Korea, Japan, and the broader Asian scene

• Seoul — Algorave Seoul has run intermittently since 2023. Postech and KAIST undergraduates have led some of them.
• Tokyo — Algorave Tokyo runs regularly. Japan has a deep population of live coders, often connected to the media art scene.
• Taipei, Hong Kong, Kuala Lumpur — Small scenes in each.

How to get on stage for the first time

Live coding's barrier to performance is surprisingly low. Most Algorave events keep an "open slot" for newcomers. Post one line of code and a short video clip in Discord, ask "Can I do ten minutes at the next event?" and you'll usually get a yes.

You don't need much.

• A laptop (whichever of Sonic Pi, Strudel, or Tidal you know best).
• Headphones or monitor speakers.
• An HDMI or USB-C adapter so your screen can project to the venue.
• A 10 to 15 minute set. For your first time you can bring a code base prepared in advance (purists would frown, but reducing nerves matters more on your debut).

8 · Live coding + visuals — pairing with Hydra and TouchDesigner

Some live coders do only music, but many pair it with live visuals. If the music changes live, the screen changes live too.

Hydra — live coding for visuals

Built by Olivia Jack as a browser-based live coding tool for visuals. Open https://hydra.ojack.xyz/ and start typing.

// Hydra — visuals that react to the music
osc(20, 0.1, 1.2)
  .color(1, 0.5, 0.3)
  .rotate(0.1)
  .modulate(noise(3, 0.5))
  .out()

osc is a one-line shader that fills the screen with a sine wave. modulate adds noise. You can run Strudel on the same page so Strudel's beats drive Hydra's screen — a natural live set.

TouchDesigner and VVVV — node-based visuals

For heavier visual works, TouchDesigner (macOS, Windows) or VVVV (Windows). They talk to live coding tools via OSC. Tidal's patterns can directly modulate TouchDesigner's visual parameters.

9 · People who do this seriously

Three live coders, briefly.

Alex McLean — creator of TidalCycles

Based in Sheffield and London. Cambridge computer music background. Central figure of TidalCycles and the Algorave movement. His sets are academic in spirit yet land in clubs. There are several full sets of his on YouTube.

Sam Aaron — creator of Sonic Pi

Cambridge. Aaron's sets are the model of "friendly live coding." Every Sonic Pi demo is his own. Plenty of his classroom teaching is on YouTube too.

Renick Bell, CNDSD, char stiles, and others

The scene is small and new faces appear every year. Spend 30 minutes on the Algorave YouTube channel and you'll quickly find someone who matches your taste.

10 · The charm of pattern abstraction — why functional programmers fall in

If you've spent some time with TidalCycles or Strudel, you've noticed: mini-notation makes patterns first-class values and functions transform those patterns. In other words, functional programming.

// Strudel — transforming a beat through function composition
const basicKick = s("bd*4")

basicKick
  .every(4, x => x.fast(2))           // every 4 cycles, twice as fast
  .sometimes(x => x.degradeBy(0.3))   // sometimes drop 30% of the notes
  .jux(rev)                           // place forward/reverse across stereo

That isn't merely music — it's patterns as abstraction. every, sometimes, jux, fast, slow, rev, palindrome, shuffle — the combinators a live coder reaches for. Function composition becomes musical expression.

This is why functional programmers gravitate to live coding. Making music is composing functions. The language is the instrument.

Epilogue — Why this is the happiest hobby for developers

People who start live coding all say the same thing.

"It's just so much fun that I type code and sound comes out."

At work you don't get instant feedback from typing code. You wait for builds, tests, and rollouts before anything actually happens. Reviews and approvals are squeezed in between.

Live coding compresses all that to zero seconds. The moment you press Ctrl+Enter, the code you just wrote becomes sound. Botched, you hear it; perfect, you hear it. It's the shortest feedback loop in programming.

And the result is fun. Not a green CI badge — a good beat.

For working developers, is there a better hobby? Not on the work laptop but on your own. Not on the company codebase but on your own patterns. Not waiting for the company build but listening to your own beat. And mistakes get applause, not anger.

Starter checklist

1. Open https://strudel.cc/.
2. Walk through the 30-minute tutorial from chapter 6.
3. Build your own one-track beat.
4. Share the URL with a friend.
5. Join the TOPLAP Discord.
6. Listen to 30 minutes of Algorave videos within a month.
7. Try a 5-minute public set within six months (in front of friends or in a Discord voice channel).
8. Apply for a newcomer slot at your local Algorave within a year.

Anti-patterns — how to ruin your start

1. Trying to install Tidal first. Start with Strudel or Sonic Pi. Tidal once you're comfortable.
2. Approaching it with a DAW mindset. Live coding isn't "finish a track" — it's "sculpt a pattern."
3. Trying to learn all music theory before starting. Knowing just one scale (C-minor pentatonic) is enough.
4. Trying to make your first set perfect. A live coder's set is 90 percent improvisation. A "perfect" set isn't live coding.
5. Relying on the mouse to drive the GUI. Keyboard shortcuts and text only.
6. Trying to build your own samples. Strudel and Sonic Pi ship with hundreds.
7. Writing your own library from day one. Wait six months.
8. Going solo. You learn faster in a community — TOPLAP, Algorave, Strudel Discord.
9. Focusing only on recordings. Live coding is fundamentally live. Recordings are a byproduct.
10. Not watching Algorave videos. Thirty minutes a day for a month locks in your style.

What's next

Possible follow-ups: Hydra live coding for visuals — make club imagery with one line of shader, Build your own synth in SuperCollider — sound design from scratch, 30 minutes of music theory — 12 chord progressions every live coder should know.

"Type code. A beat comes out. Change one line. The next bar shifts. That's live coding. That's the most joyful kind of programming."

— Live Coding Music 2026, end.

참고 / References

• TOPLAP — the live coding movement's home
• Sonic Pi official site
• Sonic Pi GitHub repository
• Sam Aaron live coding talks
• TidalCycles official site
• TidalCycles docs — mini-notation
• Tidal GitHub
• SuperCollider official
• SuperDirt — Tidal's backend
• Strudel REPL — live code in your browser
• Strudel GitHub
• Strudel Learn tutorial
• Algorave event calendar
• Algorave YouTube channel
• FoxDot — Python live coding
• FoxDot GitHub
• Csound official
• ORCA — Hundred Rabbits
• Hydra — live coding for visuals
• TouchDesigner official
• Alex McLean's mini-notation paper
• TOPLAP manifesto
• Sonic Pi in-thread forum
• Live Coding Research Network