The Open-Source Libraries Powering Ghost Arcade — A Credits Essay

What we stand on

Ghost Arcade isn't built from scratch. It's a thin layer of opinion

and integration sitting on top of decades of work by other people

who released their code under licenses that let us use it. The

v1.7.1 plugin tier — eight new visualizers landing in one release —

exists because eight other communities already did the hard part.

This is the credit essay. Every library below earned its keep,

shipped to your laptop, and gets named because that's the deal you

make when you take someone's open-source work.

Visualizers we integrate

Butterchurn (Milkdrop reborn)

`@jberg/butterchurn` — MIT licensed. A pure-JS port of the

Milkdrop visualizer that has been on Winamp since 2001. Ghost

Arcade's Milkdrop plugin is butterchurn + the official preset

pack with a panel for choosing presets, blending between them, and

routing audio bands per-stem. The preset library is a piece of

culture — twenty years of psychedelic shader work by hundreds of

contributors — and butterchurn lets it run unmodified in the

browser.

If you grew up watching the cymatic waveforms swirl over a Winamp

playlist, the same presets are now playing inside Ghost Arcade with

a routing matrix you can wire your kick drum into.

Hydra (Olivia Jack)

`hydra-synth` — AGPL-3.0. Olivia Jack's live-coding video synth.

Hydra is a functional pipeline of video transforms — `osc(20).rotate(0.1).out()`

is a complete program. Ghost Arcade ships Hydra as a plugin with a

curated preset library AND a code editor so you can write your own

sketches inline. The Hydra panel auto-compiles as you type; a typo

shows red but doesn't crash the layer.

Hydra changed what live-coded visuals look like on the web. Picking

it up was the obvious thing to do.

MediaPipe Hand Landmarker (Google)

`@mediapipe/tasks-vision` — Apache-2.0. The hand-tracking pipeline

that powers v1.7.1's gesture binding system + the HandFX visualizer.

MediaPipe is published by Google's MediaPipe team and runs the

inference on the GPU delegate, which means a modern laptop can

track two hands at 60fps with <15ms inference per frame.

We do a small amount of post-processing — adaptive smoothing,

forward prediction, handedness-label swap when mirror is on — but

the actual landmark detection is all MediaPipe. See the

MediaPipe gesture binding post

for the full technical writeup.

AudioMotion-Analyzer (Henrique Vianna)

`audiomotion-analyzer` — AGPL-3.0. Henrique's Web-Audio-driven

spectrum analyzer is the engine behind Ghost Arcade's AudioMotion

plugin. Logarithmic frequency scaling, customizable bar count,

gradient palettes, peak holds — every visual knob the original

exposes is wired through Ghost Arcade's panel. The reactivity to

your actual audio source (mic, line-in, browser tab, virtual cable)

inherits from Ghost Arcade's audio routing system, so any source

the rest of the app can hear, AudioMotion visualizes.

Wave.js (foobar404)

`@foobar404/wave` — MIT. Lightweight Web-Audio waveform / shape

visualizer with a long catalog of animation styles (Bars, Cubes,

Flower, Wave, Wings, Stars, …). Ghost Arcade's Wave.js plugin

exposes the catalog as a select and every animation's parameters as

modulation-aware sliders. Smaller surface than AudioMotion but very

fast — good when you want one element of audio reactivity layered

into a busier composition.

ISF Shader Library (Vidvox)

`interactive-shader-format` — public domain shader format from

Vidvox (the company behind VDMX). ISF is what made it tractable to

ship a library of 500+ user-tunable shaders: every shader carries

metadata about its inputs (sliders, colors, points) so the panel can

auto-generate UI for any new shader you drop in. Vidvox's

shadertest.vidvox.net library is

where most of our curated shaders started life.

Three.js (mrdoob et al.)

`three` — MIT. The compositing engine that takes every layer's

output texture and composites it through warp / blend / mask /

effects to the master output. Ghost Arcade's layer pipeline,

projection mapping mesh, model3D layers, and every shader effect

ride on Three. The post-FX system is custom but every WebGL primitive

underneath is Three. Twelve years old; still the workhorse of the

web-3D ecosystem for good reason.

WebGPU (W3C standard, browser implementations)

Not a library, an API. The new low-level GPU access standard for

browsers; Ghost Arcade uses it for the master warp + dome

reprojection (v1.7.0), the GPU shader layer renderer, several

visualizers (Flythrough, Ink Cloud, Fluid Sim, Paint Drip, the

3D-smoke pipeline), and the per-screen output windows. Chromium's

implementation (Dawn) is what runs inside Electron. WebGPU is the

thing that made it possible to do real-time GPU compute on

arbitrary user-supplied shader code without dropping out of the

browser.

The application stack

Svelte 5 (Rich Harris)

`svelte` — MIT. The reactivity model that the entire Ghost Arcade

UI is built in. Svelte 5's runes API (`$state`, `$derived`,

`$effect`) replaced a lot of `writable` / `subscribe` boilerplate

for v1.6+ and the codebase reads cleaner now. The whole VJ Mode

panel, the layer mixer, the binding overlays — every interactive

element you see is a Svelte component.

Electron (OpenJS Foundation)

`electron` — MIT. The shell that wraps the web app into a desktop

binary with native filesystem access, MIDI/OSC, system video output,

Spout/Syphon/NDI bridges, and codesigning. Every desktop integration

that the browser sandbox would deny — Ghost Arcade gets via Electron.

Vite (Evan You)

`vite` — MIT. Dev server + build tool. Hot-module reload that

actually keeps app state across reloads when editing a Svelte

component. The build pipeline that produces the production bundle.

Boring infrastructure that just works, every time.

Audio + MIDI + OSC

decoding when the browser native codecs don't cover the format

(HAP, ProRes, etc.) and the offline render pipeline for export.

(FFT, beat detection, per-band energy, multi-stem analysis) rides

on `AudioContext` + `AnalyserNode`.

and clock sync.

OSC messages route into the same dispatch surface as MIDI.

File formats + content

research community + a renderer ported from Mark Kellogg's

three.js-splat work, MIT.

Arcade wraps it via a native Electron addon. NOT open source but

free for non-commercial use; commercial deployments need a Vizrt

license.

Windows / macOS respectively; we wrap each via a native addon.

What we contributed back

Most of our contributions live in our own codebase as bug-fix forks

or wrapper abstractions, but a handful have landed upstream:

files seen in the wild.

tasks-vision repo around module-worker initialization.

toolchain.

If you maintain one of these projects and Ghost Arcade has been a

useful adopter, please reach out — we want to support the work that

supports us. Contact via the

community page.

Why this matters

Two things.

One: when you download a closed-source VJ tool, the only thing you

ever own is the binary. When you download an open-source one, you

own the source and you own the right to fork it the day the vendor

disappears. We chose AGPL-3.0 for Ghost Arcade specifically so the

fork-rights propagate — anyone who modifies and ships a derivative

work has to share the modifications back. This is the same license

Mastodon, Synapse, and Nextcloud use, and we picked it for the

same reasons.

Two: the eight visualizers that landed in v1.7.1 took a year of

combined work by their original authors before we ever touched

them. Plugging them into Ghost Arcade took a few weeks each. The

multiplier on open-source work is enormous. If you're building a

creative tool in 2026, this is the path: pick the AGPL or MIT

libraries that already do 80% of what you need, integrate them

honestly with credit, and ship the 20% that makes your tool yours.

Ghost Arcade is free, open source, and downloadable at

/download. The source is at

github.com/riskcapital/ghost-arcade.

Every dependency above is in package.json.