Skip to content
Published on

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

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

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.

  • Sonic Pi is in UK primary and secondary music curricula, and it is an official instrument at BBC Music Day concerts.
  • TidalCycles is the de facto standard of the global algorave scene; Strudel (its JavaScript port) runs full club sets from a single browser tab.
  • Hydra is used by roughly 90% of live-coding visualists. Two lines of code produce psychedelic shaders.
  • TouchDesigner has become the standard in media-art studios, dominating LED walls across COEX, Itaewon, and DDP in Seoul.
  • SuperCollider has been in active service since 1996 — 35 years and still going, alive in both academia and industry.

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.

  • Declarative patterns — not "make this rhythm" but "the rhythm itself" expressed as code. The mini-notation of TidalCycles, Strudel, and Sonic Pi all live here.
  • Hot reload — edit the code, press Ctrl+Enter, and the currently playing sound or visual morphs without stopping. This is the essence of live coding.
  • Time as a first-class citizen — cycle, beat, and tempo enter as function arguments; time maps through functions.

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:

  • Friendly syntax, rich sample library (:bd_haus, :elec_blip, and hundreds more)
  • Ableton Link support (since 2.0) — sync BPM with other DJs and musicians
  • Free, open source, runs out-of-the-box on a Raspberry Pi
  • Overwhelming volume of educational material

Limitations:

  • Pattern combinators are weaker than TidalCycles (fewer sequence-transformation functions)
  • The GUI is built for learners — a bit cramped on a two-monitor stage setup

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:

  • d1 — slot 1 (d1, d2, ..., up to d16 simultaneous slots)
  • s "..." — a sample pattern
  • bd*4 — bass drum four times per cycle
  • [~ sn] — [] is a sub-group; ~ is a rest
  • cp hh*8 — one clap, eight hi-hats

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:

  • A mathematically clean pattern algebra — every, sometimes, chunk, striate, chop, juxby, and dozens more, freely composable
  • Sends OSC to SuperDirt (a SuperCollider-based sampler) — sound engine is SuperCollider, pattern language is Haskell, and the two are cleanly separated
  • A live GHCi REPL for on-stage compilation

Weaknesses:

  • Haskell + SuperCollider + OSC + Atom/Pulsar editor — installation is notoriously painful. Still true in 2026.
  • Easier on macOS and Linux; Windows remains rough.

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:

  • Install time: zero seconds. Open strudel.cc.
  • Web Audio + Web MIDI full stack. Sound is generated entirely in the browser.
  • Sharing is a URL — the code is encoded into the URL; you can share a full set in a tweet.
  • Pattern compatibility with Tidal — Tidal patterns mostly run unchanged.

Limitations:

  • Web Audio constraints mean the timbral variety is not yet as rich as SuperDirt
  • Closing the browser tab ends the show — slightly less stable than native software

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.

  • MiniTidal — TidalCycles mini-notation (music)
  • Punctual — a functional shader DSL by Ogborn (visuals)
  • CineCer0 — video composition
  • Hydra — video synth (Olivia Jack)
  • TimeNot — time notation

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:

  • No install, just a browser and an account
  • Multiple languages side by side — one person on Tidal, another on Hydra, a third on Punctual
  • Tidal/Hydra/Punctual all synchronized on a single time axis

Limitations:

  • Latency from Korea or Japan to the McMaster server can be noticeable
  • More suited to collaboration and education than solo live shows

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:

  • Everything is visible on a 16x16 grid — the code screen on stage is itself the visual
  • Deterministic — the same grid always produces the same pattern
  • The image of Devine composing on a sailboat with solar power has cult status

Limitations:

  • Steep learning curve — really does look like alien text at first
  • Requires thinking outside conventional music-writing models

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:

  • Lowest barrier for Python developers
  • Not as powerful a pattern algebra as TidalCycles, but enough for live use
  • Composes in the same environment as data-analysis code (works inside Jupyter too)

Limitations:

  • Community has shrunk; updates have slowed (less activity in 2024–2025)
  • Fewer transformation functions than TidalCycles or Strudel

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.

  • Free, open source
  • Runs well on Raspberry Pi and embedded boards
  • Pd-extended brings rich external libraries
  • A standard in academia, sound art, and installation work

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).

  • Paid (about USD 399 perpetual, or USD 9.99 a month)
  • Max for Live integrates directly with Ableton Live
  • Jitter adds video and 3D inside the same environment
  • A standard in media-art schools (NYU ITP, Goldsmiths, GSAS)

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:

  • osc(20, 0.1, 0.8) — oscillator with 20 stripes, fast change, brightness 0.8
  • .kaleid(4) — 4-fold kaleidoscope
  • .color(2, 0.5, 1) — multiply colour channels
  • .modulate(noise(3, 0.5)) — distort with noise
  • .out() — render to screen

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:

  • Zero install — one browser tab
  • Camera and external video composition — s0.initCam() pipes the webcam into shaders
  • Multiple channels — outputs o0, o1, o2, o3 can modulate each other
  • The code is genuinely short — five lines for psychedelic visuals

Limitations:

  • Text and 2D graphics are limited — being shader-based, lines and letters are hard
  • Complex scene graphs are better handled by p5.js or TouchDesigner

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:

  • Live reloading is not natural — replacing function draw() mid-frame flickers
  • Strong on 2D canvas, weaker on complex shaders

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.

  • GPU acceleration is default — 4K multi-screen is everyday
  • Nodes are sorted into TOP/CHOP/DAT/COMP (textures/channels/data/components)
  • Python scripting is built in — you call Python from inside the node graph
  • Educational tier free, Commercial about USD 600 per year

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.

  • More motion-graphics focused than TouchDesigner
  • Used heavily on stadium tours (Coldplay, Billie Eilish, BTS)
  • Tightly integrated with media-server workflows (d3, disguise)
  • Licensing is expensive (several thousand dollars a year)

Resolume Avenue / Arena

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

  • The standard for stage VJs (70–80%)
  • Avenue around USD 449, Arena (multiple outputs) around USD 899
  • Integrates Ableton Link, MIDI, OSC

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.

  • Strong in installations, advertising, interactive art
  • Steep learning curve, but powerful once mastered
  • The centre of the German and Austrian media-art scene

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:

  • Lua scripting — nearly everything is customizable in Lua
  • Redux (Renoise's sampler) is even used inside Ableton and Logic
  • A standard in the demoscene and chiptune communities

Connection to live coding:

  • Pairs nicely with ORCA — Orca emits MIDI/OSC, Renoise receives
  • Lua scripts inside Renoise can themselves become a live-coding set

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".

  • Publishes a yearly TOPLAP manifesto — "Show us your screens" is the core slogan
  • The parent body of the algorave movement
  • Hosts the annual International Conference on Live Coding (ICLC) each December

Algorave

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

  • All music and visuals are generated in realtime by algorithms
  • The code is projected for the audience to read
  • It is dance music, but the stage is "laptop and projector"

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.

  • Hosted in a different city each year (2024 ASU, 2025 KAIST Seoul, 2026 Canada)
  • Live coding, haptic instruments, EEG-driven instruments, AI composition systems — the scope is broad
  • Roughly half of academic live-coding papers land at NIME

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.

  • NIME 2025 at KAIST Seoul (June 2025) was a turning point for the local scene
  • Seoul Algorave has regular events around Hongdae and Mullae
  • KAIST CT, SNU College of Music, and K-Arts (Korea National University of Arts) lead academia
  • On the media-art side, D'STRICT, a'strict, Nam June Paik Art Center, and ZER01NE are the hubs

Traits of the Korean scene:

  • TouchDesigner has an unusually high market share — driven by the large media-facade industry
  • TidalCycles, Strudel, Hydra communities are still small but growing fast (active Slack and Discord)
  • Sonic Pi adoption in school music education is still minimal — a wide gap versus the UK

Japan

Tokyo is the Asian hub of algorave.

  • Tokyo Demo Fest (every February) is the Japanese home of the demoscene, with live-coding sets in the lineup
  • Real Algorave (Tokyo and Osaka) runs irregularly but with strong lineups
  • Performers like renick falls, hosi, and kindohm are active on the international circuit
  • Japanese-language resources on dezaina.net and similar blogs cover live coding and TouchDesigner in depth

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.

  • Transparency — it is not magic but algorithm. The audience watches the algorithm running.
  • Vulnerability — if you make a compile error on stage, it shows. That is proof a human is up there.

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

Discuss on Twitter • View on GitHub