The Kontinuum mark: marks travelling one infinity path, each turning from a round red dot into an amber square and back — music becoming data, forever.
The architecture

Tracks are visualizations
of executable musical code.

Not audio clips. Not MIDI clips. In Kontinuum the structured representation is the song: instruments, synthesis, samples, patterns, melodies, effects, automation, arrangement, mixing, modulation, probability and generative rules — one document the engine performs. The surface still feels like a DAW, and nobody has to write a line: move a note, swap an instrument, draw automation, and the code rewrites itself underneath.

SCORE — the generative source seed 0xC0DE7 · bar 00
one pattern expression · never changes
expanding… same seed → the same bar, forever

The expression above is the source of truth. The bars beneath it are what plays. Nothing is pre-recorded, nothing loops, and none of it is random: re-run the same seed and you get the same audio, sample for sample.

The point

Generative is architectural,
not an AI button.

Most "AI music" flattens a prompt into a finished file. Kontinuum keeps the structure that made it. A composition carries rules, probabilities, controlled randomness and transformations, so the same piece performs differently every time and is still recognizably itself. That is a property of the document, not a feature of a model — which is why it survives when the model is switched off.

WHAT A DAW STORES

A recording of decisions already made. Copy the clip to bar 33 and bar 33 is a copy. To make it vary, you do the varying — by hand, once, forever frozen.

bar 01 [kick.wav ][hat.wav ] bar 02 [kick.wav ][hat.wav ] bar 03 [kick.wav ][hat.wav ] bar 04 [kick.wav ][hat.wav ]
WHAT KONTINUUM STORES

The system that makes the decisions. The document says how the part behaves; every bar is derived, deterministic, and different. You edit the behaviour, or you edit one bar and that edit survives everything around it changing.

hat: euclid(5,16,2) .every(4, rotate(3)) .sometimes(.25, degrade) .humanize(6ms)
What each category of music software stores, and what follows from it
Streaminga recording One-shot AIprompt in, file out Adaptive audiorules over fixed stems A DAWclips on a timeline Kontinuummusic as code
What is stored A recording A generated file Stems plus a rule engine Clips and the edits you made The system that composes it
Changes per listen Never Never — regenerate for a new one Recombines, within fixed material Never Every bar, and never repeats
Can you open it No No No Yes — the clips, not the reasoning Yes, and it reads as code BUILDING
Cost per hour played Per-stream licensing $0.03–0.26 per track, every time Near zero — $0 — synthesis, not inference
Works offline Cached tracks only No — generation is a server Yes Yes Yes, indefinitely
What the AI touches — The audio itself — — The representation, never the audio
Same input, same output Yes — it is one file No Partly Yes Bit-identical from a seed

This is a comparison of architectures, not of quality — those are different claims and we only make the one we can show. Generation prices are published first-party API rates as of August 2026 (Google Lyria, Stable Audio, ElevenLabs); the full working is in our cost model. Categories rather than brands, because the point is not who else is in the room — it is that storing the code instead of the recording is what makes every other row possible.

The layers

One document, two levels.

The Score is the code you edit. Expanding it produces the Performance — the concrete, literal music for the bars about to play. The Performance compiles to sample-accurate events, and the real-time core renders them. Expansion is pure and seeded, runs on the control thread at lookahead, and never touches the audio path.

SCORE Generators, rules, probabilities, transformations, overrides, locks, seed. This is "the code" — the thing the code view shows and the AI edits. NEW
↓ expand pure · seeded per node path · control thread · at lookahead
PERFORMANCE The concrete session: literal patterns, automation lanes, sections. What will actually play, and what the track view draws. SHIPPED
↓ compile incremental compiler → pre-scheduled event blocks
BLOCKS Sample-accurate events, queued ahead of the playhead. SHIPPED
↓ render allocation-free, lock-free, panic-contained
AUDIO The Rust real-time core. Unchanged by any of this — it has never seen a generator and never will. SHIPPED

Four projections read this one document: the code view renders the Score as text; the track view draws the Performance and edits the Score; the composer proposes changes to it; and DJ moves, Siri and Shortcuts are changes to it too. One write path, one validator, one history.

Four things the language needs

Everything else follows from these.

GENERATORS AS NODES BUILDING

Patterns compose

A combinator tree over pattern values, seeded per node so expansion stays pure. Rhythm: steps, euclid, every, sometimes, degrade, rotate, choose, humanize. Melody: fit(scale), walk, arp, and motif transforms — invert, retrograde, transpose.

RULES IN THE DOCUMENT BUILDING

A style is code, not a code path

The arrangement grammar, per-style density caps, energy curves and the transition catalog move out of the engine and into the composition. A genre becomes a Score fragment you can read, fork and share — and the engine becomes an interpreter of rules rather than their author.

OVERRIDES & LOCKS BUILDING

Your edit survives regeneration

Drag one note in a generated part and it becomes an override anchored to musical time — concrete, and immune to everything around it changing. Lock a region and generators and the composer both leave it alone. This is what lets a generative document still feel like a DAW.

ONE ADDRESS SPACE BUILDING

Every parameter has a path

tracks/bass/instrument/filter/cutoff. Automation lanes, modulation sources, overrides, AI edits and the UI all target the same paths — so an LFO, a drawn curve, a macro knob and a model proposal are the same kind of thing pointed at the same place.

The AI's actual job

It edits the representation.
It never makes a sound.

The composer proposes changes to the Score in the same language you edit in. Every proposal passes a strict validator — bounds, schema, CPU budget — with machine-readable error codes it uses to repair its own output. Only validated changes reach the arranger, and only at musical boundaries, so steering never clicks and the stream never starves.

A QUALITY KNOB, NOT A TRUST BOUNDARY

No model can break the music

A deterministic watchdog shadows everything, with an endless fallback arrangement behind it. The worst case of a bad model is plainer music — never silence, never a crash, never a dropout. Which is also why the model is optional.

HUMAN AND MACHINE ARE PEERS

The same write path for both

Your gesture in the grid, a DJ filter sweep, a Shortcuts automation and the composer's proposal all become the same validated edit, in the same history, with the same undo. There is no privileged path and no hidden state.

The path

Where this goes, in order.

The engine, the IR, the validator, the diff API and the determinism gates are built and shipping today. What follows moves the generative rules out of the engine and into the document, one milestone at a time — surfaces always second, language always first. Sessions written today keep loading unchanged.

M1

One mutation API

Every editor in the app writes through the validated diff path, and nothing writes any other way. DJ controls become edits for free.

proves: human, UI and AI are peers
M2

Generators as nodes

Pattern expressions land in the language, with the validator, the schema and the determinism tests around them. Tap a line, change it, hear it next bar.

proves: generative is architectural
M3

Overrides and locks

Hand edits on generated material survive regeneration; locked regions are off-limits to generators and to the composer.

proves: the DAW edits the code, and the code keeps generating
M4

Rules move into the document

Grammar, density caps, energy maps and transitions leave the engine; the built-in genres become Score fragments like any pack you install.

proves: a style is code
M5

Everything addressable

Parameter paths everywhere, plus modulation nodes — LFOs, envelope followers, sidechain, random walks, macros — expanding into automation at lookahead.

proves: instruments, samples, modulation and automation are one graph
M6

Melody and harmony as generators

Scale and chord tracks, melodic generators, motif transforms — with piano-roll edits landing as overrides or as parameter changes.

proves: melody is code, and still playable by hand
M7

Mix and master as rules

Bus targets, mix decisions and the mastering profile become Score nodes, with the critic's reference targets living in the document beside them.

proves: the whole signal chain is in the document
M8

The whole production is code

A project is one Score plus the packs it names. Export a performance as audio, or share the Score and let it perform itself, differently, forever.

proves: the thing this was all for

Watch the language get built.

The plan, the schema and every milestone above are in the open. The beta comes when the sound is ready — leave an address and you'll hear first.

one message when it ships · nothing else, ever
Read the code See it as a studio →