🎸

Bonfire Quest

Updated: 2026-06-02

Build a music-learning engine, not a tab player

The origin story of Bonfire — Dad's own music-learning engine, the music sibling of the image engine Ember. Why you build a learning engine instead of renting a tab service or bending a DAW into a teacher, and what every architectural choice teaches about owning the way you learn.

8 tracks · 33 lessons · ~6h · difficulty: intermediate-to-advanced

Level 0Cold Ash

0 XP0/33 lessons0/12 achievements

0/100 XP to next level100 XP to go0% complete

Bonfire is not a tab player, not a DAW, not a transcription tool. It is an independent engine that owns music analysis, one music model, easy-mode simplification, the theory reference, and an API — with a built-in Konva web UI as its first client. This quest walks that engine end to end: the core bet (easy mode over note-for-note, a blue ocean that is impossible as static data), the central model (instrument is a view, music is the model — pure OOP polymorphism), the API-first engine/client boundary, the input tiers where its dead predecessor Guitopia drowned and Bonfire instead starts, why no DAW can host a learning tool, the lived build (web over native, one shared audio clock, one scheduler with many consumers), and the closing discipline of owning your own tools. It is the music engine telling its own origin story — conceptual open-sourcing, not a repo you clone.

Tracks

01🪵The Hearth
0/4 lessons
What Bonfire is, where its name comes from, and why it exists
Before any architecture, the orientation. Bonfire is a music-learning engine — not a tab player, not a DAW, not a transcription tool. This track shows you the working v1, decodes the Dark Souls name, places Bonfire in the four-repo sibling family, and answers the first question anyone asks a self-built tool: why not just rent one?
Bonfire v1 — fretboard, waveform, easy-mode note grid, and chord voicings, all reading one music model.
Lesson list (4)
Quiz · 4 questions→
02✂️Easy Mode
0/4 lessons
The core bet: simplify to your level, don't transcribe note-for-note
The heart of Bonfire, and the reason it exists as software at all. Note-for-note is a saturated red ocean; easy-mode simplification is a blue ocean that can't exist as static data. This track explains why simplification and explanation are the same act, and breaks the simplification down into the actual knobs an engine turns.
Lesson list (4)
Quiz · 4 questions→
03🎼One Model, Many Views
0/4 lessons
Instrument is a view; music is the model
The architectural heart. There is one musical truth — a key, a scale, a chord progression, notes on a time grid — and the fretboard, keyboard, staff, and tab are polymorphic views of it. This is OOP the way Dad reads the world: music theory is the abstract base class; each instrument canvas is a concrete inheritor. Adding a view must never change the model.
Lesson list (4)
Quiz · 4 questions→
04🔌API First
0/4 lessons
The engine owns the model; clients consume the API
The seam that makes the engine reusable. Bonfire produces and owns the music model; every client — the built-in Konva UI, the Pippa Sidekick, a future Live bridge — consumes it through the same API, never through engine internals. This is Ember's pattern transplanted: finish the engine, open the API, let sidecars come after.
Lesson list (4)
Quiz · 4 questions→
05🎚️Input Tiers
0/4 lessons
Where Guitopia drowned, Bonfire starts
Audio analysis isn't one monolith of difficulty — it's a spectrum. Tier A (tempo, key, chords, sections, stem separation) is automatic and mature; Tier B (note-for-note transcription) is semi-automatic and never a hard dependency. This track shows why the killer features all stand on the cheap tier, how MIR libraries like Demucs are wrapped as a parts library, and why human-in-the-loop analysis is a feature, not a defect.
Lesson list (4)
Quiz · 4 questions→
06🎹Why Not a DAW Sidecar
0/4 lessons
The Cinder:Photoshop idea, pushed until it breaks
The brainstorm asked: is Bonfire to a DAW what Cinder is to Photoshop? Pushing that to its end is what proves the independent-engine path. Cinder:Photoshop held on three conditions; Logic fails the API condition, Live fails the residency and value conditions, and the conclusion is that DAWs are production tools that cannot host a learning tool.
Lesson list (4)
Quiz · 4 questions→
07🔨The Build
0/5 lessons
Web over native, one clock, one scheduler with many sinks
Where the philosophy meets the keyboard. Why Bonfire is web and not native (deliberately and reversibly), why it serves a dev Vite server instead of a prod build right now, and three lived lessons from the v1 playback engine: one anchored audio clock that killed the jitter, Web MIDI as just another consumer of that one scheduler, and the callback-ref fix for measuring a late-appearing element.
Lesson list (5)
Quiz · 4 questions→
08🏕️Own Your Tools
0/4 lessons
No borrowed brain, scope held, concrete-first — the hearth is yours
The closing discipline. Bonfire's Sidekick borrows no brain — it binds to cwkPippa. Its scope is held by an explicit out-of-scope list, the discipline that kept it from freezing like Guitopia. It's concrete-first all the way down. And the final payoff: when you own the engine, you own the way you learn.
Lesson list (4)
Quiz · 4 questions→

Tracks

01🪵The Hearth

02✂️Easy Mode

03🎼One Model, Many Views

04🔌API First

05🎚️Input Tiers

06🎹Why Not a DAW Sidecar

07🔨The Build

08🏕️Own Your Tools