The AMPLE language specification

Spec version 0.1, status: draft. This is the normative description of the AMPLE source language (.amplet) and of the data files around it. If a page elsewhere in ample/docs/ disagrees with this folder, this folder wins and the other page is fixed.

This spec is maintained. Every change to the language, diagnostics, lint rules, block templates or CLI must update ../../spec/ (the data), the page here, a conformance case in ../../spec-tests/, an example and CHANGELOG.md, in the same change. See 99-maintenance.md.

Which syntax? The syntax specified here is the mock syntax of the clickable sketch (../sketch/index.html): block headers (drums beats stable@1.2 at 1 for 16 {), parameters, from x.out -> in lines. The older example songs in ../examples/ use a different, statement style (track, voice, pattern, mix); that style is not part of this spec yet. See the open question in ../open-questions.md ("Two syntaxes").

Reading order

The machine-readable half

../../spec/ holds the same facts as data, so the parser, linter, language server, formatter and help.html never hard-code them: grammar.ebnf, tokens.json, types.json, classes.json, templates/*.json, diagnostics.json, lint-rules.json, plugins.json, version.json and JSON Schemas in schema/. The conformance corpus is in ../../spec-tests/. Check everything with node ample/tools/validate-spec.mjs.

01 Overview

Goals

• A song is text that can be read, diffed, versioned and generated. The node editor, the arrangement and the source editor are three views of the same text (source-and-views).
• Reproducible by default: every random choice is derived from a master seed; AI results are recorded as takes with their plans (06).
• Good errors: one front end produces diagnostics with stable codes and exact ranges for the editor, the terminal and CI (08).
• Small and checkable: a line-oriented syntax a person can write by hand and a tool can recover from.

Non-goals (spec 0.1)

General-purpose programming (no variables, loops or functions yet); defining new block types in the language (templates come from the library and plugins); audio DSP details (the engine's business).

The model in one paragraph

A song file declares a project (name, tempo, master seed), optional features and lint settings, and a list of blocks. A block has a type (from the template catalogue), a unique name, a class@version, optional placements on the timeline, optional flags, parameters and from lines that connect another block's output port to one of its own input ports. The blocks and their from lines form a directed acyclic graph that the engine builds into audio.

File kinds

Conformance

A tool conforms to spec 0.1 when it passes the corpus in spec-tests/: the same diagnostics (code, severity, range) for every case in invalid/, no errors for every case in valid/, identical output for format/, roundtrip/ and the recovery expectations in recovery/.

02 Lexical structure

Text

• Encoding UTF-8, no BOM required (a BOM is accepted and removed by the formatter). Line endings \n or \r\n; the formatter writes \n.
• The language is line oriented: one statement per line, except a block, which opens with a header line ending in { and closes with } alone on a line.
• Positions are 1-based line and column, columns counted in characters (code points). The language server converts to UTF-16 for editors. A diagnostic range is [col, endCol) on one line.

Comments

# starts a comment that runs to the end of the line. A comment that reads # ample-ignore L001, L005 silences those lint rules for the next block (08). Comments are preserved by the formatter.

Names

• identifier: one or more of letters, digits, _ and -. Examples: drums, kit, lm_seed, master-seed, felt-piano.
• string: double quoted, with the escapes \", \\, \n, \t; any other backslash sequence stands for the escaped character itself (a parser never fails on an escape). A name is an identifier or a string; use a string when the name contains spaces or other characters.
• Block names are compared exactly (case sensitive); two names that differ only by case trigger lint rule L008.

Numbers

integer is digits; number is digits with an optional .digits. There are no negative literals in structure positions (tempo, bars, seeds); a parameter value is free text and may contain a leading - (for example -4 dB). Seeds are unsigned 64-bit integers from 0 to 18446744073709551615.

Keywords

Keywords are reserved only in their own position (a block may be named at if it is quoted). The list is in ../../spec/tokens.json: project features lint layout tempo master-seed at for as from bake lock refresh freeze seeds plan stable pinned live on off assist diff button auto info warning error.

Operators and punctuation

{ } , . -> @. -> and . appear only in from lines; @ only in class@version; , only between placement parts and inside nothing else.

Limits (spec 0.1)

Tempo 20 to 300. Project master seeds and block seeds range from 0 to 18446744073709551615. Bars start at 1; a part is at least one bar; a part reaching past bar 1024 is a warning (AMP5002), not an error.

03 Syntax

The grammar below is the same text as ../../spec/grammar.ebnf (a test compares them). It describes the structure; the meaning of block types, parameters and ports comes from the template data (05).

(* AMPLE source grammar, spec version 0.1 (draft, provisional). One statement per line; blocks span lines.
   Notation: ISO-style EBNF; "..." terminals; [ ] optional; { } repetition; ( | ) choice; (* *) comment.
   The prose in docs/language/03-syntax.md contains the same grammar; validate-spec checks they are equal. *)

file        = { line } ;
line        = blank | comment | project | features | settings | lint | layout | use | block ;
blank       = eol ;
comment     = "#" , { any-char } , eol ;
ignore      = "#" , "ample-ignore" , rule-code , { [ "," ] , rule-code } , eol ;

project     = "project" , string , "{" , "tempo" , number , "master-seed" , integer , "}" , eol ;
features    = "features" , "{" , { feature-pair } , "}" , eol ;
feature-pair = module , ( "on" | "off" ) | "assist" , assist-level ;
module      = "quality" | "credits" | "signing" | "secrets" | "lyrics" | "git-mirror" ;
assist-level = "off" | "diff" | "button" | "auto" ;
settings    = "settings" , "{" , { setting-pair } , "}" , eol ;
setting-pair = identifier , "." , identifier , whitespace , ( string | setting-atom ) ;
setting-atom = { any-char-except-space-or-brace } ;
lint        = "lint" , "{" , { rule-code , level } , "}" , eol ;
level       = "off" | "info" | "warning" | "error" ;
rule-code   = "L" , digit , digit , digit ;
layout      = "layout" , name , integer , integer , eol ;

use         = "use" , module-ref , "as" , name , "{" , eol , { use-line } , "}" , eol ;
module-ref  = ( identifier , { "/" , identifier } | string ) , [ "@" , version ] ;
use-line    = blank | comment | parameter | from ;

block       = block-header , "{" , eol , { block-line } , "}" , eol ;
block-header = block-type , name , class-version , [ placement ] , { flag } , [ freeze ] ;
block-type  = identifier ;
class-version = class , "@" , version ;
class       = "stable" | "pinned" | "live" ;
version     = digit-run , { "." , digit-run } ;
placement   = "at" , part , { "," , part } ;
part        = integer , "for" , integer , [ "as" , name ] ;
flag        = "bake" | "lock" | "refresh" | "disabled" ;
freeze      = "freeze" , ( "seeds" | "plan" ) ;
block-line  = blank | comment | parameter | from | expanded-midi-notes | embedded-sequence ;
expanded-midi-notes = "notes" , "{" , eol , { comment | midi-note } , "}" , eol ;
embedded-sequence = "sequence" , "{" , eol , { sequence-line } , "}" , eol ;
sequence-line = { any-char-except-eol } , eol ;
midi-note   = "note" , "{" , eol , { comment | midi-note-field } , "}" , eol ;
midi-note-field = identifier , value-text , eol ;
parameter   = identifier , value-text , eol ;
from        = "from" , name , "." , name , "->" , name , eol ;

name        = identifier | string ;
identifier  = letter-or-digit-or-dash-or-underscore , { letter-or-digit-or-dash-or-underscore } ;
string      = '"' , { string-char | escape } , '"' ;
escape      = "\" , ( '"' | "\" | "n" | "t" ) ;
number      = digit-run , [ "." , digit-run ] ;
integer     = digit-run ;
value-text  = { any-char-except-eol } ;

(* A module file, modules/NAME.module: the declarations first, then ordinary blocks and nested use statements.
   Inside the module, "from in.<input> -> port" reads a module input; "$name" in a value stands for a parameter. *)
module-file = { blank | comment } , module-decl , { blank | comment | param-decl | input-decl | output-decl | block | use } ;
module-decl = "module" , module-ref , "version" , version , eol ;
param-decl  = "param" , identifier , value-text , eol ;
input-decl  = "input" , identifier , eol ;
output-decl = "output" , identifier , name , "." , name , eol ;

Statements

Finals are project metadata kept in .ample/finals.json and managed through the Finals view or API; they are not a statement or block in the AMPLE song language.

Blocks

drums beats stable@1.2 at 1 for 8 as intro, 9 for 8 as outro lock {
  kit kit/tape
  from chords.notes -> trigger
}

• Header order is fixed: type, name, class@version, placement, flags, freeze.
• Placement: at <bar> for <bars> [as <name>], several separated by commas. Parts of one block may not overlap (lint L004).
• Flags: bake (the take is stored and used), lock (the value is kept), refresh (always fetch again), disabled (the block produces no take). A connected block that requires a disabled block is implicitly disabled with the warning AMP5253; an unconnected disabled block is simply omitted. lock with refresh is contradictory (L003).
• Freeze: freeze seeds or freeze plan (06).
• Body lines: a parameter is name value (the value is the rest of the line, free text, validated by the template); a from line is from <block>.<output> -> <input>. A parameter name appears once per block.
• The closing } is alone on its line.

Expanded MIDI notes

Only midi-clip may use a nested notes body. It represents the same notes as the compact notes parameter and remains in source after editing:

midi-clip verse stable@1.1 {
  ppq 480
  notes {
    # comment stays with this note
    note {
      bar 18
      start 22
      length 72
      pitch 121
      velocity 96
      channel 5
      bank 0
      program 60
      tie-id 2
    }
  }
}

bar is one-based. start and length use quarter-note beats (up to six decimal places) when ppq is absent or uses the legacy million-unit scale; otherwise they use integer ticks at the clip's ppq. pitch is 0–127 and velocity is 1–127. channel, bank and program are optional as a complete set; tie-id is optional and identifies bar-split segments. The clip remains in 4/4 for note placement; imported meter events stay available in the MIDI event source. # comments are retained verbatim and ignored when building note data.

Error recovery (normative)

A conforming parser never stops at the first error and never throws on any input. Required behaviour:

1. A line that is not any statement reports AMP1100 and parsing continues with the next line.
2. A bad block header reports an error (AMP1102-AMP1106); the block body is still consumed up to its } so later blocks are found. If the header yielded a type and name, the block is kept in the tree (so the editor can still show it); otherwise its body is skipped.
3. A bad body line (AMP1107-AMP1109) does not remove the block; the rest of the body is parsed.
4. An unclosed block at the end of the file reports AMP1101 at the block header and keeps the block.
5. Semantic checks (AMP2xxx, lint) run on everything that parsed, even when syntax errors exist; blocks that are known to be broken (skipped) take no part in them.
6. The order of diagnostics in the output is by position (line, column, then code) when a tool prints them; implementations may produce them in another order internally, and the corpus compares them as a set sorted by (line, column, code).

The recovery corpus (../../spec-tests/recovery/) fixes the expected blocks and codes for broken inputs.

Modules (use and module files)

use <module>[@version] as <name> { ... } puts an instance of a reusable module into the song. The body gives the module's parameters (name value) and connects its inputs (from block.output -> input, where the last word is the module's input name). Other blocks read the instance like a block: from intro.audio -> mix, where audio is one of the module's outputs. The parser only checks the shape; the module is found and expanded when the song is built (ample modules expand, 07).

04 Types and ports

A connection can be temporarily switched off without removing it: from kit.audio -> in disabled. The canvas retains it as a dimmed dashed line; its context menu enables it again. Disabled connections supply no input and do not create active build dependencies. Mixer inputs are optional; a mixer processes the active channels, or produces no take when none remain. Required consumers and audio/render effects with their main input switched off become implicitly disabled. Enabling a connection restores its original endpoints.

Every block template declares input ports and output ports, each with a type. The types of spec 0.1 are in ../../spec/types.json:

Connection rule

from <block>.<output> -> <input> connects when the output type and input type are equal, or either is any, except that render only connects to render. This keeps source recipes distinct from materialized audio even at group boundaries. There are no implicit conversions. A mismatch is AMP2007.

Render recipes

Audio sources expose audio and render outputs. audio is the ordinary built sound. render carries an immutable recipe for that source and does not change its ordinary take. Effects accept either active in:audio or active render_in:render; both connections may be present when one or both are disabled. An effect can pass the recipe onward through render or materialize it at its existing audio output.

drums.render -> eq.render_in -> reverb.render_in
reverb.out -> mixer.in1
drums.audio -> mixer.in2

The effect chain is collected in order and the source is rendered with those effects when its audio output is consumed or the final effect is explicitly built. Intermediate render links create no takes. The mixer receives the effected variant on in1 and ordinary drums on in2. Two render branches remain independent. Connecting drums.audio -> eq.in keeps the existing post-render effect path.

The plan and cache identity include the source and its inputs, then the ordered effects and parameters. A changed effect rebuilds its variant and dependent audio consumers. render is not MIDI/events, and any cannot convert it.

Port rules

• An input takes one source (AMP2008 for a second). To combine several sources use a mixer-like block.
• A block cannot read itself (AMP2009); the graph must be acyclic (AMP2010, with the cycle path in the message).
• A required input with no source is lint rule L002 (a warning by default): the template marks which inputs are required.
• Naming a missing block, output or input is AMP2004, AMP2005, AMP2006; the hint lists the valid names.
• Output ports may stay unconnected. Unused outputs are lint rule L001 (info); audio that never reaches a master block is L007.

Groups

A group block has one any input and one any output and may contain an inner graph that is edited in the node editor. Inner graphs are not part of the .amplet text in spec 0.1.

05 Blocks and templates

A template defines a block type: its ports, parameters, class, version, whether it is dynamic, and which plugin it needs. The catalogue is data: one file per template in ../../spec/templates/<id>.json, validated by ../../spec/schema/template.schema.json. The generated help (help.html) renders one card per template; this page defines the rules.

The provisional voice-clone block reads a project voice sample from file and speaks its text. model selects XTTS, Qwen3 or Chatterbox; language is passed to that model. Qwen3 additionally needs reference_text, unless auto_detect on is selected. The sample is hashed into the build plan, so changing it invalidates the generated take. Common audio formats are accepted and converted to WAV internally when needed. Model weights are configured locally and are not downloaded by the plugin.

Class and version

Every block header carries class@version:

The version is dotted numbers (1.2, 0.9). The template states its current version; a block states the version it uses.

Parameters

splitter stable@1.0 takes audio in and exposes mono audio outputs left and right. It preserves channel level and duration; mono input is duplicated onto both outputs. The node preview plays the original input. Connect a render chain's materialized audio output to the splitter; the splitter itself does not forward render recipes.

splitter channels stable@1.0 {
  from level.out -> in
}
eq left_eq stable@1.0 {
  from channels.left -> in
}
eq right_eq stable@1.0 {
  from channels.right -> in
}

The volume stable@1.0 effect accepts either audio in or render_in. It exposes three fixed audio outputs: left and right are individual mono output channels; mixed contains both output channels as stereo. The render output continues the recipe. The earlier out identifier remains a source compatibility alias for mixed, hidden on the canvas. The block preview plays the mixed output.

The two channel faders use left_gain and right_gain (−60 to +12 dB, default 0). With linked on (default), moving either fader moves both by the same amount and preserves their difference, stopping at the shared bounds. Properties can set exact values independently. Linking is a UI setting and does not alter audio by itself. The existing gain parameter remains a common gain, default 0 dB. Positive gain can clip rendered PCM.

mono on averages the input channels before applying common gain, separate channel gains and mutes. Left and right remain separate ports with their connections intact; turning mono off restores stereo routing. left off and right off silence their respective output channels. Mono input feeds both channels. All settings are available in source and Properties; the canvas and Advanced panel provide L/R faders, meters, mutes and Mono. enabled off bypasses processing while preserving every output.

volume level stable@1.0 {
  left_gain -3 dB
  right_gain -6 dB
  linked on
  left on
  right off
  mono off
  from kit.audio -> in
}

• A block accepts only the parameters its template lists (AMP2003 otherwise; the hint lists the valid ones).
• The template gives each parameter a type (number or text) and a default. A missing parameter takes the default.
• A parameter appears once per block (AMP1109).
• Seed parameters (seed, lm_seed) are the word derived or an unsigned 64-bit integer 0 to 18446744073709551615 (AMP2011). A custom seed is allowed and recorded (L009).
• A template may declare modalEditor: true for text that benefits from the property's expanded … editor, and multiline: true when line breaks are meaningful. Multiline values are stored as the existing \n source escape and restored as line breaks by the property editor; a single-line value visibly wraps but line breaks are converted to spaces when saved.
• A template may declare affectsOutput: false on a parameter that is an execution policy rather than a sound setting: a hint about how the renderer gets to its result (for example a time/memory trade-off) where every option gives byte-identical audio. It defaults to true. A studio panel may show such parameters apart from the musical controls (denoise's optimize does); a renderer that sets it false must prove the claim (same input, same output, for every option) before relying on it, since nothing else enforces it.

The universal block header flag disabled is independent of template parameters and effect enabled off bypass. It keeps the block visible but returns no take. Blocks depending on its required inputs, including audio and render effect chains, become implicitly disabled without a build failure; the block reports the warning AMP5253 so it is visible why it produced nothing. Optional inputs, such as mixer channels, omit the disabled branch so other channels can still render. A mixer with no connected inputs or only disabled inputs produces no take and is implicitly disabled. Implicit disabling is derived from connections and disappears when an upstream input becomes active; it does not write a disabled flag into downstream source.

Audio sources expose a render output alongside ordinary audio. Built-in audio effects accept an audio in for post-render processing or a render_in recipe for a source variant. Both connections may be present when at least one is disabled; only active connections determine the effect input. The next audio connection materializes the whole recipe as a variant take; explicitly building a render-connected effect also materializes that effect's variant. Intermediate render links create no takes. Effects remain independent blocks with their own parameters.

Block takes use local time: their first placed part starts at local bar 1, without leading silence from the arrangement position. Moving the whole block preserves its take and the takes of its audio/render effects; relative gaps between multiple parts remain part of its content. Mixer and master inputs apply arrangement placement and range cropping, and their plans include that placement. Moving a block invalidates the arranged mix, which can be regenerated using cached local takes. The local-v1 plan marker separates these takes from earlier song-length renders; existing selected frozen takes retain their original content until explicitly replaced.

The midi-clip template also accepts an optional structured notes value. It can be a space-separated list of bar:beat:length:pitch:velocity entries or a persistent notes { note { ... } } body with named fields. Beat and length use quarter-note beats with up to six decimal places by default; set ppq to use exact integer ticks per quarter note instead. Eight-field entries can append channel:bank:program to retain source instrument routing; generated nine-field entries add a tie identity so bar-split sustains remain distinct from repeated notes. A compact entry may append ;pan=, ;fine=, ;rel=, ;cut=, ;slide= or ;port=; the language server completes these keys after a semicolon, and invalid values produce AMP2012. The expanded body accepts bar, start, length, pitch, velocity, optional routing fields and optional tie-id; # comments stay in source beside the note or field they describe. Notes are polyphonic, must fit within one 4/4 bar, and represent a tie across a bar as one entry in each bar. GM/SF2, synth and sample-set piano/bass/guitar render per-note expression; slide renders a glide without a retrigger. MIDI module import/export retains supported note-start expression and writes pitch-bend ramps for slide notes. Portamento settings round-trip as CC65/CC5; renderer portamento is not implemented. The empty default keeps existing chords and melody behavior unchanged.

Compact notes additionally accept ;tie=N (integer 0 through 2000000) to join consecutive bar-split pieces without explicitly setting channel, bank or program. Expanded tie-id also works without routing fields. Nine-field ties remain supported; writing both forms on one entry, or repeating tie, is invalid. A long piano-roll note is stored as these valid bar segments; the editor merges them for display and resizing. This preserves the connected instrument's inherited routing when a note grows over a bar line.

The midi block exposes notes, the complete typed sequence, and audio ports. Connect the sequence to midi-render to render the file through a project SF2 file or the installed GM pack with a gain control. MIDI, midi-render and GM instrument blocks default to an integer soft limiter before PCM output; set limiter off only when hard clipping is wanted. The song mixer also soft-limits summed inputs. If an SF2 bank lacks a source bank/program, the GM renderer uses the matching GM program (or piano) and reports the fallback. The notes port remains available for piano, GM and other instrument blocks.

The midi data block reads a project .mid or .midi file. Its track parameter is all or a zero-based track index; its notes:midi output has the same shape as midi-clip, and its optional warnings:text output describes unsupported note-adjacent events. The block may also retain source-file, variant-file and variant-module for an editable MIDI variant: Edit MIDI variant opens the module, saving it exports a new active MIDI asset, and the context menu can switch between Original and Edited.

File parameters and what can be dropped on them. A parameter of kind: file lists the extensions it takes in accept (for example .mid, .midi for the file of midi; .sf2 for gm and midi-render); a parameter of kind: sampleset takes a folder. The web app uses these lists to decide which blocks a file can be used in (Use in song, drag and drop). A new file parameter that should take drops needs an accept list.

Fades: fadein, fadeout and the fade and crossfade blocks

A fade is a value that goes from silence to full (a fade in) or from full to exact silence (a fade out). It is written as the value of a volume gain or of the mix of an effect:

volume v stable@1.0 {
  from drums.audio -> in
  gain fadeout(5, 2, equal)      # from bar 5 over two bars, ends in silence
}

• fadein(start, length [, shape]) and fadeout(start, length [, shape]). A fade in is silent before its start and full after its end; a fade out is full before its start and exactly silent after its end.
• Units: a plain number is bars (5 is the start of bar 5, 5.5 is half way through it; the start counts from bar 1; the length 0.5 is half a bar). A number with an s is seconds (12s, 1.5s); a start in seconds counts from the beginning of the song. Start and length may use different units. Up to six decimals.
• Shapes: lin (a straight line in volume, the default), equal (equal power: a fade in and a fade out of the same length add up to constant power for unrelated sounds, so use it for a crossfade) and exp (starts slowly, ends fast).
• All arithmetic is integer, so every machine gets the same bytes. A fade on a pan, a cutoff or a threshold is refused with AMP5371.

The fade block does the same with one audio input and one output (direction out or in, start, length, shape). The crossfade block has two inputs, a and b: a fades out and b fades in over the same stretch (start, length, shape, equal power by default). Both build the same fade text and use the same engine as the formula, so a block and a formula with the same settings give the same bytes. The curve editor (the ∿ button) has a Fade… button for a gain and a mix.

Patterns and sections. drums and guitar take two optional parameters, patterns (named patterns, name=grids / name=grids) and song (the sections in order, verse*4 fill chorus*8); see Samples.

Time stretch. stretch.speed is a percentage from 25 to 400; 50 plays at half speed and keeps pitch. It also accepts auto(bar:percent, ...), such as speed auto(1:100, 9:50), for a linear speed ramp by bar. The rendered block keeps its length. This does not change the project's tempo.

Dynamic blocks and plugins

A template can be dynamic (its result can change, for example an AI take) and can require a plugin. A block whose plugin is not installed is AMP5001, a warning: AMPLE reports it instead of silently skipping the block. Plugins are listed in ../../spec/plugins.json (opt-in or built in).

The catalogue (spec 0.1, provisional)

midi-clip, midi, gm, synth (a small subtractive synth on MIDI notes), sampler (one sample played on notes, moved in pitch from a root note), import-audio (plays a WAV file of the project), the MIDI effects transpose, midi-humanize, quantize, arpeggiator and chord (notes in, notes out, between a clip and an instrument), send (a shared effect bus: through and send outputs), drums, bass, piano, the effects eq, distortion, delay, reverb, compressor, filter, limiter, width, pan, gate, deesser, chorus, flanger, phaser, bitcrusher, pitch, stretch and duck (audio in, audio out, with an enabled off bypass), ai-voice, ace-music, mood-scene, choir, lyrics, weather, import-audio, mixer, master, variants, scorer, group. gm plays a zero-based General MIDI program and bank from the installed MuseScore General SF2 pack or a project-local .sf2 file. ai-voice is for isolated vocals: its voice parameter is a vocal direction, not a selected speaker identity, and it requires linked lyrics. Both ACE blocks expose guidance (CFG) as a stored generation parameter, visibly resolved to 7 for Base/SFT and 1 for Turbo; changing it changes the requested ACE guidance scale and can change the sound. Keep it fixed when comparing seeds. ace-music intentionally allows accompaniment and has optional lyrics, so it can make an instrumental. mood-scene.style supplies reusable scene direction to either ACE block. Adding or changing a template is a language change (99).

Filter wobble. A filter block can move its cutoff with lfo_rate (off, 1/1 through 1/32, and triplet rates 1/4t, 1/8t, 1/16t), lfo_depth (0–8 octaves above the base cutoff), and lfo_shape (sine, triangle, saw, square). The oscillator phase follows the song bar, so rendering a selected range keeps the same phase as rendering the whole song.

Example

project "demo" { tempo 92  master-seed 424242 }
midi-clip chords stable@1.0 {
  chords Am F C G
}
piano piano pinned@2.0 at 1 for 8 as verse {
  from chords.notes -> notes
}

06 Seeds and determinism

The explanations live in determinism, controllability and regeneration safety; this page states what the language says.

Master seed

project "name" { ... master-seed N } sets the master seed (unsigned 64-bit integer 0 to 18446744073709551615). Explicit block seeds use the same range; derived follows AMPLE's stable generator. Every block with random behaviour derives its own seeds from the master seed and a stable path (block identity and purpose), so a song is a pure function of its text and its recorded takes. The derivation uses the stable integer-only generator specified in chunk 30; its algorithm and test vectors will be added here and are frozen once released (rngVersion).

Seed parameters

A block may set seed or lm_seed to derived (default) or to a number. A number is a custom seed: allowed, recorded, and reported as lint L009 (info). Changing a seed later means takes made with the old one cannot be reproduced from the new one.

Flags and freeze

bake is the top of the freeze ladder (free, seeds, plan, take). freeze and bake are mutually consistent: a baked block needs no freeze word (the serializer omits it).

What the language does not promise

Regenerating an AI block is only guaranteed to give the same result on the same machine and toolprint. Notices AMP5101 and AMP5102 say so (08); the stored take is what guarantees the song.

Algorithms (RngVersion 1, frozen once released)

• Seed expansion: SplitMix64 (state += 0x9E3779B97F4A7C15; z = (z ^ z>>30) * 0xBF58476D1CE4E5B9; z = (z ^ z>>27) * 0x94D049BB133111EB; output z ^ z>>31). A seed is expanded into four 64-bit state words by four calls.
• Stream: xoshiro256** (result = rotl(s1 * 5, 7) * 9; t = s1 << 17; s2 ^= s0; s3 ^= s1; s1 ^= s2; s0 ^= s3; s2 ^= t; s3 = rotl(s3, 45)).
• Bounded integers: unbiased by rejection: discard values below (2^{64 - bound) mod bound, then take the value mod bound. Unit fractions: the top 53 bits as an integer divided by 2}53 (the only floating-point step; both numbers are exact). Shuffle: Fisher-Yates from the end, j = bounded(i + 1). Pick: bounded(count).
• Seed derivation: SipHash-2-4 with key (k0 = master seed, k1 = 0x414D504C45534545, the ASCII text "AMPLESEE") over the bytes: the RngVersion byte, then for each path part either 0x01, the UTF-8 length as 4 bytes little endian and the UTF-8 bytes (a string), or 0x02 and the value as 8 bytes little endian (a non-negative integer). The 32-bit seed is the low 32 bits.
• Verification: the vectors in spec-tests/prng/vectors.json (generated by ample/tools/gen-prng-vectors.mjs, checked against the published SplitMix64 outputs for seed 1234567 and the SipHash-2-4 paper vector) are tested by the C# code (Ample.Core.Random) and the JavaScript twin (web/lib/stable-rng.js). Changing any of this creates a new RngVersion; plans store the version they used.

Guarantee layers

1. A stored take plus the deterministic mix is bit-identical (hash verified).
2. Everything AMPLE renders itself is identical on every supported platform.
3. Regenerating an AI block is guaranteed only locally; the regeneration flow verifies and defaults to restoring the previous take.

What a change of the master seed reaches (2026-10-08)

The master seed only changes a block whose seed is derived from it. A block does not follow it when it has a custom seed (seed 77), when its seed is locked (the take bank keeps the locked value), or when its block type never reads a seed (clips, mixer, master, groups, lyrics, import, effects and the like): the plan of such a block carries seed 0, so it keeps its take when the master seed or the block's name changes. The editor shows the same: after a new master seed only the blocks that follow it, and the blocks that read them, lose their built state (GET /api/doc/inputs lists them as followsMaster).

07 References and modules

Names and references

• Block names are unique in a song (AMP2002) and are the only identifiers references use. A from line names <block>.<output>; both parts may be quoted when they contain spaces.
• Reference resolution is by exact name. A near miss gets a hint ("Did you mean ...?") and a quick fix, never an automatic correction.
• Apply (the editor's action) matches text blocks to the existing graph by name and type: the same name and type keeps its identity, its inside and its cache state; a new name creates a block; a name that is gone removes the block (source-and-views).

Files

Blocks that point at files (for example lyrics with file lyrics/chorus.lyr) use project-relative paths with / separators; a path never escapes the project or a registered link. Resolution order (library chunk 85): project, linked folders, the user library, installed packs. A missing file is a diagnostic with a "relocate" fix. (Built in chunk 85 as a service, not yet as a static diagnostic; see the library manager. Names are written without the file extension; the order is the project folder (<name> or assets/<name>), the project's linked folders, the user's linked folders, installed packs; codes AMP5290, AMP5291, AMP5294.)

Plugins, packs, locks

• Plugins and packs are referenced by name and version in the project and pinned by hash in ample.lock, which the tool writes and people do not edit.
• A template that needs a plugin that is not installed is AMP5001 (a warning).

Modules (spec 0.1)

features { ... } switches opt-in modules on or off: quality, credits, signing, secrets, lyrics, git-mirror; assist sets how much help the editor gives (off diff button auto). Reusable block modules are defined below (added in chunk 94).

Not yet specified

include of other .amplet files, imports of audio, MIDI or lyrics files, and the statement style of the older examples. They are tracked in open-questions.

Reusable modules (use and module files)

A module is a file modules/<name>.module in the project (or in a linked folder or pack, found the same way as other assets). Its first line says what it is, then it declares its knobs and doors, then it holds ordinary blocks:

module groove version 1.2
param kit kit/tape        # a parameter with its default
input chords              # a door the song connects
output audio mix.mix      # what the song can read: <block>.<port> inside the module

bass bass stable@1.1 {
  from in.chords -> notes # "in.<input>" reads the module's input
}
drums drums stable@1.2 {
  kit $kit                # $name stands for the parameter
}
mixer mix stable@1.0 {
  from drums.audio -> in1
  from bass.audio -> in2
}

The song uses it with use groove@1.0 as intro { kit kit/808 from chords.notes -> chords } and reads from intro.audio -> mix.

• Expansion. Before a song is built each use becomes plain blocks named <instance>/<block> (nested instances: outer/inner/block). The tool expands in memory; the song file keeps the short use. ample modules expand song.amplet prints the result.
• Seeds. A block's seed is derived from its name, so the seeds of an instance depend on the instance path: the same module used twice gives two different sets of seeds, each stable, and renaming an instance changes its seeds (like renaming a block).
• Parameters. The use may set any declared parameter; the others keep their default. $name is replaced in parameter values only.
• Versions. @1.0 asks for the same major version and a minor version that is not older; no @ takes any. The versions and hashes that were used are pinned in ample.lock (a modules section); a changed module is AMP5328 until ample lock update.
• Not in a module: placement (at ... for ...) works as written but cannot be moved by the use, and a module cannot read a block of the song except through its inputs.
• Diagnostics (runtime): AMP5320 to AMP5328 are reported at the use line. The editor (parser) does not load modules; it accepts the shape of use and references to an instance.

08 Diagnostics and lint

The catalogue of codes is data: ../../spec/diagnostics.json (code, severity, title, explanation, wrong and right example, since, stage) and ../../spec/lint-rules.json. The generated help renders every code on its own anchor (help.html#AMP2003); ample explain AMP2003 prints the same text. This page defines the rules around them. Background: language-support.

The record

Every diagnostic has: code, severity (error, warning, info), a range (line, col, endCol, 1-based, one line), message (one plain sentence), optional hint, optional related (another place that matters), and optional fixes (a label and a text edit, marked safe or risky).

Code ranges

Stability: a code is never reused. A retired code stays in the catalogue (retired: true). Each code's stage is static (found by reading the song) or runtime (found by running or regenerating). Messages may be reworded; codes, severity and ranges are the contract.

Severity and blocking

error blocks Apply and leaving the source editor. warning and info never block. A lint rule raised to error blocks like any error.

Ranges

A diagnostic points at the smallest range that is wrong (the parameter name, not the whole line). Where a code can point at two places the range is the one the message talks about; the other is related.

Lint rules

Nine rules in spec 0.1 (see lint-rules.json for names, defaults and descriptions): L001 unused-output, L002 missing-input, L003 lock-and-refresh, L004 overlapping-parts, L005 dynamic-not-fixed, L006 pinned-outdated, L007 no-path-to-master, L008 name-case-clash, L009 custom-seed.

• Level per rule in the song: lint { L004 error L005 info } (only entries that differ from the default). Unknown rule AMP1007, bad level AMP1008.
• Suppression: a comment # ample-ignore L004, L005 silences those rules for the next block only.
• Lint runs only on blocks that parsed; it never changes the sound.

Notices about regeneration

AMP5101 (info): regeneration is only guaranteed to give the same result on this machine with the same plugin, model and GPU setup. AMP5102 (warning): the toolprint differs from the one that made the take, or the plugin's determinism is unverified. Both are runtime stage; the exact wording is in diagnostics.json and is shown by the UI, the CLI and the help (regeneration safety).

Output formats

Text (for people), JSON (the record above, one per diagnostic) and SARIF (later). The corpus compares JSON records as a set sorted by (line, col, code).

09 Formatting

The output of the formatter is the canonical form. ample fmt rewrites a file to it; the language server's formatting does the same; the corpus (../../spec-tests/format/ pairs and roundtrip/ files) defines it by example.

Rules (spec 0.1)

1. UTF-8, \n line endings, no trailing whitespace, exactly one final newline; a BOM is removed.
2. Indentation is two spaces inside blocks; tabs are replaced.
3. Blank lines: a run of blank lines collapses to one; blank lines inside a block are kept as one.
4. Single spaces between words in a header, between a parameter name and its value, and around ->; no space before , and one after it.
5. Brace lines (project, features, lint) read keyword { pair pair }: one space inside the braces, two spaces between pairs.
6. A block header ends with {; the closing } is alone on its line.
7. Comments are preserved exactly, except that trailing whitespace is removed and the line is indented to its context (no indent at top level, two spaces inside a block). A comment after code on the same line is not part of the language (it would make the line unreadable to the parser).
8. The formatter never reorders statements, parameters or from lines, and never changes values or names.
9. The formatter is idempotent: formatting its own output changes nothing, and parsing then printing a canonical file gives the same bytes (round trip).

Behaviour on broken input

The formatter formats everything it understands and leaves a line it cannot parse unchanged (besides trailing whitespace and indentation inside blocks). It never refuses.

10 Lyrics format

Status: only partly specified. The own lyric format .amplelrc (all lyric information in one extensible structure: words, line and word timing, syllables, sounds, singers, language, notes; it states format: amplelrc and a version) is decided in principle (decisions, "Lyric formats") but its field-by-field layout is still open design work (open-questions).

What exists in the mock (provisional)

The sketch's lyrics block points at a plain file (lyrics/chorus.lyr) with one line per row, written [bar 9] text. The file is the canonical source: the Lyrics editor reads and writes it, and linked AI voice or ACE music blocks receive its marker-free words. The old text parameter remains as a compatibility fallback only when the file is absent or empty; it is not edited by the Lyrics editor. The editor checks live: the first line within 5 seconds, lines in order, lines outside the block's placement, empty lines, long lines, too many words for the gap.

Importers (planned, not part of the grammar)

.lrc, enhanced .lrc, .srt/.vtt, TextGrid and aligner JSON convert to and from .amplelrc (chunk 20 and later).

Plan

This page becomes normative when .amplelrc is designed: a JSON Schema in ../../spec/schema/, a conformance corpus under ../../spec-tests/lyrics/, and the checks listed above as diagnostic codes.

11 Versioning and compatibility

Spec version

../../spec/version.json holds specVersion (major.minor) and status (draft or stable). A song does not state a language version in spec 0.1; the first line of a future file may (reserved).

• Patch-level wording fixes do not change the version.
• Minor versions add things in a backward-compatible way (a new template, a new optional parameter, a new diagnostic code).
• Major versions break compatibility and come with a migration note in CHANGELOG.md.
• Before 1.0 a minor version may break; every break has a migration note and the tool offers ample migrate once real songs exist.

Stability of the data

• Diagnostic and lint codes are never reused or renumbered; retired codes stay listed.
• Template ids are never reused; a template is provisional, stable, deprecated or retired, with since and optionally deprecated (the version and the replacement).
• The canonical plan form and the stable random generator are frozen once released and carry their own version (rngVersion); see 06.

Compatibility promise (at 1.0)

A song that is valid at 1.x stays valid at every later 1.y and builds to the same take references; deprecated features keep working with a warning for at least one minor version.

File format versions

.amplet, .amplelrc, .ample exports and plugin.json each carry a format version; opening an older format runs a migration with a backup copy first (project-management).

99 Maintaining this specification

The language specification must be kept true for as long as AMPLE exists. It is the one place where parser, linter, language server, formatter, help generator and UI agree on what the language is.

The rules

1. The spec is normative. ample/docs/ pages explain; this folder and ample/spec/ define. On conflict, the spec wins and the other page is fixed.
2. A language change is five edits in one change:
   • the data in ample/spec/ (template, diagnostic, lint rule, grammar, tokens);
   • the prose page in this folder;
   • a conformance case in ample/spec-tests/ (a valid case for new syntax, an invalid case with expected diagnostics for a new code);
   • an updated example (in the page, tagged ```amplet run once the help generator executes them, chunk 12);
   • a line in CHANGELOG.md, with a migration note if it breaks anything.
3. CI enforces it: node ample/tools/validate-spec.mjs (schemas, unique ids, grammar equals prose, links, every static diagnostic and lint rule has a failing example) and, from chunk 12, ample docs check (the generated help.html is up to date and all examples compile or fail as stated). A change that breaks either is not done.
4. The help is generated, never edited by hand. It is built from this folder and ample/spec/ (chunk 12).
5. Codes and ids are never reused. Retire, do not delete.
6. Provisional is allowed, silent is not. A not-yet-decided detail is marked provisional in the data and listed in ../open-questions.md; it is never guessed in code.
7. Corpus before code. When the implementation and the corpus disagree, decide which is right, fix the spec and the corpus first, then the code. Never edit the corpus just to make a test pass.

Review points

• Whenever a chunk that touches the language is marked done, the agent re-runs validate-spec and reads README.md for staleness.
• At each milestone (M1 to M5 in the plan) the owner reviews the spec index and the changelog.
• Before 1.0: a full read-through against the working product, with every difference fixed on the side that is wrong.

Where the corpus came from

The first corpus (spec version 0.1) was generated by ample/tools/gen-corpus.mjs from the clickable sketch's mock parser, because that was the only executable reference of the mock syntax. Expected diagnostics therefore describe the mock; chunk 20's real parser must match them, and from then on the corpus is edited by hand. The templates, codes and lint rules were seeded by ample/tools/extract-spec-from-sketch.mjs and are hand-maintained now.

Language changelog

Piano-roll ties (2026-10-18)

• Compact notes accept ;tie=0..2000000 to join bar-split sustains while keeping instrument routing inherited. Legacy nine-field ties remain valid; duplicate or conflicting tie identities are rejected. Expanded tie-id also works without explicit channel/bank/program.
• The built-in midi-clip renderer is version 4 so cached note output includes the new tie semantics.

Render stream extension (implementation in progress; verification paused)

• Added the render port type, render outputs on audio sources, and render_in inputs on built-in audio effects. Effects may use their existing audio input or the render recipe input; both may be connected when one or both connections are disabled.
• Added AMP2020 for connecting both effect input modes while both are active. Source variants now retain ordered render recipes, materialize at audio boundaries, and record effect parameters and seeds in the plan. Full build, cache, UI and conformance acceptance remains in progress; testing is paused at the owner's request.
• Added docs/examples/16-audio-vs-render/, a self-contained song with matching EQ/reverb chains on ordinary audio and render paths, mixed for direct comparison.

Added in MIDI M03 (2026-10-04)

• midi-clip is version 1.1 and accepts optional structured polyphonic notes as bar:beat:length:pitch:velocity entries. Beat values use integer microbeats internally with up to six decimal places in source; ties crossing bars are split. Existing chord and melody songs are unchanged.
• Added static diagnostic AMP2012 for malformed structured MIDI note entries. Migration: none; the new parameter defaults to empty.

Added in MIDI M13 (2026-10-04)

• midi-clip retains imported note onset and duration in source PPQ ticks, including output metadata, while preserving readable beat fields.

Added in MIDI M15 (2026-10-04)

• The MIDI file template exposes note, typed sequence and audio outputs. The midi-render template accepts sequence or note input and provides a SoundFont-backed audio conversion path.

Added in MIDI M02 (2026-10-04)

• Added the midi source template for bounded .mid/.midi project files, deterministic track selection and notes:midi rendering, with a text warnings output.
• Added build diagnostics AMP5501–AMP5503 for invalid assets, unsupported exact note timing and missing track indices.

0.1 draft (2026-10-03)

• Added mood-scene (a stable style:data source) and ace-music (a live ACE-Step block with optional lyrics:text, optional melody:midi, optional style:data and audio:audio). ai-voice remains a live ACE-Step block with required lyrics and a vocal-only contract.
• Template parameters can now describe modalEditor and multiline property editing behavior. The display label and short documentation are also template data.
• Migration: existing ai-voice voice values retain their parameter name, but the UI calls it Vocal direction. Existing inline lyrics text values still render only when the linked file has no content; move new work into the Lyrics editor file.

0.1 draft (2026-10-02)

• First written specification: lexical rules, grammar, error recovery, types and ports, template rules, seeds and determinism, references, diagnostics and lint, formatting, versioning, maintenance.
• Data seeded from the clickable sketch: 14 templates, 31 static diagnostic codes (AMP1xxx, AMP2xxx, AMP5001, AMP5002), 9 lint rules, plus the runtime notices AMP5101 and AMP5102 (regeneration safety).
• Conformance corpus: 15 valid, 42 invalid (one per code and lint rule), 8 recovery, 10 format pairs, 7 round trip.
• Known gaps: the statement-style syntax of ../examples/, include and imports, .amplelrc, inner graphs of groups, defining new block types (all in ../open-questions.md).

Added in chunk 94 (2026-10-03)

• New statement use <module>[@version] as <name> { ... } and the module file format (module, param, input, output); new static code AMP1110 and runtime codes AMP5320 to AMP5328; keyword use. Nothing that parsed before changes meaning (a block type called use did not exist). Migration: none.

Added after chunk 98 (2026-10-03)

• drums is now 1.3 (S07): optional choke parameter (open:hat,pedal; rules separated by ;) cuts a voice when a closing voice is hit, with a 7 ms fade. Sample folders may hold a set.json with gain (dB) and tune (semitones) for the whole set. Songs that say drums ... stable@1.2 stay valid (the class is stable, not pinned). Migration: none.
• Sampler velocity layers (S05): sample files name_v<L>_r<R>.wav are layer L, round robin R; accents, strokes and note velocity choose the layer. melody notes take an optional third field, the MIDI velocity (c4:1:110, default 96, unchanged output). Round robins (S06) are chosen per hit from a separate seeded stream (no change to humanize bytes). Built-in drums, bass, piano and guitar renderers are version 2. Migration: none, folders without layer files sound the same.
• Template parameters can say how the property panel edits them: kind (text, number, choice, combo, seed, sampleset, file, pattern, channels) with options, min, max, step, unit, placeholder, accept and count. Parameters no longer start with made-up text; an empty value shows a placeholder. Migration: none, old values keep their meaning.
• Six audio effect templates (category Effects, stable@1.0): eq, distortion, delay, reverb, compressor and filter. Each has one required in:audio, one out:audio and an enabled on|off bypass. Integer arithmetic only, so they are bit-reproducible. Migration: none.
• midi-clip has an optional melody parameter (note name, octave, length in beats; r is a rest). When it is set, the clip plays the melody instead of the chords. Notes now carry beat and beats; the built-in piano plays them at that place and length (notes without them still last the whole bar). Migration: none.
• lyrics is now 1.1: the legacy inline text parameter is gone. The words live in the lyrics file, which the lyrics editor creates and names (lyrics/<block name>.lyr) the first time you open it. Migration: move old inline text into a lyrics file ([bar N] words per line) and set file; songs that still say text get AMP2003.
• piano is now 2.1 and bass 1.2: set can name a sample folder of the project (note-named WAV files, like the guitar), and both have a gain in dB. The built-in sounds are unchanged. Migration: none.
• ai-voice is now 0.10: the optional parameter sing (bars) says how long the voice sings. ACE fills all the time it is given, so a voice longer than its words repeats the last sounds; with sing the voice is made that long and the rest of the block stays silent (short fade at the end). Empty means the whole block, as before. Migration: none.
• ai-voice sing also takes the word auto: the voice is as long as the linked lyrics file needs (from the start of the block to the end of the last timed line; the last line gets as many bars as the one before it). The build replaces the word by the number, so the plan holds the real length.
• The lyrics file can hold section tags as lines of their own ([Verse], [Chorus], [Outro]). They have no bar, are not timed, are passed to ACE with the words and show as heading rows in the lyrics editor. Migration: none (such lines used to be reported as unreadable).
• ai-voice is now 0.11: the optional parameter fit (off or stretch). ACE tends to sing a little faster than the music and then runs out; stretch slows the voice down without changing its pitch so it ends where the lyrics end (at most 1.6 times as long). The factor is written into the take (voiceStretch). Default off. Migration: none.
• ai-voice 0.12 and ace-music 0.2: steps is empty by default, which takes the number of steps the chosen ACE model wants (turbo 8, sft and base 50). A block that says steps itself keeps that number. The model is a plugin setting (synthModel). Migration: none.
• New statement settings { plugin.name value ... } for the plugin settings of one song (new static code AMP1112 for a malformed line). The settings of a song are part of the plan of the blocks of that plugin, so choosing another ACE model or isolation gives a new take instead of the cached one. The plugin settings that were stored once per project (.ample/plugin-settings.json) are now only the defaults for new songs: a build reads the settings of the song, not those of the project. Migration: a song that relied on project-level settings needs a settings line (the plugin settings screen has "Use the project defaults" and "Apply and back" writes it).
• Plugins can report progress with sub-steps (ctx.progress(fraction, step, stepFraction)), shown as bars in the node editor; the server sends the event build.block. No change to songs.
• A song that lacks a setting its plugin marks as required fails its blocks with AMP5370, which names the setting and the project default; the node menu offers "Use the project default" (writes it into the song's settings line and builds again). New songs are made with + New song (POST /api/songs) and start with the project defaults in their settings line. No change to existing songs.
• New effect block duck (stable@1.0, category Effects): the sound dips at every hit of a 16-step pattern (default every beat) by depth dB and comes back over release ms, like a sidechain pumping effect. Integer gain, deterministic. Migration: none.
• ai-voice sing auto also looks at the words: the length is the smaller of the lyrics timeline and an estimate from the text (about four syllables a second plus a breath per line), so a short text is no longer stretched over a long block. Voices with sing auto get a new take once.
• ACE plugin 0.5.1: a voice or music block that sits later in the song (at 5 for 4) is now made as long as its own bars and placed where the block starts; before, the sound began at the start of the song. Voice takes are made again once.
• ACE plugin 0.6.0: the setting backend (server, cli, server-then-cli) with aceBinFolder and cliLmModel. A plugin can mark settings every song must state itself (x-songRequired); a song that does not gets the editor warning AMP2013 with a quick fix (the project default) and AMP5370 when it is built. The example songs now state acestep.backend server. Migration: songs that use ai-voice or ace-music need settings { acestep.backend server } (the quick fix writes it).

2026-10-04

• Added the midi file block with project-contained inputs, deterministic track selection, canonical notes output and unsupported-event warnings.

Block templates

Every block type of the language, generated from spec/templates/. Click a type for its ports and parameters.

project "demo" { tempo 92  master-seed 424242 }
ace-music example live@0.4 {
  solver euler
  lm_temperature 0.85
  lm_cfg_scale 2
  lm_top_p 0.9
  lm_top_k 0
  lm_seed derived
  seed derived
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
ai-voice example live@0.14 {
  fit off
  solver euler
  lm_temperature 0.85
  lm_cfg_scale 2
  lm_top_p 0.9
  lm_top_k 0
  lm_seed derived
  seed derived
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
ambience example stable@1.0 {
  enabled on
  segment 12
  crossfade 3
  variation 40
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
arpeggiator example stable@1.0 {
  enabled on
  rate 1/16
  pattern up
  octaves 1
  gate 80
}

project "demo" { tempo 92  master-seed 424242 }
bass example stable@1.2 {
  set analog-808
  pattern bass-A
  gain 0
  humanize 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
bitcrusher example stable@1.0 {
  enabled on
  bits 8
  downsample 1
  mix 100
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
bus example stable@1.0 {
  gains 0 0 0 0
  pan c c c c
  inputs 4
  gain 0
  mute off
  solo off
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
choir example stable@1.0 {
  voices 3
  spread 12%
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
chord example stable@1.0 {
  enabled on
  type major
  inversion 0
}

project "demo" { tempo 92  master-seed 424242 }
chorus example stable@1.0 {
  enabled on
  depth 5 ms
  period 1500 ms
  mix 50
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
compressor example stable@1.2 {
  enabled on
  threshold -18 dB
  ratio 4
  attack 10 ms
  release 120 ms
  makeup 0 dB
  keyFilter 0 Hz
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
convolution example stable@1.0 {
  enabled on
  ir file
  mix 30
  predelay 0
  length 3
  level 0
  normalize on
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
crossfade example stable@1.0 {
  start 1
  length 2
  shape equal
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
cut example stable@1.0 {
  enabled on
  loop off
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
deesser example stable@1.0 {
  enabled on
  frequency 6000 Hz
  threshold -30 dB
  ratio 4
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
delay example stable@1.0 {
  enabled on
  time 250 ms
  feedback 35%
  mix 30%
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
denoise example stable@1.0 {
  enabled on
  reduction 12
  sensitivity 50
  noise auto
  learn 0.5
  learn_from 0
  channels auto
  optimize auto
}

project "demo" { tempo 92  master-seed 424242 }
distortion example stable@1.0 {
  enabled on
  drive 12 dB
  mode soft
  tone 8000 Hz
  level 0 dB
  mix 100%
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
drums example stable@1.5 {
  kit kit/tape
  pattern beat-A
  bars 16
  swing 0
  humanize 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
duck example stable@1.0 {
  enabled on
  depth 10 dB
  release 160 ms
  pattern x...x...x...x...
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
eq example stable@1.0 {
  enabled on
  low 0 dB
  mid 0 dB
  high 0 dB
  low_hz 250 Hz
  high_hz 3000 Hz
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
fade example stable@1.0 {
  enabled on
  direction out
  start 1
  length 2
  shape lin
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
filter example stable@1.0 {
  enabled on
  type lowpass
  cutoff 1000 Hz
  lfo_rate off
  lfo_depth 0 oct
  lfo_shape sine
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
flanger example stable@1.0 {
  enabled on
  depth 2 ms
  period 2000 ms
  feedback 50
  mix 50
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
gate example stable@1.0 {
  enabled on
  threshold -50 dB
  attack 5 ms
  hold 80 ms
  release 150 ms
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
gm example stable@1.0 {
  file samples/musescore-general/MuseScore_General.sf2
  bank 0
  program 0
  channel -1
  gain 0
  limiter soft
  level auto
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
granular example stable@1.0 {
  enabled on
  grain 120
  density 40
  scatter 60
  pitch 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
group example stable@1.0 {
}

project "demo" { tempo 92  master-seed 424242 }
guitar example stable@1.0 {
  strum D...D...D.u.D.u.
  voicing open
  stagger 22
  gain 0
  humanize 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
import-audio example stable@1.0 {
  loop off
  fingerprint content
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
join example stable@1.0 {
  enabled on
  seconds 0.5
  beats 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
limiter example stable@1.0 {
  enabled on
  ceiling -1 dB
  release 100 ms
  lookahead 5 ms
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
lyrics example stable@1.1 {
  lang nl
  timing per-word
  first5s check
}

project "demo" { tempo 92  master-seed 424242 }
master example live@1.3 {
  limiter -1 dB
  target -14 LUFS
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
meter example stable@1.0 {
  enabled on
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
midi-clip example stable@1.1 {
  ppq 1000000
  scale none
  bars 8
}

project "demo" { tempo 92  master-seed 424242 }
midi-humanize example stable@1.0 {
  enabled on
  velocity 10
  timing 20
}

project "demo" { tempo 92  master-seed 424242 }
midi-render example stable@1.0 {
  file pack:musescore-general
  bank source
  program source
  gain 0
  limiter soft
  track all
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
midi example stable@1.0 {
  track all
  bars 8
  limiter soft
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
mixer example stable@1.1 {
  gains 0 0 0 0
  pan c c c c
  inputs 4
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
mood-scene example stable@1.0 {
}

project "demo" { tempo 92  master-seed 424242 }
normalize example stable@1.0 {
  enabled on
  mode peak
  peak -1
  loudness -18
  max_gain 48
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
pan example stable@1.0 {
  enabled on
  pan 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
phaser example stable@1.0 {
  enabled on
  stages 4
  period 2500 ms
  mix 50
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
piano example pinned@2.1 {
  set felt-piano
  velocity natural
  gain 0
  humanize 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
pitch example stable@1.0 {
  enabled on
  semitones 0
  method wsola
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
quantize example stable@1.0 {
  enabled on
  grid 1/16
  strength 100
  lengths off
}

project "demo" { tempo 92  master-seed 424242 }
reverb example stable@1.0 {
  enabled on
  size 50%
  decay 60%
  mix 25%
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
reverse example stable@1.0 {
  enabled on
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
sampler example stable@1.0 {
  enabled on
  root 60
  mode oneshot
  release 30 ms
  gain 0 dB
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
scorer example stable@1.0 {
  limit 120 ms
}

project "demo" { tempo 92  master-seed 424242 }
scratch example stable@1.0 {
  enabled on
  pattern x.x.b...x.x.r...
  depth 120 ms
  mix 100%
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
send example stable@1.0 {
  levels -12 -12 -12 -12
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
sequencer example stable@1.0 {
  gain 0 dB
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
shift example stable@1.0 {
  enabled on
  seconds 0
  beats 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
splitter example stable@1.0 {
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
stretch example stable@1.0 {
  enabled on
  speed 100
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
synth example stable@1.0 {
  enabled on
  wave saw
  attack 10 ms
  decay 200 ms
  sustain 70
  release 250 ms
  detune 0
  cutoff 8000 Hz
  gain -6 dB
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
transpose example stable@1.0 {
  enabled on
  semitones 0
}

project "demo" { tempo 92  master-seed 424242 }
tremolo example stable@1.0 {
  enabled on
  mode tremolo
  rate 4
  sync off
  depth 50
  shape sine
  phase 0
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
variants example stable@1.0 {
  count 20
  vary seed
  channels auto
}

project "demo" { tempo 92  master-seed 424242 }
voice-clone example live@0.1 {
  model xtts
  language nl
  auto_detect off
  channels auto
}