Feat: lissajous

.github/workflows/ci.yml

@@ -81,6 +81,9 @@ jobs:
         if: runner.os != 'Windows'
         run: cargo bundle --release --features desktop --bin cagire-desktop --target ${{ matrix.target }}
 
+      - name: Bundle CLAP plugin
+        run: cargo xtask bundle cagire-plugins --release --target ${{ matrix.target }}
+
       - name: Zip macOS app bundle
         if: runner.os == 'macOS'
         run: |
@@ -122,9 +125,129 @@ jobs:
           name: ${{ matrix.artifact }}-desktop
           path: target/${{ matrix.target }}/release/cagire-desktop.exe
 
-  release:
+      - name: Upload CLAP artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact }}-clap
+          path: target/bundled/cagire-plugins.clap
+
+      - name: Upload VST3 artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact }}-vst3
+          path: target/bundled/cagire-plugins.vst3
+
+  universal-macos:
     needs: build
     if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: macos-14
+    timeout-minutes: 10
+
+    steps:
+      - name: Download macOS artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: cagire-macos-*
+          path: artifacts
+
+      - name: Create universal CLI binary
+        run: |
+          lipo -create \
+            artifacts/cagire-macos-x86_64/cagire \
+            artifacts/cagire-macos-aarch64/cagire \
+            -output cagire
+          chmod +x cagire
+          lipo -info cagire
+
+      - name: Create universal app bundle
+        run: |
+          cd artifacts/cagire-macos-aarch64-desktop
+          unzip Cagire.app.zip
+          cd ../cagire-macos-x86_64-desktop
+          unzip Cagire.app.zip
+          cd ../..
+          cp -R artifacts/cagire-macos-aarch64-desktop/Cagire.app Cagire.app
+          lipo -create \
+            artifacts/cagire-macos-x86_64-desktop/Cagire.app/Contents/MacOS/cagire-desktop \
+            artifacts/cagire-macos-aarch64-desktop/Cagire.app/Contents/MacOS/cagire-desktop \
+            -output Cagire.app/Contents/MacOS/cagire-desktop
+          lipo -info Cagire.app/Contents/MacOS/cagire-desktop
+          zip -r Cagire.app.zip Cagire.app
+
+      - name: Create universal CLAP plugin
+        run: |
+          mkdir -p cagire-plugins.clap/Contents/MacOS
+          cp artifacts/cagire-macos-aarch64-clap/cagire-plugins.clap/Contents/Info.plist \
+            cagire-plugins.clap/Contents/ 2>/dev/null || true
+          cp artifacts/cagire-macos-aarch64-clap/cagire-plugins.clap/Contents/PkgInfo \
+            cagire-plugins.clap/Contents/ 2>/dev/null || true
+          lipo -create \
+            artifacts/cagire-macos-x86_64-clap/cagire-plugins.clap/Contents/MacOS/cagire-plugins \
+            artifacts/cagire-macos-aarch64-clap/cagire-plugins.clap/Contents/MacOS/cagire-plugins \
+            -output cagire-plugins.clap/Contents/MacOS/cagire-plugins
+          lipo -info cagire-plugins.clap/Contents/MacOS/cagire-plugins
+
+      - name: Create universal VST3 plugin
+        run: |
+          mkdir -p cagire-plugins.vst3/Contents/MacOS
+          cp -R artifacts/cagire-macos-aarch64-vst3/cagire-plugins.vst3/Contents/Info.plist \
+            cagire-plugins.vst3/Contents/ 2>/dev/null || true
+          cp artifacts/cagire-macos-aarch64-vst3/cagire-plugins.vst3/Contents/PkgInfo \
+            cagire-plugins.vst3/Contents/ 2>/dev/null || true
+          cp -R artifacts/cagire-macos-aarch64-vst3/cagire-plugins.vst3/Contents/Resources \
+            cagire-plugins.vst3/Contents/ 2>/dev/null || true
+          lipo -create \
+            artifacts/cagire-macos-x86_64-vst3/cagire-plugins.vst3/Contents/MacOS/cagire-plugins \
+            artifacts/cagire-macos-aarch64-vst3/cagire-plugins.vst3/Contents/MacOS/cagire-plugins \
+            -output cagire-plugins.vst3/Contents/MacOS/cagire-plugins
+          lipo -info cagire-plugins.vst3/Contents/MacOS/cagire-plugins
+
+      - name: Build .pkg installer
+        run: |
+          VERSION="${GITHUB_REF_NAME#v}"
+          mkdir -p pkg-root/Applications pkg-root/usr/local/bin
+          cp -R Cagire.app pkg-root/Applications/
+          cp cagire pkg-root/usr/local/bin/
+          pkgbuild --analyze --root pkg-root component.plist
+          plutil -replace BundleIsRelocatable -bool NO component.plist
+          pkgbuild --root pkg-root --identifier com.sova.cagire \
+            --version "$VERSION" --install-location / \
+            --component-plist component.plist \
+            "Cagire-${VERSION}-universal.pkg"
+
+      - name: Upload universal CLI
+        uses: actions/upload-artifact@v4
+        with:
+          name: cagire-macos-universal
+          path: cagire
+
+      - name: Upload universal app bundle
+        uses: actions/upload-artifact@v4
+        with:
+          name: cagire-macos-universal-desktop
+          path: Cagire.app.zip
+
+      - name: Upload universal CLAP plugin
+        uses: actions/upload-artifact@v4
+        with:
+          name: cagire-macos-universal-clap
+          path: cagire-plugins.clap
+
+      - name: Upload universal VST3 plugin
+        uses: actions/upload-artifact@v4
+        with:
+          name: cagire-macos-universal-vst3
+          path: cagire-plugins.vst3
+
+      - name: Upload .pkg installer
+        uses: actions/upload-artifact@v4
+        with:
+          name: cagire-macos-universal-pkg
+          path: Cagire-*-universal.pkg
+
+  release:
+    needs: [build, universal-macos]
+    if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     timeout-minutes: 10
     permissions:
@@ -141,7 +264,23 @@ jobs:
           mkdir -p release
           for dir in artifacts/*/; do
             name=$(basename "$dir")
-            if [[ "$name" == *-desktop ]]; then
+            if [[ "$name" == "cagire-macos-universal-pkg" ]]; then
+              cp "$dir"/*.pkg release/
+            elif [[ "$name" == "cagire-macos-universal-desktop" ]]; then
+              cp "$dir/Cagire.app.zip" "release/cagire-macos-universal-desktop.app.zip"
+            elif [[ "$name" == "cagire-macos-universal" ]]; then
+              cp "$dir/cagire" "release/cagire-macos-universal"
+            elif [[ "$name" == "cagire-macos-universal-clap" ]]; then
+              cd "$dir" && zip -r "../../release/cagire-macos-universal-clap.zip" cagire-plugins.clap && cd ../..
+            elif [[ "$name" == "cagire-macos-universal-vst3" ]]; then
+              cd "$dir" && zip -r "../../release/cagire-macos-universal-vst3.zip" cagire-plugins.vst3 && cd ../..
+            elif [[ "$name" == *-clap ]]; then
+              base="${name%-clap}"
+              cd "$dir" && zip -r "../../release/${base}-clap.zip" cagire-plugins.clap && cd ../..
+            elif [[ "$name" == *-vst3 ]]; then
+              base="${name%-vst3}"
+              cd "$dir" && zip -r "../../release/${base}-vst3.zip" cagire-plugins.vst3 && cd ../..
+            elif [[ "$name" == *-desktop ]]; then
               base="${name%-desktop}"
               if ls "$dir"/*.deb 1>/dev/null 2>&1; then
                 cp "$dir"/*.deb "release/${base}-desktop.deb"

.gitignore

@@ -3,6 +3,9 @@ Cargo.lock
 *.prof
 .DS_Store
 
+# Cargo config
+.cargo/config.toml
+
 # Claude
 .claude/
 CLAUDE.md

CHANGELOG.md

@@ -2,7 +2,208 @@
 
 All notable changes to this project will be documented in this file.
 
-## [Unreleased]
+## [0.1.0]
+
+### UI / UX (breaking cosmetic changes)
+- **Options page**: Each option now shows a short description line below when focused, replacing the static header box.
+- **Dictionary page**: Removed the Forth description box at the top. The word list now uses the full page height.
+
+### CLAP Plugin (experimental)
+- Early CLAP plugin support via nih-plug, baseview, and egui. Feature-gated builds separate CLI from plugin targets.
+
+### Forth Language
+- Removed `chain` word (replaced by pattern-level Follow Up setting).
+- `case/of/endof/endcase` control flow for pattern-matching dispatch.
+- `bjork` / `pbjork` — euclidean rhythm gates using quotations: execute a block only on Bjorklund-distributed hits.
+- `arp` — arpeggio list type that spreads notes across time positions instead of stacking them simultaneously.
+- `,varname` assignment syntax (SetKeep): assign to a variable without consuming the value from the stack.
+- `every` reworked to accept quotations for cleaner conditional step logic.
+- All parameter words now accept varargs — over 100 words updated to consume the full stack.
+- Reverb parameter words added.
+
+### Engine
+- Follow-up actions: patterns now have a configurable follow-up behavior (Loop, Stop, or Chain to another pattern). Replaces the Forth `chain` word with a declarative setting in the Pattern Properties modal (`e` key). Chain targets specify bank and pattern via UI fields.
+- Delta-time MIDI scheduling for tighter, sample-accurate timing.
+- Tempo and current beat exposed in sequencer snapshot.
+- Spectrum analyzer rescaling.
+
+### UI / UX
+- Patterns view redesign: new layout with banks column (showing pattern counts), expandable detail rows for the focused pattern (quantization, sync mode, progress bar), and a bottom preview strip with mini step grid and pattern properties.
+- Smooth playback progress: playing patterns display a real-time progress bar interpolated between steps.
+- Dynamic step grid sizing: `steps_per_page` adapts to terminal height instead of using a fixed constant.
+- Mouse support: click navigation on the pattern grid, panels, and modals.
+- F1–F6 page navigation across the 3×2 page grid.
+- Collapsible help sections with code block copy.
+- Onboarding system for first-time users.
+- New reusable widgets: CategoryList, HintBar, PropsForm, ScrollIndicators, SearchBar, SectionHeader.
+- Show/hide preview pane toggle and zoom factor setting.
+
+### Documentation
+- Complete reorganization into `docs/` subdirectories.
+- 10 getting-started guides, 5 interactive tutorials.
+- New topics: control flow, generators, harmony, randomness, variables, timing.
+
+### Theme System
+- Palette-based generation: all 18 themes now derived from a 14-field Palette via Oklab color space.
+- Theme definitions reduced from ~300 lines each to ~20 lines.
+
+### Codebase
+- `src/app.rs` split into 10 focused modules (dispatch, clipboard, editing, navigation, persistence, scripting, sequencer, staging, undo).
+- `src/input.rs` split into 8 page-specific handlers.
+- Undo/redo system with scope-based tracking.
+- Feature-gated CLI vs plugin builds.
+
+## [0.0.9]
+
+### Website
+- Compressed screenshot images: resized to 1600px and converted PNG to WebP (8MB → 538KB).
+- Version number displayed in subtitle, read automatically from `Cargo.toml` at build time.
+
+### Added
+- `arp` word for arpeggios: wraps stack values into an arpeggio list that spreads notes across time positions instead of playing them all simultaneously. With explicit `at` deltas, arp items zip with deltas (cycling the shorter list); without `at`, the step is auto-subdivided evenly. Example: `sine s c4 e4 g4 b4 arp note .` plays a 4-note arpeggio across the step.
+- Resolved value annotations: nondeterministic words (`rand`, `choose`, `cycle`, `bounce`, `wchoose`, `coin`, `chance`, `prob`, `exprand`, `logrand`) now display their resolved value inline (e.g., `choose [sine]`, `rand [7]`, `chance [yes]`) during playback in both Preview and Editor modals.
+- Inline sample finder in the editor: press `Ctrl+B` to open a fuzzy-search popup of all sample folder names. Type to filter, `Ctrl+N`/`Ctrl+P` to navigate, `Tab`/`Enter` to insert the folder name at cursor, `Esc` to dismiss. Mutually exclusive with word completion.
+- Sample browser now displays the 0-based file index next to each sample name, making it easy to reference samples by index in Forth scripts (e.g., `"drums" bank 0 n`).
+
+### Improved
+- Header bar stats block (CPU/voices/Link peers) is now centered like all other header sections.
+- CPU percentage changes color when load is high: accent color at 50%+, error color at 80%+.
+- Extracted 6 reusable TUI components into `cagire-ratatui`: `CategoryList`, `render_scroll_indicators`, `render_search_bar`, `render_section_header`, `render_props_form`, `hint_line`. Reduces duplication across views.
+
+### Fixed
+- Soundless emits (e.g., `1 gain .`) no longer stack infinite voices. All emitted commands now receive a default duration of one beat unless the user explicitly sets `dur`. Use `0 dur` for intentionally infinite voices.
+
+## [0.0.8] - 2026-02-07
+
+### Fixed
+- macOS `.pkg` installer bundle relocation: disabled `BundleIsRelocatable` so `Cagire.app` always installs to `/Applications/` instead of being redirected to an existing bundle location.
+
+### Added
+- Syntax highlighting for user-defined Forth words: words created with `: name ... ;` now render with a distinct color in both the editor and step preview, instead of dimmed gray.
+- Multi-selection in Patterns view: Shift+Up/Down selects adjacent ranges of banks or patterns using anchor-based selection. Works with copy/paste (Ctrl+C/V), reset (Delete), toggle play (`p`), mute (`m`), and solo (`x`). Selection is column-scoped and clears on plain arrows, column switch, or Esc. Single-only actions (rename, pattern props, enter) are disabled during multi-selection.
+- Audio-rate modulation DSL: LFO words (`lfo`, `tlfo`, `wlfo`, `qlfo` for sine/triangle/sawtooth/square), transition envelopes (`slide`, `expslide`, `sslide` for linear/exponential/smooth), random modulation (`jit`, `sjit`, `drunk` for random hold/smooth random/drunk walk), and multi-segment envelope (`env`). These produce modulation strings consumed by parameter words for continuous audio-rate control.
+- Feedback delay FX words: `feedback`/`fb` (level), `fbtime`/`fbt` (delay time), `fbdamp`/`fbd` (damping), `fblfo` (LFO rate), `fblfodepth` (LFO depth), `fblfoshape` (LFO shape).
+- `bounce` word: ping-pong cycle through n items by step runs (e.g., `60 64 67 72 4 bounce` → 60 64 67 72 67 64 60 64...).
+- `wchoose` word: weighted random selection from n value/weight pairs (e.g., `60 0.6  64 0.3  67 0.1  3 wchoose`). Supports quotations.
+- New themes: **Eden** (dark forest — green-only palette on black), **Georges** (Commodore 64 palette on black), **Ember** (warm dark tones), **Letz Light** (light theme).
+- Proper desktop app icon and metadata across all platforms: moved icon to `assets/Cagire.png`, added Windows `.exe` icon and file properties embedding via `winres` build script, added PNG to cargo-bundle icon list for Linux `.deb` packaging.
+- Universal macOS `.pkg` installer in CI: combines Intel and Apple Silicon builds into fat binaries via `lipo`, then packages `Cagire.app` and CLI into a single `.pkg` installer.
+- Waveform rendering widget in the TUI.
+
+### Improved
+- Sample library browser: search now shows folder names only (no files) while typing, sorted by fuzzy match score. After confirming search with Enter, folders can be expanded and collapsed normally. Esc clears the search filter before closing the panel. Left arrow on a file collapses the parent folder. Cursor and scroll position stay valid after expand/collapse operations.
+- RAM optimizations saving ~5 MB at startup plus smaller enums and fewer hot-path allocations:
+  - Removed dead `Step::command` field (~3.1 MB)
+  - Narrowed `Step::source` from `Option<usize>` to `Option<u8>` (~1.8 MB)
+  - `Op::SetParam` and `Op::GetContext` now use `&'static str` instead of `String`
+  - `SourceSpan` fields narrowed from `usize` to `u32`
+  - Dirty pattern tracking uses fixed `[[bool; 32]; 32]` array instead of `HashSet`
+  - Boxed `FileBrowserState` in `Modal` enum to shrink all variants
+  - `StepContext::cc_access` borrows instead of cloning `Arc<dyn CcAccess>`
+  - Removed unnecessary `Arc` wrapper from `Stack` type
+  - Variable key cache computes on-demand with reusable buffers instead of pre-allocating 2048 Strings
+- Render pipeline: background fill uses `Clear` widget instead of generating blank paragraph lines.
+
+### Fixed
+- Sequencer sync: auto-loaded patterns now use PhaseLock instead of Reset, so they align to the global beat grid and stay in sync with manually-started patterns.
+- PhaseLock off-by-one: start step calculation now uses the frontier beat instead of the lookahead end, eliminating a systematic 1-step offset.
+- Stale pattern cache on load: dirty patterns are now flushed before queued start/stop changes, ensuring pattern data arrives before activation.
+- Loading while paused no longer drops auto-started patterns; pending starts are preserved and activate on resume.
+
+### Changed
+- Header bar is now always 3 lines tall with vertically centered content and full-height background colors, replacing the previous 1-or-2-line width-dependent layout.
+- Help view Welcome page: BigText title is now gated behind `cfg(not(feature = "desktop"))`, falling back to a plain text title in the desktop build (same strategy as the splash screen).
+- Space now toggles play/pause on all views, including the Patterns page where it previously toggled pattern play. Pattern play on the Patterns page is now bound to `p`.
+
+## [0.0.7] - 2026-05-02
+
+### Added
+- 3-operator FM synthesis words: `fm2` (operator 2 depth), `fm2h` (operator 2 harmonic ratio), `fmalgo` (algorithm: 0=cascade, 1=parallel, 2=branch), `fmfb` (feedback amount). Extends the existing 2-OP FM engine to a full 3-OP architecture with configurable routing and operator feedback.
+- Background head-preload for sample libraries. At startup, a background thread decodes the first 4096 frames (~93ms) of every sample into RAM. Short samples (most percussion/drums) are fully captured and play instantly on first trigger. Eliminates first-hit misses for live performance.
+- Most changes are on doux side. It makes sense to recompile and release now to ship a version that comes with these improvements.
+
+### Fixed
+- Code editor now scrolls vertically to keep the cursor visible. Previously, lines beyond the visible area were clipped and the cursor could move off-screen.
+
+## [0.0.6] - 2026-05-02
+
+### Added
+- TachyonFX based animations
+- Prelude: project-level Forth script for persistent word definitions. Press `d` to edit, `D` to re-evaluate. Runs automatically on playback start and project load.
+- Varargs stack words: `rev`, `shuffle`, `sort` (ascending), `rsort` (descending), `sum`, `prod`. All take a count and operate on the top n items.
+- Euclidean rhythm words: `euclid` (k n -- hits) distributes k hits across n steps, `euclidrot` (k n r -- hits) adds rotation offset.
+- Shorthand float syntax: `.25` parses as `0.25`, `-.5` parses as `-0.5`.
+
+### Changed
+- Split `words.rs` (3,078 lines) into a `words/` directory module with category-based files: `core.rs`, `sound.rs`, `effects.rs`, `sequencing.rs`, `music.rs`, `midi.rs`, plus `compile.rs` and `mod.rs`.
+- Renamed `tri` Forth word to `triangle`.
+- Sequencer rewritten with prospective lookahead scheduling. Instead of sleeping until a substep, waking late, and detecting past events, the sequencer now pre-computes all events within a ~20ms forward window. Events arrive at doux with positive time deltas, scheduled before they need to fire. Sleep+spin-wait replaced by `recv_timeout(3ms)` on the command channel. Timing no longer depends on OS sleep precision.
+- `audio_sample_pos` updated at buffer start instead of end, so `engine_time` reflects current playback position.
+- Doux grace period increased from 1ms to 50ms as a safety net (events should never be late with lookahead).
+- Flattened model re-export indirection; `script.rs` now exports only `ScriptEngine`.
+- Hue rotation step size increased from 1° to 5° for faster adjustment.
+- Moved catalog data (DOCS, CATEGORIES) from views to `src/model/`, eliminating state-to-view layer inversion.
+- Extracted shared initialization into `src/init.rs`, deduplicating ~140 lines between terminal and desktop binaries.
+- Split App dispatch into focused service modules (`help_nav`, `dict_nav`, `euclidean`, `clipboard`, extended `pattern_editor`), reducing `app.rs` by ~310 lines.
+- Moved stack preview computation from render path to input time, making editor rendering pure.
+- Decoupled script runtime state between UI and sequencer threads, eliminating shared mutexes on the RT path.
+
+### Fixed
+- Prelude content no longer leaks into step editor. Closing the prelude editor now restores the current step's content to the buffer.
+- Desktop binary now loads color theme and connects MIDI devices on startup (was missing).
+- Audio commands no longer silently dropped when channel is full; switched to unbounded channel matching MIDI dispatch pattern.
+- PatternProps and EuclideanDistribution modals now use the global theme background instead of the terminal default.
+- Changing pattern properties is now a stage/commit operation.
+- Changing pattern speed only happens at pattern boundaries.
+- `mlockall` warning no longer appears on macOS; memory locking is now Linux-only.
+- `clear` now resets `at` deltas, so subsequent emits default to a single emit at position 0.
+
+## [0.0.5] - 2026-04-02
+
+### Added
+- Mute/solo for patterns: stage with `m`/`x`, commit with `c`. Solo mutes all other patterns. Clear with `M`/`X`.
+- Lookahead scheduling: scripts are pre-evaluated ahead of time and audio commands are scheduled at precise beat positions, improving timing accuracy under CPU load.
+- Realtime thread scheduling (`SCHED_FIFO`) for sequencer thread on Unix systems, improving timing reliability.
+- Deep into the Linux hellscape: trying to get reliable performance, better stability, etc.
+
+### Fixed
+- Editor completion popup no longer steals arrow keys. Arrow keys always move the cursor; use Ctrl+N/Ctrl+P to navigate the completion list.
+
+## [0.0.4] - 2026-02-02
+
+### Added
+- Double-stack words: `2dup`, `2drop`, `2swap`, `2over`.
+- `forget` word to remove user-defined words from the dictionary.
+- Active patterns panel showing playing patterns with bank, pattern, iteration count, and step position.
+- Configurable visualization layout (Top/Bottom/Left/Right) for scope and spectrum placement.
+- Euclidean distribution modal to spread a step's script across the pattern using Euclidean rhythms.
+- Fairyfloss theme (pastel candy colors by sailorhg).
+- Hot Dog Stand theme (classic Windows 3.1 red/yellow).
+- Hue rotation option in Options menu to shift all theme colors (0-360°).
+
+### Changed
+- Title view now adapts to smaller terminal sizes gracefully.
+
+### Fixed
+- Scope/spectrum ratio asymmetry in Left/Right layout modes.
+- Updated `cpal` dependency from 0.15 to 0.17 to fix type mismatch with `doux` audio backend.
+- Copy/paste (Ctrl+C/V/X) not working in desktop version due to egui intercepting clipboard shortcuts.
+
+## [0.0.3] - 2026-02-02
+
+### Added
+- Polyphonic parameters: param words (`note`, `freq`, `gain`, etc.) and sound words now consume the entire stack, enabling polyphony (e.g., `60 64 67 note sine s .` emits 3 voices).
+- New random distribution words: `exprand` (exponential) and `logrand` (logarithmic).
+- Music theory chord words: `maj`, `m`, `dim`, `aug`, `sus2`, `sus4`, `maj7`, `min7`, `dom7`, `dim7`, `m7b5`, `minmaj7`, `aug7`, `maj6`, `min6`, `dom9`, `maj9`, `min9`, `dom11`, `min11`, `dom13`, `add9`, `add11`, `madd9`, `dom7b9`, `dom7s9`, `dom7b5`, `dom7s5`.
+- Playing patterns are now saved with the project and restored on load.
+
+### Changed
+- `at` now consumes the entire stack for time offsets; polyphony multiplies with deltas (2 notes × 2 times = 4 voices).
+- Iterator (`iter`) now resets when a pattern restarts.
+- Project loading now properly resets state: stops all patterns, clears user variables/dictionary, and clears queued changes.
+
+### Removed
+- `tcycle` word (replaced by polyphonic parameter behavior).
 
 ## [0.0.2] - 2026-02-01
 - CI testing and codebase cleanup

Cargo.toml

@@ -1,8 +1,8 @@
 [workspace]
-members = ["crates/forth", "crates/markdown", "crates/project", "crates/ratatui"]
+members = ["crates/forth", "crates/markdown", "crates/project", "crates/ratatui", "plugins/cagire-plugins", "plugins/baseview", "plugins/egui-baseview", "plugins/nih-plug-egui", "xtask"]
 
 [workspace.package]
-version = "0.0.2"
+version = "0.0.9"
 edition = "2021"
 authors = ["Raphaël Forment <raphael.forment@gmail.com>"]
 license = "AGPL-3.0"
@@ -30,18 +30,20 @@ path = "src/main.rs"
 
 [[bin]]
 name = "cagire-desktop"
-path = "src/bin/desktop.rs"
+path = "src/bin/desktop/main.rs"
 required-features = ["desktop"]
 
 [features]
-default = []
+default = ["cli"]
+cli = ["dep:cpal", "dep:midir", "dep:confy", "dep:clap", "dep:thread-priority"]
+block-renderer = ["dep:soft_ratatui", "dep:rustc-hash", "dep:egui"]
 desktop = [
+    "cli",
+    "block-renderer",
     "cagire-forth/desktop",
-    "egui",
-    "eframe",
-    "egui_ratatui",
-    "soft_ratatui",
-    "image",
+    "dep:eframe",
+    "dep:egui_ratatui",
+    "dep:image",
 ]
 
 [dependencies]
@@ -49,33 +51,41 @@ cagire-forth = { path = "crates/forth" }
 cagire-markdown = { path = "crates/markdown" }
 cagire-project = { path = "crates/project" }
 cagire-ratatui = { path = "crates/ratatui" }
-doux = { git = "https://github.com/sova-org/doux", features = ["native"] }
+doux = { path = "/Users/bubo/doux", features = ["native"] }
 rusty_link = "0.4"
 ratatui = "0.30"
 crossterm = "0.29"
-cpal = "0.15"
-clap = { version = "4", features = ["derive"] }
+cpal = { version = "0.17", features = ["jack"], optional = true }
+clap = { version = "4", features = ["derive"], optional = true }
 rand = "0.8"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+tachyonfx = { version = "0.22", features = ["std-duration"] }
 tui-big-text = "0.8"
 arboard = "3"
 minimad = "0.13"
 crossbeam-channel = "0.5"
-confy = "2"
+confy = { version = "2", optional = true }
 rustfft = "6"
-thread-priority = "1"
+thread-priority = { version = "1", optional = true }
 ringbuf = "0.4"
 arc-swap = "1"
-midir = "0.10"
+midir = { version = "0.10", optional = true }
+parking_lot = "0.12"
+libc = "0.2"
 
 # Desktop-only dependencies (behind feature flag)
 egui = { version = "0.33", optional = true }
 eframe = { version = "0.33", optional = true }
 egui_ratatui = { version = "2.1", optional = true }
 soft_ratatui = { version = "0.1.3", features = ["unicodefonts"], optional = true }
+rustc-hash = { version = "2", optional = true }
 image = { version = "0.25", default-features = false, features = ["png"], optional = true }
 
+
+[target.'cfg(windows)'.build-dependencies]
+winres = "0.1"
+
 [profile.release]
 opt-level = 3
 lto = "fat"
@@ -83,10 +93,19 @@ codegen-units = 1
 panic = "abort"
 strip = true
 
+[patch."https://github.com/robbert-vdh/nih-plug"]
+nih_plug_egui = { path = "plugins/nih-plug-egui" }
+
+[patch."https://github.com/BillyDM/egui-baseview.git"]
+egui-baseview = { path = "plugins/egui-baseview" }
+
+[patch."https://github.com/RustAudio/baseview.git"]
+baseview = { path = "plugins/baseview" }
+
 [package.metadata.bundle.bin.cagire-desktop]
 name = "Cagire"
 identifier = "com.sova.cagire"
-icon = ["assets/Cagire.icns", "assets/Cagire.ico"]
+icon = ["assets/Cagire.icns", "assets/Cagire.ico", "assets/Cagire.png"]
 copyright = "Copyright (c) 2025 Raphaël Forment"
 category = "Music"
 short_description = "Forth-based music sequencer"

README.md

@@ -6,7 +6,7 @@
   <img src="cagire_pixel.png" alt="Cagire" width="256">
 </p>
 
-Cagire is a terminal-based step sequencer for live coding music. Each step in a pattern contains a **Forth** script that produces sound and create events. It is made by BuboBubo (Raphaël Maurice Forment): [https://raphaelforment.fr](https://raphaelforment.fr). Cagire is open-source (AGPL-3.0 licensed) and available on GitHub : [https://github.com/BuboBubo/cagire](https://github.com/BuboBubo/cagire).
+Cagire is a terminal-based step sequencer for live coding music. Each step in a pattern contains a **Forth** script that produces sound and create events.
 
 ## Build
 

build.rs

@@ -0,0 +1,11 @@
+fn main() {
+    #[cfg(windows)]
+    {
+        let mut res = winres::WindowsResource::new();
+        res.set_icon("assets/Cagire.ico")
+            .set("ProductName", "Cagire")
+            .set("FileDescription", "Forth-based music sequencer")
+            .set("LegalCopyright", "Copyright (c) 2025 Raphaël Forment");
+        res.compile().expect("Failed to compile Windows resources");
+    }
+}

crates/forth/Cargo.toml

@@ -13,3 +13,5 @@ desktop = []
 
 [dependencies]
 rand = "0.8"
+parking_lot = "0.12"
+arc-swap = "1"

crates/forth/src/compiler.rs

@@ -1,3 +1,8 @@
+//! Single-pass compiler from Forth source text to Op sequences.
+
+use std::borrow::Cow;
+use std::sync::Arc;
+
 use super::ops::Op;
 use super::types::{Dictionary, SourceSpan};
 use super::words::compile_word;
@@ -43,7 +48,7 @@ fn tokenize(input: &str) -> Vec<Token> {
                 }
                 s.push(ch);
             }
-            tokens.push(Token::Str(s, SourceSpan { start, end }));
+            tokens.push(Token::Str(s, SourceSpan { start: start as u32, end: end as u32 }));
             continue;
         }
 
@@ -64,8 +69,8 @@ fn tokenize(input: &str) -> Vec<Token> {
             tokens.push(Token::Word(
                 ";".to_string(),
                 SourceSpan {
-                    start: pos,
-                    end: pos + 1,
+                    start: pos as u32,
+                    end: (pos + 1) as u32,
                 },
             ));
             continue;
@@ -83,10 +88,26 @@ fn tokenize(input: &str) -> Vec<Token> {
             chars.next();
         }
 
-        let span = SourceSpan { start, end };
-        if let Ok(i) = word.parse::<i64>() {
+        let span = SourceSpan { start: start as u32, end: end as u32 };
+
+        // Normalize shorthand float syntax: .25 -> 0.25, -.5 -> -0.5
+        let word_to_parse: Cow<str> = if word.starts_with('.')
+            && word.len() > 1
+            && word.as_bytes()[1].is_ascii_digit()
+        {
+            Cow::Owned(format!("0{word}"))
+        } else if word.starts_with("-.")
+            && word.len() > 2
+            && word.as_bytes()[2].is_ascii_digit()
+        {
+            Cow::Owned(format!("-0{}", &word[1..]))
+        } else {
+            Cow::Borrowed(&word)
+        };
+
+        if let Ok(i) = word_to_parse.parse::<i64>() {
             tokens.push(Token::Int(i, span));
-        } else if let Ok(f) = word.parse::<f64>() {
+        } else if let Ok(f) = word_to_parse.parse::<f64>() {
             tokens.push(Token::Float(f, span));
         } else {
             tokens.push(Token::Word(word, span));
@@ -103,22 +124,12 @@ fn compile(tokens: &[Token], dict: &Dictionary) -> Result<Vec<Op>, String> {
     while i < tokens.len() {
         match &tokens[i] {
             Token::Int(n, span) => {
-                let key = n.to_string();
-                if let Some(body) = dict.lock().unwrap().get(&key).cloned() {
-                    ops.extend(body);
-                } else {
-                    ops.push(Op::PushInt(*n, Some(*span)));
-                }
+                ops.push(Op::PushInt(*n, Some(*span)));
             }
             Token::Float(f, span) => {
-                let key = f.to_string();
-                if let Some(body) = dict.lock().unwrap().get(&key).cloned() {
-                    ops.extend(body);
-                } else {
-                    ops.push(Op::PushFloat(*f, Some(*span)));
-                }
+                ops.push(Op::PushFloat(*f, Some(*span)));
             }
-            Token::Str(s, span) => ops.push(Op::PushStr(s.clone(), Some(*span))),
+            Token::Str(s, span) => ops.push(Op::PushStr(Arc::from(s.as_str()), Some(*span))),
             Token::Word(w, span) => {
                 let word = w.as_str();
                 if word == "{" {
@@ -129,13 +140,13 @@ fn compile(tokens: &[Token], dict: &Dictionary) -> Result<Vec<Op>, String> {
                         start: span.start,
                         end: end_span.end,
                     };
-                    ops.push(Op::Quotation(quote_ops, Some(body_span)));
+                    ops.push(Op::Quotation(Arc::from(quote_ops), Some(body_span)));
                 } else if word == "}" {
                     return Err("unexpected }".into());
                 } else if word == ":" {
                     let (consumed, name, body) = compile_colon_def(&tokens[i + 1..], dict)?;
                     i += consumed;
-                    dict.lock().unwrap().insert(name, body);
+                    dict.lock().insert(name, body);
                 } else if word == ";" {
                     return Err("unexpected ;".into());
                 } else if word == "if" {
@@ -151,6 +162,12 @@ fn compile(tokens: &[Token], dict: &Dictionary) -> Result<Vec<Op>, String> {
                         ops.push(Op::Branch(else_ops.len()));
                         ops.extend(else_ops);
                     }
+                } else if word == "case" {
+                    let (case_ops, consumed) = compile_case(&tokens[i + 1..], dict)?;
+                    i += consumed;
+                    ops.extend(case_ops);
+                } else if word == "of" || word == "endof" || word == "endcase" {
+                    return Err(format!("unexpected '{word}'"));
                 } else if !compile_word(word, Some(*span), &mut ops, dict) {
                     return Err(format!("unknown word: {word}"));
                 }
@@ -291,3 +308,69 @@ fn compile_if(
 
     Ok((then_ops, else_ops, then_pos + 1, then_span, else_span))
 }
+
+fn compile_case(tokens: &[Token], dict: &Dictionary) -> Result<(Vec<Op>, usize), String> {
+    let mut depth = 1;
+    let mut endcase_pos = None;
+    let mut clauses: Vec<(usize, usize)> = Vec::new();
+    let mut last_of = None;
+
+    for (i, tok) in tokens.iter().enumerate() {
+        if let Token::Word(w, _) = tok {
+            match w.as_str() {
+                "case" => depth += 1,
+                "endcase" => {
+                    depth -= 1;
+                    if depth == 0 {
+                        endcase_pos = Some(i);
+                        break;
+                    }
+                }
+                "of" if depth == 1 => last_of = Some(i),
+                "endof" if depth == 1 => {
+                    let of_pos = last_of.ok_or("'endof' without matching 'of'")?;
+                    clauses.push((of_pos, i));
+                    last_of = None;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    let endcase_pos = endcase_pos.ok_or("missing 'endcase'")?;
+
+    let mut ops = Vec::new();
+    let mut branch_fixups: Vec<usize> = Vec::new();
+    let mut clause_start = 0;
+
+    for &(of_pos, endof_pos) in &clauses {
+        let test_ops = compile(&tokens[clause_start..of_pos], dict)?;
+        let body_ops = compile(&tokens[of_pos + 1..endof_pos], dict)?;
+
+        ops.extend(test_ops);
+        ops.push(Op::Over);
+        ops.push(Op::Eq);
+        ops.push(Op::BranchIfZero(body_ops.len() + 2, None, None));
+        ops.push(Op::Drop);
+        ops.extend(body_ops);
+        branch_fixups.push(ops.len());
+        ops.push(Op::Branch(0));
+
+        clause_start = endof_pos + 1;
+    }
+
+    let default_tokens = &tokens[clause_start..endcase_pos];
+    if !default_tokens.is_empty() {
+        let default_ops = compile(default_tokens, dict)?;
+        ops.extend(default_ops);
+    }
+
+    ops.push(Op::Drop);
+
+    let end = ops.len();
+    for pos in branch_fixups {
+        ops[pos] = Op::Branch(end - pos - 1);
+    }
+
+    Ok((ops, endcase_pos + 1))
+}

crates/forth/src/lib.rs

@@ -1,3 +1,5 @@
+//! Forth virtual machine for the Cagire music sequencer.
+
 mod compiler;
 mod ops;
 mod theory;
@@ -6,7 +8,8 @@ mod vm;
 mod words;
 
 pub use types::{
-    CcAccess, Dictionary, ExecutionTrace, Rng, SourceSpan, StepContext, Value, Variables,
+    CcAccess, Dictionary, ExecutionTrace, ResolvedValue, Rng, SourceSpan, StepContext, Value,
+    Variables, VariablesMap,
 };
 pub use vm::Forth;
-pub use words::{Word, WordCompile, WORDS};
+pub use words::{lookup_word, Word, WordCompile, WORDS};

crates/forth/src/ops.rs

@@ -1,10 +1,14 @@
+//! Compiled operation variants for the Forth VM instruction set.
+
+use std::sync::Arc;
+
 use super::types::SourceSpan;
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Op {
     PushInt(i64, Option<SourceSpan>),
     PushFloat(f64, Option<SourceSpan>),
-    PushStr(String, Option<SourceSpan>),
+    PushStr(Arc<str>, Option<SourceSpan>),
     Dup,
     Dupn,
     Drop,
@@ -13,6 +17,17 @@ pub enum Op {
     Rot,
     Nip,
     Tuck,
+    Dup2,
+    Drop2,
+    Swap2,
+    Over2,
+    Rev,
+    Shuffle,
+    Sort,
+    RSort,
+    Sum,
+    Prod,
+    Forget,
     Add,
     Sub,
     Mul,
@@ -47,45 +62,70 @@ pub enum Op {
     BranchIfZero(usize, Option<SourceSpan>, Option<SourceSpan>),
     Branch(usize),
     NewCmd,
-    SetParam(String),
+    SetParam(&'static str),
     Emit,
     Get,
     Set,
-    GetContext(String),
-    Rand,
+    SetKeep,
+    GetContext(&'static str),
+    Rand(Option<SourceSpan>),
+    ExpRand(Option<SourceSpan>),
+    LogRand(Option<SourceSpan>),
     Seed,
-    Cycle,
-    PCycle,
-    TCycle,
-    Choose,
-    ChanceExec,
-    ProbExec,
-    Coin,
+    Cycle(Option<SourceSpan>),
+    PCycle(Option<SourceSpan>),
+    Choose(Option<SourceSpan>),
+    Bounce(Option<SourceSpan>),
+    WChoose(Option<SourceSpan>),
+    ChanceExec(Option<SourceSpan>),
+    ProbExec(Option<SourceSpan>),
+    Coin(Option<SourceSpan>),
     Mtof,
     Ftom,
     SetTempo,
-    Every,
-    Quotation(Vec<Op>, Option<SourceSpan>),
+    Every(Option<SourceSpan>),
+    Bjork(Option<SourceSpan>),
+    PBjork(Option<SourceSpan>),
+    Quotation(Arc<[Op]>, Option<SourceSpan>),
     When,
     Unless,
     Adsr,
     Ad,
     Apply,
     Ramp,
-    Tri,
+    Triangle,
     Range,
+    LinMap,
+    ExpMap,
     Perlin,
-    Chain,
     Loop,
     Degree(&'static [i64]),
     Oct,
     ClearCmd,
     SetSpeed,
     At,
+    Arp,
     IntRange,
+    StepRange,
     Generate,
     GeomRange,
+    Euclid,
+    EuclidRot,
     Times,
+    Chord(&'static [i64]),
+    Transpose,
+    Invert,
+    DownInvert,
+    VoiceDrop2,
+    VoiceDrop3,
+    SetKey,
+    DiatonicTriad(&'static [i64]),
+    DiatonicSeventh(&'static [i64]),
+    // Audio-rate modulation DSL
+    ModLfo(u8),
+    ModSlide(u8),
+    ModRnd(u8),
+    ModEnv,
     // MIDI
     MidiEmit,
     GetMidiCC,

crates/forth/src/theory/chords.rs

@@ -0,0 +1,174 @@
+pub struct Chord {
+    pub name: &'static str,
+    pub intervals: &'static [i64],
+}
+
+pub static CHORDS: &[Chord] = &[
+    // Triads
+    Chord {
+        name: "maj",
+        intervals: &[0, 4, 7],
+    },
+    Chord {
+        name: "m",
+        intervals: &[0, 3, 7],
+    },
+    Chord {
+        name: "dim",
+        intervals: &[0, 3, 6],
+    },
+    Chord {
+        name: "aug",
+        intervals: &[0, 4, 8],
+    },
+    Chord {
+        name: "sus2",
+        intervals: &[0, 2, 7],
+    },
+    Chord {
+        name: "sus4",
+        intervals: &[0, 5, 7],
+    },
+    // Seventh chords
+    Chord {
+        name: "maj7",
+        intervals: &[0, 4, 7, 11],
+    },
+    Chord {
+        name: "min7",
+        intervals: &[0, 3, 7, 10],
+    },
+    Chord {
+        name: "dom7",
+        intervals: &[0, 4, 7, 10],
+    },
+    Chord {
+        name: "dim7",
+        intervals: &[0, 3, 6, 9],
+    },
+    Chord {
+        name: "m7b5",
+        intervals: &[0, 3, 6, 10],
+    },
+    Chord {
+        name: "minmaj7",
+        intervals: &[0, 3, 7, 11],
+    },
+    Chord {
+        name: "aug7",
+        intervals: &[0, 4, 8, 10],
+    },
+    // Sixth chords
+    Chord {
+        name: "maj6",
+        intervals: &[0, 4, 7, 9],
+    },
+    Chord {
+        name: "min6",
+        intervals: &[0, 3, 7, 9],
+    },
+    // Extended chords
+    Chord {
+        name: "dom9",
+        intervals: &[0, 4, 7, 10, 14],
+    },
+    Chord {
+        name: "maj9",
+        intervals: &[0, 4, 7, 11, 14],
+    },
+    Chord {
+        name: "min9",
+        intervals: &[0, 3, 7, 10, 14],
+    },
+    Chord {
+        name: "dom11",
+        intervals: &[0, 4, 7, 10, 14, 17],
+    },
+    Chord {
+        name: "min11",
+        intervals: &[0, 3, 7, 10, 14, 17],
+    },
+    Chord {
+        name: "dom13",
+        intervals: &[0, 4, 7, 10, 14, 21],
+    },
+    // Add chords
+    Chord {
+        name: "add9",
+        intervals: &[0, 4, 7, 14],
+    },
+    Chord {
+        name: "add11",
+        intervals: &[0, 4, 7, 17],
+    },
+    Chord {
+        name: "madd9",
+        intervals: &[0, 3, 7, 14],
+    },
+    // Power chord
+    Chord {
+        name: "pwr",
+        intervals: &[0, 7],
+    },
+    // Suspended seventh
+    Chord {
+        name: "7sus4",
+        intervals: &[0, 5, 7, 10],
+    },
+    Chord {
+        name: "9sus4",
+        intervals: &[0, 5, 7, 10, 14],
+    },
+    // Augmented major
+    Chord {
+        name: "augmaj7",
+        intervals: &[0, 4, 8, 11],
+    },
+    // 6/9 chords
+    Chord {
+        name: "maj69",
+        intervals: &[0, 4, 7, 9, 14],
+    },
+    Chord {
+        name: "min69",
+        intervals: &[0, 3, 7, 9, 14],
+    },
+    // Extended
+    Chord {
+        name: "maj11",
+        intervals: &[0, 4, 7, 11, 14, 17],
+    },
+    Chord {
+        name: "maj13",
+        intervals: &[0, 4, 7, 11, 14, 21],
+    },
+    Chord {
+        name: "min13",
+        intervals: &[0, 3, 7, 10, 14, 21],
+    },
+    // Altered dominants
+    Chord {
+        name: "dom7b9",
+        intervals: &[0, 4, 7, 10, 13],
+    },
+    Chord {
+        name: "dom7s9",
+        intervals: &[0, 4, 7, 10, 15],
+    },
+    Chord {
+        name: "dom7b5",
+        intervals: &[0, 4, 6, 10],
+    },
+    Chord {
+        name: "dom7s5",
+        intervals: &[0, 4, 8, 10],
+    },
+    Chord {
+        name: "dom7s11",
+        intervals: &[0, 4, 7, 10, 18],
+    },
+];
+
+pub fn lookup(name: &str) -> Option<&'static [i64]> {
+    CHORDS.iter().find(|c| c.name == name).map(|c| c.intervals)
+}

crates/forth/src/theory/mod.rs

@@ -1,3 +1,4 @@
+pub mod chords;
 mod scales;
 
 pub use scales::lookup;

crates/forth/src/types.rs

@@ -1,6 +1,10 @@
+//! Core types for the Forth VM: values, execution context, and shared state.
+
+use arc_swap::ArcSwap;
+use parking_lot::Mutex;
 use rand::rngs::StdRng;
 use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 use super::ops::Op;
 
@@ -12,17 +16,37 @@ pub trait CcAccess: Send + Sync {
 
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub struct SourceSpan {
-    pub start: usize,
-    pub end: usize,
+    pub start: u32,
+    pub end: u32,
+}
+
+#[derive(Clone, Debug)]
+pub enum ResolvedValue {
+    Int(i64),
+    Float(f64),
+    Bool(bool),
+    Str(Arc<str>),
+}
+
+impl ResolvedValue {
+    pub fn display(&self) -> String {
+        match self {
+            ResolvedValue::Int(i) => i.to_string(),
+            ResolvedValue::Float(f) => format!("{f:.2}"),
+            ResolvedValue::Bool(b) => if *b { "yes" } else { "no" }.into(),
+            ResolvedValue::Str(s) => s.to_string(),
+        }
+    }
 }
 
 #[derive(Clone, Debug, Default)]
 pub struct ExecutionTrace {
     pub executed_spans: Vec<SourceSpan>,
     pub selected_spans: Vec<SourceSpan>,
+    pub resolved: Vec<(SourceSpan, ResolvedValue)>,
 }
 
-pub struct StepContext {
+pub struct StepContext<'a> {
     pub step: usize,
     pub beat: f64,
     pub bank: usize,
@@ -35,34 +59,34 @@ pub struct StepContext {
     pub speed: f64,
     pub fill: bool,
     pub nudge_secs: f64,
-    pub cc_access: Option<Arc<dyn CcAccess>>,
-    #[cfg(feature = "desktop")]
+    pub cc_access: Option<&'a dyn CcAccess>,
+    pub speed_key: &'a str,
     pub mouse_x: f64,
-    #[cfg(feature = "desktop")]
     pub mouse_y: f64,
-    #[cfg(feature = "desktop")]
     pub mouse_down: f64,
 }
 
-impl StepContext {
+impl StepContext<'_> {
     pub fn step_duration(&self) -> f64 {
         60.0 / self.tempo / 4.0 / self.speed
     }
 }
 
-pub type Variables = Arc<Mutex<HashMap<String, Value>>>;
+pub type VariablesMap = HashMap<String, Value>;
+pub type Variables = Arc<ArcSwap<VariablesMap>>;
 pub type Dictionary = Arc<Mutex<HashMap<String, Vec<Op>>>>;
 pub type Rng = Arc<Mutex<StdRng>>;
-pub type Stack = Arc<Mutex<Vec<Value>>>;
-pub(super) type CmdSnapshot<'a> = (Option<&'a Value>, &'a [(String, Value)]);
+pub type Stack = Mutex<Vec<Value>>;
+pub(super) type CmdSnapshot<'a> = (Option<&'a Value>, &'a [(&'static str, Value)]);
 
 #[derive(Clone, Debug)]
 pub enum Value {
     Int(i64, Option<SourceSpan>),
     Float(f64, Option<SourceSpan>),
-    Str(String, Option<SourceSpan>),
-    Quotation(Vec<Op>, Option<SourceSpan>),
-    CycleList(Vec<Value>),
+    Str(Arc<str>, Option<SourceSpan>),
+    Quotation(Arc<[Op]>, Option<SourceSpan>),
+    CycleList(Arc<[Value]>),
+    ArpList(Arc<[Value]>),
 }
 
 impl PartialEq for Value {
@@ -73,6 +97,7 @@ impl PartialEq for Value {
             (Value::Str(a, _), Value::Str(b, _)) => a == b,
             (Value::Quotation(a, _), Value::Quotation(b, _)) => a == b,
             (Value::CycleList(a), Value::CycleList(b)) => a == b,
+            (Value::ArpList(a), Value::ArpList(b)) => a == b,
             _ => false,
         }
     }
@@ -108,7 +133,7 @@ impl Value {
             Value::Float(f, _) => *f != 0.0,
             Value::Str(s, _) => !s.is_empty(),
             Value::Quotation(..) => true,
-            Value::CycleList(items) => !items.is_empty(),
+            Value::CycleList(items) | Value::ArpList(items) => !items.is_empty(),
         }
     }
 
@@ -116,16 +141,16 @@ impl Value {
         match self {
             Value::Int(i, _) => i.to_string(),
             Value::Float(f, _) => f.to_string(),
-            Value::Str(s, _) => s.clone(),
+            Value::Str(s, _) => s.to_string(),
             Value::Quotation(..) => String::new(),
-            Value::CycleList(_) => String::new(),
+            Value::CycleList(_) | Value::ArpList(_) => String::new(),
         }
     }
 
     pub(super) fn span(&self) -> Option<SourceSpan> {
         match self {
             Value::Int(_, s) | Value::Float(_, s) | Value::Str(_, s) | Value::Quotation(_, s) => *s,
-            Value::CycleList(_) => None,
+            Value::CycleList(_) | Value::ArpList(_) => None,
         }
     }
 }
@@ -133,16 +158,24 @@ impl Value {
 #[derive(Clone, Debug, Default)]
 pub(super) struct CmdRegister {
     sound: Option<Value>,
-    params: Vec<(String, Value)>,
+    params: Vec<(&'static str, Value)>,
     deltas: Vec<Value>,
 }
 
 impl CmdRegister {
+    pub(super) fn new() -> Self {
+        Self {
+            sound: None,
+            params: Vec::with_capacity(16),
+            deltas: Vec::with_capacity(4),
+        }
+    }
+
     pub(super) fn set_sound(&mut self, val: Value) {
         self.sound = Some(val);
     }
 
-    pub(super) fn set_param(&mut self, key: String, val: Value) {
+    pub(super) fn set_param(&mut self, key: &'static str, val: Value) {
         self.params.push((key, val));
     }
 
@@ -154,6 +187,14 @@ impl CmdRegister {
         &self.deltas
     }
 
+    pub(super) fn sound(&self) -> Option<&Value> {
+        self.sound.as_ref()
+    }
+
+    pub(super) fn params(&self) -> &[(&'static str, Value)] {
+        &self.params
+    }
+
     pub(super) fn snapshot(&self) -> Option<CmdSnapshot<'_>> {
         if self.sound.is_some() || !self.params.is_empty() {
             Some((self.sound.as_ref(), self.params.as_slice()))
@@ -165,5 +206,6 @@ impl CmdRegister {
     pub(super) fn clear(&mut self) {
         self.sound = None;
         self.params.clear();
+        self.deltas.clear();
     }
 }

crates/forth/src/words/compile.rs

@@ -0,0 +1,328 @@
+use std::sync::Arc;
+
+use crate::ops::Op;
+use crate::theory;
+use crate::types::{Dictionary, SourceSpan};
+
+use super::{lookup_word, WordCompile::*};
+
+pub(super) fn simple_op(name: &str) -> Option<Op> {
+    Some(match name {
+        "dup" => Op::Dup,
+        "dupn" => Op::Dupn,
+        "drop" => Op::Drop,
+        "swap" => Op::Swap,
+        "over" => Op::Over,
+        "rot" => Op::Rot,
+        "nip" => Op::Nip,
+        "tuck" => Op::Tuck,
+        "2dup" => Op::Dup2,
+        "2drop" => Op::Drop2,
+        "2swap" => Op::Swap2,
+        "2over" => Op::Over2,
+        "rev" => Op::Rev,
+        "shuffle" => Op::Shuffle,
+        "sort" => Op::Sort,
+        "rsort" => Op::RSort,
+        "sum" => Op::Sum,
+        "prod" => Op::Prod,
+        "+" => Op::Add,
+        "-" => Op::Sub,
+        "*" => Op::Mul,
+        "/" => Op::Div,
+        "mod" => Op::Mod,
+        "neg" => Op::Neg,
+        "abs" => Op::Abs,
+        "floor" => Op::Floor,
+        "ceil" => Op::Ceil,
+        "round" => Op::Round,
+        "min" => Op::Min,
+        "max" => Op::Max,
+        "pow" => Op::Pow,
+        "sqrt" => Op::Sqrt,
+        "sin" => Op::Sin,
+        "cos" => Op::Cos,
+        "log" => Op::Log,
+        "=" => Op::Eq,
+        "!=" => Op::Ne,
+        "lt" => Op::Lt,
+        "gt" => Op::Gt,
+        "<=" => Op::Le,
+        ">=" => Op::Ge,
+        "and" => Op::And,
+        "or" => Op::Or,
+        "not" => Op::Not,
+        "xor" => Op::Xor,
+        "nand" => Op::Nand,
+        "nor" => Op::Nor,
+        "ifelse" => Op::IfElse,
+        "pick" => Op::Pick,
+        "sound" => Op::NewCmd,
+        "." => Op::Emit,
+        "rand" => Op::Rand(None),
+        "exprand" => Op::ExpRand(None),
+        "logrand" => Op::LogRand(None),
+        "seed" => Op::Seed,
+        "cycle" => Op::Cycle(None),
+        "pcycle" => Op::PCycle(None),
+        "choose" => Op::Choose(None),
+        "bounce" => Op::Bounce(None),
+        "wchoose" => Op::WChoose(None),
+        "every" => Op::Every(None),
+        "bjork" => Op::Bjork(None),
+        "pbjork" => Op::PBjork(None),
+        "chance" => Op::ChanceExec(None),
+        "prob" => Op::ProbExec(None),
+        "coin" => Op::Coin(None),
+        "mtof" => Op::Mtof,
+        "ftom" => Op::Ftom,
+        "?" => Op::When,
+        "!?" => Op::Unless,
+        "tempo!" => Op::SetTempo,
+        "speed!" => Op::SetSpeed,
+        "at" => Op::At,
+        "arp" => Op::Arp,
+        "adsr" => Op::Adsr,
+        "ad" => Op::Ad,
+        "apply" => Op::Apply,
+        "ramp" => Op::Ramp,
+        "triangle" => Op::Triangle,
+        "range" => Op::Range,
+        "linmap" => Op::LinMap,
+        "expmap" => Op::ExpMap,
+        "perlin" => Op::Perlin,
+        "loop" => Op::Loop,
+        "oct" => Op::Oct,
+        "clear" => Op::ClearCmd,
+        ".." => Op::IntRange,
+        ".," => Op::StepRange,
+        "gen" => Op::Generate,
+        "geom.." => Op::GeomRange,
+        "euclid" => Op::Euclid,
+        "euclidrot" => Op::EuclidRot,
+        "times" => Op::Times,
+        "m." => Op::MidiEmit,
+        "ccval" => Op::GetMidiCC,
+        "mclock" => Op::MidiClock,
+        "mstart" => Op::MidiStart,
+        "mstop" => Op::MidiStop,
+        "mcont" => Op::MidiContinue,
+        "forget" => Op::Forget,
+        "key!" => Op::SetKey,
+        "tp" => Op::Transpose,
+        "inv" => Op::Invert,
+        "dinv" => Op::DownInvert,
+        "drop2" => Op::VoiceDrop2,
+        "drop3" => Op::VoiceDrop3,
+        "lfo" => Op::ModLfo(0),
+        "tlfo" => Op::ModLfo(1),
+        "wlfo" => Op::ModLfo(2),
+        "qlfo" => Op::ModLfo(3),
+        "slide" => Op::ModSlide(0),
+        "expslide" => Op::ModSlide(1),
+        "sslide" => Op::ModSlide(2),
+        "jit" => Op::ModRnd(0),
+        "sjit" => Op::ModRnd(1),
+        "drunk" => Op::ModRnd(2),
+        "env" => Op::ModEnv,
+        _ => return None,
+    })
+}
+
+fn parse_note_name(name: &str) -> Option<i64> {
+    let name = name.to_lowercase();
+    let bytes = name.as_bytes();
+
+    if bytes.len() < 2 {
+        return None;
+    }
+
+    let base = match bytes[0] {
+        b'c' => 0,
+        b'd' => 2,
+        b'e' => 4,
+        b'f' => 5,
+        b'g' => 7,
+        b'a' => 9,
+        b'b' => 11,
+        _ => return None,
+    };
+
+    let (modifier, octave_start) = match bytes[1] {
+        b'#' | b's' => (1, 2),
+        b'b' if bytes.len() > 2 && bytes[2].is_ascii_digit() => (-1, 2),
+        b'0'..=b'9' => (0, 1),
+        _ => return None,
+    };
+
+    let octave_str = &name[octave_start..];
+    let octave: i64 = octave_str.parse().ok()?;
+
+    if !(-1..=9).contains(&octave) {
+        return None;
+    }
+
+    Some((octave + 1) * 12 + base + modifier)
+}
+
+fn parse_interval(name: &str) -> Option<i64> {
+    let simple = match name {
+        "P1" | "unison" => 0,
+        "m2" => 1,
+        "M2" => 2,
+        "m3" => 3,
+        "M3" => 4,
+        "P4" => 5,
+        "aug4" | "dim5" | "tritone" => 6,
+        "P5" => 7,
+        "m6" => 8,
+        "M6" => 9,
+        "m7" => 10,
+        "M7" => 11,
+        "P8" => 12,
+        "m9" => 13,
+        "M9" => 14,
+        "m10" => 15,
+        "M10" => 16,
+        "P11" => 17,
+        "aug11" => 18,
+        "P12" => 19,
+        "m13" => 20,
+        "M13" => 21,
+        "m14" => 22,
+        "M14" => 23,
+        "P15" => 24,
+        _ => return None,
+    };
+    Some(simple)
+}
+
+fn attach_span(op: &mut Op, span: SourceSpan) {
+    match op {
+        Op::Rand(s) | Op::ExpRand(s) | Op::LogRand(s) | Op::Coin(s)
+        | Op::Choose(s) | Op::WChoose(s) | Op::Cycle(s) | Op::PCycle(s)
+        | Op::Bounce(s) | Op::ChanceExec(s) | Op::ProbExec(s)
+        | Op::Every(s)
+        | Op::Bjork(s) | Op::PBjork(s) => *s = Some(span),
+        _ => {}
+    }
+}
+
+pub(crate) fn compile_word(
+    name: &str,
+    span: Option<SourceSpan>,
+    ops: &mut Vec<Op>,
+    dict: &Dictionary,
+) -> bool {
+    match name {
+        "linramp" => {
+            ops.push(Op::PushFloat(1.0, span));
+            ops.push(Op::Ramp);
+            return true;
+        }
+        "expramp" => {
+            ops.push(Op::PushFloat(3.0, span));
+            ops.push(Op::Ramp);
+            return true;
+        }
+        "logramp" => {
+            ops.push(Op::PushFloat(0.3, span));
+            ops.push(Op::Ramp);
+            return true;
+        }
+        _ => {}
+    }
+
+    if name == "triad" || name == "seventh" {
+        if let Some(Op::Degree(pattern)) = ops.last() {
+            let pattern = *pattern;
+            ops.pop();
+            ops.push(if name == "triad" {
+                Op::DiatonicTriad(pattern)
+            } else {
+                Op::DiatonicSeventh(pattern)
+            });
+            return true;
+        }
+        return false;
+    }
+
+    if let Some(pattern) = theory::lookup(name) {
+        ops.push(Op::Degree(pattern));
+        return true;
+    }
+
+    if let Some(intervals) = theory::chords::lookup(name) {
+        ops.push(Op::Chord(intervals));
+        return true;
+    }
+
+    if let Some(word) = lookup_word(name) {
+        match &word.compile {
+            Simple => {
+                if let Some(mut op) = simple_op(word.name) {
+                    if let Some(sp) = span {
+                        attach_span(&mut op, sp);
+                    }
+                    ops.push(op);
+                }
+            }
+            Context(ctx) => ops.push(Op::GetContext(ctx)),
+            Param => ops.push(Op::SetParam(word.name)),
+            Probability(p) => {
+                ops.push(Op::PushFloat(*p, None));
+                ops.push(Op::ChanceExec(span));
+            }
+        }
+        return true;
+    }
+
+    if let Some(var_name) = name.strip_prefix('@') {
+        if !var_name.is_empty() {
+            ops.push(Op::PushStr(Arc::from(var_name), span));
+            ops.push(Op::Get);
+            return true;
+        }
+    }
+
+    if let Some(var_name) = name.strip_prefix('!') {
+        if !var_name.is_empty() {
+            ops.push(Op::PushStr(Arc::from(var_name), span));
+            ops.push(Op::Set);
+            return true;
+        }
+    }
+
+    if let Some(var_name) = name.strip_prefix(',') {
+        if !var_name.is_empty() {
+            ops.push(Op::PushStr(Arc::from(var_name), span));
+            ops.push(Op::SetKeep);
+            return true;
+        }
+    }
+
+    if let Some(midi) = parse_note_name(name) {
+        ops.push(Op::PushInt(midi, span));
+        return true;
+    }
+
+    if let Some(semitones) = parse_interval(name) {
+        ops.push(Op::Dup);
+        ops.push(Op::PushInt(semitones, span));
+        ops.push(Op::Add);
+        return true;
+    }
+
+    if let Some(op) = simple_op(name) {
+        ops.push(op);
+        return true;
+    }
+
+    if let Some(body) = dict.lock().get(name) {
+        ops.extend(body.iter().cloned());
+        return true;
+    }
+
+    ops.push(Op::PushStr(Arc::from(name), span));
+    true
+}

crates/forth/src/words/core.rs

@@ -0,0 +1,622 @@
+use super::{Word, WordCompile::*};
+
+// Stack, Arithmetic, Comparison, Logic, Control, Variables, Definitions
+pub(super) const WORDS: &[Word] = &[
+    // Stack manipulation
+    Word {
+        name: "dup",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a -- a a)",
+        desc: "Duplicate top of stack",
+        example: "3 dup => 3 3",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "dupn",
+        aliases: &["!"],
+        category: "Stack",
+        stack: "(a n -- a a ... a)",
+        desc: "Duplicate a onto stack n times",
+        example: "2 4 dupn => 2 2 2 2",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "drop",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a --)",
+        desc: "Remove top of stack",
+        example: "1 2 drop => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "swap",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b -- b a)",
+        desc: "Exchange top two items",
+        example: "1 2 swap => 2 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "over",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b -- a b a)",
+        desc: "Copy second to top",
+        example: "1 2 over => 1 2 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "rot",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b c -- b c a)",
+        desc: "Rotate top three",
+        example: "1 2 3 rot => 2 3 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "nip",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b -- b)",
+        desc: "Remove second item",
+        example: "1 2 nip => 2",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "tuck",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b -- b a b)",
+        desc: "Copy top under second",
+        example: "1 2 tuck => 2 1 2",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "2dup",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b -- a b a b)",
+        desc: "Duplicate top two values",
+        example: "1 2 2dup => 1 2 1 2",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "2drop",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b --)",
+        desc: "Drop top two values",
+        example: "1 2 3 2drop => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "2swap",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b c d -- c d a b)",
+        desc: "Swap top two pairs",
+        example: "1 2 3 4 2swap => 3 4 1 2",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "2over",
+        aliases: &[],
+        category: "Stack",
+        stack: "(a b c d -- a b c d a b)",
+        desc: "Copy second pair to top",
+        example: "1 2 3 4 2over => 1 2 3 4 1 2",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "rev",
+        aliases: &[],
+        category: "Stack",
+        stack: "(..n n -- ..n)",
+        desc: "Reverse top n items",
+        example: "1 2 3 3 rev => 3 2 1",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "shuffle",
+        aliases: &[],
+        category: "Stack",
+        stack: "(..n n -- ..n)",
+        desc: "Randomly shuffle top n items",
+        example: "1 2 3 3 shuffle",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "sort",
+        aliases: &[],
+        category: "Stack",
+        stack: "(..n n -- ..n)",
+        desc: "Sort top n items ascending",
+        example: "3 1 2 3 sort => 1 2 3",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "rsort",
+        aliases: &[],
+        category: "Stack",
+        stack: "(..n n -- ..n)",
+        desc: "Sort top n items descending",
+        example: "1 2 3 3 rsort => 3 2 1",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "sum",
+        aliases: &[],
+        category: "Stack",
+        stack: "(..n n -- total)",
+        desc: "Sum top n items",
+        example: "1 2 3 3 sum => 6",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "prod",
+        aliases: &[],
+        category: "Stack",
+        stack: "(..n n -- product)",
+        desc: "Multiply top n items",
+        example: "2 3 4 3 prod => 24",
+        compile: Simple,
+        varargs: true,
+    },
+    // Arithmetic
+    Word {
+        name: "+",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a b -- a+b)",
+        desc: "Add",
+        example: "2 3 + => 5",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "-",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a b -- a-b)",
+        desc: "Subtract",
+        example: "5 3 - => 2",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "*",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a b -- a*b)",
+        desc: "Multiply",
+        example: "3 4 * => 12",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "/",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a b -- a/b)",
+        desc: "Divide",
+        example: "10 2 / => 5",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "mod",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a b -- a%b)",
+        desc: "Modulo",
+        example: "7 3 mod => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "neg",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a -- -a)",
+        desc: "Negate",
+        example: "5 neg => -5",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "abs",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a -- |a|)",
+        desc: "Absolute value",
+        example: "-5 abs => 5",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "floor",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(f -- n)",
+        desc: "Round down to integer",
+        example: "3.7 floor => 3",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "ceil",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(f -- n)",
+        desc: "Round up to integer",
+        example: "3.2 ceil => 4",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "round",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(f -- n)",
+        desc: "Round to nearest integer",
+        example: "3.5 round => 4",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "min",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a b -- min)",
+        desc: "Minimum of two values",
+        example: "3 5 min => 3",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "max",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a b -- max)",
+        desc: "Maximum of two values",
+        example: "3 5 max => 5",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "pow",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a b -- a^b)",
+        desc: "Exponentiation",
+        example: "2 3 pow => 8",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "sqrt",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a -- √a)",
+        desc: "Square root",
+        example: "16 sqrt => 4",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "sin",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a -- sin(a))",
+        desc: "Sine (radians)",
+        example: "3.14159 2 / sin => 1.0",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "cos",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a -- cos(a))",
+        desc: "Cosine (radians)",
+        example: "0 cos => 1.0",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "log",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(a -- ln(a))",
+        desc: "Natural logarithm",
+        example: "2.718 log => 1.0",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "linmap",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(val inlo inhi outlo outhi -- mapped)",
+        desc: "Linear map from [inlo,inhi] to [outlo,outhi]",
+        example: "64 0 127 200 2000 linmap => 1007.87",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "expmap",
+        aliases: &[],
+        category: "Arithmetic",
+        stack: "(val lo hi -- mapped)",
+        desc: "Exponential map from [0,1] to [lo,hi]",
+        example: "0.5 200 8000 expmap => 1264.91",
+        compile: Simple,
+        varargs: false,
+    },
+    // Comparison
+    Word {
+        name: "=",
+        aliases: &[],
+        category: "Comparison",
+        stack: "(a b -- bool)",
+        desc: "Equal",
+        example: "3 3 = => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "!=",
+        aliases: &["<>"],
+        category: "Comparison",
+        stack: "(a b -- bool)",
+        desc: "Not equal",
+        example: "3 4 != => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "lt",
+        aliases: &[],
+        category: "Comparison",
+        stack: "(a b -- bool)",
+        desc: "Less than",
+        example: "2 3 lt => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "gt",
+        aliases: &[],
+        category: "Comparison",
+        stack: "(a b -- bool)",
+        desc: "Greater than",
+        example: "3 2 gt => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "<=",
+        aliases: &[],
+        category: "Comparison",
+        stack: "(a b -- bool)",
+        desc: "Less or equal",
+        example: "3 3 <= => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: ">=",
+        aliases: &[],
+        category: "Comparison",
+        stack: "(a b -- bool)",
+        desc: "Greater or equal",
+        example: "3 3 >= => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    // Logic
+    Word {
+        name: "and",
+        aliases: &[],
+        category: "Logic",
+        stack: "(a b -- bool)",
+        desc: "Logical and",
+        example: "1 1 and => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "or",
+        aliases: &[],
+        category: "Logic",
+        stack: "(a b -- bool)",
+        desc: "Logical or",
+        example: "0 1 or => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "not",
+        aliases: &[],
+        category: "Logic",
+        stack: "(a -- bool)",
+        desc: "Logical not",
+        example: "0 not => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "xor",
+        aliases: &[],
+        category: "Logic",
+        stack: "(a b -- bool)",
+        desc: "Exclusive or",
+        example: "1 0 xor => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "nand",
+        aliases: &[],
+        category: "Logic",
+        stack: "(a b -- bool)",
+        desc: "Not and",
+        example: "1 1 nand => 0",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "nor",
+        aliases: &[],
+        category: "Logic",
+        stack: "(a b -- bool)",
+        desc: "Not or",
+        example: "0 0 nor => 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "ifelse",
+        aliases: &[],
+        category: "Logic",
+        stack: "(true-quot false-quot bool --)",
+        desc: "Execute true-quot if true, else false-quot",
+        example: "{ 1 } { 2 } coin ifelse",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "pick",
+        aliases: &[],
+        category: "Logic",
+        stack: "(..quots n --)",
+        desc: "Execute nth quotation (0-indexed)",
+        example: "{ 1 } { 2 } { 3 } 2 pick => 3",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "?",
+        aliases: &[],
+        category: "Logic",
+        stack: "(quot bool --)",
+        desc: "Execute quotation if true",
+        example: "{ 2 distort } 0.5 chance ?",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "!?",
+        aliases: &[],
+        category: "Logic",
+        stack: "(quot bool --)",
+        desc: "Execute quotation if false",
+        example: "{ 1 distort } 0.5 chance !?",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "apply",
+        aliases: &[],
+        category: "Logic",
+        stack: "(quot --)",
+        desc: "Execute quotation unconditionally",
+        example: "{ 2 * } apply",
+        compile: Simple,
+        varargs: false,
+    },
+    // Control
+    Word {
+        name: "times",
+        aliases: &[],
+        category: "Control",
+        stack: "(n quot --)",
+        desc: "Execute quotation n times, @i holds current index",
+        example: "4 { @i . } times => 0 1 2 3",
+        compile: Simple,
+        varargs: false,
+    },
+    // Variables
+    Word {
+        name: "@<var>",
+        aliases: &[],
+        category: "Variables",
+        stack: "( -- val)",
+        desc: "Fetch variable value",
+        example: "@freq => 440",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "!<var>",
+        aliases: &[],
+        category: "Variables",
+        stack: "(val --)",
+        desc: "Store value in variable",
+        example: "440 !freq",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: ",<var>",
+        aliases: &[],
+        category: "Variables",
+        stack: "(val -- val)",
+        desc: "Store value in variable, keep on stack",
+        example: "440 ,freq => 440",
+        compile: Simple,
+        varargs: false,
+    },
+    // Definitions
+    Word {
+        name: ":",
+        aliases: &[],
+        category: "Definitions",
+        stack: "( -- )",
+        desc: "Begin word definition",
+        example: ": kick \"kick\" s emit ;",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: ";",
+        aliases: &[],
+        category: "Definitions",
+        stack: "( -- )",
+        desc: "End word definition",
+        example: ": kick \"kick\" s emit ;",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "forget",
+        aliases: &[],
+        category: "Definitions",
+        stack: "(name --)",
+        desc: "Remove user-defined word from dictionary",
+        example: "\"double\" forget",
+        compile: Simple,
+        varargs: false,
+    },
+];

crates/forth/src/words/effects.rs

@@ -0,0 +1,962 @@
+use super::{Word, WordCompile::*};
+
+// Filter, Envelope, Reverb, Delay, Lo-fi, Stereo, Mod FX
+pub(super) const WORDS: &[Word] = &[
+    // Envelope
+    Word {
+        name: "gain",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set volume (0-1)",
+        example: "0.8 gain",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "postgain",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set post gain",
+        example: "1.2 postgain",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "velocity",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set velocity",
+        example: "100 velocity",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "attack",
+        aliases: &["att"],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set attack time",
+        example: "0.01 attack",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "decay",
+        aliases: &["dec"],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set decay time",
+        example: "0.1 decay",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "sustain",
+        aliases: &["sus"],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set sustain level",
+        example: "0.5 sustain",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "release",
+        aliases: &["rel"],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set release time",
+        example: "0.3 release",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "adsr",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(a d s r --)",
+        desc: "Set attack, decay, sustain, release",
+        example: "0.01 0.1 0.5 0.3 adsr",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "ad",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(a d --)",
+        desc: "Set attack, decay (sustain=0)",
+        example: "0.01 0.1 ad",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "penv",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set pitch envelope",
+        example: "0.5 penv",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "patt",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set pitch attack",
+        example: "0.01 patt",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "pdec",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set pitch decay",
+        example: "0.1 pdec",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "psus",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set pitch sustain",
+        example: "0 psus",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "prel",
+        aliases: &[],
+        category: "Envelope",
+        stack: "(v.. --)",
+        desc: "Set pitch release",
+        example: "0.1 prel",
+        compile: Param,
+        varargs: true,
+    },
+    // Filter
+    Word {
+        name: "lpf",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set lowpass frequency",
+        example: "2000 lpf",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lpq",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set lowpass resonance",
+        example: "0.5 lpq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lpe",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set lowpass envelope",
+        example: "0.5 lpe",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lpa",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set lowpass attack",
+        example: "0.01 lpa",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lpd",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set lowpass decay",
+        example: "0.1 lpd",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lps",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set lowpass sustain",
+        example: "0.5 lps",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lpr",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set lowpass release",
+        example: "0.3 lpr",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "hpf",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set highpass frequency",
+        example: "100 hpf",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "hpq",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set highpass resonance",
+        example: "0.5 hpq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "hpe",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set highpass envelope",
+        example: "0.5 hpe",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "hpa",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set highpass attack",
+        example: "0.01 hpa",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "hpd",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set highpass decay",
+        example: "0.1 hpd",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "hps",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set highpass sustain",
+        example: "0.5 hps",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "hpr",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set highpass release",
+        example: "0.3 hpr",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "bpf",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set bandpass frequency",
+        example: "1000 bpf",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "bpq",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set bandpass resonance",
+        example: "0.5 bpq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "bpe",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set bandpass envelope",
+        example: "0.5 bpe",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "bpa",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set bandpass attack",
+        example: "0.01 bpa",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "bpd",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set bandpass decay",
+        example: "0.1 bpd",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "bps",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set bandpass sustain",
+        example: "0.5 bps",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "bpr",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set bandpass release",
+        example: "0.3 bpr",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "llpf",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set ladder lowpass frequency",
+        example: "2000 llpf",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "llpq",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set ladder lowpass resonance",
+        example: "0.5 llpq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lhpf",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set ladder highpass frequency",
+        example: "100 lhpf",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lhpq",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set ladder highpass resonance",
+        example: "0.5 lhpq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lbpf",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set ladder bandpass frequency",
+        example: "1000 lbpf",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "lbpq",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set ladder bandpass resonance",
+        example: "0.5 lbpq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "ftype",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set filter type",
+        example: "1 ftype",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "eqlo",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set low shelf gain (dB)",
+        example: "3 eqlo",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "eqmid",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set mid peak gain (dB)",
+        example: "-2 eqmid",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "eqhi",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set high shelf gain (dB)",
+        example: "1 eqhi",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "tilt",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set tilt EQ (-1 dark, 1 bright)",
+        example: "-0.5 tilt",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "comb",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set comb filter mix",
+        example: "0.5 comb",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "combfreq",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set comb frequency",
+        example: "200 combfreq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "combfeedback",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set comb feedback",
+        example: "0.5 combfeedback",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "combdamp",
+        aliases: &[],
+        category: "Filter",
+        stack: "(v.. --)",
+        desc: "Set comb damping",
+        example: "0.5 combdamp",
+        compile: Param,
+        varargs: true,
+    },
+    // Reverb
+    Word {
+        name: "verb",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb mix",
+        example: "0.3 verb",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbdecay",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb decay (0-1)",
+        example: "0.75 verbdecay",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbdamp",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb damping",
+        example: "0.5 verbdamp",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbpredelay",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb predelay (0-1)",
+        example: "0.1 verbpredelay",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbdiff",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb diffusion",
+        example: "0.7 verbdiff",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbtype",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb algorithm (vital or dattorro)",
+        example: "vital verbtype",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbchorus",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb chorus amount (0-1)",
+        example: "0.3 verbchorus",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbchorusfreq",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb chorus frequency (0-1)",
+        example: "0.2 verbchorusfreq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbprelow",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb pre-low filter (0-1)",
+        example: "0.2 verbprelow",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbprehigh",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb pre-high filter (0-1)",
+        example: "0.8 verbprehigh",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verblowcut",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb low cut frequency (0-1)",
+        example: "0.5 verblowcut",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verbhighcut",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb high cut frequency (0-1)",
+        example: "0.7 verbhighcut",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "verblowgain",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set reverb low gain (0-1)",
+        example: "0.4 verblowgain",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "size",
+        aliases: &[],
+        category: "Reverb",
+        stack: "(v.. --)",
+        desc: "Set size",
+        example: "1 size",
+        compile: Param,
+        varargs: true,
+    },
+    // Delay
+    Word {
+        name: "delay",
+        aliases: &[],
+        category: "Delay",
+        stack: "(v.. --)",
+        desc: "Set delay mix",
+        example: "0.3 delay",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "delaytime",
+        aliases: &[],
+        category: "Delay",
+        stack: "(v.. --)",
+        desc: "Set delay time",
+        example: "0.25 delaytime",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "delayfeedback",
+        aliases: &[],
+        category: "Delay",
+        stack: "(v.. --)",
+        desc: "Set delay feedback",
+        example: "0.5 delayfeedback",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "delaytype",
+        aliases: &[],
+        category: "Delay",
+        stack: "(v.. --)",
+        desc: "Set delay type",
+        example: "1 delaytype",
+        compile: Param,
+        varargs: true,
+    },
+    // Lo-fi
+    Word {
+        name: "crush",
+        aliases: &[],
+        category: "Lo-fi",
+        stack: "(v.. --)",
+        desc: "Set bit crush",
+        example: "8 crush",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fold",
+        aliases: &[],
+        category: "Lo-fi",
+        stack: "(v.. --)",
+        desc: "Set wave fold",
+        example: "2 fold",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "wrap",
+        aliases: &[],
+        category: "Lo-fi",
+        stack: "(v.. --)",
+        desc: "Set wave wrap",
+        example: "0.5 wrap",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "distort",
+        aliases: &[],
+        category: "Lo-fi",
+        stack: "(v.. --)",
+        desc: "Set distortion",
+        example: "0.5 distort",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "distortvol",
+        aliases: &[],
+        category: "Lo-fi",
+        stack: "(v.. --)",
+        desc: "Set distortion volume",
+        example: "0.8 distortvol",
+        compile: Param,
+        varargs: true,
+    },
+    // Stereo
+    Word {
+        name: "pan",
+        aliases: &[],
+        category: "Stereo",
+        stack: "(v.. --)",
+        desc: "Set pan (-1 to 1)",
+        example: "0.5 pan",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "width",
+        aliases: &[],
+        category: "Stereo",
+        stack: "(v.. --)",
+        desc: "Set stereo width (0 mono, 1 normal, 2 wide)",
+        example: "0 width",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "haas",
+        aliases: &[],
+        category: "Stereo",
+        stack: "(v.. --)",
+        desc: "Set Haas delay in ms (spatial placement)",
+        example: "8 haas",
+        compile: Param,
+        varargs: true,
+    },
+    // Mod FX
+    Word {
+        name: "phaser",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set phaser rate",
+        example: "1 phaser",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "phaserdepth",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set phaser depth",
+        example: "0.5 phaserdepth",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "phasersweep",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set phaser sweep",
+        example: "0.5 phasersweep",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "phasercenter",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set phaser center",
+        example: "1000 phasercenter",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "flanger",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set flanger rate",
+        example: "0.5 flanger",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "flangerdepth",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set flanger depth",
+        example: "0.5 flangerdepth",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "flangerfeedback",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set flanger feedback",
+        example: "0.5 flangerfeedback",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "smear",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set smear allpass chain wet/dry mix (0=bypass, 1=full wet)",
+        example: "0.5 smear",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "smearfreq",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set smear allpass break frequency in Hz",
+        example: "800 smearfreq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "smearfb",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set smear feedback for resonance (0-0.95)",
+        example: "0.8 smearfb",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "chorus",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set chorus rate",
+        example: "1 chorus",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "chorusdepth",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set chorus depth",
+        example: "0.5 chorusdepth",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "chorusdelay",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set chorus delay",
+        example: "0.02 chorusdelay",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "feedback",
+        aliases: &["fb"],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set feedback delay level",
+        example: "0.7 feedback",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fbtime",
+        aliases: &["fbt"],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set feedback delay time in ms",
+        example: "30 fbtime",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fbdamp",
+        aliases: &["fbd"],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set feedback delay damping",
+        example: "0.3 fbdamp",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fblfo",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set feedback delay LFO rate in Hz",
+        example: "2 fblfo",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fblfodepth",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set feedback delay LFO depth",
+        example: "0.5 fblfodepth",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fblfoshape",
+        aliases: &[],
+        category: "Mod FX",
+        stack: "(v.. --)",
+        desc: "Set feedback delay LFO shape",
+        example: "tri fblfoshape",
+        compile: Param,
+        varargs: true,
+    },
+];

crates/forth/src/words/midi.rs

@@ -0,0 +1,135 @@
+use super::{Word, WordCompile::*};
+
+// MIDI
+pub(super) const WORDS: &[Word] = &[
+    Word {
+        name: "chan",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(v.. --)",
+        desc: "Set MIDI channel 1-16",
+        example: "1 chan",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "ccnum",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(v.. --)",
+        desc: "Set MIDI CC number 0-127",
+        example: "1 ccnum",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "ccout",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(v.. --)",
+        desc: "Set MIDI CC output value 0-127",
+        example: "64 ccout",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "bend",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(v.. --)",
+        desc: "Set pitch bend -1.0 to 1.0 (0 = center)",
+        example: "0.5 bend",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "pressure",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(v.. --)",
+        desc: "Set channel pressure (aftertouch) 0-127",
+        example: "64 pressure",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "program",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(v.. --)",
+        desc: "Set program change number 0-127",
+        example: "0 program",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "m.",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(--)",
+        desc: "Emit MIDI message from params (note/cc/bend/pressure/program)",
+        example: "60 note 100 velocity 1 chan m.",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "mclock",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(--)",
+        desc: "Send MIDI clock pulse (24 per quarter note)",
+        example: "mclock",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "mstart",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(--)",
+        desc: "Send MIDI start message",
+        example: "mstart",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "mstop",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(--)",
+        desc: "Send MIDI stop message",
+        example: "mstop",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "mcont",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(--)",
+        desc: "Send MIDI continue message",
+        example: "mcont",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "ccval",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(cc chan -- val)",
+        desc: "Read CC value 0-127 from MIDI input (uses dev param for device)",
+        example: "1 1 ccval",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "dev",
+        aliases: &[],
+        category: "MIDI",
+        stack: "(v.. --)",
+        desc: "Set MIDI device slot 0-3 for output/input",
+        example: "1 dev 60 note m.",
+        compile: Param,
+        varargs: true,
+    },
+];

crates/forth/src/words/mod.rs

@@ -0,0 +1,58 @@
+mod compile;
+mod core;
+mod effects;
+mod midi;
+mod music;
+mod sequencing;
+mod sound;
+
+use std::collections::HashMap;
+use std::sync::LazyLock;
+
+pub(crate) use compile::compile_word;
+
+#[derive(Clone, Copy)]
+pub enum WordCompile {
+    Simple,
+    Context(&'static str),
+    Param,
+    Probability(f64),
+}
+
+#[derive(Clone, Copy)]
+pub struct Word {
+    pub name: &'static str,
+    pub aliases: &'static [&'static str],
+    pub category: &'static str,
+    pub stack: &'static str,
+    pub desc: &'static str,
+    pub example: &'static str,
+    pub compile: WordCompile,
+    pub varargs: bool,
+}
+
+pub static WORDS: LazyLock<Vec<Word>> = LazyLock::new(|| {
+    let mut words = Vec::new();
+    words.extend_from_slice(self::core::WORDS);
+    words.extend_from_slice(sound::WORDS);
+    words.extend_from_slice(effects::WORDS);
+    words.extend_from_slice(sequencing::WORDS);
+    words.extend_from_slice(music::WORDS);
+    words.extend_from_slice(midi::WORDS);
+    words
+});
+
+static WORD_MAP: LazyLock<HashMap<&'static str, &'static Word>> = LazyLock::new(|| {
+    let mut map = HashMap::with_capacity(WORDS.len() * 2);
+    for word in WORDS.iter() {
+        map.insert(word.name, word);
+        for alias in word.aliases {
+            map.insert(alias, word);
+        }
+    }
+    map
+});
+
+pub fn lookup_word(name: &str) -> Option<&'static Word> {
+    WORD_MAP.get(name).copied()
+}

crates/forth/src/words/music.rs

@@ -0,0 +1,495 @@
+use super::{Word, WordCompile::*};
+
+// Music, Chord
+pub(super) const WORDS: &[Word] = &[
+    // Music
+    Word {
+        name: "mtof",
+        aliases: &[],
+        category: "Music",
+        stack: "(midi -- hz)",
+        desc: "MIDI note to frequency",
+        example: "69 mtof => 440.0",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "ftom",
+        aliases: &[],
+        category: "Music",
+        stack: "(hz -- midi)",
+        desc: "Frequency to MIDI note",
+        example: "440 ftom => 69.0",
+        compile: Simple,
+        varargs: false,
+    },
+    // Harmony
+    Word {
+        name: "key!",
+        aliases: &[],
+        category: "Harmony",
+        stack: "(root --)",
+        desc: "Set tonal center for scale operations",
+        example: "g3 key! 0 major => 55",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "triad",
+        aliases: &[],
+        category: "Harmony",
+        stack: "(degree -- n1 n2 n3)",
+        desc: "Diatonic triad from scale degree (follows a scale word)",
+        example: "0 major triad => 60 64 67",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "seventh",
+        aliases: &[],
+        category: "Harmony",
+        stack: "(degree -- n1 n2 n3 n4)",
+        desc: "Diatonic seventh from scale degree (follows a scale word)",
+        example: "0 major seventh => 60 64 67 71",
+        compile: Simple,
+        varargs: true,
+    },
+    // Chord voicings
+    Word {
+        name: "inv",
+        aliases: &[],
+        category: "Chord",
+        stack: "(a b c.. -- b c.. a+12)",
+        desc: "Inversion: bottom note moves up an octave",
+        example: "c4 maj inv => 64 67 72",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dinv",
+        aliases: &[],
+        category: "Chord",
+        stack: "(a b.. z -- z-12 a b..)",
+        desc: "Down inversion: top note moves down an octave",
+        example: "c4 maj dinv => 55 60 64",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "drop2",
+        aliases: &[],
+        category: "Chord",
+        stack: "(a b c d -- b-12 a c d)",
+        desc: "Drop-2 voicing: 2nd from top moves down an octave",
+        example: "c4 maj7 drop2 => 55 60 64 71",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "drop3",
+        aliases: &[],
+        category: "Chord",
+        stack: "(a b c d -- c-12 a b d)",
+        desc: "Drop-3 voicing: 3rd from top moves down an octave",
+        example: "c4 maj7 drop3 => 52 60 67 71",
+        compile: Simple,
+        varargs: true,
+    },
+    // Transpose
+    Word {
+        name: "tp",
+        aliases: &[],
+        category: "Harmony",
+        stack: "(n --)",
+        desc: "Transpose all ints on stack by N semitones",
+        example: "c4 maj 3 tp => 63 67 70",
+        compile: Simple,
+        varargs: true,
+    },
+    // Chords - Triads
+    Word {
+        name: "pwr",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root fifth)",
+        desc: "Power chord",
+        example: "c4 pwr => 60 67",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "maj",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth)",
+        desc: "Major triad",
+        example: "c4 maj => 60 64 67",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "m",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth)",
+        desc: "Minor triad",
+        example: "c4 m => 60 63 67",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dim",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth)",
+        desc: "Diminished triad",
+        example: "c4 dim => 60 63 66",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "aug",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth)",
+        desc: "Augmented triad",
+        example: "c4 aug => 60 64 68",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "sus2",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root second fifth)",
+        desc: "Suspended 2nd",
+        example: "c4 sus2 => 60 62 67",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "sus4",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root fourth fifth)",
+        desc: "Suspended 4th",
+        example: "c4 sus4 => 60 65 67",
+        compile: Simple,
+        varargs: true,
+    },
+    // Chords - Seventh
+    Word {
+        name: "maj7",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh)",
+        desc: "Major 7th",
+        example: "c4 maj7 => 60 64 67 71",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "min7",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh)",
+        desc: "Minor 7th",
+        example: "c4 min7 => 60 63 67 70",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dom7",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh)",
+        desc: "Dominant 7th",
+        example: "c4 dom7 => 60 64 67 70",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dim7",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh)",
+        desc: "Diminished 7th",
+        example: "c4 dim7 => 60 63 66 69",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "m7b5",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh)",
+        desc: "Half-diminished (min7b5)",
+        example: "c4 m7b5 => 60 63 66 70",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "minmaj7",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh)",
+        desc: "Minor-major 7th",
+        example: "c4 minmaj7 => 60 63 67 71",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "aug7",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh)",
+        desc: "Augmented 7th",
+        example: "c4 aug7 => 60 64 68 70",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "augmaj7",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh)",
+        desc: "Augmented major 7th",
+        example: "c4 augmaj7 => 60 64 68 71",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "7sus4",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root fourth fifth seventh)",
+        desc: "Dominant 7 sus4",
+        example: "c4 7sus4 => 60 65 67 70",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "9sus4",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root fourth fifth seventh ninth)",
+        desc: "9 sus4",
+        example: "c4 9sus4 => 60 65 67 70 74",
+        compile: Simple,
+        varargs: true,
+    },
+    // Chords - Sixth
+    Word {
+        name: "maj6",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth sixth)",
+        desc: "Major 6th",
+        example: "c4 maj6 => 60 64 67 69",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "min6",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth sixth)",
+        desc: "Minor 6th",
+        example: "c4 min6 => 60 63 67 69",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "maj69",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth sixth ninth)",
+        desc: "Major 6/9",
+        example: "c4 maj69 => 60 64 67 69 74",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "min69",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth sixth ninth)",
+        desc: "Minor 6/9",
+        example: "c4 min69 => 60 63 67 69 74",
+        compile: Simple,
+        varargs: true,
+    },
+    // Chords - Extended
+    Word {
+        name: "dom9",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth)",
+        desc: "Dominant 9th",
+        example: "c4 dom9 => 60 64 67 70 74",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "maj9",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth)",
+        desc: "Major 9th",
+        example: "c4 maj9 => 60 64 67 71 74",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "min9",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth)",
+        desc: "Minor 9th",
+        example: "c4 min9 => 60 63 67 70 74",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dom11",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth eleventh)",
+        desc: "Dominant 11th",
+        example: "c4 dom11 => 60 64 67 70 74 77",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "maj11",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth eleventh)",
+        desc: "Major 11th",
+        example: "c4 maj11 => 60 64 67 71 74 77",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "min11",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth eleventh)",
+        desc: "Minor 11th",
+        example: "c4 min11 => 60 63 67 70 74 77",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dom13",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth thirteenth)",
+        desc: "Dominant 13th",
+        example: "c4 dom13 => 60 64 67 70 74 81",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "maj13",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth thirteenth)",
+        desc: "Major 13th",
+        example: "c4 maj13 => 60 64 67 71 74 81",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "min13",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh ninth thirteenth)",
+        desc: "Minor 13th",
+        example: "c4 min13 => 60 63 67 70 74 81",
+        compile: Simple,
+        varargs: true,
+    },
+    // Chords - Add
+    Word {
+        name: "add9",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth ninth)",
+        desc: "Major add 9",
+        example: "c4 add9 => 60 64 67 74",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "add11",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth eleventh)",
+        desc: "Major add 11",
+        example: "c4 add11 => 60 64 67 77",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "madd9",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth ninth)",
+        desc: "Minor add 9",
+        example: "c4 madd9 => 60 63 67 74",
+        compile: Simple,
+        varargs: true,
+    },
+    // Chords - Altered dominants
+    Word {
+        name: "dom7b9",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh flatninth)",
+        desc: "7th flat 9",
+        example: "c4 dom7b9 => 60 64 67 70 73",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dom7s9",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh sharpninth)",
+        desc: "7th sharp 9 (Hendrix chord)",
+        example: "c4 dom7s9 => 60 64 67 70 75",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dom7b5",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third flatfifth seventh)",
+        desc: "7th flat 5",
+        example: "c4 dom7b5 => 60 64 66 70",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dom7s5",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third sharpfifth seventh)",
+        desc: "7th sharp 5",
+        example: "c4 dom7s5 => 60 64 68 70",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "dom7s11",
+        aliases: &[],
+        category: "Chord",
+        stack: "(root -- root third fifth seventh sharpelev)",
+        desc: "7th sharp 11 (lydian dominant)",
+        example: "c4 dom7s11 => 60 64 67 70 78",
+        compile: Simple,
+        varargs: true,
+    },
+];

crates/forth/src/words/sequencing.rs

@@ -0,0 +1,473 @@
+use super::{Word, WordCompile::*};
+
+// Time, Context, Probability, Generator, Desktop
+pub(super) const WORDS: &[Word] = &[
+    // Probability
+    Word {
+        name: "rand",
+        aliases: &[],
+        category: "Probability",
+        stack: "(min max -- n|f)",
+        desc: "Random in range. Int if both args are int, float otherwise",
+        example: "1 6 rand => 4 | 0.0 1.0 rand => 0.42",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "exprand",
+        aliases: &[],
+        category: "Probability",
+        stack: "(lo hi -- f)",
+        desc: "Exponential random biased toward lo. Both args must be positive",
+        example: "1.0 100.0 exprand => 3.7",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "logrand",
+        aliases: &[],
+        category: "Probability",
+        stack: "(lo hi -- f)",
+        desc: "Exponential random biased toward hi. Both args must be positive",
+        example: "1.0 100.0 logrand => 87.2",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "seed",
+        aliases: &[],
+        category: "Probability",
+        stack: "(n --)",
+        desc: "Set random seed",
+        example: "12345 seed",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "coin",
+        aliases: &[],
+        category: "Probability",
+        stack: "(-- bool)",
+        desc: "50/50 random boolean",
+        example: "coin => 0 or 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "chance",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot prob --)",
+        desc: "Execute quotation with probability (0.0-1.0)",
+        example: "{ 2 distort } 0.75 chance",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "prob",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot pct --)",
+        desc: "Execute quotation with probability (0-100)",
+        example: "{ 2 distort } 75 prob",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "choose",
+        aliases: &[],
+        category: "Probability",
+        stack: "(..n n -- val)",
+        desc: "Random pick from n items",
+        example: "1 2 3 3 choose",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "cycle",
+        aliases: &[],
+        category: "Probability",
+        stack: "(v1..vn n -- selected)",
+        desc: "Cycle through n items by step runs",
+        example: "60 64 67 3 cycle",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "pcycle",
+        aliases: &[],
+        category: "Probability",
+        stack: "(v1..vn n -- selected)",
+        desc: "Cycle through n items by pattern iteration",
+        example: "60 64 67 3 pcycle",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "bounce",
+        aliases: &[],
+        category: "Probability",
+        stack: "(v1..vn n -- selected)",
+        desc: "Ping-pong cycle through n items by step runs",
+        example: "60 64 67 72 4 bounce",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "wchoose",
+        aliases: &[],
+        category: "Probability",
+        stack: "(v1 w1 v2 w2 ... n -- selected)",
+        desc: "Weighted random pick from n value/weight pairs",
+        example: "60 0.6  64 0.3  67 0.1  3 wchoose",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "always",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot --)",
+        desc: "Always execute quotation",
+        example: "{ 2 distort } always",
+        compile: Probability(1.0),
+        varargs: false,
+    },
+    Word {
+        name: "never",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot --)",
+        desc: "Never execute quotation",
+        example: "{ 2 distort } never",
+        compile: Probability(0.0),
+        varargs: false,
+    },
+    Word {
+        name: "often",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot --)",
+        desc: "Execute quotation 75% of the time",
+        example: "{ 2 distort } often",
+        compile: Probability(0.75),
+        varargs: false,
+    },
+    Word {
+        name: "sometimes",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot --)",
+        desc: "Execute quotation 50% of the time",
+        example: "{ 2 distort } sometimes",
+        compile: Probability(0.5),
+        varargs: false,
+    },
+    Word {
+        name: "rarely",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot --)",
+        desc: "Execute quotation 25% of the time",
+        example: "{ 2 distort } rarely",
+        compile: Probability(0.25),
+        varargs: false,
+    },
+    Word {
+        name: "almostNever",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot --)",
+        desc: "Execute quotation 10% of the time",
+        example: "{ 2 distort } almostNever",
+        compile: Probability(0.1),
+        varargs: false,
+    },
+    Word {
+        name: "almostAlways",
+        aliases: &[],
+        category: "Probability",
+        stack: "(quot --)",
+        desc: "Execute quotation 90% of the time",
+        example: "{ 2 distort } almostAlways",
+        compile: Probability(0.9),
+        varargs: false,
+    },
+    // Time
+    Word {
+        name: "every",
+        aliases: &[],
+        category: "Time",
+        stack: "(quot n --)",
+        desc: "Execute quotation every nth iteration",
+        example: "{ 2 distort } 4 every",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "bjork",
+        aliases: &[],
+        category: "Time",
+        stack: "(quot k n --)",
+        desc: "Execute quotation using Euclidean distribution over step runs",
+        example: "{ 2 distort } 3 8 bjork",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "pbjork",
+        aliases: &[],
+        category: "Time",
+        stack: "(quot k n --)",
+        desc: "Execute quotation using Euclidean distribution over pattern iterations",
+        example: "{ 2 distort } 3 8 pbjork",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "loop",
+        aliases: &[],
+        category: "Time",
+        stack: "(n --)",
+        desc: "Fit sample to n beats",
+        example: "\"break\" s 4 loop @",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "tempo!",
+        aliases: &[],
+        category: "Time",
+        stack: "(bpm --)",
+        desc: "Set global tempo",
+        example: "140 tempo!",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "speed!",
+        aliases: &[],
+        category: "Time",
+        stack: "(multiplier --)",
+        desc: "Set pattern speed multiplier",
+        example: "2.0 speed!",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "at",
+        aliases: &[],
+        category: "Time",
+        stack: "(v1..vn --)",
+        desc: "Set delta context for emit timing",
+        example: "0 0.5 at kick s . => emits at 0 and 0.5 of step",
+        compile: Simple,
+        varargs: true,
+    },
+    // Context
+    Word {
+        name: "step",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- n)",
+        desc: "Current step index",
+        example: "step => 0",
+        compile: Context("step"),
+        varargs: false,
+    },
+    Word {
+        name: "beat",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- f)",
+        desc: "Current beat position",
+        example: "beat => 4.5",
+        compile: Context("beat"),
+        varargs: false,
+    },
+    Word {
+        name: "pattern",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- n)",
+        desc: "Current pattern index",
+        example: "pattern => 0",
+        compile: Context("pattern"),
+        varargs: false,
+    },
+    Word {
+        name: "pbank",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- n)",
+        desc: "Current pattern's bank index",
+        example: "pbank => 0",
+        compile: Context("bank"),
+        varargs: false,
+    },
+    Word {
+        name: "tempo",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- f)",
+        desc: "Current BPM",
+        example: "tempo => 120.0",
+        compile: Context("tempo"),
+        varargs: false,
+    },
+    Word {
+        name: "phase",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- f)",
+        desc: "Phase in bar (0-1)",
+        example: "phase => 0.25",
+        compile: Context("phase"),
+        varargs: false,
+    },
+    Word {
+        name: "slot",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- n)",
+        desc: "Current slot number",
+        example: "slot => 0",
+        compile: Context("slot"),
+        varargs: false,
+    },
+    Word {
+        name: "runs",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- n)",
+        desc: "Times this step ran",
+        example: "runs => 3",
+        compile: Context("runs"),
+        varargs: false,
+    },
+    Word {
+        name: "iter",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- n)",
+        desc: "Pattern iteration count",
+        example: "iter => 2",
+        compile: Context("iter"),
+        varargs: false,
+    },
+    Word {
+        name: "stepdur",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- f)",
+        desc: "Step duration in seconds",
+        example: "stepdur => 0.125",
+        compile: Context("stepdur"),
+        varargs: false,
+    },
+    Word {
+        name: "fill",
+        aliases: &[],
+        category: "Context",
+        stack: "(-- bool)",
+        desc: "True when fill is on (f key)",
+        example: "\"snare\" s . fill ?",
+        compile: Context("fill"),
+        varargs: false,
+    },
+    // Desktop
+    #[cfg(feature = "desktop")]
+    Word {
+        name: "mx",
+        aliases: &[],
+        category: "Desktop",
+        stack: "(-- x)",
+        desc: "Normalized mouse X position (0-1)",
+        example: "mx 440 880 range freq",
+        compile: Context("mx"),
+        varargs: false,
+    },
+    #[cfg(feature = "desktop")]
+    Word {
+        name: "my",
+        aliases: &[],
+        category: "Desktop",
+        stack: "(-- y)",
+        desc: "Normalized mouse Y position (0-1)",
+        example: "my 0.1 0.9 range gain",
+        compile: Context("my"),
+        varargs: false,
+    },
+    #[cfg(feature = "desktop")]
+    Word {
+        name: "mdown",
+        aliases: &[],
+        category: "Desktop",
+        stack: "(-- bool)",
+        desc: "1 when mouse button held, 0 otherwise",
+        example: "mdown { \"crash\" s . } ?",
+        compile: Context("mdown"),
+        varargs: false,
+    },
+    // Generator
+    Word {
+        name: "..",
+        aliases: &[],
+        category: "Generator",
+        stack: "(start end -- start start+1 ... end)",
+        desc: "Push arithmetic sequence from start to end",
+        example: "1 4 .. => 1 2 3 4",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: ".,",
+        aliases: &[],
+        category: "Generator",
+        stack: "(start end step -- start start+step ...)",
+        desc: "Push arithmetic sequence with custom step",
+        example: "0 1 0.25 ., => 0 0.25 0.5 0.75 1",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "gen",
+        aliases: &[],
+        category: "Generator",
+        stack: "(quot n -- results...)",
+        desc: "Execute quotation n times, push all results",
+        example: "{ 1 6 rand } 4 gen => 4 random values",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "geom..",
+        aliases: &[],
+        category: "Generator",
+        stack: "(start ratio count -- start start*r start*r^2 ...)",
+        desc: "Push geometric sequence",
+        example: "1 2 4 geom.. => 1 2 4 8",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "euclid",
+        aliases: &[],
+        category: "Generator",
+        stack: "(k n -- i1 i2 ... ik)",
+        desc: "Push indices for k hits evenly distributed over n steps",
+        example: "4 8 euclid => 0 2 4 6",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "euclidrot",
+        aliases: &[],
+        category: "Generator",
+        stack: "(k n r -- i1 i2 ... ik)",
+        desc: "Push Euclidean indices with rotation r",
+        example: "3 8 2 euclidrot => 1 4 6",
+        compile: Simple,
+        varargs: false,
+    },
+];

crates/forth/src/words/sound.rs

@@ -0,0 +1,793 @@
+use super::{Word, WordCompile::*};
+
+// Sound, Oscillator, Sample, Wavetable, FM, Modulation, LFO
+pub(super) const WORDS: &[Word] = &[
+    // Sound
+    Word {
+        name: "sound",
+        aliases: &["s"],
+        category: "Sound",
+        stack: "(name --)",
+        desc: "Begin sound command",
+        example: "\"kick\" sound",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: ".",
+        aliases: &[],
+        category: "Sound",
+        stack: "(--)",
+        desc: "Emit current sound",
+        example: "\"kick\" s . . . .",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "arp",
+        aliases: &[],
+        category: "Sound",
+        stack: "(v1..vn -- arplist)",
+        desc: "Wrap stack values as arpeggio list for spreading across deltas",
+        example: "c4 e4 g4 b4 arp note => arpeggio",
+        compile: Simple,
+        varargs: true,
+    },
+    Word {
+        name: "clear",
+        aliases: &[],
+        category: "Sound",
+        stack: "(--)",
+        desc: "Clear sound register (sound and all params)",
+        example: "\"kick\" s 0.5 gain . clear \"hat\" s .",
+        compile: Simple,
+        varargs: false,
+    },
+    // Sample
+    Word {
+        name: "bank",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set sample bank suffix",
+        example: "\"a\" bank",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "time",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set time offset",
+        example: "0.1 time",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "repeat",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set repeat count",
+        example: "4 repeat",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "dur",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set duration",
+        example: "0.5 dur",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "gate",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set gate time",
+        example: "0.8 gate",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "speed",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set playback speed",
+        example: "1.5 speed",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "begin",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set sample start (0-1)",
+        example: "0.25 begin",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "end",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set sample end (0-1)",
+        example: "0.75 end",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "voice",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set voice number",
+        example: "1 voice",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "orbit",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set orbit/bus",
+        example: "0 orbit",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "n",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set sample number",
+        example: "0 n",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "cut",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Set cut group",
+        example: "1 cut",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "reset",
+        aliases: &[],
+        category: "Sample",
+        stack: "(v.. --)",
+        desc: "Reset parameter",
+        example: "1 reset",
+        compile: Param,
+        varargs: true,
+    },
+    // Oscillator
+    Word {
+        name: "freq",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set frequency (Hz)",
+        example: "440 freq",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "detune",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set detune amount",
+        example: "0.01 detune",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "glide",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set glide/portamento",
+        example: "0.1 glide",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "pw",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set pulse width",
+        example: "0.5 pw",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "wave",
+        aliases: &["waveform"],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set drum waveform [0,1]: 0=sine, 0.5=tri, 1=saw",
+        example: "0.5 wave",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "spread",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set stereo spread",
+        example: "0.5 spread",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "mult",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set multiplier",
+        example: "2 mult",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "warp",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set warp amount",
+        example: "0.5 warp",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "mirror",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set mirror",
+        example: "1 mirror",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "harmonics",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set harmonics (mutable only)",
+        example: "4 harmonics",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "timbre",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set timbre (mutable only)",
+        example: "0.5 timbre",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "morph",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set morph (mutable only)",
+        example: "0.5 morph",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "coarse",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set coarse tune",
+        example: "12 coarse",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "sub",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set sub oscillator level",
+        example: "0.5 sub",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "suboct",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set sub oscillator octave",
+        example: "2 suboct",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "subwave",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set sub oscillator waveform",
+        example: "1 subwave",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "note",
+        aliases: &[],
+        category: "Oscillator",
+        stack: "(v.. --)",
+        desc: "Set MIDI note",
+        example: "60 note",
+        compile: Param,
+        varargs: true,
+    },
+    // Wavetable
+    Word {
+        name: "scan",
+        aliases: &[],
+        category: "Wavetable",
+        stack: "(v.. --)",
+        desc: "Set wavetable scan position (0-1)",
+        example: "0.5 scan",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "wtlen",
+        aliases: &[],
+        category: "Wavetable",
+        stack: "(v.. --)",
+        desc: "Set wavetable cycle length in samples",
+        example: "2048 wtlen",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "scanlfo",
+        aliases: &[],
+        category: "Wavetable",
+        stack: "(v.. --)",
+        desc: "Set scan LFO rate (Hz)",
+        example: "0.2 scanlfo",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "scandepth",
+        aliases: &[],
+        category: "Wavetable",
+        stack: "(v.. --)",
+        desc: "Set scan LFO depth (0-1)",
+        example: "0.4 scandepth",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "scanshape",
+        aliases: &[],
+        category: "Wavetable",
+        stack: "(v.. --)",
+        desc: "Set scan LFO shape (sine/tri/saw/square/sh)",
+        example: "\"tri\" scanshape",
+        compile: Param,
+        varargs: true,
+    },
+    // FM
+    Word {
+        name: "fm",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM frequency",
+        example: "200 fm",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fmh",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM harmonic ratio",
+        example: "2 fmh",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fmshape",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM shape",
+        example: "0 fmshape",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fme",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM envelope",
+        example: "0.5 fme",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fma",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM attack",
+        example: "0.01 fma",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fmd",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM decay",
+        example: "0.1 fmd",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fms",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM sustain",
+        example: "0.5 fms",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fmr",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM release",
+        example: "0.1 fmr",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fm2",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM operator 2 depth",
+        example: "1.5 fm2",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fm2h",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM operator 2 harmonic ratio",
+        example: "3 fm2h",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fmalgo",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM algorithm (0=cascade 1=parallel 2=branch)",
+        example: "0 fmalgo",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "fmfb",
+        aliases: &[],
+        category: "FM",
+        stack: "(v.. --)",
+        desc: "Set FM feedback amount",
+        example: "0.5 fmfb",
+        compile: Param,
+        varargs: true,
+    },
+    // Modulation
+    Word {
+        name: "vib",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set vibrato rate",
+        example: "5 vib",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "vibmod",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set vibrato depth",
+        example: "0.5 vibmod",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "vibshape",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set vibrato shape",
+        example: "0 vibshape",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "am",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set AM frequency",
+        example: "10 am",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "amdepth",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set AM depth",
+        example: "0.5 amdepth",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "amshape",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set AM shape",
+        example: "0 amshape",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "rm",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set RM frequency",
+        example: "100 rm",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "rmdepth",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set RM depth",
+        example: "0.5 rmdepth",
+        compile: Param,
+        varargs: true,
+    },
+    Word {
+        name: "rmshape",
+        aliases: &[],
+        category: "Modulation",
+        stack: "(v.. --)",
+        desc: "Set RM shape",
+        example: "0 rmshape",
+        compile: Param,
+        varargs: true,
+    },
+    // LFO
+    Word {
+        name: "ramp",
+        aliases: &[],
+        category: "LFO",
+        stack: "(freq curve -- val)",
+        desc: "Ramp [0,1]: fract(freq*beat)^curve",
+        example: "0.25 2.0 ramp",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "range",
+        aliases: &[],
+        category: "LFO",
+        stack: "(val min max -- scaled)",
+        desc: "Scale [0,1] to [min,max]",
+        example: "0.5 200 800 range => 500",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "linramp",
+        aliases: &[],
+        category: "LFO",
+        stack: "(freq -- val)",
+        desc: "Linear ramp (curve=1)",
+        example: "1.0 linramp",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "expramp",
+        aliases: &[],
+        category: "LFO",
+        stack: "(freq -- val)",
+        desc: "Exponential ramp (curve=3)",
+        example: "0.25 expramp",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "logramp",
+        aliases: &[],
+        category: "LFO",
+        stack: "(freq -- val)",
+        desc: "Logarithmic ramp (curve=0.3)",
+        example: "2.0 logramp",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "triangle",
+        aliases: &[],
+        category: "LFO",
+        stack: "(freq -- val)",
+        desc: "Triangle wave [0,1]: 0→1→0",
+        example: "0.5 triangle",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "perlin",
+        aliases: &[],
+        category: "LFO",
+        stack: "(freq -- val)",
+        desc: "Perlin noise [0,1] sampled at freq*beat",
+        example: "0.25 perlin",
+        compile: Simple,
+        varargs: false,
+    },
+    // Audio-rate Modulation DSL
+    Word {
+        name: "lfo",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(min max period -- str)",
+        desc: "Sine oscillation: min~max:period",
+        example: "200 4000 2 lfo lpf",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "tlfo",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(min max period -- str)",
+        desc: "Triangle oscillation: min~max:periodt",
+        example: "0.3 0.7 0.5 tlfo pan",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "wlfo",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(min max period -- str)",
+        desc: "Sawtooth oscillation: min~max:periodw",
+        example: "200 4000 1 wlfo lpf",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "qlfo",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(min max period -- str)",
+        desc: "Square oscillation: min~max:periodq",
+        example: "0.0 1.0 0.25 qlfo gain",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "slide",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(start end dur -- str)",
+        desc: "Linear transition: start>end:dur",
+        example: "0 1 0.01 slide gain",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "expslide",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(start end dur -- str)",
+        desc: "Exponential transition: start>end:dure",
+        example: "0 1 0.5 expslide gain",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "sslide",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(start end dur -- str)",
+        desc: "Smooth transition: start>end:durs",
+        example: "200 800 1 sslide lpf",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "jit",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(min max period -- str)",
+        desc: "Random hold: min?max:period",
+        example: "200 4000 0.5 jit lpf",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "sjit",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(min max period -- str)",
+        desc: "Smooth random: min?max:periods",
+        example: "200 4000 0.5 sjit lpf",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "drunk",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(min max period -- str)",
+        desc: "Drunk walk: min?max:periodd",
+        example: "200 4000 0.5 drunk lpf",
+        compile: Simple,
+        varargs: false,
+    },
+    Word {
+        name: "env",
+        aliases: &[],
+        category: "Audio Modulation",
+        stack: "(start t1 d1 ... -- str)",
+        desc: "Multi-segment envelope: start>t1:d1>...",
+        example: "0 1 0.01 0.7 0.1 0 2 env gain",
+        compile: Simple,
+        varargs: false,
+    },
+];

crates/markdown/src/lib.rs

@@ -3,5 +3,5 @@ mod parser;
 mod theme;
 
 pub use highlighter::{CodeHighlighter, NoHighlight};
-pub use parser::parse;
+pub use parser::{parse, CodeBlock, ParsedMarkdown};
 pub use theme::{DefaultTheme, MarkdownTheme};

crates/markdown/src/parser.rs

@@ -5,17 +5,31 @@ use ratatui::text::{Line as RLine, Span};
 use crate::highlighter::CodeHighlighter;
 use crate::theme::MarkdownTheme;
 
+pub struct CodeBlock {
+    pub start_line: usize,
+    pub end_line: usize,
+    pub source: String,
+}
+
+pub struct ParsedMarkdown {
+    pub lines: Vec<RLine<'static>>,
+    pub code_blocks: Vec<CodeBlock>,
+}
+
 pub fn parse<T: MarkdownTheme, H: CodeHighlighter>(
     md: &str,
     theme: &T,
     highlighter: &H,
-) -> Vec<RLine<'static>> {
+) -> ParsedMarkdown {
     let processed = preprocess_markdown(md);
     let text = minimad::Text::from(processed.as_str());
     let mut lines = Vec::new();
 
     let mut code_line_nr: usize = 0;
     let mut table_buffer: Vec<TableRow> = Vec::new();
+    let mut code_blocks: Vec<CodeBlock> = Vec::new();
+    let mut current_block_start: Option<usize> = None;
+    let mut current_block_source: Vec<String> = Vec::new();
 
     let flush_table = |buf: &mut Vec<TableRow>, out: &mut Vec<RLine<'static>>, theme: &T| {
         if buf.is_empty() {
@@ -27,16 +41,43 @@ pub fn parse<T: MarkdownTheme, H: CodeHighlighter>(
         }
     };
 
+    let close_block = |start: Option<usize>,
+                       source: &mut Vec<String>,
+                       blocks: &mut Vec<CodeBlock>,
+                       lines: &Vec<RLine<'static>>| {
+        if let Some(start) = start {
+            blocks.push(CodeBlock {
+                start_line: start,
+                end_line: lines.len(),
+                source: std::mem::take(source).join("\n"),
+            });
+        }
+    };
+
     for line in text.lines {
+        let is_code = matches!(&line, Line::Normal(c) if c.style == CompositeStyle::Code);
+        if !is_code {
+            close_block(
+                current_block_start.take(),
+                &mut current_block_source,
+                &mut code_blocks,
+                &lines,
+            );
+        }
+
         match line {
             Line::Normal(composite) if composite.style == CompositeStyle::Code => {
                 flush_table(&mut table_buffer, &mut lines, theme);
                 code_line_nr += 1;
+                if current_block_start.is_none() {
+                    current_block_start = Some(lines.len());
+                }
                 let raw: String = composite
                     .compounds
                     .iter()
                     .map(|c: &minimad::Compound| c.src)
                     .collect();
+                current_block_source.push(raw.clone());
                 let mut spans = vec![
                     Span::styled(format!(" {code_line_nr:>2} "), theme.code_border()),
                     Span::styled("│ ", theme.code_border()),
@@ -66,9 +107,15 @@ pub fn parse<T: MarkdownTheme, H: CodeHighlighter>(
             }
         }
     }
+    close_block(
+        current_block_start.take(),
+        &mut current_block_source,
+        &mut code_blocks,
+        &lines,
+    );
     flush_table(&mut table_buffer, &mut lines, theme);
 
-    lines
+    ParsedMarkdown { lines, code_blocks }
 }
 
 pub fn preprocess_markdown(md: &str) -> String {
@@ -300,28 +347,39 @@ mod tests {
     #[test]
     fn test_parse_headings() {
         let md = "# H1\n## H2\n### H3";
-        let lines = parse(md, &DefaultTheme, &NoHighlight);
-        assert_eq!(lines.len(), 3);
+        let parsed = parse(md, &DefaultTheme, &NoHighlight);
+        assert_eq!(parsed.lines.len(), 3);
     }
 
     #[test]
     fn test_parse_code_block() {
         let md = "```\ncode line\n```";
-        let lines = parse(md, &DefaultTheme, &NoHighlight);
-        assert!(!lines.is_empty());
+        let parsed = parse(md, &DefaultTheme, &NoHighlight);
+        assert!(!parsed.lines.is_empty());
+        assert_eq!(parsed.code_blocks.len(), 1);
+        assert_eq!(parsed.code_blocks[0].source, "code line");
     }
 
     #[test]
     fn test_parse_table() {
         let md = "| A | B |\n|---|---|\n| 1 | 2 |";
-        let lines = parse(md, &DefaultTheme, &NoHighlight);
-        assert_eq!(lines.len(), 2);
+        let parsed = parse(md, &DefaultTheme, &NoHighlight);
+        assert_eq!(parsed.lines.len(), 2);
     }
 
     #[test]
     fn test_default_theme_works() {
         let md = "Hello **world**";
-        let lines = parse(md, &DefaultTheme, &NoHighlight);
-        assert_eq!(lines.len(), 1);
+        let parsed = parse(md, &DefaultTheme, &NoHighlight);
+        assert_eq!(parsed.lines.len(), 1);
+    }
+
+    #[test]
+    fn test_multiple_code_blocks() {
+        let md = "text\n```\nfirst\n```\nmore text\n```\nsecond line 1\nsecond line 2\n```";
+        let parsed = parse(md, &DefaultTheme, &NoHighlight);
+        assert_eq!(parsed.code_blocks.len(), 2);
+        assert_eq!(parsed.code_blocks[0].source, "first");
+        assert_eq!(parsed.code_blocks[1].source, "second line 1\nsecond line 2");
     }
 }

crates/project/src/file.rs

@@ -25,6 +25,10 @@ struct ProjectFile {
     sample_paths: Vec<PathBuf>,
     #[serde(default = "default_tempo")]
     tempo: f64,
+    #[serde(default)]
+    playing_patterns: Vec<(usize, usize)>,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    prelude: String,
 }
 
 fn default_tempo() -> f64 {
@@ -38,6 +42,8 @@ impl From<&Project> for ProjectFile {
             banks: project.banks.clone(),
             sample_paths: project.sample_paths.clone(),
             tempo: project.tempo,
+            playing_patterns: project.playing_patterns.clone(),
+            prelude: project.prelude.clone(),
         }
     }
 }
@@ -48,6 +54,8 @@ impl From<ProjectFile> for Project {
             banks: file.banks,
             sample_paths: file.sample_paths,
             tempo: file.tempo,
+            playing_patterns: file.playing_patterns,
+            prelude: file.prelude,
         };
         project.normalize();
         project
@@ -93,7 +101,11 @@ pub fn save(project: &Project, path: &Path) -> Result<PathBuf, FileError> {
 
 pub fn load(path: &Path) -> Result<Project, FileError> {
     let json = fs::read_to_string(path)?;
-    let file: ProjectFile = serde_json::from_str(&json)?;
+    load_str(&json)
+}
+
+pub fn load_str(json: &str) -> Result<Project, FileError> {
+    let file: ProjectFile = serde_json::from_str(json)?;
     if file.version > VERSION {
         return Err(FileError::Version(file.version));
     }

crates/project/src/lib.rs

@@ -1,10 +1,12 @@
+//! Project data model: banks, patterns, and steps for the Cagire sequencer.
+
 mod file;
 mod project;
 
 pub const MAX_BANKS: usize = 32;
 pub const MAX_PATTERNS: usize = 32;
-pub const MAX_STEPS: usize = 128;
+pub const MAX_STEPS: usize = 1024;
 pub const DEFAULT_LENGTH: usize = 16;
 
-pub use file::{load, save, FileError};
-pub use project::{Bank, LaunchQuantization, Pattern, PatternSpeed, Project, Step, SyncMode};
+pub use file::{load, load_str, save, FileError};
+pub use project::{Bank, FollowUp, LaunchQuantization, Pattern, PatternSpeed, Project, Step, SyncMode};

crates/project/src/project.rs

@@ -1,3 +1,5 @@
+//! Project, Bank, Pattern, and Step structs with serialization.
+
 use std::path::PathBuf;
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -206,14 +208,50 @@ impl SyncMode {
     }
 }
 
+#[derive(Clone, Copy, Serialize, Deserialize, Default, PartialEq, Eq)]
+pub enum FollowUp {
+    #[default]
+    Loop,
+    Stop,
+    Chain { bank: usize, pattern: usize },
+}
+
+impl FollowUp {
+    pub fn label(&self) -> &'static str {
+        match self {
+            Self::Loop => "Loop",
+            Self::Stop => "Stop",
+            Self::Chain { .. } => "Chain",
+        }
+    }
+
+    pub fn next_mode(&self) -> Self {
+        match self {
+            Self::Loop => Self::Stop,
+            Self::Stop => Self::Chain { bank: 0, pattern: 0 },
+            Self::Chain { .. } => Self::Loop,
+        }
+    }
+
+    pub fn prev_mode(&self) -> Self {
+        match self {
+            Self::Loop => Self::Chain { bank: 0, pattern: 0 },
+            Self::Stop => Self::Loop,
+            Self::Chain { .. } => Self::Stop,
+        }
+    }
+}
+
+fn is_default_follow_up(f: &FollowUp) -> bool {
+    *f == FollowUp::default()
+}
+
 #[derive(Clone, Serialize, Deserialize)]
 pub struct Step {
     pub active: bool,
     pub script: String,
-    #[serde(skip)]
-    pub command: Option<String>,
     #[serde(default)]
-    pub source: Option<usize>,
+    pub source: Option<u8>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
 }
@@ -222,6 +260,10 @@ impl Step {
     pub fn is_default(&self) -> bool {
         self.active && self.script.is_empty() && self.source.is_none() && self.name.is_none()
     }
+
+    pub fn has_content(&self) -> bool {
+        !self.script.is_empty()
+    }
 }
 
 impl Default for Step {
@@ -229,7 +271,6 @@ impl Default for Step {
         Self {
             active: true,
             script: String::new(),
-            command: None,
             source: None,
             name: None,
         }
@@ -244,6 +285,7 @@ pub struct Pattern {
     pub name: Option<String>,
     pub quantization: LaunchQuantization,
     pub sync_mode: SyncMode,
+    pub follow_up: FollowUp,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -254,7 +296,7 @@ struct SparseStep {
     #[serde(default, skip_serializing_if = "String::is_empty")]
     script: String,
     #[serde(default, skip_serializing_if = "Option::is_none")]
-    source: Option<usize>,
+    source: Option<u8>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     name: Option<String>,
 }
@@ -279,6 +321,8 @@ struct SparsePattern {
     quantization: LaunchQuantization,
     #[serde(default, skip_serializing_if = "is_default_sync_mode")]
     sync_mode: SyncMode,
+    #[serde(default, skip_serializing_if = "is_default_follow_up")]
+    follow_up: FollowUp,
 }
 
 fn is_default_quantization(q: &LaunchQuantization) -> bool {
@@ -301,6 +345,8 @@ struct LegacyPattern {
     quantization: LaunchQuantization,
     #[serde(default)]
     sync_mode: SyncMode,
+    #[serde(default)]
+    follow_up: FollowUp,
 }
 
 impl Serialize for Pattern {
@@ -326,6 +372,7 @@ impl Serialize for Pattern {
             name: self.name.clone(),
             quantization: self.quantization,
             sync_mode: self.sync_mode,
+            follow_up: self.follow_up,
         };
         sparse.serialize(serializer)
     }
@@ -348,7 +395,6 @@ impl<'de> Deserialize<'de> for Pattern {
                         steps[ss.i] = Step {
                             active: ss.active,
                             script: ss.script,
-                            command: None,
                             source: ss.source,
                             name: ss.name,
                         };
@@ -361,6 +407,7 @@ impl<'de> Deserialize<'de> for Pattern {
                     name: sparse.name,
                     quantization: sparse.quantization,
                     sync_mode: sparse.sync_mode,
+                    follow_up: sparse.follow_up,
                 })
             }
             PatternFormat::Legacy(legacy) => Ok(Pattern {
@@ -370,6 +417,7 @@ impl<'de> Deserialize<'de> for Pattern {
                 name: legacy.name,
                 quantization: legacy.quantization,
                 sync_mode: legacy.sync_mode,
+                follow_up: legacy.follow_up,
             }),
         }
     }
@@ -384,6 +432,7 @@ impl Default for Pattern {
             name: None,
             quantization: LaunchQuantization::default(),
             sync_mode: SyncMode::default(),
+            follow_up: FollowUp::default(),
         }
     }
 }
@@ -410,7 +459,7 @@ impl Pattern {
         for _ in 0..self.steps.len() {
             if let Some(step) = self.steps.get(current) {
                 if let Some(source) = step.source {
-                    current = source;
+                    current = source as usize;
                 } else {
                     return current;
                 }
@@ -425,6 +474,14 @@ impl Pattern {
         let source_idx = self.resolve_source(index);
         self.steps.get(source_idx).map(|s| s.script.as_str())
     }
+
+    pub fn content_step_count(&self) -> usize {
+        self.steps[..self.length]
+            .iter()
+            .filter(|s| s.has_content() || s.source.is_some())
+            .count()
+    }
+
 }
 
 #[derive(Clone, Serialize, Deserialize)]
@@ -434,6 +491,15 @@ pub struct Bank {
     pub name: Option<String>,
 }
 
+impl Bank {
+    pub fn content_pattern_count(&self) -> usize {
+        self.patterns
+            .iter()
+            .filter(|p| p.content_step_count() > 0)
+            .count()
+    }
+}
+
 impl Default for Bank {
     fn default() -> Self {
         Self {
@@ -450,6 +516,10 @@ pub struct Project {
     pub sample_paths: Vec<PathBuf>,
     #[serde(default = "default_tempo")]
     pub tempo: f64,
+    #[serde(default)]
+    pub playing_patterns: Vec<(usize, usize)>,
+    #[serde(default)]
+    pub prelude: String,
 }
 
 fn default_tempo() -> f64 {
@@ -462,6 +532,8 @@ impl Default for Project {
             banks: (0..MAX_BANKS).map(|_| Bank::default()).collect(),
             sample_paths: Vec::new(),
             tempo: default_tempo(),
+            playing_patterns: Vec::new(),
+            prelude: String::new(),
         }
     }
 }

crates/ratatui/src/category_list.rs

@@ -0,0 +1,184 @@
+use ratatui::layout::Rect;
+use ratatui::style::{Color, Modifier, Style};
+use ratatui::widgets::{Block, Borders, List, ListItem};
+use ratatui::Frame;
+
+use crate::theme;
+
+pub struct CategoryItem<'a> {
+    pub label: &'a str,
+    pub is_section: bool,
+    pub collapsed: bool,
+}
+
+pub enum Selection {
+    Item(usize),
+    Section(usize),
+}
+
+pub struct CategoryList<'a> {
+    items: &'a [CategoryItem<'a>],
+    selection: Selection,
+    focused: bool,
+    title: &'a str,
+    section_color: Color,
+    focused_color: Color,
+    selected_color: Color,
+    normal_color: Color,
+    dimmed_color: Option<Color>,
+}
+
+impl<'a> CategoryList<'a> {
+    pub fn new(items: &'a [CategoryItem<'a>], selection: Selection) -> Self {
+        let theme = theme::get();
+        Self {
+            items,
+            selection,
+            focused: false,
+            title: "",
+            section_color: theme.ui.text_dim,
+            focused_color: theme.dict.category_focused,
+            selected_color: theme.dict.category_selected,
+            normal_color: theme.dict.category_normal,
+            dimmed_color: None,
+        }
+    }
+
+    pub fn focused(mut self, focused: bool) -> Self {
+        self.focused = focused;
+        self
+    }
+
+    pub fn title(mut self, title: &'a str) -> Self {
+        self.title = title;
+        self
+    }
+
+    pub fn selected_color(mut self, color: Color) -> Self {
+        self.selected_color = color;
+        self
+    }
+
+    pub fn normal_color(mut self, color: Color) -> Self {
+        self.normal_color = color;
+        self
+    }
+
+    pub fn dimmed(mut self, color: Color) -> Self {
+        self.dimmed_color = Some(color);
+        self
+    }
+
+    /// Build the visible items list, filtering out children of collapsed sections.
+    /// Returns (item, section_index_if_section, item_index_if_item).
+    fn visible_items(&self) -> Vec<(&CategoryItem<'a>, Option<usize>, Option<usize>)> {
+        let mut result = Vec::new();
+        let mut skipping = false;
+        let mut section_idx = 0usize;
+        let mut item_idx = 0usize;
+        for item in self.items.iter() {
+            if item.is_section {
+                skipping = item.collapsed;
+                result.push((item, Some(section_idx), None));
+                section_idx += 1;
+            } else if !skipping {
+                result.push((item, None, Some(item_idx)));
+                item_idx += 1;
+            } else {
+                item_idx += 1;
+            }
+        }
+        result
+    }
+
+    pub fn render(self, frame: &mut Frame, area: Rect) {
+        let theme = theme::get();
+        let visible = self.visible_items();
+
+        let visible_height = area.height.saturating_sub(2) as usize;
+        let total_items = visible.len();
+
+        let selected_visual_idx = match &self.selection {
+            Selection::Item(sel) => visible
+                .iter()
+                .position(|(_, _, item_idx)| *item_idx == Some(*sel))
+                .unwrap_or(0),
+            Selection::Section(sel) => visible
+                .iter()
+                .position(|(_, sec_idx, _)| *sec_idx == Some(*sel))
+                .unwrap_or(0),
+        };
+
+        let scroll = if selected_visual_idx < visible_height / 2 {
+            0
+        } else if selected_visual_idx > total_items.saturating_sub(visible_height / 2) {
+            total_items.saturating_sub(visible_height)
+        } else {
+            selected_visual_idx.saturating_sub(visible_height / 2)
+        };
+
+        let is_dimmed = self.dimmed_color.is_some();
+
+        let items: Vec<ListItem> = visible
+            .iter()
+            .skip(scroll)
+            .take(visible_height)
+            .enumerate()
+            .map(|(vis_offset, (item, sec_idx, _itm_idx))| {
+                let visual_pos = scroll + vis_offset;
+                if item.is_section {
+                    let is_selected =
+                        matches!(&self.selection, Selection::Section(s) if Some(*s) == *sec_idx);
+                    let arrow = if item.collapsed { "▸" } else { "▾" };
+                    let style = if is_selected && self.focused {
+                        Style::new()
+                            .fg(self.focused_color)
+                            .add_modifier(Modifier::BOLD)
+                    } else if is_selected {
+                        Style::new()
+                            .fg(self.selected_color)
+                            .add_modifier(Modifier::BOLD)
+                    } else {
+                        Style::new().fg(self.section_color)
+                    };
+                    let prefix = if is_selected && !is_dimmed { "> " } else { "" };
+                    ListItem::new(format!("{prefix}{arrow} {}", item.label)).style(style)
+                } else {
+                    let is_selected = visual_pos == selected_visual_idx
+                        && matches!(&self.selection, Selection::Item(_));
+                    let style = if let Some(dim_color) = self.dimmed_color {
+                        Style::new().fg(dim_color)
+                    } else if is_selected && self.focused {
+                        Style::new()
+                            .fg(self.focused_color)
+                            .add_modifier(Modifier::BOLD)
+                    } else if is_selected {
+                        Style::new()
+                            .fg(self.selected_color)
+                            .add_modifier(Modifier::BOLD)
+                    } else {
+                        Style::new().fg(self.normal_color)
+                    };
+                    let prefix = if is_selected && !is_dimmed {
+                        "> "
+                    } else {
+                        "  "
+                    };
+                    ListItem::new(format!("{prefix}{}", item.label)).style(style)
+                }
+            })
+            .collect();
+
+        let border_color = if self.focused {
+            theme.dict.border_focused
+        } else {
+            theme.dict.border_normal
+        };
+        let block = Block::default()
+            .borders(Borders::ALL)
+            .border_style(Style::new().fg(border_color))
+            .title(self.title);
+        let list = List::new(items).block(block);
+        frame.render_widget(list, area);
+    }
+}

crates/ratatui/src/confirm.rs

@@ -22,7 +22,7 @@ impl<'a> ConfirmModal<'a> {
         }
     }
 
-    pub fn render_centered(self, frame: &mut Frame, term: Rect) {
+    pub fn render_centered(self, frame: &mut Frame, term: Rect) -> Rect {
         let t = theme::get();
         let inner = ModalFrame::new(self.title)
             .width(30)
@@ -58,5 +58,7 @@ impl<'a> ConfirmModal<'a> {
             Paragraph::new(buttons).alignment(Alignment::Center),
             rows[1],
         );
+
+        inner
     }
 }

crates/ratatui/src/editor.rs

@@ -1,3 +1,5 @@
+use std::cell::Cell;
+
 use crate::theme;
 use ratatui::{
     layout::Rect,
@@ -8,8 +10,9 @@ use ratatui::{
 };
 use tui_textarea::TextArea;
 
-pub type Highlighter<'a> = &'a dyn Fn(usize, &str) -> Vec<(Style, String)>;
+pub type Highlighter<'a> = &'a dyn Fn(usize, &str) -> Vec<(Style, String, bool)>;
 
+#[derive(Clone)]
 pub struct CompletionCandidate {
     pub name: String,
     pub signature: String,
@@ -41,6 +44,26 @@ impl CompletionState {
     }
 }
 
+struct SampleFinderState {
+    query: String,
+    folders: Vec<String>,
+    matches: Vec<usize>,
+    cursor: usize,
+    active: bool,
+}
+
+impl SampleFinderState {
+    fn new() -> Self {
+        Self {
+            query: String::new(),
+            folders: Vec::new(),
+            matches: Vec::new(),
+            cursor: 0,
+            active: false,
+        }
+    }
+}
+
 struct SearchState {
     query: String,
     active: bool,
@@ -58,7 +81,9 @@ impl SearchState {
 pub struct Editor {
     text: TextArea<'static>,
     completion: CompletionState,
+    sample_finder: SampleFinderState,
     search: SearchState,
+    scroll_offset: Cell<u16>,
 }
 
 impl Editor {
@@ -106,15 +131,19 @@ impl Editor {
         Self {
             text: TextArea::default(),
             completion: CompletionState::new(),
+            sample_finder: SampleFinderState::new(),
             search: SearchState::new(),
+            scroll_offset: Cell::new(0),
         }
     }
 
     pub fn set_content(&mut self, lines: Vec<String>) {
         self.text = TextArea::new(lines);
         self.completion.active = false;
+        self.sample_finder.active = false;
         self.search.query.clear();
         self.search.active = false;
+        self.scroll_offset.set(0);
     }
 
     pub fn set_candidates(&mut self, candidates: Vec<CompletionCandidate>) {
@@ -145,6 +174,18 @@ impl Editor {
         self.completion.active = false;
     }
 
+    pub fn completion_next(&mut self) {
+        if self.completion.cursor + 1 < self.completion.matches.len() {
+            self.completion.cursor += 1;
+        }
+    }
+
+    pub fn completion_prev(&mut self) {
+        if self.completion.cursor > 0 {
+            self.completion.cursor -= 1;
+        }
+    }
+
     pub fn set_completion_enabled(&mut self, enabled: bool) {
         self.completion.enabled = enabled;
         if !enabled {
@@ -208,24 +249,85 @@ impl Editor {
         }
     }
 
+    pub fn set_sample_folders(&mut self, folders: Vec<String>) {
+        self.sample_finder.folders = folders;
+    }
+
+    pub fn activate_sample_finder(&mut self) {
+        self.completion.active = false;
+        self.sample_finder.query.clear();
+        self.sample_finder.cursor = 0;
+        self.sample_finder.matches = (0..self.sample_finder.folders.len()).collect();
+        self.sample_finder.active = true;
+    }
+
+    pub fn dismiss_sample_finder(&mut self) {
+        self.sample_finder.active = false;
+    }
+
+    pub fn sample_finder_active(&self) -> bool {
+        self.sample_finder.active
+    }
+
+    pub fn sample_finder_input(&mut self, c: char) {
+        self.sample_finder.query.push(c);
+        self.update_sample_finder_matches();
+    }
+
+    pub fn sample_finder_backspace(&mut self) {
+        self.sample_finder.query.pop();
+        self.update_sample_finder_matches();
+    }
+
+    pub fn sample_finder_next(&mut self) {
+        if self.sample_finder.cursor + 1 < self.sample_finder.matches.len() {
+            self.sample_finder.cursor += 1;
+        }
+    }
+
+    pub fn sample_finder_prev(&mut self) {
+        if self.sample_finder.cursor > 0 {
+            self.sample_finder.cursor -= 1;
+        }
+    }
+
+    pub fn accept_sample_finder(&mut self) {
+        if self.sample_finder.matches.is_empty() {
+            self.sample_finder.active = false;
+            return;
+        }
+        let idx = self.sample_finder.matches[self.sample_finder.cursor];
+        let name = self.sample_finder.folders[idx].clone();
+        self.text.insert_str(&name);
+        self.sample_finder.active = false;
+    }
+
+    fn update_sample_finder_matches(&mut self) {
+        if self.sample_finder.query.is_empty() {
+            self.sample_finder.matches = (0..self.sample_finder.folders.len()).collect();
+        } else {
+            let mut scored: Vec<(usize, usize)> = self
+                .sample_finder
+                .folders
+                .iter()
+                .enumerate()
+                .filter_map(|(i, name)| fuzzy_match(&self.sample_finder.query, name).map(|s| (s, i)))
+                .collect();
+            scored.sort_by_key(|(score, _)| *score);
+            self.sample_finder.matches = scored.into_iter().map(|(_, i)| i).collect();
+        }
+        self.sample_finder.cursor = self
+            .sample_finder
+            .cursor
+            .min(self.sample_finder.matches.len().saturating_sub(1));
+    }
+
     pub fn input(&mut self, input: impl Into<tui_textarea::Input>) {
         let input: tui_textarea::Input = input.into();
         let has_modifier = input.ctrl || input.alt;
 
         if self.completion.active && !has_modifier {
             match &input {
-                tui_textarea::Input { key: tui_textarea::Key::Up, .. } => {
-                    if self.completion.cursor > 0 {
-                        self.completion.cursor -= 1;
-                    }
-                    return;
-                }
-                tui_textarea::Input { key: tui_textarea::Key::Down, .. } => {
-                    if self.completion.cursor + 1 < self.completion.matches.len() {
-                        self.completion.cursor += 1;
-                    }
-                    return;
-                }
                 tui_textarea::Input { key: tui_textarea::Key::Tab, .. } => {
                     self.accept_completion();
                     return;
@@ -255,7 +357,7 @@ impl Editor {
     }
 
     fn update_completion(&mut self) {
-        if !self.completion.enabled || self.completion.candidates.is_empty() {
+        if !self.completion.enabled || self.completion.candidates.is_empty() || self.sample_finder.active {
             return;
         }
 
@@ -350,21 +452,25 @@ impl Editor {
                 let mut spans: Vec<Span> = Vec::new();
                 let mut col = 0;
 
-                for (base_style, text) in tokens {
+                for (base_style, text, is_annotation) in tokens {
                     for ch in text.chars() {
-                        let is_cursor = row == cursor_row && col == cursor_col;
-                        let is_selected = is_in_selection(row, col, selection);
-
-                        let style = if is_cursor {
-                            cursor_style
-                        } else if is_selected {
-                            base_style.bg(selection_style.bg.unwrap())
-                        } else {
+                        let style = if is_annotation {
                             base_style
+                        } else {
+                            let is_cursor = row == cursor_row && col == cursor_col;
+                            let is_selected = is_in_selection(row, col, selection);
+                            if is_cursor {
+                                cursor_style
+                            } else if is_selected {
+                                base_style.bg(selection_style.bg.unwrap())
+                            } else {
+                                base_style
+                            }
                         };
-
                         spans.push(Span::styled(ch.to_string(), style));
-                        col += 1;
+                        if !is_annotation {
+                            col += 1;
+                        }
                     }
                 }
 
@@ -376,10 +482,23 @@ impl Editor {
             })
             .collect();
 
-        frame.render_widget(Paragraph::new(lines), area);
+        let viewport_height = area.height as usize;
+        let offset = self.scroll_offset.get() as usize;
+        let offset = if cursor_row < offset {
+            cursor_row
+        } else if cursor_row >= offset + viewport_height {
+            cursor_row - viewport_height + 1
+        } else {
+            offset
+        };
+        self.scroll_offset.set(offset as u16);
 
-        if self.completion.active && !self.completion.matches.is_empty() {
-            self.render_completion(frame, area, cursor_row);
+        frame.render_widget(Paragraph::new(lines).scroll((offset as u16, 0)), area);
+
+        if self.sample_finder.active && !self.sample_finder.matches.is_empty() {
+            self.render_sample_finder(frame, area, cursor_row - offset);
+        } else if self.completion.active && !self.completion.matches.is_empty() {
+            self.render_completion(frame, area, cursor_row - offset);
         }
     }
 
@@ -494,6 +613,98 @@ impl Editor {
 
         frame.render_widget(Paragraph::new(doc_lines), doc_area);
     }
+
+    fn render_sample_finder(&self, frame: &mut Frame, editor_area: Rect, cursor_row: usize) {
+        let t = theme::get();
+        let max_visible: usize = 8;
+        let width: u16 = 24;
+
+        let visible_count = self.sample_finder.matches.len().min(max_visible);
+        let total_height = visible_count as u16 + 1; // +1 for query line
+
+        let (_, cursor_col) = self.text.cursor();
+        let popup_x = (editor_area.x + cursor_col as u16)
+            .min(editor_area.x + editor_area.width.saturating_sub(width));
+
+        let below_y = editor_area.y + cursor_row as u16 + 1;
+        let popup_y = if below_y + total_height > editor_area.y + editor_area.height {
+            (editor_area.y + cursor_row as u16).saturating_sub(total_height)
+        } else {
+            below_y
+        };
+
+        let area = Rect::new(popup_x, popup_y, width, total_height);
+        frame.render_widget(Clear, area);
+
+        let bg_style = Style::default().bg(t.editor_widget.completion_bg);
+        let highlight_style = Style::default()
+            .fg(t.editor_widget.completion_selected)
+            .add_modifier(Modifier::BOLD);
+        let normal_style = Style::default().fg(t.editor_widget.completion_fg);
+
+        let w = width as usize;
+        let mut lines: Vec<Line> = Vec::new();
+
+        let query_display = format!("/{}", self.sample_finder.query);
+        lines.push(Line::from(Span::styled(
+            format!("{query_display:<w$}"),
+            highlight_style.bg(t.editor_widget.completion_bg),
+        )));
+
+        let scroll_offset = if self.sample_finder.cursor >= max_visible {
+            self.sample_finder.cursor - max_visible + 1
+        } else {
+            0
+        };
+
+        for i in scroll_offset..scroll_offset + visible_count {
+            let idx = self.sample_finder.matches[i];
+            let name = &self.sample_finder.folders[idx];
+            let style = if i == self.sample_finder.cursor {
+                highlight_style
+            } else {
+                normal_style
+            };
+            let prefix = if i == self.sample_finder.cursor { "> " } else { "  " };
+            let display = format!("{prefix}{name:<width$}", width = w - 2);
+            lines.push(Line::from(Span::styled(
+                format!("{display:<w$}"),
+                style.bg(t.editor_widget.completion_bg),
+            )));
+        }
+
+        // Fill rest with bg
+        for _ in lines.len() as u16..total_height {
+            lines.push(Line::from(Span::styled(" ".repeat(w), bg_style)));
+        }
+
+        frame.render_widget(Paragraph::new(lines), area);
+    }
+}
+
+pub fn fuzzy_match(query: &str, target: &str) -> Option<usize> {
+    let target_lower: Vec<char> = target.to_lowercase().chars().collect();
+    let query_lower: Vec<char> = query.to_lowercase().chars().collect();
+    let mut ti = 0;
+    let mut score = 0;
+    let mut prev_pos = 0;
+    for (qi, &qc) in query_lower.iter().enumerate() {
+        loop {
+            if ti >= target_lower.len() {
+                return None;
+            }
+            if target_lower[ti] == qc {
+                if qi > 0 {
+                    score += ti - prev_pos;
+                }
+                prev_pos = ti;
+                ti += 1;
+                break;
+            }
+            ti += 1;
+        }
+    }
+    Some(score)
 }
 
 fn is_word_char(c: char) -> bool {

crates/ratatui/src/file_browser.rs

@@ -57,7 +57,7 @@ impl<'a> FileBrowserModal<'a> {
         self
     }
 
-    pub fn render_centered(self, frame: &mut Frame, term: Rect) {
+    pub fn render_centered(self, frame: &mut Frame, term: Rect) -> Rect {
         let colors = theme::get();
         let border_color = self.border_color.unwrap_or(colors.ui.text_primary);
 
@@ -112,5 +112,7 @@ impl<'a> FileBrowserModal<'a> {
             .collect();
 
         frame.render_widget(Paragraph::new(lines), rows[1]);
+
+        inner
     }
 }

crates/ratatui/src/hint_bar.rs

@@ -0,0 +1,27 @@
+use ratatui::text::{Line, Span};
+use ratatui::style::Style;
+
+use crate::theme;
+
+pub fn hint_line(pairs: &[(&str, &str)]) -> Line<'static> {
+    let theme = theme::get();
+    let key_style = Style::default().fg(theme.hint.key);
+    let text_style = Style::default().fg(theme.hint.text);
+
+    let spans: Vec<Span> = pairs
+        .iter()
+        .enumerate()
+        .flat_map(|(i, (key, action))| {
+            let mut s = vec![
+                Span::styled(key.to_string(), key_style),
+                Span::styled(format!(" {action}"), text_style),
+            ];
+            if i + 1 < pairs.len() {
+                s.push(Span::styled("  ", text_style));
+            }
+            s
+        })
+        .collect();
+
+    Line::from(spans)
+}

crates/ratatui/src/lib.rs

@@ -1,26 +1,44 @@
+//! Reusable TUI widgets for the Cagire sequencer interface.
+
+mod category_list;
 mod confirm;
 mod editor;
 mod file_browser;
+mod hint_bar;
+mod lissajous;
 mod list_select;
 mod modal;
 mod nav_minimap;
+mod props_form;
 mod sample_browser;
 mod scope;
+mod scroll_indicators;
+mod search_bar;
+mod section_header;
 mod sparkles;
 mod spectrum;
 mod text_input;
 pub mod theme;
 mod vu_meter;
+mod waveform;
 
+pub use category_list::{CategoryItem, CategoryList, Selection};
 pub use confirm::ConfirmModal;
-pub use editor::{CompletionCandidate, Editor};
+pub use editor::{fuzzy_match, CompletionCandidate, Editor};
 pub use file_browser::FileBrowserModal;
+pub use hint_bar::hint_line;
+pub use lissajous::Lissajous;
 pub use list_select::ListSelect;
 pub use modal::ModalFrame;
-pub use nav_minimap::{NavMinimap, NavTile};
+pub use nav_minimap::{hit_test_tile, minimap_area, NavMinimap, NavTile};
+pub use props_form::render_props_form;
 pub use sample_browser::{SampleBrowser, TreeLine, TreeLineKind};
 pub use scope::{Orientation, Scope};
+pub use scroll_indicators::{render_scroll_indicators, IndicatorAlign};
+pub use search_bar::render_search_bar;
+pub use section_header::render_section_header;
 pub use sparkles::Sparkles;
 pub use spectrum::Spectrum;
 pub use text_input::TextInputModal;
 pub use vu_meter::VuMeter;
+pub use waveform::Waveform;

crates/ratatui/src/lissajous.rs

@@ -0,0 +1,103 @@
+use crate::theme;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::style::Color;
+use ratatui::widgets::Widget;
+use std::cell::RefCell;
+
+thread_local! {
+    static PATTERNS: RefCell<Vec<u8>> = const { RefCell::new(Vec::new()) };
+}
+
+pub struct Lissajous<'a> {
+    left: &'a [f32],
+    right: &'a [f32],
+    color: Option<Color>,
+}
+
+impl<'a> Lissajous<'a> {
+    pub fn new(left: &'a [f32], right: &'a [f32]) -> Self {
+        Self {
+            left,
+            right,
+            color: None,
+        }
+    }
+
+    pub fn color(mut self, c: Color) -> Self {
+        self.color = Some(c);
+        self
+    }
+}
+
+impl Widget for Lissajous<'_> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        if area.width == 0 || area.height == 0 || self.left.is_empty() || self.right.is_empty() {
+            return;
+        }
+
+        let color = self.color.unwrap_or_else(|| theme::get().meter.low);
+        let width = area.width as usize;
+        let height = area.height as usize;
+        let fine_width = width * 2;
+        let fine_height = height * 4;
+        let len = self.left.len().min(self.right.len());
+
+        let peak = self
+            .left
+            .iter()
+            .chain(self.right.iter())
+            .map(|s| s.abs())
+            .fold(0.0f32, f32::max);
+        let gain = if peak > 0.001 { 1.0 / peak } else { 1.0 };
+
+        PATTERNS.with(|p| {
+            let mut patterns = p.borrow_mut();
+            let size = width * height;
+            patterns.clear();
+            patterns.resize(size, 0);
+
+            for i in 0..len {
+                let l = (self.left[i] * gain).clamp(-1.0, 1.0);
+                let r = (self.right[i] * gain).clamp(-1.0, 1.0);
+
+                // X = right channel, Y = left channel (inverted so up = positive)
+                let fine_x = ((r + 1.0) * 0.5 * (fine_width - 1) as f32).round() as usize;
+                let fine_y = ((1.0 - l) * 0.5 * (fine_height - 1) as f32).round() as usize;
+                let fine_x = fine_x.min(fine_width - 1);
+                let fine_y = fine_y.min(fine_height - 1);
+
+                let char_x = fine_x / 2;
+                let char_y = fine_y / 4;
+                let dot_x = fine_x % 2;
+                let dot_y = fine_y % 4;
+
+                let bit = match (dot_x, dot_y) {
+                    (0, 0) => 0x01,
+                    (0, 1) => 0x02,
+                    (0, 2) => 0x04,
+                    (0, 3) => 0x40,
+                    (1, 0) => 0x08,
+                    (1, 1) => 0x10,
+                    (1, 2) => 0x20,
+                    (1, 3) => 0x80,
+                    _ => unreachable!(),
+                };
+
+                patterns[char_y * width + char_x] |= bit;
+            }
+
+            for cy in 0..height {
+                for cx in 0..width {
+                    let pattern = patterns[cy * width + cx];
+                    if pattern != 0 {
+                        let ch = char::from_u32(0x2800 + pattern as u32).unwrap_or(' ');
+                        buf[(area.x + cx as u16, area.y + cy as u16)]
+                            .set_char(ch)
+                            .set_fg(color);
+                    }
+                }
+            }
+        });
+    }
+}

crates/ratatui/src/nav_minimap.rs

@@ -4,6 +4,42 @@ use ratatui::style::Style;
 use ratatui::widgets::{Clear, Paragraph};
 use ratatui::Frame;
 
+const TILE_W: u16 = 12;
+const TILE_H: u16 = 3;
+const GAP: u16 = 1;
+const PAD: u16 = 2;
+const GRID_COLS: u16 = 3;
+const GRID_ROWS: u16 = 2;
+
+/// Compute the centered minimap area for a 3x2 grid.
+pub fn minimap_area(term: Rect) -> Rect {
+    let content_w = TILE_W * GRID_COLS + GAP * (GRID_COLS - 1);
+    let content_h = TILE_H * GRID_ROWS + GAP * (GRID_ROWS - 1);
+    let modal_w = content_w + PAD * 2;
+    let modal_h = content_h + PAD * 2;
+    let x = term.x + (term.width.saturating_sub(modal_w)) / 2;
+    let y = term.y + (term.height.saturating_sub(modal_h)) / 2;
+    Rect::new(x, y, modal_w, modal_h)
+}
+
+/// Hit-test: returns `(grid_col, grid_row)` if the click lands on a tile.
+pub fn hit_test_tile(col: u16, row: u16, term: Rect) -> Option<(i8, i8)> {
+    let area = minimap_area(term);
+    let inner_x = area.x + PAD;
+    let inner_y = area.y + PAD;
+
+    for grid_row in 0..GRID_ROWS {
+        for grid_col in 0..GRID_COLS {
+            let tx = inner_x + grid_col * (TILE_W + GAP);
+            let ty = inner_y + grid_row * (TILE_H + GAP);
+            if col >= tx && col < tx + TILE_W && row >= ty && row < ty + TILE_H {
+                return Some((grid_col as i8, grid_row as i8));
+            }
+        }
+    }
+    None
+}
+
 /// A tile in the navigation grid
 pub struct NavTile {
     pub col: i8,
@@ -27,25 +63,7 @@ impl<'a> NavMinimap<'a> {
             return;
         }
 
-        // Compute grid bounds from tiles
-        let max_col = self.tiles.iter().map(|t| t.col).max().unwrap_or(0);
-        let max_row = self.tiles.iter().map(|t| t.row).max().unwrap_or(0);
-        let cols = (max_col + 1) as u16;
-        let rows = (max_row + 1) as u16;
-
-        let tile_w: u16 = 12;
-        let tile_h: u16 = 3;
-        let gap: u16 = 1;
-        let pad: u16 = 2;
-
-        let content_w = tile_w * cols + gap * (cols.saturating_sub(1));
-        let content_h = tile_h * rows + gap * (rows.saturating_sub(1));
-        let modal_w = content_w + pad * 2;
-        let modal_h = content_h + pad * 2;
-
-        let x = term.x + (term.width.saturating_sub(modal_w)) / 2;
-        let y = term.y + (term.height.saturating_sub(modal_h)) / 2;
-        let area = Rect::new(x, y, modal_w, modal_h);
+        let area = minimap_area(term);
 
         frame.render_widget(Clear, area);
 
@@ -60,13 +78,13 @@ impl<'a> NavMinimap<'a> {
             );
         }
 
-        let inner_x = area.x + pad;
-        let inner_y = area.y + pad;
+        let inner_x = area.x + PAD;
+        let inner_y = area.y + PAD;
 
         for tile in self.tiles {
-            let tile_x = inner_x + (tile.col as u16) * (tile_w + gap);
-            let tile_y = inner_y + (tile.row as u16) * (tile_h + gap);
-            let tile_area = Rect::new(tile_x, tile_y, tile_w, tile_h);
+            let tile_x = inner_x + (tile.col as u16) * (TILE_W + GAP);
+            let tile_y = inner_y + (tile.row as u16) * (TILE_H + GAP);
+            let tile_area = Rect::new(tile_x, tile_y, TILE_W, TILE_H);
             let is_selected = (tile.col, tile.row) == self.selected;
             self.render_tile(frame, tile_area, tile.name, is_selected);
         }

crates/ratatui/src/props_form.rs

@@ -0,0 +1,42 @@
+use ratatui::layout::Rect;
+use ratatui::style::{Modifier, Style};
+use ratatui::widgets::Paragraph;
+use ratatui::Frame;
+
+use crate::theme;
+
+pub fn render_props_form(frame: &mut Frame, area: Rect, fields: &[(&str, &str, bool)]) {
+    let theme = theme::get();
+
+    for (i, (label, value, selected)) in fields.iter().enumerate() {
+        let y = area.y + i as u16;
+        if y >= area.y + area.height {
+            break;
+        }
+
+        let (label_style, value_style) = if *selected {
+            (
+                Style::default()
+                    .fg(theme.hint.key)
+                    .add_modifier(Modifier::BOLD),
+                Style::default()
+                    .fg(theme.ui.text_primary)
+                    .bg(theme.ui.surface),
+            )
+        } else {
+            (
+                Style::default().fg(theme.ui.text_muted),
+                Style::default().fg(theme.ui.text_primary),
+            )
+        };
+
+        let label_area = Rect::new(area.x + 1, y, 14, 1);
+        let value_area = Rect::new(area.x + 16, y, area.width.saturating_sub(18), 1);
+
+        frame.render_widget(
+            Paragraph::new(format!("{label}:")).style(label_style),
+            label_area,
+        );
+        frame.render_widget(Paragraph::new(*value).style(value_style), value_area);
+    }
+}

crates/ratatui/src/sample_browser.rs

@@ -158,12 +158,17 @@ impl<'a> SampleBrowser<'a> {
                 Style::new().fg(icon_color)
             };
 
-            let spans = vec![
+            let mut spans = vec![
                 Span::raw(indent),
                 Span::styled(icon, icon_style),
                 Span::styled(&entry.label, label_style),
             ];
 
+            if matches!(entry.kind, TreeLineKind::File) {
+                let idx_style = Style::new().fg(colors.browser.empty_text);
+                spans.push(Span::styled(format!(" {}", entry.index), idx_style));
+            }
+
             lines.push(Line::from(spans));
         }
 

crates/ratatui/src/scope.rs

@@ -9,7 +9,7 @@ thread_local! {
     static PATTERNS: RefCell<Vec<u8>> = const { RefCell::new(Vec::new()) };
 }
 
-#[allow(dead_code)]
+#[derive(Clone, Copy)]
 pub enum Orientation {
     Horizontal,
     Vertical,

crates/ratatui/src/scroll_indicators.rs

@@ -0,0 +1,53 @@
+use ratatui::layout::Rect;
+use ratatui::style::{Color, Style};
+use ratatui::widgets::Paragraph;
+use ratatui::Frame;
+
+pub enum IndicatorAlign {
+    Center,
+    Right,
+}
+
+pub fn render_scroll_indicators(
+    frame: &mut Frame,
+    area: Rect,
+    offset: usize,
+    visible: usize,
+    total: usize,
+    color: Color,
+    align: IndicatorAlign,
+) {
+    let style = Style::new().fg(color);
+
+    match align {
+        IndicatorAlign::Center => {
+            if offset > 0 {
+                let indicator = Paragraph::new("▲")
+                    .style(style)
+                    .alignment(ratatui::layout::Alignment::Center);
+                frame.render_widget(indicator, Rect { height: 1, ..area });
+            }
+            if offset + visible < total {
+                let y = area.y + area.height.saturating_sub(1);
+                let indicator = Paragraph::new("▼")
+                    .style(style)
+                    .alignment(ratatui::layout::Alignment::Center);
+                frame.render_widget(indicator, Rect { y, height: 1, ..area });
+            }
+        }
+        IndicatorAlign::Right => {
+            let x = area.x + area.width.saturating_sub(1);
+            if offset > 0 {
+                let indicator = Paragraph::new("▲").style(style);
+                frame.render_widget(indicator, Rect::new(x, area.y, 1, 1));
+            }
+            if offset + visible < total {
+                let indicator = Paragraph::new("▼").style(style);
+                frame.render_widget(
+                    indicator,
+                    Rect::new(x, area.y + area.height.saturating_sub(1), 1, 1),
+                );
+            }
+        }
+    }
+}

crates/ratatui/src/search_bar.rs

@@ -0,0 +1,20 @@
+use ratatui::layout::Rect;
+use ratatui::style::Style;
+use ratatui::text::{Line, Span};
+use ratatui::widgets::Paragraph;
+use ratatui::Frame;
+
+use crate::theme;
+
+pub fn render_search_bar(frame: &mut Frame, area: Rect, query: &str, active: bool) {
+    let theme = theme::get();
+    let style = if active {
+        Style::new().fg(theme.search.active)
+    } else {
+        Style::new().fg(theme.search.inactive)
+    };
+    let cursor = if active { "_" } else { "" };
+    let text = format!(" /{query}{cursor}");
+    let line = Line::from(Span::styled(text, style));
+    frame.render_widget(Paragraph::new(vec![line]), area);
+}

crates/ratatui/src/section_header.rs

@@ -0,0 +1,30 @@
+use ratatui::layout::{Constraint, Layout, Rect};
+use ratatui::style::{Modifier, Style};
+use ratatui::widgets::Paragraph;
+use ratatui::Frame;
+
+use crate::theme;
+
+pub fn render_section_header(frame: &mut Frame, title: &str, focused: bool, area: Rect) {
+    let theme = theme::get();
+    let [header_area, divider_area] =
+        Layout::vertical([Constraint::Length(1), Constraint::Length(1)]).areas(area);
+
+    let header_style = if focused {
+        Style::new()
+            .fg(theme.engine.header_focused)
+            .add_modifier(Modifier::BOLD)
+    } else {
+        Style::new()
+            .fg(theme.engine.header)
+            .add_modifier(Modifier::BOLD)
+    };
+
+    frame.render_widget(Paragraph::new(title).style(header_style), header_area);
+
+    let divider = "─".repeat(area.width as usize);
+    frame.render_widget(
+        Paragraph::new(divider).style(Style::new().fg(theme.engine.divider)),
+        divider_area,
+    );
+}

crates/ratatui/src/spectrum.rs

@@ -24,19 +24,23 @@ impl Widget for Spectrum<'_> {
 
         let colors = theme::get();
         let height = area.height as f32;
-        let band_width = area.width as usize / 32;
-        if band_width == 0 {
+        let base = area.width as usize / 32;
+        let remainder = area.width as usize % 32;
+        if base == 0 && remainder == 0 {
             return;
         }
 
+        let mut x_start = area.x;
         for (band, &mag) in self.data.iter().enumerate() {
+            let w = base + if band < remainder { 1 } else { 0 };
+            if w == 0 {
+                continue;
+            }
             let bar_height = mag * height;
             let full_cells = bar_height as usize;
             let frac = bar_height - full_cells as f32;
             let frac_idx = (frac * 8.0) as usize;
 
-            let x_start = area.x + (band * band_width) as u16;
-
             for row in 0..area.height as usize {
                 let y = area.y + area.height - 1 - row as u16;
                 let ratio = row as f32 / area.height as f32;
@@ -47,11 +51,8 @@ impl Widget for Spectrum<'_> {
                 } else {
                     Color::Rgb(colors.meter.high_rgb.0, colors.meter.high_rgb.1, colors.meter.high_rgb.2)
                 };
-                for dx in 0..band_width as u16 {
+                for dx in 0..w as u16 {
                     let x = x_start + dx;
-                    if x >= area.x + area.width {
-                        break;
-                    }
                     if row < full_cells {
                         buf[(x, y)].set_char(BLOCKS[7]).set_fg(color);
                     } else if row == full_cells && frac_idx > 0 {
@@ -59,6 +60,7 @@ impl Widget for Spectrum<'_> {
                     }
                 }
             }
+            x_start += w as u16;
         }
     }
 }

crates/ratatui/src/text_input.rs

@@ -41,7 +41,7 @@ impl<'a> TextInputModal<'a> {
         self
     }
 
-    pub fn render_centered(self, frame: &mut Frame, term: Rect) {
+    pub fn render_centered(self, frame: &mut Frame, term: Rect) -> Rect {
         let colors = theme::get();
         let border_color = self.border_color.unwrap_or(colors.ui.text_primary);
         let height = if self.hint.is_some() { 6 } else { 5 };
@@ -81,5 +81,7 @@ impl<'a> TextInputModal<'a> {
                 inner,
             );
         }
+
+        inner
     }
 }

crates/ratatui/src/theme/build.rs

@@ -0,0 +1,274 @@
+use super::*;
+use super::palette::{Palette, Rgb, darken, mid, rgb, tint};
+
+pub fn build(p: &Palette) -> ThemeColors {
+    let darker_bg = darken(p.bg, 0.15);
+
+    ThemeColors {
+        ui: UiColors {
+            bg: rgb(p.bg),
+            bg_rgb: p.bg,
+            text_primary: rgb(p.fg),
+            text_muted: rgb(p.fg_dim),
+            text_dim: rgb(p.fg_muted),
+            border: rgb(p.surface2),
+            header: rgb(p.cyan),
+            unfocused: rgb(p.fg_muted),
+            accent: rgb(p.accent),
+            surface: rgb(p.surface),
+        },
+        status: StatusColors {
+            playing_bg: rgb(tint(p.bg, p.green, 0.25)),
+            playing_fg: rgb(p.green),
+            stopped_bg: rgb(tint(p.bg, p.red, 0.25)),
+            stopped_fg: rgb(p.red),
+            fill_on: rgb(p.green),
+            fill_off: rgb(p.fg_muted),
+            fill_bg: rgb(p.surface),
+        },
+        selection: SelectionColors {
+            cursor_bg: rgb(p.accent),
+            cursor_fg: rgb(p.bg),
+            selected_bg: rgb(tint(p.bg, p.accent, 0.30)),
+            selected_fg: rgb(p.accent),
+            in_range_bg: rgb(tint(p.bg, p.accent, 0.20)),
+            in_range_fg: rgb(p.fg),
+            cursor: rgb(p.accent),
+            selected: rgb(tint(p.bg, p.accent, 0.30)),
+            in_range: rgb(tint(p.bg, p.accent, 0.20)),
+        },
+        tile: TileColors {
+            playing_active_bg: rgb(tint(p.bg, p.orange, 0.35)),
+            playing_active_fg: rgb(p.orange),
+            playing_inactive_bg: rgb(tint(p.bg, p.yellow, 0.30)),
+            playing_inactive_fg: rgb(p.yellow),
+            active_bg: rgb(tint(p.bg, p.cyan, 0.25)),
+            active_fg: rgb(p.cyan),
+            content_bg: rgb(tint(p.bg, p.cyan, 0.30)),
+            inactive_bg: rgb(p.surface),
+            inactive_fg: rgb(p.fg_dim),
+            active_selected_bg: rgb(tint(p.bg, p.accent, 0.35)),
+            active_in_range_bg: rgb(tint(p.bg, p.accent, 0.22)),
+            link_bright: p.link_bright,
+            link_dim: p.link_dim,
+        },
+        header: HeaderColors {
+            tempo_bg: rgb(tint(p.bg, p.tempo_color, 0.30)),
+            tempo_fg: rgb(p.tempo_color),
+            bank_bg: rgb(tint(p.bg, p.bank_color, 0.25)),
+            bank_fg: rgb(p.bank_color),
+            pattern_bg: rgb(tint(p.bg, p.pattern_color, 0.25)),
+            pattern_fg: rgb(p.pattern_color),
+            stats_bg: rgb(p.surface),
+            stats_fg: rgb(p.fg_dim),
+        },
+        modal: ModalColors {
+            border: rgb(p.cyan),
+            border_accent: rgb(p.accent),
+            border_warn: rgb(p.orange),
+            border_dim: rgb(p.fg_muted),
+            confirm: rgb(p.orange),
+            rename: rgb(p.purple),
+            input: rgb(p.cyan),
+            editor: rgb(p.cyan),
+            preview: rgb(p.fg_muted),
+        },
+        flash: FlashColors {
+            error_bg: rgb(tint(p.bg, p.red, 0.30)),
+            error_fg: rgb(p.red),
+            success_bg: rgb(tint(p.bg, p.green, 0.25)),
+            success_fg: rgb(p.green),
+            info_bg: rgb(p.surface),
+            info_fg: rgb(p.fg),
+        },
+        list: ListColors {
+            playing_bg: rgb(tint(p.bg, p.green, 0.25)),
+            playing_fg: rgb(p.green),
+            staged_play_bg: rgb(tint(p.bg, p.purple, 0.30)),
+            staged_play_fg: rgb(p.purple),
+            staged_stop_bg: rgb(tint(p.bg, p.red, 0.30)),
+            staged_stop_fg: rgb(p.red),
+            edit_bg: rgb(tint(p.bg, p.cyan, 0.25)),
+            edit_fg: rgb(p.cyan),
+            hover_bg: rgb(p.surface2),
+            hover_fg: rgb(p.fg),
+            muted_bg: rgb(tint(p.bg, p.surface, 0.30)),
+            muted_fg: rgb(p.fg_muted),
+            soloed_bg: rgb(tint(p.bg, p.yellow, 0.30)),
+            soloed_fg: rgb(p.yellow),
+        },
+        link_status: LinkStatusColors {
+            disabled: rgb(p.red),
+            connected: rgb(p.green),
+            listening: rgb(p.yellow),
+        },
+        syntax: syntax_colors(p, darker_bg),
+        table: TableColors {
+            row_even: rgb(darker_bg),
+            row_odd: rgb(p.bg),
+        },
+        values: ValuesColors {
+            tempo: rgb(p.orange),
+            value: rgb(p.fg_dim),
+        },
+        hint: HintColors {
+            key: rgb(p.orange),
+            text: rgb(p.fg_muted),
+        },
+        view_badge: ViewBadgeColors {
+            bg: rgb(p.fg),
+            fg: rgb(p.bg),
+        },
+        nav: NavColors {
+            selected_bg: rgb(tint(p.bg, p.accent, 0.35)),
+            selected_fg: rgb(p.fg),
+            unselected_bg: rgb(p.surface),
+            unselected_fg: rgb(p.fg_muted),
+        },
+        editor_widget: EditorWidgetColors {
+            cursor_bg: rgb(p.fg),
+            cursor_fg: rgb(p.bg),
+            selection_bg: rgb(tint(p.bg, p.accent, 0.30)),
+            completion_bg: rgb(p.surface),
+            completion_fg: rgb(p.fg),
+            completion_selected: rgb(p.orange),
+            completion_example: rgb(p.cyan),
+        },
+        browser: BrowserColors {
+            directory: rgb(p.blue),
+            project_file: rgb(p.purple),
+            selected: rgb(p.orange),
+            file: rgb(p.fg),
+            focused_border: rgb(p.orange),
+            unfocused_border: rgb(p.fg_muted),
+            root: rgb(p.fg),
+            file_icon: rgb(p.fg_muted),
+            folder_icon: rgb(p.blue),
+            empty_text: rgb(p.fg_muted),
+        },
+        input: InputColors {
+            text: rgb(p.cyan),
+            cursor: rgb(p.fg),
+            hint: rgb(p.fg_muted),
+        },
+        search: SearchColors {
+            active: rgb(p.orange),
+            inactive: rgb(p.fg_muted),
+            match_bg: rgb(p.yellow),
+            match_fg: rgb(p.bg),
+        },
+        markdown: MarkdownColors {
+            h1: rgb(p.cyan),
+            h2: rgb(p.orange),
+            h3: rgb(p.purple),
+            code: rgb(p.green),
+            code_border: rgb(mid(p.surface2, p.fg_muted, 0.3)),
+            link: rgb(p.accent),
+            link_url: rgb(mid(p.fg_muted, p.fg_dim, 0.3)),
+            quote: rgb(p.fg_muted),
+            text: rgb(p.fg),
+            list: rgb(p.fg),
+        },
+        engine: engine_colors(p),
+        dict: dict_colors(p),
+        title: TitleColors {
+            big_title: rgb(p.title_accent),
+            author: rgb(p.title_author),
+            link: rgb(p.green),
+            license: rgb(p.orange),
+            prompt: rgb(mid(p.fg_dim, p.fg, 0.3)),
+            subtitle: rgb(p.fg),
+        },
+        meter: MeterColors {
+            low: rgb(p.green),
+            mid: rgb(p.yellow),
+            high: rgb(p.red),
+            low_rgb: p.meter[0],
+            mid_rgb: p.meter[1],
+            high_rgb: p.meter[2],
+        },
+        sparkle: SparkleColors {
+            colors: p.sparkle,
+        },
+        confirm: ConfirmColors {
+            border: rgb(p.orange),
+            button_selected_bg: rgb(p.orange),
+            button_selected_fg: rgb(p.bg),
+        },
+    }
+}
+
+fn syntax_colors(p: &Palette, darker_bg: Rgb) -> SyntaxColors {
+    let syn_bg = |accent: Rgb| -> Color { rgb(tint(p.bg, accent, 0.20)) };
+    let interval_fg = mid(p.green, p.fg, 0.3);
+
+    SyntaxColors {
+        gap_bg: rgb(darker_bg),
+        executed_bg: rgb(tint(p.bg, p.purple, 0.15)),
+        selected_bg: rgb(tint(p.bg, p.orange, 0.30)),
+        emit: (rgb(p.fg), syn_bg(p.accent)),
+        number: (rgb(p.purple), syn_bg(p.purple)),
+        string: (rgb(p.green), syn_bg(p.green)),
+        comment: (rgb(p.fg_muted), rgb(darker_bg)),
+        keyword: (rgb(p.accent), syn_bg(p.accent)),
+        stack_op: (rgb(p.blue), syn_bg(p.blue)),
+        operator: (rgb(p.red), syn_bg(p.red)),
+        sound: (rgb(p.cyan), syn_bg(p.cyan)),
+        param: (rgb(p.orange), syn_bg(p.orange)),
+        context: (rgb(p.orange), syn_bg(p.orange)),
+        note: (rgb(p.green), syn_bg(p.green)),
+        interval: (rgb(interval_fg), syn_bg(p.green)),
+        variable: (rgb(p.purple), syn_bg(p.purple)),
+        vary: (rgb(p.yellow), syn_bg(p.yellow)),
+        generator: (rgb(p.cyan), syn_bg(p.cyan)),
+        user_defined: (rgb(p.secondary), syn_bg(p.secondary)),
+        default: (rgb(p.fg_dim), rgb(darker_bg)),
+    }
+}
+
+fn engine_colors(p: &Palette) -> EngineColors {
+    let divider = mid(p.surface2, p.fg_muted, 0.2);
+    let label = mid(p.fg_muted, p.fg, 0.4);
+
+    EngineColors {
+        header: rgb(p.cyan),
+        header_focused: rgb(p.yellow),
+        divider: rgb(divider),
+        scroll_indicator: rgb(mid(divider, p.fg_muted, 0.3)),
+        label: rgb(label),
+        label_focused: rgb(mid(label, p.fg, 0.3)),
+        label_dim: rgb(mid(p.fg_muted, label, 0.3)),
+        value: rgb(mid(p.fg_dim, p.fg, 0.5)),
+        focused: rgb(p.yellow),
+        normal: rgb(p.fg),
+        dim: rgb(mid(divider, p.fg_muted, 0.3)),
+        path: rgb(label),
+        border_magenta: rgb(p.purple),
+        border_green: rgb(p.green),
+        border_cyan: rgb(p.cyan),
+        separator: rgb(divider),
+        hint_active: rgb(mid(p.orange, p.yellow, 0.5)),
+        hint_inactive: rgb(divider),
+    }
+}
+
+fn dict_colors(p: &Palette) -> DictColors {
+    let divider = mid(p.surface2, p.fg_muted, 0.2);
+    let label = mid(p.fg_muted, p.fg, 0.4);
+
+    DictColors {
+        word_name: rgb(p.green),
+        word_bg: rgb(tint(p.bg, p.cyan, 0.20)),
+        alias: rgb(p.fg_muted),
+        stack_sig: rgb(p.purple),
+        description: rgb(p.fg),
+        example: rgb(label),
+        category_focused: rgb(p.yellow),
+        category_selected: rgb(p.cyan),
+        category_normal: rgb(p.fg),
+        category_dimmed: rgb(mid(divider, p.fg_muted, 0.3)),
+        border_focused: rgb(p.yellow),
+        border_normal: rgb(divider),
+        header_desc: rgb(mid(label, p.fg, 0.3)),
+    }
+}

crates/ratatui/src/theme/catppuccin_latte.rs

@@ -1,282 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let crust = Color::Rgb(220, 224, 232);
-    let mantle = Color::Rgb(230, 233, 239);
-    let base = Color::Rgb(239, 241, 245);
-    let surface0 = Color::Rgb(204, 208, 218);
-    let surface1 = Color::Rgb(188, 192, 204);
-    let overlay0 = Color::Rgb(156, 160, 176);
-    let overlay1 = Color::Rgb(140, 143, 161);
-    let subtext0 = Color::Rgb(108, 111, 133);
-    let subtext1 = Color::Rgb(92, 95, 119);
-    let text = Color::Rgb(76, 79, 105);
-    let pink = Color::Rgb(234, 118, 203);
-    let mauve = Color::Rgb(136, 57, 239);
-    let red = Color::Rgb(210, 15, 57);
-    let maroon = Color::Rgb(230, 69, 83);
-    let peach = Color::Rgb(254, 100, 11);
-    let yellow = Color::Rgb(223, 142, 29);
-    let green = Color::Rgb(64, 160, 43);
-    let teal = Color::Rgb(23, 146, 153);
-    let sapphire = Color::Rgb(32, 159, 181);
-    let lavender = Color::Rgb(114, 135, 253);
-
-    ThemeColors {
-        ui: UiColors {
-            bg: base,
-            bg_rgb: (239, 241, 245),
-            text_primary: text,
-            text_muted: subtext0,
-            text_dim: overlay1,
-            border: surface1,
-            header: lavender,
-            unfocused: overlay0,
-            accent: mauve,
-            surface: surface0,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(220, 240, 225),
-            playing_fg: green,
-            stopped_bg: Color::Rgb(245, 220, 225),
-            stopped_fg: red,
-            fill_on: green,
-            fill_off: overlay0,
-            fill_bg: surface0,
-        },
-        selection: SelectionColors {
-            cursor_bg: mauve,
-            cursor_fg: base,
-            selected_bg: Color::Rgb(200, 200, 230),
-            selected_fg: lavender,
-            in_range_bg: Color::Rgb(210, 210, 235),
-            in_range_fg: subtext1,
-            cursor: mauve,
-            selected: Color::Rgb(200, 200, 230),
-            in_range: Color::Rgb(210, 210, 235),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(250, 220, 210),
-            playing_active_fg: peach,
-            playing_inactive_bg: Color::Rgb(250, 235, 200),
-            playing_inactive_fg: yellow,
-            active_bg: Color::Rgb(200, 235, 235),
-            active_fg: teal,
-            inactive_bg: surface0,
-            inactive_fg: subtext0,
-            active_selected_bg: Color::Rgb(215, 210, 240),
-            active_in_range_bg: Color::Rgb(210, 215, 230),
-            link_bright: [
-                (136, 57, 239),
-                (234, 118, 203),
-                (254, 100, 11),
-                (4, 165, 229),
-                (64, 160, 43),
-            ],
-            link_dim: [
-                (210, 200, 240),
-                (240, 210, 230),
-                (250, 220, 200),
-                (200, 230, 240),
-                (210, 235, 210),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(220, 210, 240),
-            tempo_fg: mauve,
-            bank_bg: Color::Rgb(200, 230, 235),
-            bank_fg: sapphire,
-            pattern_bg: Color::Rgb(200, 230, 225),
-            pattern_fg: teal,
-            stats_bg: surface0,
-            stats_fg: subtext0,
-        },
-        modal: ModalColors {
-            border: lavender,
-            border_accent: mauve,
-            border_warn: peach,
-            border_dim: overlay1,
-            confirm: peach,
-            rename: mauve,
-            input: sapphire,
-            editor: lavender,
-            preview: overlay1,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(250, 215, 220),
-            error_fg: red,
-            success_bg: Color::Rgb(210, 240, 215),
-            success_fg: green,
-            info_bg: surface0,
-            info_fg: text,
-            event_rgb: (225, 215, 240),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(210, 235, 220),
-            playing_fg: green,
-            staged_play_bg: Color::Rgb(225, 215, 245),
-            staged_play_fg: mauve,
-            staged_stop_bg: Color::Rgb(245, 215, 225),
-            staged_stop_fg: maroon,
-            edit_bg: Color::Rgb(210, 235, 235),
-            edit_fg: teal,
-            hover_bg: surface1,
-            hover_fg: text,
-        },
-        link_status: LinkStatusColors {
-            disabled: red,
-            connected: green,
-            listening: yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: mantle,
-            executed_bg: Color::Rgb(225, 220, 240),
-            selected_bg: Color::Rgb(250, 235, 210),
-            emit: (text, Color::Rgb(250, 220, 215)),
-            number: (peach, Color::Rgb(252, 235, 220)),
-            string: (green, Color::Rgb(215, 240, 215)),
-            comment: (overlay1, crust),
-            keyword: (mauve, Color::Rgb(230, 220, 245)),
-            stack_op: (sapphire, Color::Rgb(215, 230, 240)),
-            operator: (yellow, Color::Rgb(245, 235, 210)),
-            sound: (teal, Color::Rgb(210, 240, 240)),
-            param: (lavender, Color::Rgb(220, 225, 245)),
-            context: (peach, Color::Rgb(252, 235, 220)),
-            note: (green, Color::Rgb(215, 240, 215)),
-            interval: (Color::Rgb(50, 140, 30), Color::Rgb(215, 240, 210)),
-            variable: (pink, Color::Rgb(245, 220, 240)),
-            vary: (yellow, Color::Rgb(245, 235, 210)),
-            generator: (teal, Color::Rgb(210, 240, 235)),
-            default: (subtext0, mantle),
-        },
-        table: TableColors {
-            row_even: mantle,
-            row_odd: base,
-        },
-        values: ValuesColors {
-            tempo: peach,
-            value: subtext0,
-        },
-        hint: HintColors {
-            key: peach,
-            text: overlay1,
-        },
-        view_badge: ViewBadgeColors { bg: text, fg: base },
-        nav: NavColors {
-            selected_bg: Color::Rgb(215, 205, 245),
-            selected_fg: text,
-            unselected_bg: surface0,
-            unselected_fg: overlay1,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: text,
-            cursor_fg: base,
-            selection_bg: Color::Rgb(200, 210, 240),
-            completion_bg: surface0,
-            completion_fg: text,
-            completion_selected: peach,
-            completion_example: teal,
-        },
-        browser: BrowserColors {
-            directory: sapphire,
-            project_file: mauve,
-            selected: peach,
-            file: text,
-            focused_border: peach,
-            unfocused_border: overlay0,
-            root: text,
-            file_icon: overlay1,
-            folder_icon: sapphire,
-            empty_text: overlay1,
-        },
-        input: InputColors {
-            text: sapphire,
-            cursor: text,
-            hint: overlay1,
-        },
-        search: SearchColors {
-            active: peach,
-            inactive: overlay0,
-            match_bg: yellow,
-            match_fg: base,
-        },
-        markdown: MarkdownColors {
-            h1: sapphire,
-            h2: peach,
-            h3: mauve,
-            code: green,
-            code_border: Color::Rgb(190, 195, 205),
-            link: teal,
-            link_url: Color::Rgb(150, 150, 150),
-            quote: overlay1,
-            text,
-            list: text,
-        },
-        engine: EngineColors {
-            header: Color::Rgb(30, 120, 150),
-            header_focused: yellow,
-            divider: Color::Rgb(180, 185, 195),
-            scroll_indicator: Color::Rgb(160, 165, 175),
-            label: Color::Rgb(100, 105, 120),
-            label_focused: Color::Rgb(70, 75, 90),
-            label_dim: Color::Rgb(120, 125, 140),
-            value: Color::Rgb(60, 65, 80),
-            focused: yellow,
-            normal: text,
-            dim: Color::Rgb(160, 165, 175),
-            path: Color::Rgb(100, 105, 120),
-            border_magenta: mauve,
-            border_green: green,
-            border_cyan: sapphire,
-            separator: Color::Rgb(180, 185, 200),
-            hint_active: Color::Rgb(180, 140, 40),
-            hint_inactive: Color::Rgb(190, 195, 205),
-        },
-        dict: DictColors {
-            word_name: green,
-            word_bg: Color::Rgb(210, 225, 235),
-            alias: overlay1,
-            stack_sig: mauve,
-            description: text,
-            example: Color::Rgb(100, 105, 115),
-            category_focused: yellow,
-            category_selected: sapphire,
-            category_normal: text,
-            category_dimmed: Color::Rgb(160, 165, 175),
-            border_focused: yellow,
-            border_normal: Color::Rgb(180, 185, 195),
-            header_desc: Color::Rgb(90, 95, 110),
-        },
-        title: TitleColors {
-            big_title: mauve,
-            author: lavender,
-            link: teal,
-            license: peach,
-            prompt: Color::Rgb(90, 100, 115),
-            subtitle: text,
-        },
-        meter: MeterColors {
-            low: green,
-            mid: yellow,
-            high: red,
-            low_rgb: (50, 150, 40),
-            mid_rgb: (200, 140, 30),
-            high_rgb: (200, 40, 50),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (114, 135, 253),
-                (254, 100, 11),
-                (64, 160, 43),
-                (234, 118, 203),
-                (136, 57, 239),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: peach,
-            button_selected_bg: peach,
-            button_selected_fg: base,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (239, 241, 245),
+        surface: (204, 208, 218),
+        surface2: (188, 192, 204),
+        fg: (76, 79, 105),
+        fg_dim: (108, 111, 133),
+        fg_muted: (140, 143, 161),
+        accent: (136, 57, 239),     // mauve
+        red: (210, 15, 57),
+        green: (64, 160, 43),
+        yellow: (223, 142, 29),
+        blue: (32, 159, 181),       // sapphire
+        purple: (136, 57, 239),
+        cyan: (23, 146, 153),       // teal
+        orange: (254, 100, 11),     // peach
+        tempo_color: (136, 57, 239),
+        bank_color: (32, 159, 181),
+        pattern_color: (23, 146, 153),
+        title_accent: (136, 57, 239),
+        title_author: (114, 135, 253),
+        secondary: (230, 69, 83),    // maroon
+        link_bright: [
+            (136, 57, 239), (234, 118, 203), (254, 100, 11),
+            (4, 165, 229), (64, 160, 43),
+        ],
+        link_dim: [
+            (210, 200, 240), (240, 210, 230), (250, 220, 200),
+            (200, 230, 240), (210, 235, 210),
+        ],
+        sparkle: [
+            (114, 135, 253), (254, 100, 11), (64, 160, 43),
+            (234, 118, 203), (136, 57, 239),
+        ],
+        meter: [(50, 150, 40), (200, 140, 30), (200, 40, 50)],
     }
 }

crates/ratatui/src/theme/catppuccin_mocha.rs

@@ -1,285 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let crust = Color::Rgb(17, 17, 27);
-    let mantle = Color::Rgb(24, 24, 37);
-    let base = Color::Rgb(30, 30, 46);
-    let surface0 = Color::Rgb(49, 50, 68);
-    let surface1 = Color::Rgb(69, 71, 90);
-    let overlay0 = Color::Rgb(108, 112, 134);
-    let overlay1 = Color::Rgb(127, 132, 156);
-    let subtext0 = Color::Rgb(166, 173, 200);
-    let subtext1 = Color::Rgb(186, 194, 222);
-    let text = Color::Rgb(205, 214, 244);
-    let pink = Color::Rgb(245, 194, 231);
-    let mauve = Color::Rgb(203, 166, 247);
-    let red = Color::Rgb(243, 139, 168);
-    let maroon = Color::Rgb(235, 160, 172);
-    let peach = Color::Rgb(250, 179, 135);
-    let yellow = Color::Rgb(249, 226, 175);
-    let green = Color::Rgb(166, 227, 161);
-    let teal = Color::Rgb(148, 226, 213);
-    let sapphire = Color::Rgb(116, 199, 236);
-    let lavender = Color::Rgb(180, 190, 254);
-
-    ThemeColors {
-        ui: UiColors {
-            bg: base,
-            bg_rgb: (30, 30, 46),
-            text_primary: text,
-            text_muted: subtext0,
-            text_dim: overlay1,
-            border: surface1,
-            header: lavender,
-            unfocused: overlay0,
-            accent: mauve,
-            surface: surface0,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(30, 50, 40),
-            playing_fg: green,
-            stopped_bg: Color::Rgb(50, 30, 40),
-            stopped_fg: red,
-            fill_on: green,
-            fill_off: overlay0,
-            fill_bg: surface0,
-        },
-        selection: SelectionColors {
-            cursor_bg: mauve,
-            cursor_fg: crust,
-            selected_bg: Color::Rgb(60, 60, 90),
-            selected_fg: lavender,
-            in_range_bg: Color::Rgb(50, 50, 75),
-            in_range_fg: subtext1,
-            cursor: mauve,
-            selected: Color::Rgb(60, 60, 90),
-            in_range: Color::Rgb(50, 50, 75),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(80, 50, 60),
-            playing_active_fg: peach,
-            playing_inactive_bg: Color::Rgb(70, 55, 45),
-            playing_inactive_fg: yellow,
-            active_bg: Color::Rgb(40, 55, 55),
-            active_fg: teal,
-            inactive_bg: surface0,
-            inactive_fg: subtext0,
-            active_selected_bg: Color::Rgb(70, 60, 80),
-            active_in_range_bg: Color::Rgb(55, 55, 70),
-            link_bright: [
-                (203, 166, 247),
-                (245, 194, 231),
-                (250, 179, 135),
-                (137, 220, 235),
-                (166, 227, 161),
-            ],
-            link_dim: [
-                (70, 55, 85),
-                (85, 65, 80),
-                (85, 60, 45),
-                (45, 75, 80),
-                (55, 80, 55),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(50, 40, 60),
-            tempo_fg: mauve,
-            bank_bg: Color::Rgb(35, 50, 55),
-            bank_fg: sapphire,
-            pattern_bg: Color::Rgb(40, 50, 50),
-            pattern_fg: teal,
-            stats_bg: surface0,
-            stats_fg: subtext0,
-        },
-        modal: ModalColors {
-            border: lavender,
-            border_accent: mauve,
-            border_warn: peach,
-            border_dim: overlay1,
-            confirm: peach,
-            rename: mauve,
-            input: sapphire,
-            editor: lavender,
-            preview: overlay1,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(50, 30, 40),
-            error_fg: red,
-            success_bg: Color::Rgb(30, 50, 40),
-            success_fg: green,
-            info_bg: surface0,
-            info_fg: text,
-            event_rgb: (55, 45, 70),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(35, 55, 45),
-            playing_fg: green,
-            staged_play_bg: Color::Rgb(55, 45, 65),
-            staged_play_fg: mauve,
-            staged_stop_bg: Color::Rgb(60, 40, 50),
-            staged_stop_fg: maroon,
-            edit_bg: Color::Rgb(40, 55, 55),
-            edit_fg: teal,
-            hover_bg: surface1,
-            hover_fg: text,
-        },
-        link_status: LinkStatusColors {
-            disabled: red,
-            connected: green,
-            listening: yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: mantle,
-            executed_bg: Color::Rgb(45, 40, 55),
-            selected_bg: Color::Rgb(70, 55, 40),
-            emit: (text, Color::Rgb(80, 50, 60)),
-            number: (peach, Color::Rgb(55, 45, 35)),
-            string: (green, Color::Rgb(35, 50, 40)),
-            comment: (overlay1, crust),
-            keyword: (mauve, Color::Rgb(50, 40, 60)),
-            stack_op: (sapphire, Color::Rgb(35, 45, 55)),
-            operator: (yellow, Color::Rgb(55, 50, 35)),
-            sound: (teal, Color::Rgb(35, 55, 55)),
-            param: (lavender, Color::Rgb(45, 45, 60)),
-            context: (peach, Color::Rgb(55, 45, 35)),
-            note: (green, Color::Rgb(35, 50, 40)),
-            interval: (Color::Rgb(180, 230, 150), Color::Rgb(40, 55, 35)),
-            variable: (pink, Color::Rgb(55, 40, 55)),
-            vary: (yellow, Color::Rgb(55, 50, 35)),
-            generator: (teal, Color::Rgb(35, 55, 50)),
-            default: (subtext0, mantle),
-        },
-        table: TableColors {
-            row_even: mantle,
-            row_odd: base,
-        },
-        values: ValuesColors {
-            tempo: peach,
-            value: subtext0,
-        },
-        hint: HintColors {
-            key: peach,
-            text: overlay1,
-        },
-        view_badge: ViewBadgeColors {
-            bg: text,
-            fg: crust,
-        },
-        nav: NavColors {
-            selected_bg: Color::Rgb(60, 50, 75),
-            selected_fg: text,
-            unselected_bg: surface0,
-            unselected_fg: overlay1,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: text,
-            cursor_fg: crust,
-            selection_bg: Color::Rgb(50, 60, 90),
-            completion_bg: surface0,
-            completion_fg: text,
-            completion_selected: peach,
-            completion_example: teal,
-        },
-        browser: BrowserColors {
-            directory: sapphire,
-            project_file: mauve,
-            selected: peach,
-            file: text,
-            focused_border: peach,
-            unfocused_border: overlay0,
-            root: text,
-            file_icon: overlay1,
-            folder_icon: sapphire,
-            empty_text: overlay1,
-        },
-        input: InputColors {
-            text: sapphire,
-            cursor: text,
-            hint: overlay1,
-        },
-        search: SearchColors {
-            active: peach,
-            inactive: overlay0,
-            match_bg: yellow,
-            match_fg: crust,
-        },
-        markdown: MarkdownColors {
-            h1: sapphire,
-            h2: peach,
-            h3: mauve,
-            code: green,
-            code_border: Color::Rgb(60, 60, 70),
-            link: teal,
-            link_url: Color::Rgb(100, 100, 100),
-            quote: overlay1,
-            text,
-            list: text,
-        },
-        engine: EngineColors {
-            header: Color::Rgb(100, 160, 180),
-            header_focused: yellow,
-            divider: Color::Rgb(60, 65, 70),
-            scroll_indicator: Color::Rgb(80, 85, 95),
-            label: Color::Rgb(120, 125, 135),
-            label_focused: Color::Rgb(150, 155, 165),
-            label_dim: Color::Rgb(100, 105, 115),
-            value: Color::Rgb(180, 180, 190),
-            focused: yellow,
-            normal: text,
-            dim: Color::Rgb(80, 85, 95),
-            path: Color::Rgb(120, 125, 135),
-            border_magenta: mauve,
-            border_green: green,
-            border_cyan: sapphire,
-            separator: Color::Rgb(60, 65, 75),
-            hint_active: Color::Rgb(180, 180, 100),
-            hint_inactive: Color::Rgb(60, 60, 70),
-        },
-        dict: DictColors {
-            word_name: green,
-            word_bg: Color::Rgb(40, 50, 60),
-            alias: overlay1,
-            stack_sig: mauve,
-            description: text,
-            example: Color::Rgb(120, 130, 140),
-            category_focused: yellow,
-            category_selected: sapphire,
-            category_normal: text,
-            category_dimmed: Color::Rgb(80, 80, 90),
-            border_focused: yellow,
-            border_normal: Color::Rgb(60, 60, 70),
-            header_desc: Color::Rgb(140, 145, 155),
-        },
-        title: TitleColors {
-            big_title: mauve,
-            author: lavender,
-            link: teal,
-            license: peach,
-            prompt: Color::Rgb(140, 160, 170),
-            subtitle: text,
-        },
-        meter: MeterColors {
-            low: green,
-            mid: yellow,
-            high: red,
-            low_rgb: (40, 180, 80),
-            mid_rgb: (220, 180, 40),
-            high_rgb: (220, 60, 40),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (200, 220, 255),
-                (250, 179, 135),
-                (166, 227, 161),
-                (245, 194, 231),
-                (203, 166, 247),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: peach,
-            button_selected_bg: peach,
-            button_selected_fg: crust,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (30, 30, 46),
+        surface: (49, 50, 68),
+        surface2: (69, 71, 90),
+        fg: (205, 214, 244),
+        fg_dim: (166, 173, 200),
+        fg_muted: (127, 132, 156),
+        accent: (203, 166, 247),    // mauve
+        red: (243, 139, 168),
+        green: (166, 227, 161),
+        yellow: (249, 226, 175),
+        blue: (116, 199, 236),      // sapphire
+        purple: (203, 166, 247),    // mauve
+        cyan: (148, 226, 213),      // teal
+        orange: (250, 179, 135),    // peach
+        tempo_color: (203, 166, 247),
+        bank_color: (116, 199, 236),
+        pattern_color: (148, 226, 213),
+        title_accent: (203, 166, 247),
+        title_author: (180, 190, 254),
+        secondary: (235, 160, 172),  // maroon
+        link_bright: [
+            (203, 166, 247), (245, 194, 231), (250, 179, 135),
+            (137, 220, 235), (166, 227, 161),
+        ],
+        link_dim: [
+            (70, 55, 85), (85, 65, 80), (85, 60, 45),
+            (45, 75, 80), (55, 80, 55),
+        ],
+        sparkle: [
+            (200, 220, 255), (250, 179, 135), (166, 227, 161),
+            (245, 194, 231), (203, 166, 247),
+        ],
+        meter: [(40, 180, 80), (220, 180, 40), (220, 60, 40)],
     }
 }

crates/ratatui/src/theme/dracula.rs

@@ -1,279 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let background = Color::Rgb(40, 42, 54);
-    let current_line = Color::Rgb(68, 71, 90);
-    let foreground = Color::Rgb(248, 248, 242);
-    let comment = Color::Rgb(98, 114, 164);
-    let cyan = Color::Rgb(139, 233, 253);
-    let green = Color::Rgb(80, 250, 123);
-    let orange = Color::Rgb(255, 184, 108);
-    let pink = Color::Rgb(255, 121, 198);
-    let purple = Color::Rgb(189, 147, 249);
-    let red = Color::Rgb(255, 85, 85);
-    let yellow = Color::Rgb(241, 250, 140);
-
-    let darker_bg = Color::Rgb(33, 34, 44);
-    let lighter_bg = Color::Rgb(55, 57, 70);
-
-    ThemeColors {
-        ui: UiColors {
-            bg: background,
-            bg_rgb: (40, 42, 54),
-            text_primary: foreground,
-            text_muted: comment,
-            text_dim: Color::Rgb(80, 85, 110),
-            border: current_line,
-            header: purple,
-            unfocused: comment,
-            accent: purple,
-            surface: current_line,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(40, 60, 50),
-            playing_fg: green,
-            stopped_bg: Color::Rgb(65, 45, 50),
-            stopped_fg: red,
-            fill_on: green,
-            fill_off: comment,
-            fill_bg: current_line,
-        },
-        selection: SelectionColors {
-            cursor_bg: purple,
-            cursor_fg: background,
-            selected_bg: Color::Rgb(80, 75, 110),
-            selected_fg: purple,
-            in_range_bg: Color::Rgb(65, 65, 90),
-            in_range_fg: foreground,
-            cursor: purple,
-            selected: Color::Rgb(80, 75, 110),
-            in_range: Color::Rgb(65, 65, 90),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(85, 60, 65),
-            playing_active_fg: orange,
-            playing_inactive_bg: Color::Rgb(80, 75, 55),
-            playing_inactive_fg: yellow,
-            active_bg: Color::Rgb(50, 70, 70),
-            active_fg: cyan,
-            inactive_bg: current_line,
-            inactive_fg: comment,
-            active_selected_bg: Color::Rgb(80, 70, 95),
-            active_in_range_bg: Color::Rgb(65, 65, 85),
-            link_bright: [
-                (189, 147, 249),
-                (255, 121, 198),
-                (255, 184, 108),
-                (139, 233, 253),
-                (80, 250, 123),
-            ],
-            link_dim: [
-                (75, 60, 95),
-                (95, 55, 80),
-                (95, 70, 50),
-                (55, 90, 95),
-                (40, 95, 55),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(65, 50, 75),
-            tempo_fg: purple,
-            bank_bg: Color::Rgb(45, 65, 70),
-            bank_fg: cyan,
-            pattern_bg: Color::Rgb(40, 70, 60),
-            pattern_fg: green,
-            stats_bg: current_line,
-            stats_fg: comment,
-        },
-        modal: ModalColors {
-            border: purple,
-            border_accent: pink,
-            border_warn: orange,
-            border_dim: comment,
-            confirm: orange,
-            rename: purple,
-            input: cyan,
-            editor: purple,
-            preview: comment,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(70, 45, 50),
-            error_fg: red,
-            success_bg: Color::Rgb(40, 65, 50),
-            success_fg: green,
-            info_bg: current_line,
-            info_fg: foreground,
-            event_rgb: (70, 55, 85),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(40, 65, 50),
-            playing_fg: green,
-            staged_play_bg: Color::Rgb(70, 55, 85),
-            staged_play_fg: purple,
-            staged_stop_bg: Color::Rgb(80, 50, 60),
-            staged_stop_fg: red,
-            edit_bg: Color::Rgb(45, 70, 70),
-            edit_fg: cyan,
-            hover_bg: lighter_bg,
-            hover_fg: foreground,
-        },
-        link_status: LinkStatusColors {
-            disabled: red,
-            connected: green,
-            listening: yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: darker_bg,
-            executed_bg: Color::Rgb(55, 50, 70),
-            selected_bg: Color::Rgb(85, 70, 50),
-            emit: (foreground, Color::Rgb(85, 55, 65)),
-            number: (orange, Color::Rgb(75, 55, 45)),
-            string: (yellow, Color::Rgb(70, 70, 45)),
-            comment: (comment, darker_bg),
-            keyword: (pink, Color::Rgb(80, 50, 70)),
-            stack_op: (cyan, Color::Rgb(45, 65, 75)),
-            operator: (green, Color::Rgb(40, 70, 50)),
-            sound: (cyan, Color::Rgb(45, 70, 70)),
-            param: (purple, Color::Rgb(60, 50, 75)),
-            context: (orange, Color::Rgb(75, 55, 45)),
-            note: (green, Color::Rgb(40, 70, 50)),
-            interval: (Color::Rgb(120, 255, 150), Color::Rgb(40, 75, 50)),
-            variable: (pink, Color::Rgb(80, 50, 65)),
-            vary: (yellow, Color::Rgb(70, 70, 45)),
-            generator: (cyan, Color::Rgb(45, 70, 65)),
-            default: (comment, darker_bg),
-        },
-        table: TableColors {
-            row_even: darker_bg,
-            row_odd: background,
-        },
-        values: ValuesColors {
-            tempo: orange,
-            value: comment,
-        },
-        hint: HintColors {
-            key: orange,
-            text: comment,
-        },
-        view_badge: ViewBadgeColors {
-            bg: foreground,
-            fg: background,
-        },
-        nav: NavColors {
-            selected_bg: Color::Rgb(75, 65, 100),
-            selected_fg: foreground,
-            unselected_bg: current_line,
-            unselected_fg: comment,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: foreground,
-            cursor_fg: background,
-            selection_bg: Color::Rgb(70, 75, 105),
-            completion_bg: current_line,
-            completion_fg: foreground,
-            completion_selected: orange,
-            completion_example: cyan,
-        },
-        browser: BrowserColors {
-            directory: cyan,
-            project_file: purple,
-            selected: orange,
-            file: foreground,
-            focused_border: orange,
-            unfocused_border: comment,
-            root: foreground,
-            file_icon: comment,
-            folder_icon: cyan,
-            empty_text: comment,
-        },
-        input: InputColors {
-            text: cyan,
-            cursor: foreground,
-            hint: comment,
-        },
-        search: SearchColors {
-            active: orange,
-            inactive: comment,
-            match_bg: yellow,
-            match_fg: background,
-        },
-        markdown: MarkdownColors {
-            h1: cyan,
-            h2: orange,
-            h3: purple,
-            code: green,
-            code_border: Color::Rgb(85, 90, 110),
-            link: pink,
-            link_url: Color::Rgb(120, 130, 150),
-            quote: comment,
-            text: foreground,
-            list: foreground,
-        },
-        engine: EngineColors {
-            header: cyan,
-            header_focused: yellow,
-            divider: Color::Rgb(80, 85, 105),
-            scroll_indicator: Color::Rgb(95, 100, 120),
-            label: Color::Rgb(140, 145, 165),
-            label_focused: Color::Rgb(170, 175, 195),
-            label_dim: Color::Rgb(110, 115, 135),
-            value: Color::Rgb(200, 205, 220),
-            focused: yellow,
-            normal: foreground,
-            dim: Color::Rgb(95, 100, 120),
-            path: Color::Rgb(140, 145, 165),
-            border_magenta: pink,
-            border_green: green,
-            border_cyan: cyan,
-            separator: Color::Rgb(80, 85, 105),
-            hint_active: Color::Rgb(220, 200, 100),
-            hint_inactive: Color::Rgb(80, 85, 105),
-        },
-        dict: DictColors {
-            word_name: green,
-            word_bg: Color::Rgb(55, 65, 80),
-            alias: comment,
-            stack_sig: purple,
-            description: foreground,
-            example: Color::Rgb(140, 145, 165),
-            category_focused: yellow,
-            category_selected: cyan,
-            category_normal: foreground,
-            category_dimmed: Color::Rgb(95, 100, 120),
-            border_focused: yellow,
-            border_normal: Color::Rgb(80, 85, 105),
-            header_desc: Color::Rgb(160, 165, 185),
-        },
-        title: TitleColors {
-            big_title: purple,
-            author: pink,
-            link: cyan,
-            license: orange,
-            prompt: Color::Rgb(160, 165, 185),
-            subtitle: foreground,
-        },
-        meter: MeterColors {
-            low: green,
-            mid: yellow,
-            high: red,
-            low_rgb: (70, 230, 110),
-            mid_rgb: (230, 240, 130),
-            high_rgb: (240, 80, 80),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (189, 147, 249),
-                (255, 184, 108),
-                (80, 250, 123),
-                (255, 121, 198),
-                (139, 233, 253),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: orange,
-            button_selected_bg: orange,
-            button_selected_fg: background,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (40, 42, 54),
+        surface: (68, 71, 90),
+        surface2: (55, 57, 70),
+        fg: (248, 248, 242),
+        fg_dim: (98, 114, 164),
+        fg_muted: (80, 85, 110),
+        accent: (189, 147, 249),    // purple
+        red: (255, 85, 85),
+        green: (80, 250, 123),
+        yellow: (241, 250, 140),
+        blue: (139, 233, 253),      // cyan
+        purple: (189, 147, 249),
+        cyan: (139, 233, 253),
+        orange: (255, 184, 108),
+        tempo_color: (189, 147, 249),
+        bank_color: (139, 233, 253),
+        pattern_color: (80, 250, 123),
+        title_accent: (189, 147, 249),
+        title_author: (255, 121, 198),
+        secondary: (255, 184, 108),
+        link_bright: [
+            (189, 147, 249), (255, 121, 198), (255, 184, 108),
+            (139, 233, 253), (80, 250, 123),
+        ],
+        link_dim: [
+            (75, 60, 95), (95, 55, 80), (95, 70, 50),
+            (55, 90, 95), (40, 95, 55),
+        ],
+        sparkle: [
+            (189, 147, 249), (255, 184, 108), (80, 250, 123),
+            (255, 121, 198), (139, 233, 253),
+        ],
+        meter: [(70, 230, 110), (230, 240, 130), (240, 80, 80)],
     }
 }

crates/ratatui/src/theme/eden.rs

@@ -0,0 +1,39 @@
+use super::palette::Palette;
+
+pub fn palette() -> Palette {
+    Palette {
+        bg: (8, 12, 8),
+        surface: (16, 24, 16),
+        surface2: (32, 48, 32),
+        fg: (200, 216, 192),
+        fg_dim: (122, 144, 112),
+        fg_muted: (64, 88, 56),
+        accent: (64, 192, 64),      // green
+        red: (192, 80, 64),
+        green: (96, 224, 96),       // bright_green
+        yellow: (160, 160, 64),
+        blue: (80, 128, 160),
+        purple: (128, 104, 144),
+        cyan: (80, 168, 144),
+        orange: (176, 128, 48),
+        tempo_color: (128, 104, 144),
+        bank_color: (80, 128, 160),
+        pattern_color: (80, 168, 144),
+        title_accent: (64, 192, 64),
+        title_author: (80, 168, 144),
+        secondary: (176, 128, 48),
+        link_bright: [
+            (64, 192, 64), (80, 168, 144), (160, 160, 64),
+            (80, 128, 160), (192, 80, 64),
+        ],
+        link_dim: [
+            (14, 38, 14), (16, 34, 28), (32, 32, 14),
+            (16, 26, 32), (38, 16, 14),
+        ],
+        sparkle: [
+            (64, 192, 64), (96, 224, 96), (80, 168, 144),
+            (160, 160, 64), (48, 128, 48),
+        ],
+        meter: [(64, 192, 64), (160, 160, 64), (192, 80, 64)],
+    }
+}

crates/ratatui/src/theme/ember.rs

@@ -0,0 +1,39 @@
+use super::palette::Palette;
+
+pub fn palette() -> Palette {
+    Palette {
+        bg: (10, 8, 8),
+        surface: (20, 16, 16),
+        surface2: (42, 32, 32),
+        fg: (232, 221, 208),
+        fg_dim: (160, 144, 128),
+        fg_muted: (96, 80, 64),
+        accent: (224, 128, 48),     // orange
+        red: (224, 80, 64),
+        green: (128, 160, 80),
+        yellow: (208, 160, 48),
+        blue: (96, 128, 176),
+        purple: (160, 112, 144),
+        cyan: (112, 160, 160),
+        orange: (224, 128, 48),
+        tempo_color: (160, 112, 144),
+        bank_color: (96, 128, 176),
+        pattern_color: (112, 160, 160),
+        title_accent: (224, 128, 48),
+        title_author: (224, 80, 64),
+        secondary: (160, 112, 144),
+        link_bright: [
+            (224, 128, 48), (224, 80, 64), (208, 160, 48),
+            (112, 160, 160), (128, 160, 80),
+        ],
+        link_dim: [
+            (45, 28, 14), (45, 18, 14), (42, 32, 12),
+            (22, 32, 32), (26, 32, 18),
+        ],
+        sparkle: [
+            (224, 128, 48), (224, 80, 64), (208, 160, 48),
+            (112, 160, 160), (128, 160, 80),
+        ],
+        meter: [(128, 160, 80), (208, 160, 48), (224, 80, 64)],
+    }
+}

crates/ratatui/src/theme/fairyfloss.rs

@@ -0,0 +1,39 @@
+use super::palette::Palette;
+
+pub fn palette() -> Palette {
+    Palette {
+        bg: (90, 84, 117),
+        surface: (113, 103, 153),
+        surface2: (130, 120, 165),
+        fg: (248, 248, 240),
+        fg_dim: (197, 163, 255),
+        fg_muted: (168, 164, 177),
+        accent: (255, 184, 209),    // pink
+        red: (255, 133, 127),       // coral
+        green: (194, 255, 223),     // mint
+        yellow: (255, 243, 82),
+        blue: (197, 163, 255),      // lavender
+        purple: (174, 129, 255),
+        cyan: (194, 255, 223),      // mint
+        orange: (255, 133, 127),    // coral
+        tempo_color: (255, 184, 209),
+        bank_color: (194, 255, 223),
+        pattern_color: (174, 129, 255),
+        title_accent: (255, 184, 209),
+        title_author: (194, 255, 223),
+        secondary: (255, 133, 127),
+        link_bright: [
+            (255, 184, 209), (174, 129, 255), (255, 133, 127),
+            (194, 255, 223), (255, 243, 82),
+        ],
+        link_dim: [
+            (100, 75, 90), (85, 70, 105), (100, 65, 65),
+            (75, 100, 95), (100, 95, 55),
+        ],
+        sparkle: [
+            (194, 255, 223), (255, 133, 127), (255, 243, 82),
+            (255, 184, 209), (174, 129, 255),
+        ],
+        meter: [(194, 255, 223), (255, 243, 82), (255, 133, 127)],
+    }
+}

crates/ratatui/src/theme/georges.rs

@@ -0,0 +1,40 @@
+use super::palette::Palette;
+
+// C64 palette on pure black
+pub fn palette() -> Palette {
+    Palette {
+        bg: (0, 0, 0),
+        surface: (16, 16, 16),
+        surface2: (24, 24, 24),
+        fg: (187, 187, 187),
+        fg_dim: (119, 119, 119),
+        fg_muted: (51, 51, 51),
+        accent: (0, 136, 255),      // lightblue
+        red: (255, 119, 119),       // lightred
+        green: (0, 204, 85),
+        yellow: (238, 238, 119),
+        blue: (0, 136, 255),        // lightblue
+        purple: (204, 68, 204),     // violet
+        cyan: (170, 255, 238),
+        orange: (221, 136, 85),
+        tempo_color: (204, 68, 204),
+        bank_color: (0, 136, 255),
+        pattern_color: (0, 204, 85),
+        title_accent: (0, 136, 255),
+        title_author: (0, 204, 85),
+        secondary: (221, 136, 85),
+        link_bright: [
+            (0, 136, 255), (0, 204, 85), (238, 238, 119),
+            (204, 68, 204), (170, 255, 238),
+        ],
+        link_dim: [
+            (0, 20, 40), (0, 30, 12), (34, 34, 16),
+            (30, 10, 30), (24, 36, 34),
+        ],
+        sparkle: [
+            (0, 136, 255), (170, 255, 238), (0, 204, 85),
+            (238, 238, 119), (204, 68, 204),
+        ],
+        meter: [(0, 204, 85), (238, 238, 119), (255, 119, 119)],
+    }
+}

crates/ratatui/src/theme/gruvbox_dark.rs

@@ -1,278 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let bg0 = Color::Rgb(40, 40, 40);
-    let bg1 = Color::Rgb(60, 56, 54);
-    let bg2 = Color::Rgb(80, 73, 69);
-    let fg = Color::Rgb(235, 219, 178);
-    let fg2 = Color::Rgb(213, 196, 161);
-    let fg3 = Color::Rgb(189, 174, 147);
-    let fg4 = Color::Rgb(168, 153, 132);
-    let red = Color::Rgb(251, 73, 52);
-    let green = Color::Rgb(184, 187, 38);
-    let yellow = Color::Rgb(250, 189, 47);
-    let blue = Color::Rgb(131, 165, 152);
-    let purple = Color::Rgb(211, 134, 155);
-    let aqua = Color::Rgb(142, 192, 124);
-    let orange = Color::Rgb(254, 128, 25);
-
-    let darker_bg = Color::Rgb(29, 32, 33);
-
-    ThemeColors {
-        ui: UiColors {
-            bg: bg0,
-            bg_rgb: (40, 40, 40),
-            text_primary: fg,
-            text_muted: fg3,
-            text_dim: fg4,
-            border: bg2,
-            header: yellow,
-            unfocused: fg4,
-            accent: orange,
-            surface: bg1,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(50, 60, 45),
-            playing_fg: green,
-            stopped_bg: Color::Rgb(65, 45, 45),
-            stopped_fg: red,
-            fill_on: green,
-            fill_off: fg4,
-            fill_bg: bg1,
-        },
-        selection: SelectionColors {
-            cursor_bg: orange,
-            cursor_fg: bg0,
-            selected_bg: Color::Rgb(80, 70, 55),
-            selected_fg: yellow,
-            in_range_bg: Color::Rgb(65, 60, 50),
-            in_range_fg: fg2,
-            cursor: orange,
-            selected: Color::Rgb(80, 70, 55),
-            in_range: Color::Rgb(65, 60, 50),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(90, 65, 50),
-            playing_active_fg: orange,
-            playing_inactive_bg: Color::Rgb(80, 75, 45),
-            playing_inactive_fg: yellow,
-            active_bg: Color::Rgb(50, 65, 55),
-            active_fg: aqua,
-            inactive_bg: bg1,
-            inactive_fg: fg3,
-            active_selected_bg: Color::Rgb(85, 70, 60),
-            active_in_range_bg: Color::Rgb(70, 65, 55),
-            link_bright: [
-                (254, 128, 25),
-                (211, 134, 155),
-                (250, 189, 47),
-                (131, 165, 152),
-                (184, 187, 38),
-            ],
-            link_dim: [
-                (85, 55, 35),
-                (75, 55, 65),
-                (80, 70, 40),
-                (50, 60, 60),
-                (60, 65, 35),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(75, 55, 40),
-            tempo_fg: orange,
-            bank_bg: Color::Rgb(50, 60, 60),
-            bank_fg: blue,
-            pattern_bg: Color::Rgb(50, 65, 50),
-            pattern_fg: aqua,
-            stats_bg: bg1,
-            stats_fg: fg3,
-        },
-        modal: ModalColors {
-            border: yellow,
-            border_accent: orange,
-            border_warn: red,
-            border_dim: fg4,
-            confirm: orange,
-            rename: purple,
-            input: blue,
-            editor: yellow,
-            preview: fg4,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(70, 45, 45),
-            error_fg: red,
-            success_bg: Color::Rgb(50, 65, 45),
-            success_fg: green,
-            info_bg: bg1,
-            info_fg: fg,
-            event_rgb: (70, 55, 45),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(50, 65, 45),
-            playing_fg: green,
-            staged_play_bg: Color::Rgb(70, 55, 60),
-            staged_play_fg: purple,
-            staged_stop_bg: Color::Rgb(75, 50, 50),
-            staged_stop_fg: red,
-            edit_bg: Color::Rgb(50, 65, 55),
-            edit_fg: aqua,
-            hover_bg: bg2,
-            hover_fg: fg,
-        },
-        link_status: LinkStatusColors {
-            disabled: red,
-            connected: green,
-            listening: yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: darker_bg,
-            executed_bg: Color::Rgb(55, 50, 45),
-            selected_bg: Color::Rgb(85, 70, 45),
-            emit: (fg, Color::Rgb(80, 55, 50)),
-            number: (orange, Color::Rgb(70, 50, 40)),
-            string: (green, Color::Rgb(50, 60, 40)),
-            comment: (fg4, darker_bg),
-            keyword: (red, Color::Rgb(70, 45, 45)),
-            stack_op: (blue, Color::Rgb(50, 55, 60)),
-            operator: (yellow, Color::Rgb(70, 65, 40)),
-            sound: (aqua, Color::Rgb(45, 60, 50)),
-            param: (purple, Color::Rgb(65, 50, 55)),
-            context: (orange, Color::Rgb(70, 50, 40)),
-            note: (green, Color::Rgb(50, 60, 40)),
-            interval: (Color::Rgb(170, 200, 100), Color::Rgb(55, 65, 40)),
-            variable: (purple, Color::Rgb(65, 50, 55)),
-            vary: (yellow, Color::Rgb(70, 65, 40)),
-            generator: (aqua, Color::Rgb(45, 60, 50)),
-            default: (fg3, darker_bg),
-        },
-        table: TableColors {
-            row_even: darker_bg,
-            row_odd: bg0,
-        },
-        values: ValuesColors {
-            tempo: orange,
-            value: fg3,
-        },
-        hint: HintColors {
-            key: orange,
-            text: fg4,
-        },
-        view_badge: ViewBadgeColors { bg: fg, fg: bg0 },
-        nav: NavColors {
-            selected_bg: Color::Rgb(80, 65, 50),
-            selected_fg: fg,
-            unselected_bg: bg1,
-            unselected_fg: fg4,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: fg,
-            cursor_fg: bg0,
-            selection_bg: Color::Rgb(70, 65, 55),
-            completion_bg: bg1,
-            completion_fg: fg,
-            completion_selected: orange,
-            completion_example: aqua,
-        },
-        browser: BrowserColors {
-            directory: blue,
-            project_file: purple,
-            selected: orange,
-            file: fg,
-            focused_border: orange,
-            unfocused_border: fg4,
-            root: fg,
-            file_icon: fg4,
-            folder_icon: blue,
-            empty_text: fg4,
-        },
-        input: InputColors {
-            text: blue,
-            cursor: fg,
-            hint: fg4,
-        },
-        search: SearchColors {
-            active: orange,
-            inactive: fg4,
-            match_bg: yellow,
-            match_fg: bg0,
-        },
-        markdown: MarkdownColors {
-            h1: blue,
-            h2: orange,
-            h3: purple,
-            code: green,
-            code_border: Color::Rgb(80, 75, 70),
-            link: aqua,
-            link_url: Color::Rgb(120, 115, 105),
-            quote: fg4,
-            text: fg,
-            list: fg,
-        },
-        engine: EngineColors {
-            header: blue,
-            header_focused: yellow,
-            divider: Color::Rgb(75, 70, 65),
-            scroll_indicator: Color::Rgb(90, 85, 80),
-            label: Color::Rgb(145, 135, 125),
-            label_focused: Color::Rgb(175, 165, 155),
-            label_dim: Color::Rgb(115, 105, 95),
-            value: Color::Rgb(200, 190, 175),
-            focused: yellow,
-            normal: fg,
-            dim: Color::Rgb(90, 85, 80),
-            path: Color::Rgb(145, 135, 125),
-            border_magenta: purple,
-            border_green: green,
-            border_cyan: aqua,
-            separator: Color::Rgb(75, 70, 65),
-            hint_active: Color::Rgb(220, 180, 80),
-            hint_inactive: Color::Rgb(75, 70, 65),
-        },
-        dict: DictColors {
-            word_name: green,
-            word_bg: Color::Rgb(55, 60, 55),
-            alias: fg4,
-            stack_sig: purple,
-            description: fg,
-            example: Color::Rgb(145, 135, 125),
-            category_focused: yellow,
-            category_selected: blue,
-            category_normal: fg,
-            category_dimmed: Color::Rgb(90, 85, 80),
-            border_focused: yellow,
-            border_normal: Color::Rgb(75, 70, 65),
-            header_desc: Color::Rgb(165, 155, 145),
-        },
-        title: TitleColors {
-            big_title: orange,
-            author: yellow,
-            link: aqua,
-            license: purple,
-            prompt: Color::Rgb(165, 155, 145),
-            subtitle: fg,
-        },
-        meter: MeterColors {
-            low: green,
-            mid: yellow,
-            high: red,
-            low_rgb: (170, 175, 35),
-            mid_rgb: (235, 180, 45),
-            high_rgb: (240, 70, 50),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (250, 189, 47),
-                (254, 128, 25),
-                (184, 187, 38),
-                (211, 134, 155),
-                (131, 165, 152),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: orange,
-            button_selected_bg: orange,
-            button_selected_fg: bg0,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (40, 40, 40),
+        surface: (60, 56, 54),
+        surface2: (80, 73, 69),
+        fg: (235, 219, 178),
+        fg_dim: (189, 174, 147),
+        fg_muted: (168, 153, 132),
+        accent: (254, 128, 25),     // orange
+        red: (251, 73, 52),
+        green: (184, 187, 38),
+        yellow: (250, 189, 47),
+        blue: (131, 165, 152),
+        purple: (211, 134, 155),
+        cyan: (142, 192, 124),      // aqua
+        orange: (254, 128, 25),
+        tempo_color: (254, 128, 25),
+        bank_color: (131, 165, 152),
+        pattern_color: (142, 192, 124),
+        title_accent: (254, 128, 25),
+        title_author: (250, 189, 47),
+        secondary: (254, 128, 25),
+        link_bright: [
+            (254, 128, 25), (211, 134, 155), (250, 189, 47),
+            (131, 165, 152), (184, 187, 38),
+        ],
+        link_dim: [
+            (85, 55, 35), (75, 55, 65), (80, 70, 40),
+            (50, 60, 60), (60, 65, 35),
+        ],
+        sparkle: [
+            (250, 189, 47), (254, 128, 25), (184, 187, 38),
+            (211, 134, 155), (131, 165, 152),
+        ],
+        meter: [(170, 175, 35), (235, 180, 45), (240, 70, 50)],
     }
 }

crates/ratatui/src/theme/hot_dog_stand.rs

@@ -0,0 +1,39 @@
+use super::palette::Palette;
+
+pub fn palette() -> Palette {
+    Palette {
+        bg: (255, 0, 0),
+        surface: (215, 0, 0),
+        surface2: (175, 0, 0),
+        fg: (255, 255, 0),
+        fg_dim: (255, 255, 95),
+        fg_muted: (255, 215, 0),
+        accent: (255, 255, 0),
+        red: (255, 255, 255),
+        green: (255, 255, 0),
+        yellow: (255, 215, 0),
+        blue: (255, 255, 0),
+        purple: (255, 255, 255),
+        cyan: (255, 255, 0),
+        orange: (255, 215, 0),
+        tempo_color: (255, 255, 0),
+        bank_color: (255, 255, 0),
+        pattern_color: (255, 255, 0),
+        title_accent: (255, 255, 0),
+        title_author: (255, 255, 255),
+        secondary: (255, 215, 0),
+        link_bright: [
+            (255, 255, 0), (255, 255, 255), (255, 215, 0),
+            (255, 255, 95), (255, 255, 0),
+        ],
+        link_dim: [
+            (140, 140, 0), (140, 140, 140), (140, 120, 0),
+            (140, 140, 60), (140, 140, 0),
+        ],
+        sparkle: [
+            (255, 255, 0), (255, 255, 255), (255, 215, 0),
+            (255, 255, 95), (255, 255, 0),
+        ],
+        meter: [(255, 255, 0), (255, 215, 0), (255, 255, 255)],
+    }
+}

crates/ratatui/src/theme/kanagawa.rs

@@ -1,278 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let bg = Color::Rgb(31, 31, 40);
-    let bg_light = Color::Rgb(43, 43, 54);
-    let bg_lighter = Color::Rgb(54, 54, 70);
-    let fg = Color::Rgb(220, 215, 186);
-    let fg_dim = Color::Rgb(160, 158, 140);
-    let comment = Color::Rgb(114, 113, 105);
-    let crystal_blue = Color::Rgb(126, 156, 216);
-    let oni_violet = Color::Rgb(149, 127, 184);
-    let autumn_green = Color::Rgb(118, 148, 106);
-    let autumn_red = Color::Rgb(195, 64, 67);
-    let carp_yellow = Color::Rgb(230, 195, 132);
-    let spring_blue = Color::Rgb(127, 180, 202);
-    let wave_red = Color::Rgb(226, 109, 115);
-    let sakura_pink = Color::Rgb(212, 140, 149);
-
-    let darker_bg = Color::Rgb(26, 26, 34);
-
-    ThemeColors {
-        ui: UiColors {
-            bg,
-            bg_rgb: (31, 31, 40),
-            text_primary: fg,
-            text_muted: fg_dim,
-            text_dim: comment,
-            border: bg_lighter,
-            header: crystal_blue,
-            unfocused: comment,
-            accent: sakura_pink,
-            surface: bg_light,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(40, 55, 45),
-            playing_fg: autumn_green,
-            stopped_bg: Color::Rgb(60, 40, 45),
-            stopped_fg: autumn_red,
-            fill_on: autumn_green,
-            fill_off: comment,
-            fill_bg: bg_light,
-        },
-        selection: SelectionColors {
-            cursor_bg: sakura_pink,
-            cursor_fg: bg,
-            selected_bg: Color::Rgb(65, 55, 70),
-            selected_fg: sakura_pink,
-            in_range_bg: Color::Rgb(50, 50, 60),
-            in_range_fg: fg,
-            cursor: sakura_pink,
-            selected: Color::Rgb(65, 55, 70),
-            in_range: Color::Rgb(50, 50, 60),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(65, 60, 50),
-            playing_active_fg: carp_yellow,
-            playing_inactive_bg: Color::Rgb(55, 55, 50),
-            playing_inactive_fg: fg_dim,
-            active_bg: Color::Rgb(45, 55, 70),
-            active_fg: crystal_blue,
-            inactive_bg: bg_light,
-            inactive_fg: fg_dim,
-            active_selected_bg: Color::Rgb(65, 55, 70),
-            active_in_range_bg: Color::Rgb(50, 50, 60),
-            link_bright: [
-                (226, 109, 115),
-                (149, 127, 184),
-                (230, 195, 132),
-                (127, 180, 202),
-                (118, 148, 106),
-            ],
-            link_dim: [
-                (75, 45, 50),
-                (55, 50, 70),
-                (70, 60, 50),
-                (45, 60, 70),
-                (45, 55, 45),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(55, 50, 65),
-            tempo_fg: oni_violet,
-            bank_bg: Color::Rgb(45, 55, 70),
-            bank_fg: crystal_blue,
-            pattern_bg: Color::Rgb(45, 55, 45),
-            pattern_fg: autumn_green,
-            stats_bg: bg_light,
-            stats_fg: fg_dim,
-        },
-        modal: ModalColors {
-            border: crystal_blue,
-            border_accent: sakura_pink,
-            border_warn: carp_yellow,
-            border_dim: comment,
-            confirm: carp_yellow,
-            rename: oni_violet,
-            input: crystal_blue,
-            editor: crystal_blue,
-            preview: comment,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(60, 40, 45),
-            error_fg: wave_red,
-            success_bg: Color::Rgb(40, 55, 45),
-            success_fg: autumn_green,
-            info_bg: bg_light,
-            info_fg: fg,
-            event_rgb: (50, 50, 60),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(40, 55, 45),
-            playing_fg: autumn_green,
-            staged_play_bg: Color::Rgb(55, 50, 70),
-            staged_play_fg: oni_violet,
-            staged_stop_bg: Color::Rgb(65, 45, 50),
-            staged_stop_fg: wave_red,
-            edit_bg: Color::Rgb(45, 55, 70),
-            edit_fg: crystal_blue,
-            hover_bg: bg_lighter,
-            hover_fg: fg,
-        },
-        link_status: LinkStatusColors {
-            disabled: autumn_red,
-            connected: autumn_green,
-            listening: carp_yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: darker_bg,
-            executed_bg: Color::Rgb(45, 45, 55),
-            selected_bg: Color::Rgb(65, 60, 50),
-            emit: (fg, Color::Rgb(60, 50, 60)),
-            number: (oni_violet, Color::Rgb(55, 50, 65)),
-            string: (autumn_green, Color::Rgb(45, 55, 45)),
-            comment: (comment, darker_bg),
-            keyword: (sakura_pink, Color::Rgb(60, 50, 55)),
-            stack_op: (spring_blue, Color::Rgb(45, 55, 65)),
-            operator: (wave_red, Color::Rgb(60, 45, 50)),
-            sound: (crystal_blue, Color::Rgb(45, 55, 70)),
-            param: (carp_yellow, Color::Rgb(65, 60, 50)),
-            context: (carp_yellow, Color::Rgb(65, 60, 50)),
-            note: (autumn_green, Color::Rgb(45, 55, 45)),
-            interval: (Color::Rgb(150, 180, 130), Color::Rgb(45, 55, 45)),
-            variable: (autumn_green, Color::Rgb(45, 55, 45)),
-            vary: (carp_yellow, Color::Rgb(65, 60, 50)),
-            generator: (spring_blue, Color::Rgb(45, 55, 65)),
-            default: (fg_dim, darker_bg),
-        },
-        table: TableColors {
-            row_even: darker_bg,
-            row_odd: bg,
-        },
-        values: ValuesColors {
-            tempo: carp_yellow,
-            value: fg_dim,
-        },
-        hint: HintColors {
-            key: carp_yellow,
-            text: comment,
-        },
-        view_badge: ViewBadgeColors { bg: fg, fg: bg },
-        nav: NavColors {
-            selected_bg: Color::Rgb(60, 50, 70),
-            selected_fg: fg,
-            unselected_bg: bg_light,
-            unselected_fg: comment,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: fg,
-            cursor_fg: bg,
-            selection_bg: Color::Rgb(55, 55, 70),
-            completion_bg: bg_light,
-            completion_fg: fg,
-            completion_selected: carp_yellow,
-            completion_example: spring_blue,
-        },
-        browser: BrowserColors {
-            directory: crystal_blue,
-            project_file: oni_violet,
-            selected: carp_yellow,
-            file: fg,
-            focused_border: carp_yellow,
-            unfocused_border: comment,
-            root: fg,
-            file_icon: comment,
-            folder_icon: crystal_blue,
-            empty_text: comment,
-        },
-        input: InputColors {
-            text: crystal_blue,
-            cursor: fg,
-            hint: comment,
-        },
-        search: SearchColors {
-            active: carp_yellow,
-            inactive: comment,
-            match_bg: carp_yellow,
-            match_fg: bg,
-        },
-        markdown: MarkdownColors {
-            h1: crystal_blue,
-            h2: carp_yellow,
-            h3: oni_violet,
-            code: autumn_green,
-            code_border: Color::Rgb(65, 65, 80),
-            link: sakura_pink,
-            link_url: Color::Rgb(100, 100, 115),
-            quote: comment,
-            text: fg,
-            list: fg,
-        },
-        engine: EngineColors {
-            header: crystal_blue,
-            header_focused: carp_yellow,
-            divider: Color::Rgb(60, 60, 75),
-            scroll_indicator: Color::Rgb(75, 75, 92),
-            label: Color::Rgb(140, 138, 125),
-            label_focused: Color::Rgb(170, 168, 155),
-            label_dim: Color::Rgb(110, 108, 100),
-            value: Color::Rgb(200, 195, 175),
-            focused: carp_yellow,
-            normal: fg,
-            dim: Color::Rgb(75, 75, 92),
-            path: Color::Rgb(140, 138, 125),
-            border_magenta: oni_violet,
-            border_green: autumn_green,
-            border_cyan: spring_blue,
-            separator: Color::Rgb(60, 60, 75),
-            hint_active: Color::Rgb(220, 185, 120),
-            hint_inactive: Color::Rgb(60, 60, 75),
-        },
-        dict: DictColors {
-            word_name: autumn_green,
-            word_bg: Color::Rgb(45, 50, 50),
-            alias: comment,
-            stack_sig: oni_violet,
-            description: fg,
-            example: Color::Rgb(140, 138, 125),
-            category_focused: carp_yellow,
-            category_selected: crystal_blue,
-            category_normal: fg,
-            category_dimmed: Color::Rgb(75, 75, 92),
-            border_focused: carp_yellow,
-            border_normal: Color::Rgb(60, 60, 75),
-            header_desc: Color::Rgb(160, 158, 145),
-        },
-        title: TitleColors {
-            big_title: sakura_pink,
-            author: crystal_blue,
-            link: autumn_green,
-            license: carp_yellow,
-            prompt: Color::Rgb(160, 158, 145),
-            subtitle: fg,
-        },
-        meter: MeterColors {
-            low: autumn_green,
-            mid: carp_yellow,
-            high: wave_red,
-            low_rgb: (118, 148, 106),
-            mid_rgb: (230, 195, 132),
-            high_rgb: (226, 109, 115),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (127, 180, 202),
-                (230, 195, 132),
-                (118, 148, 106),
-                (226, 109, 115),
-                (149, 127, 184),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: carp_yellow,
-            button_selected_bg: carp_yellow,
-            button_selected_fg: bg,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (31, 31, 40),
+        surface: (43, 43, 54),
+        surface2: (54, 54, 70),
+        fg: (220, 215, 186),
+        fg_dim: (160, 158, 140),
+        fg_muted: (114, 113, 105),
+        accent: (210, 126, 153),    // sakura_pink
+        red: (195, 64, 67),
+        green: (118, 148, 106),
+        yellow: (230, 195, 132),    // carp_yellow
+        blue: (126, 156, 216),      // crystal_blue
+        purple: (149, 127, 184),    // oni_violet
+        cyan: (127, 180, 202),      // spring_blue
+        orange: (230, 195, 132),    // carp_yellow
+        tempo_color: (149, 127, 184),
+        bank_color: (126, 156, 216),
+        pattern_color: (118, 148, 106),
+        title_accent: (210, 126, 153),
+        title_author: (126, 156, 216),
+        secondary: (210, 126, 153),
+        link_bright: [
+            (228, 104, 118), (149, 127, 184), (230, 195, 132),
+            (127, 180, 202), (118, 148, 106),
+        ],
+        link_dim: [
+            (75, 45, 50), (55, 50, 70), (70, 60, 50),
+            (45, 60, 70), (45, 55, 45),
+        ],
+        sparkle: [
+            (127, 180, 202), (230, 195, 132), (118, 148, 106),
+            (228, 104, 118), (149, 127, 184),
+        ],
+        meter: [(118, 148, 106), (230, 195, 132), (228, 104, 118)],
     }
 }

crates/ratatui/src/theme/letz_light.rs

@@ -0,0 +1,39 @@
+use super::palette::Palette;
+
+pub fn palette() -> Palette {
+    Palette {
+        bg: (255, 255, 255),
+        surface: (235, 235, 240),
+        surface2: (210, 210, 215),
+        fg: (29, 29, 31),
+        fg_dim: (110, 110, 115),
+        fg_muted: (160, 160, 165),
+        accent: (0, 112, 243),
+        red: (209, 47, 27),
+        green: (112, 127, 52),
+        yellow: (200, 150, 20),
+        blue: (0, 112, 243),
+        purple: (173, 61, 164),     // keyword
+        cyan: (62, 128, 135),       // function
+        orange: (120, 73, 42),      // preproc
+        tempo_color: (112, 61, 170),
+        bank_color: (0, 112, 243),
+        pattern_color: (62, 128, 135),
+        title_accent: (0, 112, 243),
+        title_author: (112, 61, 170),
+        secondary: (120, 73, 42),
+        link_bright: [
+            (173, 61, 164), (0, 112, 243), (120, 73, 42),
+            (62, 128, 135), (112, 127, 52),
+        ],
+        link_dim: [
+            (235, 215, 235), (210, 225, 250), (240, 225, 210),
+            (215, 235, 240), (225, 235, 215),
+        ],
+        sparkle: [
+            (0, 112, 243), (173, 61, 164), (112, 127, 52),
+            (62, 128, 135), (120, 73, 42),
+        ],
+        meter: [(112, 127, 52), (200, 150, 20), (209, 47, 27)],
+    }
+}

crates/ratatui/src/theme/mod.rs

@@ -1,11 +1,19 @@
 //! Centralized color definitions for Cagire TUI.
 //! Supports multiple color schemes with runtime switching.
 
+pub mod palette;
+pub mod build;
 mod catppuccin_latte;
 mod catppuccin_mocha;
 mod dracula;
+mod eden;
+mod ember;
+mod georges;
+mod fairyfloss;
 mod gruvbox_dark;
+mod hot_dog_stand;
 mod kanagawa;
+mod letz_light;
 mod monochrome_black;
 mod monochrome_white;
 mod monokai;
@@ -13,6 +21,7 @@ mod nord;
 mod pitch_black;
 mod rose_pine;
 mod tokyo_night;
+pub mod transform;
 
 use ratatui::style::Color;
 use std::cell::RefCell;
@@ -20,26 +29,32 @@ use std::cell::RefCell;
 pub struct ThemeEntry {
     pub id: &'static str,
     pub label: &'static str,
-    pub colors: fn() -> ThemeColors,
+    pub palette: fn() -> palette::Palette,
 }
 
 pub const THEMES: &[ThemeEntry] = &[
-    ThemeEntry { id: "CatppuccinMocha", label: "Catppuccin Mocha", colors: catppuccin_mocha::theme },
-    ThemeEntry { id: "CatppuccinLatte", label: "Catppuccin Latte", colors: catppuccin_latte::theme },
-    ThemeEntry { id: "Nord", label: "Nord", colors: nord::theme },
-    ThemeEntry { id: "Dracula", label: "Dracula", colors: dracula::theme },
-    ThemeEntry { id: "GruvboxDark", label: "Gruvbox Dark", colors: gruvbox_dark::theme },
-    ThemeEntry { id: "Monokai", label: "Monokai", colors: monokai::theme },
-    ThemeEntry { id: "MonochromeBlack", label: "Monochrome (Black)", colors: monochrome_black::theme },
-    ThemeEntry { id: "MonochromeWhite", label: "Monochrome (White)", colors: monochrome_white::theme },
-    ThemeEntry { id: "PitchBlack", label: "Pitch Black", colors: pitch_black::theme },
-    ThemeEntry { id: "TokyoNight", label: "Tokyo Night", colors: tokyo_night::theme },
-    ThemeEntry { id: "RosePine", label: "Rosé Pine", colors: rose_pine::theme },
-    ThemeEntry { id: "Kanagawa", label: "Kanagawa", colors: kanagawa::theme },
+    ThemeEntry { id: "CatppuccinMocha", label: "Catppuccin Mocha", palette: catppuccin_mocha::palette },
+    ThemeEntry { id: "CatppuccinLatte", label: "Catppuccin Latte", palette: catppuccin_latte::palette },
+    ThemeEntry { id: "Nord", label: "Nord", palette: nord::palette },
+    ThemeEntry { id: "Dracula", label: "Dracula", palette: dracula::palette },
+    ThemeEntry { id: "GruvboxDark", label: "Gruvbox Dark", palette: gruvbox_dark::palette },
+    ThemeEntry { id: "Monokai", label: "Monokai", palette: monokai::palette },
+    ThemeEntry { id: "MonochromeBlack", label: "Monochrome (Black)", palette: monochrome_black::palette },
+    ThemeEntry { id: "MonochromeWhite", label: "Monochrome (White)", palette: monochrome_white::palette },
+    ThemeEntry { id: "PitchBlack", label: "Pitch Black", palette: pitch_black::palette },
+    ThemeEntry { id: "TokyoNight", label: "Tokyo Night", palette: tokyo_night::palette },
+    ThemeEntry { id: "RosePine", label: "Rosé Pine", palette: rose_pine::palette },
+    ThemeEntry { id: "Kanagawa", label: "Kanagawa", palette: kanagawa::palette },
+    ThemeEntry { id: "Fairyfloss", label: "Fairyfloss", palette: fairyfloss::palette },
+    ThemeEntry { id: "HotDogStand", label: "Hot Dog Stand", palette: hot_dog_stand::palette },
+    ThemeEntry { id: "LetzLight", label: "Letz Light", palette: letz_light::palette },
+    ThemeEntry { id: "Ember", label: "Ember", palette: ember::palette },
+    ThemeEntry { id: "Eden", label: "Eden", palette: eden::palette },
+    ThemeEntry { id: "Georges", label: "Georges", palette: georges::palette },
 ];
 
 thread_local! {
-    static CURRENT_THEME: RefCell<ThemeColors> = RefCell::new((THEMES[0].colors)());
+    static CURRENT_THEME: RefCell<ThemeColors> = RefCell::new(build::build(&(THEMES[0].palette)()));
 }
 
 pub fn get() -> ThemeColors {
@@ -126,6 +141,7 @@ pub struct TileColors {
     pub playing_inactive_fg: Color,
     pub active_bg: Color,
     pub active_fg: Color,
+    pub content_bg: Color,
     pub inactive_bg: Color,
     pub inactive_fg: Color,
     pub active_selected_bg: Color,
@@ -167,7 +183,6 @@ pub struct FlashColors {
     pub success_fg: Color,
     pub info_bg: Color,
     pub info_fg: Color,
-    pub event_rgb: (u8, u8, u8),
 }
 
 #[derive(Clone)]
@@ -182,6 +197,10 @@ pub struct ListColors {
     pub edit_fg: Color,
     pub hover_bg: Color,
     pub hover_fg: Color,
+    pub muted_bg: Color,
+    pub muted_fg: Color,
+    pub soloed_bg: Color,
+    pub soloed_fg: Color,
 }
 
 #[derive(Clone)]
@@ -211,6 +230,7 @@ pub struct SyntaxColors {
     pub variable: (Color, Color),
     pub vary: (Color, Color),
     pub generator: (Color, Color),
+    pub user_defined: (Color, Color),
     pub default: (Color, Color),
 }
 

crates/ratatui/src/theme/monochrome_black.rs

@@ -1,275 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let bg = Color::Rgb(0, 0, 0);
-    let surface = Color::Rgb(18, 18, 18);
-    let surface2 = Color::Rgb(30, 30, 30);
-    let border = Color::Rgb(60, 60, 60);
-    let fg = Color::Rgb(255, 255, 255);
-    let fg_dim = Color::Rgb(180, 180, 180);
-    let fg_muted = Color::Rgb(120, 120, 120);
-
-    let bright = Color::Rgb(255, 255, 255);
-    let medium = Color::Rgb(180, 180, 180);
-    let dim = Color::Rgb(120, 120, 120);
-    let dark = Color::Rgb(80, 80, 80);
-    let darker = Color::Rgb(50, 50, 50);
-
-    ThemeColors {
-        ui: UiColors {
-            bg,
-            bg_rgb: (0, 0, 0),
-            text_primary: fg,
-            text_muted: fg_dim,
-            text_dim: fg_muted,
-            border,
-            header: bright,
-            unfocused: fg_muted,
-            accent: bright,
-            surface,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(40, 40, 40),
-            playing_fg: bright,
-            stopped_bg: Color::Rgb(25, 25, 25),
-            stopped_fg: medium,
-            fill_on: bright,
-            fill_off: dark,
-            fill_bg: surface,
-        },
-        selection: SelectionColors {
-            cursor_bg: bright,
-            cursor_fg: bg,
-            selected_bg: Color::Rgb(60, 60, 60),
-            selected_fg: bright,
-            in_range_bg: Color::Rgb(40, 40, 40),
-            in_range_fg: fg,
-            cursor: bright,
-            selected: Color::Rgb(60, 60, 60),
-            in_range: Color::Rgb(40, 40, 40),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(70, 70, 70),
-            playing_active_fg: bright,
-            playing_inactive_bg: Color::Rgb(50, 50, 50),
-            playing_inactive_fg: medium,
-            active_bg: Color::Rgb(45, 45, 45),
-            active_fg: bright,
-            inactive_bg: surface,
-            inactive_fg: fg_dim,
-            active_selected_bg: Color::Rgb(80, 80, 80),
-            active_in_range_bg: Color::Rgb(55, 55, 55),
-            link_bright: [
-                (255, 255, 255),
-                (200, 200, 200),
-                (160, 160, 160),
-                (220, 220, 220),
-                (180, 180, 180),
-            ],
-            link_dim: [
-                (60, 60, 60),
-                (50, 50, 50),
-                (45, 45, 45),
-                (55, 55, 55),
-                (48, 48, 48),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(50, 50, 50),
-            tempo_fg: bright,
-            bank_bg: Color::Rgb(40, 40, 40),
-            bank_fg: medium,
-            pattern_bg: Color::Rgb(35, 35, 35),
-            pattern_fg: medium,
-            stats_bg: surface,
-            stats_fg: fg_dim,
-        },
-        modal: ModalColors {
-            border: bright,
-            border_accent: medium,
-            border_warn: fg_dim,
-            border_dim: fg_muted,
-            confirm: medium,
-            rename: medium,
-            input: bright,
-            editor: bright,
-            preview: fg_muted,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(60, 60, 60),
-            error_fg: bright,
-            success_bg: Color::Rgb(50, 50, 50),
-            success_fg: bright,
-            info_bg: surface,
-            info_fg: fg,
-            event_rgb: (40, 40, 40),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(50, 50, 50),
-            playing_fg: bright,
-            staged_play_bg: Color::Rgb(45, 45, 45),
-            staged_play_fg: medium,
-            staged_stop_bg: Color::Rgb(35, 35, 35),
-            staged_stop_fg: dim,
-            edit_bg: Color::Rgb(40, 40, 40),
-            edit_fg: bright,
-            hover_bg: surface2,
-            hover_fg: fg,
-        },
-        link_status: LinkStatusColors {
-            disabled: dim,
-            connected: bright,
-            listening: medium,
-        },
-        syntax: SyntaxColors {
-            gap_bg: bg,
-            executed_bg: Color::Rgb(35, 35, 35),
-            selected_bg: Color::Rgb(55, 55, 55),
-            emit: (bright, Color::Rgb(45, 45, 45)),
-            number: (medium, Color::Rgb(35, 35, 35)),
-            string: (bright, Color::Rgb(40, 40, 40)),
-            comment: (dark, bg),
-            keyword: (bright, Color::Rgb(50, 50, 50)),
-            stack_op: (medium, Color::Rgb(30, 30, 30)),
-            operator: (medium, Color::Rgb(35, 35, 35)),
-            sound: (bright, Color::Rgb(45, 45, 45)),
-            param: (medium, Color::Rgb(35, 35, 35)),
-            context: (medium, Color::Rgb(30, 30, 30)),
-            note: (bright, Color::Rgb(40, 40, 40)),
-            interval: (medium, Color::Rgb(35, 35, 35)),
-            variable: (medium, Color::Rgb(30, 30, 30)),
-            vary: (dim, Color::Rgb(25, 25, 25)),
-            generator: (bright, Color::Rgb(45, 45, 45)),
-            default: (fg_dim, bg),
-        },
-        table: TableColors {
-            row_even: bg,
-            row_odd: surface,
-        },
-        values: ValuesColors {
-            tempo: bright,
-            value: fg_dim,
-        },
-        hint: HintColors {
-            key: bright,
-            text: fg_muted,
-        },
-        view_badge: ViewBadgeColors { bg: fg, fg: bg },
-        nav: NavColors {
-            selected_bg: Color::Rgb(60, 60, 60),
-            selected_fg: fg,
-            unselected_bg: surface,
-            unselected_fg: fg_muted,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: fg,
-            cursor_fg: bg,
-            selection_bg: Color::Rgb(60, 60, 60),
-            completion_bg: surface,
-            completion_fg: fg,
-            completion_selected: bright,
-            completion_example: medium,
-        },
-        browser: BrowserColors {
-            directory: medium,
-            project_file: bright,
-            selected: bright,
-            file: fg,
-            focused_border: bright,
-            unfocused_border: fg_muted,
-            root: fg,
-            file_icon: fg_muted,
-            folder_icon: medium,
-            empty_text: fg_muted,
-        },
-        input: InputColors {
-            text: bright,
-            cursor: fg,
-            hint: fg_muted,
-        },
-        search: SearchColors {
-            active: bright,
-            inactive: fg_muted,
-            match_bg: bright,
-            match_fg: bg,
-        },
-        markdown: MarkdownColors {
-            h1: bright,
-            h2: medium,
-            h3: dim,
-            code: medium,
-            code_border: Color::Rgb(60, 60, 60),
-            link: bright,
-            link_url: dim,
-            quote: fg_muted,
-            text: fg,
-            list: fg,
-        },
-        engine: EngineColors {
-            header: bright,
-            header_focused: bright,
-            divider: Color::Rgb(50, 50, 50),
-            scroll_indicator: Color::Rgb(70, 70, 70),
-            label: dim,
-            label_focused: medium,
-            label_dim: dark,
-            value: fg,
-            focused: bright,
-            normal: fg,
-            dim: dark,
-            path: dim,
-            border_magenta: medium,
-            border_green: medium,
-            border_cyan: medium,
-            separator: Color::Rgb(50, 50, 50),
-            hint_active: bright,
-            hint_inactive: darker,
-        },
-        dict: DictColors {
-            word_name: bright,
-            word_bg: Color::Rgb(30, 30, 30),
-            alias: fg_muted,
-            stack_sig: medium,
-            description: fg,
-            example: dim,
-            category_focused: bright,
-            category_selected: medium,
-            category_normal: fg,
-            category_dimmed: dark,
-            border_focused: bright,
-            border_normal: darker,
-            header_desc: dim,
-        },
-        title: TitleColors {
-            big_title: bright,
-            author: medium,
-            link: medium,
-            license: dim,
-            prompt: dim,
-            subtitle: fg,
-        },
-        meter: MeterColors {
-            low: dim,
-            mid: medium,
-            high: bright,
-            low_rgb: (120, 120, 120),
-            mid_rgb: (180, 180, 180),
-            high_rgb: (255, 255, 255),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (255, 255, 255),
-                (200, 200, 200),
-                (160, 160, 160),
-                (220, 220, 220),
-                (180, 180, 180),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: bright,
-            button_selected_bg: bright,
-            button_selected_fg: bg,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (0, 0, 0),
+        surface: (18, 18, 18),
+        surface2: (30, 30, 30),
+        fg: (255, 255, 255),
+        fg_dim: (180, 180, 180),
+        fg_muted: (120, 120, 120),
+        accent: (255, 255, 255),
+        red: (180, 180, 180),
+        green: (255, 255, 255),
+        yellow: (180, 180, 180),
+        blue: (180, 180, 180),
+        purple: (180, 180, 180),
+        cyan: (255, 255, 255),
+        orange: (255, 255, 255),
+        tempo_color: (255, 255, 255),
+        bank_color: (180, 180, 180),
+        pattern_color: (180, 180, 180),
+        title_accent: (255, 255, 255),
+        title_author: (180, 180, 180),
+        secondary: (120, 120, 120),
+        link_bright: [
+            (255, 255, 255), (200, 200, 200), (160, 160, 160),
+            (220, 220, 220), (180, 180, 180),
+        ],
+        link_dim: [
+            (60, 60, 60), (50, 50, 50), (45, 45, 45),
+            (55, 55, 55), (48, 48, 48),
+        ],
+        sparkle: [
+            (255, 255, 255), (200, 200, 200), (160, 160, 160),
+            (220, 220, 220), (180, 180, 180),
+        ],
+        meter: [(120, 120, 120), (180, 180, 180), (255, 255, 255)],
     }
 }

crates/ratatui/src/theme/monochrome_white.rs

@@ -1,275 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let bg = Color::Rgb(255, 255, 255);
-    let surface = Color::Rgb(240, 240, 240);
-    let surface2 = Color::Rgb(225, 225, 225);
-    let border = Color::Rgb(180, 180, 180);
-    let fg = Color::Rgb(0, 0, 0);
-    let fg_dim = Color::Rgb(80, 80, 80);
-    let fg_muted = Color::Rgb(140, 140, 140);
-
-    let dark = Color::Rgb(0, 0, 0);
-    let medium = Color::Rgb(80, 80, 80);
-    let dim = Color::Rgb(140, 140, 140);
-    let light = Color::Rgb(180, 180, 180);
-    let lighter = Color::Rgb(210, 210, 210);
-
-    ThemeColors {
-        ui: UiColors {
-            bg,
-            bg_rgb: (255, 255, 255),
-            text_primary: fg,
-            text_muted: fg_dim,
-            text_dim: fg_muted,
-            border,
-            header: dark,
-            unfocused: fg_muted,
-            accent: dark,
-            surface,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(210, 210, 210),
-            playing_fg: dark,
-            stopped_bg: Color::Rgb(230, 230, 230),
-            stopped_fg: medium,
-            fill_on: dark,
-            fill_off: light,
-            fill_bg: surface,
-        },
-        selection: SelectionColors {
-            cursor_bg: dark,
-            cursor_fg: bg,
-            selected_bg: Color::Rgb(200, 200, 200),
-            selected_fg: dark,
-            in_range_bg: Color::Rgb(220, 220, 220),
-            in_range_fg: fg,
-            cursor: dark,
-            selected: Color::Rgb(200, 200, 200),
-            in_range: Color::Rgb(220, 220, 220),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(180, 180, 180),
-            playing_active_fg: dark,
-            playing_inactive_bg: Color::Rgb(200, 200, 200),
-            playing_inactive_fg: medium,
-            active_bg: Color::Rgb(210, 210, 210),
-            active_fg: dark,
-            inactive_bg: surface,
-            inactive_fg: fg_dim,
-            active_selected_bg: Color::Rgb(170, 170, 170),
-            active_in_range_bg: Color::Rgb(195, 195, 195),
-            link_bright: [
-                (0, 0, 0),
-                (60, 60, 60),
-                (100, 100, 100),
-                (40, 40, 40),
-                (80, 80, 80),
-            ],
-            link_dim: [
-                (200, 200, 200),
-                (210, 210, 210),
-                (215, 215, 215),
-                (205, 205, 205),
-                (212, 212, 212),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(200, 200, 200),
-            tempo_fg: dark,
-            bank_bg: Color::Rgb(215, 215, 215),
-            bank_fg: medium,
-            pattern_bg: Color::Rgb(220, 220, 220),
-            pattern_fg: medium,
-            stats_bg: surface,
-            stats_fg: fg_dim,
-        },
-        modal: ModalColors {
-            border: dark,
-            border_accent: medium,
-            border_warn: fg_dim,
-            border_dim: fg_muted,
-            confirm: medium,
-            rename: medium,
-            input: dark,
-            editor: dark,
-            preview: fg_muted,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(200, 200, 200),
-            error_fg: dark,
-            success_bg: Color::Rgb(210, 210, 210),
-            success_fg: dark,
-            info_bg: surface,
-            info_fg: fg,
-            event_rgb: (220, 220, 220),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(200, 200, 200),
-            playing_fg: dark,
-            staged_play_bg: Color::Rgb(210, 210, 210),
-            staged_play_fg: medium,
-            staged_stop_bg: Color::Rgb(220, 220, 220),
-            staged_stop_fg: dim,
-            edit_bg: Color::Rgb(215, 215, 215),
-            edit_fg: dark,
-            hover_bg: surface2,
-            hover_fg: fg,
-        },
-        link_status: LinkStatusColors {
-            disabled: dim,
-            connected: dark,
-            listening: medium,
-        },
-        syntax: SyntaxColors {
-            gap_bg: bg,
-            executed_bg: Color::Rgb(220, 220, 220),
-            selected_bg: Color::Rgb(200, 200, 200),
-            emit: (dark, Color::Rgb(215, 215, 215)),
-            number: (medium, Color::Rgb(225, 225, 225)),
-            string: (dark, Color::Rgb(220, 220, 220)),
-            comment: (light, bg),
-            keyword: (dark, Color::Rgb(205, 205, 205)),
-            stack_op: (medium, Color::Rgb(230, 230, 230)),
-            operator: (medium, Color::Rgb(225, 225, 225)),
-            sound: (dark, Color::Rgb(215, 215, 215)),
-            param: (medium, Color::Rgb(225, 225, 225)),
-            context: (medium, Color::Rgb(230, 230, 230)),
-            note: (dark, Color::Rgb(220, 220, 220)),
-            interval: (medium, Color::Rgb(225, 225, 225)),
-            variable: (medium, Color::Rgb(230, 230, 230)),
-            vary: (dim, Color::Rgb(235, 235, 235)),
-            generator: (dark, Color::Rgb(215, 215, 215)),
-            default: (fg_dim, bg),
-        },
-        table: TableColors {
-            row_even: bg,
-            row_odd: surface,
-        },
-        values: ValuesColors {
-            tempo: dark,
-            value: fg_dim,
-        },
-        hint: HintColors {
-            key: dark,
-            text: fg_muted,
-        },
-        view_badge: ViewBadgeColors { bg: fg, fg: bg },
-        nav: NavColors {
-            selected_bg: Color::Rgb(200, 200, 200),
-            selected_fg: fg,
-            unselected_bg: surface,
-            unselected_fg: fg_muted,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: fg,
-            cursor_fg: bg,
-            selection_bg: Color::Rgb(200, 200, 200),
-            completion_bg: surface,
-            completion_fg: fg,
-            completion_selected: dark,
-            completion_example: medium,
-        },
-        browser: BrowserColors {
-            directory: medium,
-            project_file: dark,
-            selected: dark,
-            file: fg,
-            focused_border: dark,
-            unfocused_border: fg_muted,
-            root: fg,
-            file_icon: fg_muted,
-            folder_icon: medium,
-            empty_text: fg_muted,
-        },
-        input: InputColors {
-            text: dark,
-            cursor: fg,
-            hint: fg_muted,
-        },
-        search: SearchColors {
-            active: dark,
-            inactive: fg_muted,
-            match_bg: dark,
-            match_fg: bg,
-        },
-        markdown: MarkdownColors {
-            h1: dark,
-            h2: medium,
-            h3: dim,
-            code: medium,
-            code_border: Color::Rgb(200, 200, 200),
-            link: dark,
-            link_url: dim,
-            quote: fg_muted,
-            text: fg,
-            list: fg,
-        },
-        engine: EngineColors {
-            header: dark,
-            header_focused: dark,
-            divider: Color::Rgb(210, 210, 210),
-            scroll_indicator: Color::Rgb(180, 180, 180),
-            label: dim,
-            label_focused: medium,
-            label_dim: light,
-            value: fg,
-            focused: dark,
-            normal: fg,
-            dim: light,
-            path: dim,
-            border_magenta: medium,
-            border_green: medium,
-            border_cyan: medium,
-            separator: Color::Rgb(210, 210, 210),
-            hint_active: dark,
-            hint_inactive: lighter,
-        },
-        dict: DictColors {
-            word_name: dark,
-            word_bg: Color::Rgb(230, 230, 230),
-            alias: fg_muted,
-            stack_sig: medium,
-            description: fg,
-            example: dim,
-            category_focused: dark,
-            category_selected: medium,
-            category_normal: fg,
-            category_dimmed: light,
-            border_focused: dark,
-            border_normal: lighter,
-            header_desc: dim,
-        },
-        title: TitleColors {
-            big_title: dark,
-            author: medium,
-            link: medium,
-            license: dim,
-            prompt: dim,
-            subtitle: fg,
-        },
-        meter: MeterColors {
-            low: dim,
-            mid: medium,
-            high: dark,
-            low_rgb: (140, 140, 140),
-            mid_rgb: (80, 80, 80),
-            high_rgb: (0, 0, 0),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (0, 0, 0),
-                (60, 60, 60),
-                (100, 100, 100),
-                (40, 40, 40),
-                (80, 80, 80),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: dark,
-            button_selected_bg: dark,
-            button_selected_fg: bg,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (255, 255, 255),
+        surface: (240, 240, 240),
+        surface2: (225, 225, 225),
+        fg: (0, 0, 0),
+        fg_dim: (80, 80, 80),
+        fg_muted: (140, 140, 140),
+        accent: (0, 0, 0),
+        red: (140, 140, 140),
+        green: (0, 0, 0),
+        yellow: (80, 80, 80),
+        blue: (80, 80, 80),
+        purple: (80, 80, 80),
+        cyan: (0, 0, 0),
+        orange: (0, 0, 0),
+        tempo_color: (0, 0, 0),
+        bank_color: (80, 80, 80),
+        pattern_color: (80, 80, 80),
+        title_accent: (0, 0, 0),
+        title_author: (80, 80, 80),
+        secondary: (140, 140, 140),
+        link_bright: [
+            (0, 0, 0), (60, 60, 60), (100, 100, 100),
+            (40, 40, 40), (80, 80, 80),
+        ],
+        link_dim: [
+            (200, 200, 200), (210, 210, 210), (215, 215, 215),
+            (205, 205, 205), (212, 212, 212),
+        ],
+        sparkle: [
+            (0, 0, 0), (60, 60, 60), (100, 100, 100),
+            (40, 40, 40), (80, 80, 80),
+        ],
+        meter: [(140, 140, 140), (80, 80, 80), (0, 0, 0)],
     }
 }

crates/ratatui/src/theme/monokai.rs

@@ -1,276 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let bg = Color::Rgb(39, 40, 34);
-    let bg_light = Color::Rgb(53, 54, 47);
-    let bg_lighter = Color::Rgb(70, 71, 62);
-    let fg = Color::Rgb(248, 248, 242);
-    let fg_dim = Color::Rgb(190, 190, 180);
-    let comment = Color::Rgb(117, 113, 94);
-    let pink = Color::Rgb(249, 38, 114);
-    let green = Color::Rgb(166, 226, 46);
-    let yellow = Color::Rgb(230, 219, 116);
-    let blue = Color::Rgb(102, 217, 239);
-    let purple = Color::Rgb(174, 129, 255);
-    let orange = Color::Rgb(253, 151, 31);
-
-    let darker_bg = Color::Rgb(30, 31, 26);
-
-    ThemeColors {
-        ui: UiColors {
-            bg,
-            bg_rgb: (39, 40, 34),
-            text_primary: fg,
-            text_muted: fg_dim,
-            text_dim: comment,
-            border: bg_lighter,
-            header: blue,
-            unfocused: comment,
-            accent: pink,
-            surface: bg_light,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(50, 65, 40),
-            playing_fg: green,
-            stopped_bg: Color::Rgb(70, 40, 55),
-            stopped_fg: pink,
-            fill_on: green,
-            fill_off: comment,
-            fill_bg: bg_light,
-        },
-        selection: SelectionColors {
-            cursor_bg: pink,
-            cursor_fg: bg,
-            selected_bg: Color::Rgb(85, 70, 80),
-            selected_fg: pink,
-            in_range_bg: Color::Rgb(70, 65, 70),
-            in_range_fg: fg,
-            cursor: pink,
-            selected: Color::Rgb(85, 70, 80),
-            in_range: Color::Rgb(70, 65, 70),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(90, 65, 45),
-            playing_active_fg: orange,
-            playing_inactive_bg: Color::Rgb(80, 75, 50),
-            playing_inactive_fg: yellow,
-            active_bg: Color::Rgb(55, 75, 70),
-            active_fg: blue,
-            inactive_bg: bg_light,
-            inactive_fg: fg_dim,
-            active_selected_bg: Color::Rgb(85, 65, 80),
-            active_in_range_bg: Color::Rgb(70, 65, 70),
-            link_bright: [
-                (249, 38, 114),
-                (174, 129, 255),
-                (253, 151, 31),
-                (102, 217, 239),
-                (166, 226, 46),
-            ],
-            link_dim: [
-                (90, 40, 60),
-                (70, 55, 90),
-                (85, 60, 35),
-                (50, 75, 85),
-                (60, 80, 40),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(75, 50, 65),
-            tempo_fg: pink,
-            bank_bg: Color::Rgb(50, 70, 75),
-            bank_fg: blue,
-            pattern_bg: Color::Rgb(55, 75, 50),
-            pattern_fg: green,
-            stats_bg: bg_light,
-            stats_fg: fg_dim,
-        },
-        modal: ModalColors {
-            border: blue,
-            border_accent: pink,
-            border_warn: orange,
-            border_dim: comment,
-            confirm: orange,
-            rename: purple,
-            input: blue,
-            editor: blue,
-            preview: comment,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(75, 40, 55),
-            error_fg: pink,
-            success_bg: Color::Rgb(50, 70, 45),
-            success_fg: green,
-            info_bg: bg_light,
-            info_fg: fg,
-            event_rgb: (70, 55, 70),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(50, 70, 45),
-            playing_fg: green,
-            staged_play_bg: Color::Rgb(70, 55, 80),
-            staged_play_fg: purple,
-            staged_stop_bg: Color::Rgb(80, 45, 60),
-            staged_stop_fg: pink,
-            edit_bg: Color::Rgb(50, 70, 70),
-            edit_fg: blue,
-            hover_bg: bg_lighter,
-            hover_fg: fg,
-        },
-        link_status: LinkStatusColors {
-            disabled: pink,
-            connected: green,
-            listening: yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: darker_bg,
-            executed_bg: Color::Rgb(55, 50, 55),
-            selected_bg: Color::Rgb(85, 75, 50),
-            emit: (fg, Color::Rgb(85, 55, 65)),
-            number: (purple, Color::Rgb(60, 50, 75)),
-            string: (yellow, Color::Rgb(70, 65, 45)),
-            comment: (comment, darker_bg),
-            keyword: (pink, Color::Rgb(80, 45, 60)),
-            stack_op: (blue, Color::Rgb(50, 70, 75)),
-            operator: (pink, Color::Rgb(80, 45, 60)),
-            sound: (blue, Color::Rgb(50, 70, 75)),
-            param: (orange, Color::Rgb(80, 60, 40)),
-            context: (orange, Color::Rgb(80, 60, 40)),
-            note: (green, Color::Rgb(55, 75, 45)),
-            interval: (Color::Rgb(180, 235, 80), Color::Rgb(55, 75, 40)),
-            variable: (green, Color::Rgb(55, 75, 45)),
-            vary: (yellow, Color::Rgb(70, 65, 45)),
-            generator: (blue, Color::Rgb(50, 70, 70)),
-            default: (fg_dim, darker_bg),
-        },
-        table: TableColors {
-            row_even: darker_bg,
-            row_odd: bg,
-        },
-        values: ValuesColors {
-            tempo: orange,
-            value: fg_dim,
-        },
-        hint: HintColors {
-            key: orange,
-            text: comment,
-        },
-        view_badge: ViewBadgeColors { bg: fg, fg: bg },
-        nav: NavColors {
-            selected_bg: Color::Rgb(80, 60, 75),
-            selected_fg: fg,
-            unselected_bg: bg_light,
-            unselected_fg: comment,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: fg,
-            cursor_fg: bg,
-            selection_bg: Color::Rgb(75, 70, 75),
-            completion_bg: bg_light,
-            completion_fg: fg,
-            completion_selected: orange,
-            completion_example: blue,
-        },
-        browser: BrowserColors {
-            directory: blue,
-            project_file: purple,
-            selected: orange,
-            file: fg,
-            focused_border: orange,
-            unfocused_border: comment,
-            root: fg,
-            file_icon: comment,
-            folder_icon: blue,
-            empty_text: comment,
-        },
-        input: InputColors {
-            text: blue,
-            cursor: fg,
-            hint: comment,
-        },
-        search: SearchColors {
-            active: orange,
-            inactive: comment,
-            match_bg: yellow,
-            match_fg: bg,
-        },
-        markdown: MarkdownColors {
-            h1: blue,
-            h2: orange,
-            h3: purple,
-            code: green,
-            code_border: Color::Rgb(85, 85, 75),
-            link: pink,
-            link_url: Color::Rgb(130, 125, 115),
-            quote: comment,
-            text: fg,
-            list: fg,
-        },
-        engine: EngineColors {
-            header: blue,
-            header_focused: yellow,
-            divider: Color::Rgb(80, 80, 72),
-            scroll_indicator: Color::Rgb(95, 95, 88),
-            label: Color::Rgb(150, 145, 135),
-            label_focused: Color::Rgb(180, 175, 165),
-            label_dim: Color::Rgb(120, 115, 105),
-            value: Color::Rgb(210, 205, 195),
-            focused: yellow,
-            normal: fg,
-            dim: Color::Rgb(95, 95, 88),
-            path: Color::Rgb(150, 145, 135),
-            border_magenta: pink,
-            border_green: green,
-            border_cyan: blue,
-            separator: Color::Rgb(80, 80, 72),
-            hint_active: Color::Rgb(220, 200, 100),
-            hint_inactive: Color::Rgb(80, 80, 72),
-        },
-        dict: DictColors {
-            word_name: green,
-            word_bg: Color::Rgb(55, 65, 60),
-            alias: comment,
-            stack_sig: purple,
-            description: fg,
-            example: Color::Rgb(150, 145, 135),
-            category_focused: yellow,
-            category_selected: blue,
-            category_normal: fg,
-            category_dimmed: Color::Rgb(95, 95, 88),
-            border_focused: yellow,
-            border_normal: Color::Rgb(80, 80, 72),
-            header_desc: Color::Rgb(170, 165, 155),
-        },
-        title: TitleColors {
-            big_title: pink,
-            author: blue,
-            link: green,
-            license: orange,
-            prompt: Color::Rgb(170, 165, 155),
-            subtitle: fg,
-        },
-        meter: MeterColors {
-            low: green,
-            mid: yellow,
-            high: pink,
-            low_rgb: (155, 215, 45),
-            mid_rgb: (220, 210, 105),
-            high_rgb: (240, 50, 110),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (102, 217, 239),
-                (253, 151, 31),
-                (166, 226, 46),
-                (249, 38, 114),
-                (174, 129, 255),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: orange,
-            button_selected_bg: orange,
-            button_selected_fg: bg,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (39, 40, 34),
+        surface: (53, 54, 47),
+        surface2: (70, 71, 62),
+        fg: (248, 248, 242),
+        fg_dim: (190, 190, 180),
+        fg_muted: (117, 113, 94),
+        accent: (249, 38, 114),     // pink
+        red: (249, 38, 114),
+        green: (166, 226, 46),
+        yellow: (230, 219, 116),
+        blue: (102, 217, 239),
+        purple: (174, 129, 255),
+        cyan: (102, 217, 239),
+        orange: (253, 151, 31),
+        tempo_color: (249, 38, 114),
+        bank_color: (102, 217, 239),
+        pattern_color: (166, 226, 46),
+        title_accent: (249, 38, 114),
+        title_author: (102, 217, 239),
+        secondary: (253, 151, 31),
+        link_bright: [
+            (249, 38, 114), (174, 129, 255), (253, 151, 31),
+            (102, 217, 239), (166, 226, 46),
+        ],
+        link_dim: [
+            (90, 40, 60), (70, 55, 90), (85, 60, 35),
+            (50, 75, 85), (60, 80, 40),
+        ],
+        sparkle: [
+            (102, 217, 239), (253, 151, 31), (166, 226, 46),
+            (249, 38, 114), (174, 129, 255),
+        ],
+        meter: [(155, 215, 45), (220, 210, 105), (240, 50, 110)],
     }
 }

crates/ratatui/src/theme/nord.rs

@@ -1,279 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let polar_night0 = Color::Rgb(46, 52, 64);
-    let polar_night1 = Color::Rgb(59, 66, 82);
-    let polar_night2 = Color::Rgb(67, 76, 94);
-    let polar_night3 = Color::Rgb(76, 86, 106);
-    let snow_storm0 = Color::Rgb(216, 222, 233);
-    let snow_storm2 = Color::Rgb(236, 239, 244);
-    let frost0 = Color::Rgb(143, 188, 187);
-    let frost1 = Color::Rgb(136, 192, 208);
-    let frost2 = Color::Rgb(129, 161, 193);
-    let aurora_red = Color::Rgb(191, 97, 106);
-    let aurora_orange = Color::Rgb(208, 135, 112);
-    let aurora_yellow = Color::Rgb(235, 203, 139);
-    let aurora_green = Color::Rgb(163, 190, 140);
-    let aurora_purple = Color::Rgb(180, 142, 173);
-
-    ThemeColors {
-        ui: UiColors {
-            bg: polar_night0,
-            bg_rgb: (46, 52, 64),
-            text_primary: snow_storm2,
-            text_muted: snow_storm0,
-            text_dim: polar_night3,
-            border: polar_night2,
-            header: frost1,
-            unfocused: polar_night3,
-            accent: frost1,
-            surface: polar_night1,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(50, 65, 60),
-            playing_fg: aurora_green,
-            stopped_bg: Color::Rgb(65, 50, 55),
-            stopped_fg: aurora_red,
-            fill_on: aurora_green,
-            fill_off: polar_night3,
-            fill_bg: polar_night1,
-        },
-        selection: SelectionColors {
-            cursor_bg: frost1,
-            cursor_fg: polar_night0,
-            selected_bg: Color::Rgb(70, 85, 105),
-            selected_fg: frost1,
-            in_range_bg: Color::Rgb(60, 70, 90),
-            in_range_fg: snow_storm0,
-            cursor: frost1,
-            selected: Color::Rgb(70, 85, 105),
-            in_range: Color::Rgb(60, 70, 90),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(80, 70, 65),
-            playing_active_fg: aurora_orange,
-            playing_inactive_bg: Color::Rgb(75, 70, 55),
-            playing_inactive_fg: aurora_yellow,
-            active_bg: Color::Rgb(50, 65, 65),
-            active_fg: frost0,
-            inactive_bg: polar_night1,
-            inactive_fg: snow_storm0,
-            active_selected_bg: Color::Rgb(75, 75, 95),
-            active_in_range_bg: Color::Rgb(60, 70, 85),
-            link_bright: [
-                (136, 192, 208),
-                (180, 142, 173),
-                (208, 135, 112),
-                (143, 188, 187),
-                (163, 190, 140),
-            ],
-            link_dim: [
-                (55, 75, 85),
-                (70, 60, 70),
-                (75, 55, 50),
-                (55, 75, 75),
-                (60, 75, 55),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(65, 55, 70),
-            tempo_fg: aurora_purple,
-            bank_bg: Color::Rgb(45, 60, 70),
-            bank_fg: frost2,
-            pattern_bg: Color::Rgb(50, 65, 65),
-            pattern_fg: frost0,
-            stats_bg: polar_night1,
-            stats_fg: snow_storm0,
-        },
-        modal: ModalColors {
-            border: frost1,
-            border_accent: aurora_purple,
-            border_warn: aurora_orange,
-            border_dim: polar_night3,
-            confirm: aurora_orange,
-            rename: aurora_purple,
-            input: frost2,
-            editor: frost1,
-            preview: polar_night3,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(65, 50, 55),
-            error_fg: aurora_red,
-            success_bg: Color::Rgb(50, 65, 55),
-            success_fg: aurora_green,
-            info_bg: polar_night1,
-            info_fg: snow_storm2,
-            event_rgb: (60, 55, 75),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(50, 65, 55),
-            playing_fg: aurora_green,
-            staged_play_bg: Color::Rgb(65, 55, 70),
-            staged_play_fg: aurora_purple,
-            staged_stop_bg: Color::Rgb(70, 55, 60),
-            staged_stop_fg: aurora_red,
-            edit_bg: Color::Rgb(50, 65, 65),
-            edit_fg: frost0,
-            hover_bg: polar_night2,
-            hover_fg: snow_storm2,
-        },
-        link_status: LinkStatusColors {
-            disabled: aurora_red,
-            connected: aurora_green,
-            listening: aurora_yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: polar_night1,
-            executed_bg: Color::Rgb(55, 55, 70),
-            selected_bg: Color::Rgb(80, 70, 55),
-            emit: (snow_storm2, Color::Rgb(75, 55, 60)),
-            number: (aurora_orange, Color::Rgb(65, 55, 50)),
-            string: (aurora_green, Color::Rgb(50, 60, 50)),
-            comment: (polar_night3, polar_night0),
-            keyword: (aurora_purple, Color::Rgb(60, 50, 65)),
-            stack_op: (frost2, Color::Rgb(45, 55, 70)),
-            operator: (aurora_yellow, Color::Rgb(65, 60, 45)),
-            sound: (frost0, Color::Rgb(45, 60, 60)),
-            param: (frost1, Color::Rgb(50, 60, 70)),
-            context: (aurora_orange, Color::Rgb(65, 55, 50)),
-            note: (aurora_green, Color::Rgb(50, 60, 50)),
-            interval: (Color::Rgb(170, 200, 150), Color::Rgb(50, 60, 45)),
-            variable: (aurora_purple, Color::Rgb(60, 50, 60)),
-            vary: (aurora_yellow, Color::Rgb(65, 60, 45)),
-            generator: (frost0, Color::Rgb(45, 60, 55)),
-            default: (snow_storm0, polar_night1),
-        },
-        table: TableColors {
-            row_even: polar_night1,
-            row_odd: polar_night0,
-        },
-        values: ValuesColors {
-            tempo: aurora_orange,
-            value: snow_storm0,
-        },
-        hint: HintColors {
-            key: aurora_orange,
-            text: polar_night3,
-        },
-        view_badge: ViewBadgeColors {
-            bg: snow_storm2,
-            fg: polar_night0,
-        },
-        nav: NavColors {
-            selected_bg: Color::Rgb(65, 75, 95),
-            selected_fg: snow_storm2,
-            unselected_bg: polar_night1,
-            unselected_fg: polar_night3,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: snow_storm2,
-            cursor_fg: polar_night0,
-            selection_bg: Color::Rgb(60, 75, 100),
-            completion_bg: polar_night1,
-            completion_fg: snow_storm2,
-            completion_selected: aurora_orange,
-            completion_example: frost0,
-        },
-        browser: BrowserColors {
-            directory: frost2,
-            project_file: aurora_purple,
-            selected: aurora_orange,
-            file: snow_storm2,
-            focused_border: aurora_orange,
-            unfocused_border: polar_night3,
-            root: snow_storm2,
-            file_icon: polar_night3,
-            folder_icon: frost2,
-            empty_text: polar_night3,
-        },
-        input: InputColors {
-            text: frost2,
-            cursor: snow_storm2,
-            hint: polar_night3,
-        },
-        search: SearchColors {
-            active: aurora_orange,
-            inactive: polar_night3,
-            match_bg: aurora_yellow,
-            match_fg: polar_night0,
-        },
-        markdown: MarkdownColors {
-            h1: frost2,
-            h2: aurora_orange,
-            h3: aurora_purple,
-            code: aurora_green,
-            code_border: Color::Rgb(75, 85, 100),
-            link: frost0,
-            link_url: Color::Rgb(100, 110, 125),
-            quote: polar_night3,
-            text: snow_storm2,
-            list: snow_storm2,
-        },
-        engine: EngineColors {
-            header: frost1,
-            header_focused: aurora_yellow,
-            divider: Color::Rgb(70, 80, 95),
-            scroll_indicator: Color::Rgb(85, 95, 110),
-            label: Color::Rgb(130, 140, 155),
-            label_focused: Color::Rgb(160, 170, 185),
-            label_dim: Color::Rgb(100, 110, 125),
-            value: Color::Rgb(190, 200, 215),
-            focused: aurora_yellow,
-            normal: snow_storm2,
-            dim: Color::Rgb(85, 95, 110),
-            path: Color::Rgb(130, 140, 155),
-            border_magenta: aurora_purple,
-            border_green: aurora_green,
-            border_cyan: frost2,
-            separator: Color::Rgb(70, 80, 95),
-            hint_active: Color::Rgb(200, 180, 100),
-            hint_inactive: Color::Rgb(70, 80, 95),
-        },
-        dict: DictColors {
-            word_name: aurora_green,
-            word_bg: Color::Rgb(50, 60, 75),
-            alias: polar_night3,
-            stack_sig: aurora_purple,
-            description: snow_storm2,
-            example: Color::Rgb(130, 140, 155),
-            category_focused: aurora_yellow,
-            category_selected: frost2,
-            category_normal: snow_storm2,
-            category_dimmed: Color::Rgb(85, 95, 110),
-            border_focused: aurora_yellow,
-            border_normal: Color::Rgb(70, 80, 95),
-            header_desc: Color::Rgb(150, 160, 175),
-        },
-        title: TitleColors {
-            big_title: frost1,
-            author: frost2,
-            link: frost0,
-            license: aurora_orange,
-            prompt: Color::Rgb(150, 160, 175),
-            subtitle: snow_storm2,
-        },
-        meter: MeterColors {
-            low: aurora_green,
-            mid: aurora_yellow,
-            high: aurora_red,
-            low_rgb: (140, 180, 130),
-            mid_rgb: (220, 190, 120),
-            high_rgb: (180, 90, 100),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (136, 192, 208),
-                (208, 135, 112),
-                (163, 190, 140),
-                (180, 142, 173),
-                (235, 203, 139),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: aurora_orange,
-            button_selected_bg: aurora_orange,
-            button_selected_fg: polar_night0,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (46, 52, 64),
+        surface: (59, 66, 82),
+        surface2: (67, 76, 94),
+        fg: (236, 239, 244),
+        fg_dim: (216, 222, 233),
+        fg_muted: (76, 86, 106),
+        accent: (136, 192, 208),    // frost1
+        red: (191, 97, 106),
+        green: (163, 190, 140),
+        yellow: (235, 203, 139),
+        blue: (129, 161, 193),      // frost2
+        purple: (180, 142, 173),
+        cyan: (143, 188, 187),      // frost0
+        orange: (208, 135, 112),
+        tempo_color: (180, 142, 173),
+        bank_color: (129, 161, 193),
+        pattern_color: (143, 188, 187),
+        title_accent: (136, 192, 208),
+        title_author: (129, 161, 193),
+        secondary: (208, 135, 112),
+        link_bright: [
+            (136, 192, 208), (180, 142, 173), (208, 135, 112),
+            (143, 188, 187), (163, 190, 140),
+        ],
+        link_dim: [
+            (55, 75, 85), (70, 60, 70), (75, 55, 50),
+            (55, 75, 75), (60, 75, 55),
+        ],
+        sparkle: [
+            (136, 192, 208), (208, 135, 112), (163, 190, 140),
+            (180, 142, 173), (235, 203, 139),
+        ],
+        meter: [(140, 180, 130), (220, 190, 120), (180, 90, 100)],
     }
 }

crates/ratatui/src/theme/palette.rs

@@ -0,0 +1,55 @@
+use ratatui::style::Color;
+
+pub type Rgb = (u8, u8, u8);
+
+pub struct Palette {
+    // Core
+    pub bg: Rgb,
+    pub surface: Rgb,
+    pub surface2: Rgb,
+    pub fg: Rgb,
+    pub fg_dim: Rgb,
+    pub fg_muted: Rgb,
+    // Semantic accents
+    pub accent: Rgb,
+    pub red: Rgb,
+    pub green: Rgb,
+    pub yellow: Rgb,
+    pub blue: Rgb,
+    pub purple: Rgb,
+    pub cyan: Rgb,
+    pub orange: Rgb,
+    // Role assignments
+    pub tempo_color: Rgb,
+    pub bank_color: Rgb,
+    pub pattern_color: Rgb,
+    pub title_accent: Rgb,
+    pub title_author: Rgb,
+    pub secondary: Rgb,
+    // Arrays
+    pub link_bright: [Rgb; 5],
+    pub link_dim: [Rgb; 5],
+    pub sparkle: [Rgb; 5],
+    pub meter: [Rgb; 3],
+}
+
+pub fn rgb(c: Rgb) -> Color {
+    Color::Rgb(c.0, c.1, c.2)
+}
+
+pub fn tint(bg: Rgb, accent: Rgb, amount: f32) -> Rgb {
+    let mix = |b: u8, a: u8| -> u8 {
+        let v = b as f32 + (a as f32 - b as f32) * amount;
+        v.clamp(0.0, 255.0) as u8
+    };
+    (mix(bg.0, accent.0), mix(bg.1, accent.1), mix(bg.2, accent.2))
+}
+
+pub fn mid(a: Rgb, b: Rgb, t: f32) -> Rgb {
+    tint(a, b, t)
+}
+
+pub fn darken(c: Rgb, amount: f32) -> Rgb {
+    let d = |v: u8| -> u8 { (v as f32 * (1.0 - amount)).clamp(0.0, 255.0) as u8 };
+    (d(c.0), d(c.1), d(c.2))
+}

crates/ratatui/src/theme/pitch_black.rs

@@ -1,277 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let bg = Color::Rgb(0, 0, 0);
-    let surface = Color::Rgb(10, 10, 10);
-    let surface2 = Color::Rgb(21, 21, 21);
-    let border = Color::Rgb(40, 40, 40);
-    let fg = Color::Rgb(230, 230, 230);
-    let fg_dim = Color::Rgb(160, 160, 160);
-    let fg_muted = Color::Rgb(100, 100, 100);
-
-    let red = Color::Rgb(255, 80, 80);
-    let green = Color::Rgb(80, 255, 120);
-    let yellow = Color::Rgb(255, 230, 80);
-    let blue = Color::Rgb(80, 180, 255);
-    let purple = Color::Rgb(200, 120, 255);
-    let cyan = Color::Rgb(80, 230, 230);
-    let orange = Color::Rgb(255, 160, 60);
-
-    ThemeColors {
-        ui: UiColors {
-            bg,
-            bg_rgb: (0, 0, 0),
-            text_primary: fg,
-            text_muted: fg_dim,
-            text_dim: fg_muted,
-            border,
-            header: blue,
-            unfocused: fg_muted,
-            accent: cyan,
-            surface,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(15, 35, 20),
-            playing_fg: green,
-            stopped_bg: Color::Rgb(40, 15, 20),
-            stopped_fg: red,
-            fill_on: green,
-            fill_off: fg_muted,
-            fill_bg: surface,
-        },
-        selection: SelectionColors {
-            cursor_bg: cyan,
-            cursor_fg: bg,
-            selected_bg: Color::Rgb(40, 50, 60),
-            selected_fg: cyan,
-            in_range_bg: Color::Rgb(25, 35, 45),
-            in_range_fg: fg,
-            cursor: cyan,
-            selected: Color::Rgb(40, 50, 60),
-            in_range: Color::Rgb(25, 35, 45),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(50, 35, 20),
-            playing_active_fg: orange,
-            playing_inactive_bg: Color::Rgb(45, 40, 15),
-            playing_inactive_fg: yellow,
-            active_bg: Color::Rgb(15, 40, 40),
-            active_fg: cyan,
-            inactive_bg: surface,
-            inactive_fg: fg_dim,
-            active_selected_bg: Color::Rgb(45, 40, 55),
-            active_in_range_bg: Color::Rgb(30, 35, 45),
-            link_bright: [
-                (80, 230, 230),
-                (200, 120, 255),
-                (255, 160, 60),
-                (80, 180, 255),
-                (80, 255, 120),
-            ],
-            link_dim: [
-                (25, 60, 60),
-                (50, 35, 65),
-                (60, 45, 20),
-                (25, 50, 70),
-                (25, 65, 35),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(50, 35, 55),
-            tempo_fg: purple,
-            bank_bg: Color::Rgb(20, 45, 60),
-            bank_fg: blue,
-            pattern_bg: Color::Rgb(20, 55, 50),
-            pattern_fg: cyan,
-            stats_bg: surface,
-            stats_fg: fg_dim,
-        },
-        modal: ModalColors {
-            border: cyan,
-            border_accent: purple,
-            border_warn: orange,
-            border_dim: fg_muted,
-            confirm: orange,
-            rename: purple,
-            input: blue,
-            editor: cyan,
-            preview: fg_muted,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(50, 15, 20),
-            error_fg: red,
-            success_bg: Color::Rgb(15, 45, 25),
-            success_fg: green,
-            info_bg: surface,
-            info_fg: fg,
-            event_rgb: (40, 30, 50),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(15, 45, 25),
-            playing_fg: green,
-            staged_play_bg: Color::Rgb(45, 30, 55),
-            staged_play_fg: purple,
-            staged_stop_bg: Color::Rgb(55, 25, 30),
-            staged_stop_fg: red,
-            edit_bg: Color::Rgb(15, 45, 45),
-            edit_fg: cyan,
-            hover_bg: surface2,
-            hover_fg: fg,
-        },
-        link_status: LinkStatusColors {
-            disabled: red,
-            connected: green,
-            listening: yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: bg,
-            executed_bg: Color::Rgb(25, 25, 35),
-            selected_bg: Color::Rgb(55, 45, 25),
-            emit: (fg, Color::Rgb(50, 30, 35)),
-            number: (orange, Color::Rgb(50, 35, 20)),
-            string: (green, Color::Rgb(20, 45, 25)),
-            comment: (fg_muted, bg),
-            keyword: (purple, Color::Rgb(40, 25, 50)),
-            stack_op: (blue, Color::Rgb(20, 40, 55)),
-            operator: (yellow, Color::Rgb(50, 45, 20)),
-            sound: (cyan, Color::Rgb(20, 45, 45)),
-            param: (purple, Color::Rgb(40, 25, 50)),
-            context: (orange, Color::Rgb(50, 35, 20)),
-            note: (green, Color::Rgb(20, 45, 25)),
-            interval: (Color::Rgb(130, 255, 150), Color::Rgb(25, 55, 35)),
-            variable: (purple, Color::Rgb(40, 25, 50)),
-            vary: (yellow, Color::Rgb(50, 45, 20)),
-            generator: (cyan, Color::Rgb(20, 45, 40)),
-            default: (fg_dim, bg),
-        },
-        table: TableColors {
-            row_even: bg,
-            row_odd: surface,
-        },
-        values: ValuesColors {
-            tempo: orange,
-            value: fg_dim,
-        },
-        hint: HintColors {
-            key: orange,
-            text: fg_muted,
-        },
-        view_badge: ViewBadgeColors { bg: fg, fg: bg },
-        nav: NavColors {
-            selected_bg: Color::Rgb(40, 45, 55),
-            selected_fg: fg,
-            unselected_bg: surface,
-            unselected_fg: fg_muted,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: fg,
-            cursor_fg: bg,
-            selection_bg: Color::Rgb(40, 50, 65),
-            completion_bg: surface,
-            completion_fg: fg,
-            completion_selected: orange,
-            completion_example: cyan,
-        },
-        browser: BrowserColors {
-            directory: blue,
-            project_file: purple,
-            selected: orange,
-            file: fg,
-            focused_border: orange,
-            unfocused_border: fg_muted,
-            root: fg,
-            file_icon: fg_muted,
-            folder_icon: blue,
-            empty_text: fg_muted,
-        },
-        input: InputColors {
-            text: blue,
-            cursor: fg,
-            hint: fg_muted,
-        },
-        search: SearchColors {
-            active: orange,
-            inactive: fg_muted,
-            match_bg: yellow,
-            match_fg: bg,
-        },
-        markdown: MarkdownColors {
-            h1: blue,
-            h2: orange,
-            h3: purple,
-            code: green,
-            code_border: Color::Rgb(50, 50, 50),
-            link: cyan,
-            link_url: Color::Rgb(90, 90, 90),
-            quote: fg_muted,
-            text: fg,
-            list: fg,
-        },
-        engine: EngineColors {
-            header: blue,
-            header_focused: yellow,
-            divider: Color::Rgb(45, 45, 45),
-            scroll_indicator: Color::Rgb(60, 60, 60),
-            label: Color::Rgb(130, 130, 130),
-            label_focused: Color::Rgb(170, 170, 170),
-            label_dim: Color::Rgb(90, 90, 90),
-            value: Color::Rgb(200, 200, 200),
-            focused: yellow,
-            normal: fg,
-            dim: Color::Rgb(60, 60, 60),
-            path: Color::Rgb(130, 130, 130),
-            border_magenta: purple,
-            border_green: green,
-            border_cyan: cyan,
-            separator: Color::Rgb(45, 45, 45),
-            hint_active: Color::Rgb(220, 200, 80),
-            hint_inactive: Color::Rgb(45, 45, 45),
-        },
-        dict: DictColors {
-            word_name: green,
-            word_bg: Color::Rgb(20, 30, 35),
-            alias: fg_muted,
-            stack_sig: purple,
-            description: fg,
-            example: Color::Rgb(130, 130, 130),
-            category_focused: yellow,
-            category_selected: blue,
-            category_normal: fg,
-            category_dimmed: Color::Rgb(60, 60, 60),
-            border_focused: yellow,
-            border_normal: Color::Rgb(45, 45, 45),
-            header_desc: Color::Rgb(150, 150, 150),
-        },
-        title: TitleColors {
-            big_title: cyan,
-            author: blue,
-            link: green,
-            license: orange,
-            prompt: Color::Rgb(150, 150, 150),
-            subtitle: fg,
-        },
-        meter: MeterColors {
-            low: green,
-            mid: yellow,
-            high: red,
-            low_rgb: (70, 240, 110),
-            mid_rgb: (245, 220, 75),
-            high_rgb: (245, 75, 75),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (80, 230, 230),
-                (255, 160, 60),
-                (80, 255, 120),
-                (200, 120, 255),
-                (80, 180, 255),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: orange,
-            button_selected_bg: orange,
-            button_selected_fg: bg,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (0, 0, 0),
+        surface: (10, 10, 10),
+        surface2: (21, 21, 21),
+        fg: (230, 230, 230),
+        fg_dim: (160, 160, 160),
+        fg_muted: (100, 100, 100),
+        accent: (80, 230, 230),     // cyan
+        red: (255, 80, 80),
+        green: (80, 255, 120),
+        yellow: (255, 230, 80),
+        blue: (80, 180, 255),
+        purple: (200, 120, 255),
+        cyan: (80, 230, 230),
+        orange: (255, 160, 60),
+        tempo_color: (200, 120, 255),
+        bank_color: (80, 180, 255),
+        pattern_color: (80, 230, 230),
+        title_accent: (80, 230, 230),
+        title_author: (80, 180, 255),
+        secondary: (255, 160, 60),
+        link_bright: [
+            (80, 230, 230), (200, 120, 255), (255, 160, 60),
+            (80, 180, 255), (80, 255, 120),
+        ],
+        link_dim: [
+            (25, 60, 60), (50, 35, 65), (60, 45, 20),
+            (25, 50, 70), (25, 65, 35),
+        ],
+        sparkle: [
+            (80, 230, 230), (255, 160, 60), (80, 255, 120),
+            (200, 120, 255), (80, 180, 255),
+        ],
+        meter: [(70, 240, 110), (245, 220, 75), (245, 75, 75)],
     }
 }

crates/ratatui/src/theme/rose_pine.rs

@@ -1,277 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let bg = Color::Rgb(25, 23, 36);
-    let bg_light = Color::Rgb(33, 32, 46);
-    let bg_lighter = Color::Rgb(42, 39, 63);
-    let fg = Color::Rgb(224, 222, 244);
-    let fg_dim = Color::Rgb(144, 140, 170);
-    let muted = Color::Rgb(110, 106, 134);
-    let rose = Color::Rgb(235, 111, 146);
-    let gold = Color::Rgb(246, 193, 119);
-    let foam = Color::Rgb(156, 207, 216);
-    let iris = Color::Rgb(196, 167, 231);
-    let pine = Color::Rgb(49, 116, 143);
-    let subtle = Color::Rgb(235, 188, 186);
-    let love = Color::Rgb(235, 111, 146);
-
-    let darker_bg = Color::Rgb(21, 19, 30);
-
-    ThemeColors {
-        ui: UiColors {
-            bg,
-            bg_rgb: (25, 23, 36),
-            text_primary: fg,
-            text_muted: fg_dim,
-            text_dim: muted,
-            border: bg_lighter,
-            header: foam,
-            unfocused: muted,
-            accent: rose,
-            surface: bg_light,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(35, 50, 55),
-            playing_fg: foam,
-            stopped_bg: Color::Rgb(55, 40, 50),
-            stopped_fg: love,
-            fill_on: foam,
-            fill_off: muted,
-            fill_bg: bg_light,
-        },
-        selection: SelectionColors {
-            cursor_bg: rose,
-            cursor_fg: bg,
-            selected_bg: Color::Rgb(60, 50, 70),
-            selected_fg: rose,
-            in_range_bg: Color::Rgb(50, 45, 60),
-            in_range_fg: fg,
-            cursor: rose,
-            selected: Color::Rgb(60, 50, 70),
-            in_range: Color::Rgb(50, 45, 60),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(65, 55, 50),
-            playing_active_fg: gold,
-            playing_inactive_bg: Color::Rgb(55, 55, 55),
-            playing_inactive_fg: subtle,
-            active_bg: Color::Rgb(35, 50, 60),
-            active_fg: foam,
-            inactive_bg: bg_light,
-            inactive_fg: fg_dim,
-            active_selected_bg: Color::Rgb(60, 50, 70),
-            active_in_range_bg: Color::Rgb(50, 45, 60),
-            link_bright: [
-                (235, 111, 146),
-                (196, 167, 231),
-                (246, 193, 119),
-                (156, 207, 216),
-                (49, 116, 143),
-            ],
-            link_dim: [
-                (75, 45, 55),
-                (60, 50, 75),
-                (75, 60, 45),
-                (50, 65, 70),
-                (30, 50, 55),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(60, 45, 60),
-            tempo_fg: iris,
-            bank_bg: Color::Rgb(35, 50, 60),
-            bank_fg: foam,
-            pattern_bg: Color::Rgb(35, 55, 60),
-            pattern_fg: pine,
-            stats_bg: bg_light,
-            stats_fg: fg_dim,
-        },
-        modal: ModalColors {
-            border: foam,
-            border_accent: rose,
-            border_warn: gold,
-            border_dim: muted,
-            confirm: gold,
-            rename: iris,
-            input: foam,
-            editor: foam,
-            preview: muted,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(60, 40, 50),
-            error_fg: love,
-            success_bg: Color::Rgb(35, 55, 55),
-            success_fg: foam,
-            info_bg: bg_light,
-            info_fg: fg,
-            event_rgb: (50, 45, 60),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(35, 55, 55),
-            playing_fg: foam,
-            staged_play_bg: Color::Rgb(55, 50, 70),
-            staged_play_fg: iris,
-            staged_stop_bg: Color::Rgb(60, 45, 55),
-            staged_stop_fg: love,
-            edit_bg: Color::Rgb(35, 50, 60),
-            edit_fg: foam,
-            hover_bg: bg_lighter,
-            hover_fg: fg,
-        },
-        link_status: LinkStatusColors {
-            disabled: love,
-            connected: foam,
-            listening: gold,
-        },
-        syntax: SyntaxColors {
-            gap_bg: darker_bg,
-            executed_bg: Color::Rgb(40, 40, 55),
-            selected_bg: Color::Rgb(65, 55, 50),
-            emit: (fg, Color::Rgb(60, 45, 60)),
-            number: (iris, Color::Rgb(55, 50, 70)),
-            string: (gold, Color::Rgb(65, 55, 45)),
-            comment: (muted, darker_bg),
-            keyword: (rose, Color::Rgb(60, 45, 55)),
-            stack_op: (foam, Color::Rgb(40, 55, 60)),
-            operator: (love, Color::Rgb(60, 45, 55)),
-            sound: (foam, Color::Rgb(40, 55, 60)),
-            param: (gold, Color::Rgb(65, 55, 45)),
-            context: (gold, Color::Rgb(65, 55, 45)),
-            note: (pine, Color::Rgb(35, 50, 55)),
-            interval: (Color::Rgb(100, 160, 180), Color::Rgb(35, 55, 60)),
-            variable: (pine, Color::Rgb(35, 50, 55)),
-            vary: (subtle, Color::Rgb(60, 55, 55)),
-            generator: (foam, Color::Rgb(40, 55, 60)),
-            default: (fg_dim, darker_bg),
-        },
-        table: TableColors {
-            row_even: darker_bg,
-            row_odd: bg,
-        },
-        values: ValuesColors {
-            tempo: gold,
-            value: fg_dim,
-        },
-        hint: HintColors {
-            key: gold,
-            text: muted,
-        },
-        view_badge: ViewBadgeColors { bg: fg, fg: bg },
-        nav: NavColors {
-            selected_bg: Color::Rgb(60, 50, 70),
-            selected_fg: fg,
-            unselected_bg: bg_light,
-            unselected_fg: muted,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: fg,
-            cursor_fg: bg,
-            selection_bg: Color::Rgb(55, 50, 70),
-            completion_bg: bg_light,
-            completion_fg: fg,
-            completion_selected: gold,
-            completion_example: foam,
-        },
-        browser: BrowserColors {
-            directory: foam,
-            project_file: iris,
-            selected: gold,
-            file: fg,
-            focused_border: gold,
-            unfocused_border: muted,
-            root: fg,
-            file_icon: muted,
-            folder_icon: foam,
-            empty_text: muted,
-        },
-        input: InputColors {
-            text: foam,
-            cursor: fg,
-            hint: muted,
-        },
-        search: SearchColors {
-            active: gold,
-            inactive: muted,
-            match_bg: gold,
-            match_fg: bg,
-        },
-        markdown: MarkdownColors {
-            h1: foam,
-            h2: gold,
-            h3: iris,
-            code: pine,
-            code_border: Color::Rgb(60, 55, 75),
-            link: rose,
-            link_url: Color::Rgb(100, 95, 120),
-            quote: muted,
-            text: fg,
-            list: fg,
-        },
-        engine: EngineColors {
-            header: foam,
-            header_focused: gold,
-            divider: Color::Rgb(55, 52, 70),
-            scroll_indicator: Color::Rgb(70, 65, 90),
-            label: Color::Rgb(130, 125, 155),
-            label_focused: Color::Rgb(160, 155, 185),
-            label_dim: Color::Rgb(100, 95, 125),
-            value: Color::Rgb(200, 195, 220),
-            focused: gold,
-            normal: fg,
-            dim: Color::Rgb(70, 65, 90),
-            path: Color::Rgb(130, 125, 155),
-            border_magenta: iris,
-            border_green: foam,
-            border_cyan: pine,
-            separator: Color::Rgb(55, 52, 70),
-            hint_active: Color::Rgb(230, 180, 110),
-            hint_inactive: Color::Rgb(55, 52, 70),
-        },
-        dict: DictColors {
-            word_name: pine,
-            word_bg: Color::Rgb(40, 50, 55),
-            alias: muted,
-            stack_sig: iris,
-            description: fg,
-            example: Color::Rgb(130, 125, 155),
-            category_focused: gold,
-            category_selected: foam,
-            category_normal: fg,
-            category_dimmed: Color::Rgb(70, 65, 90),
-            border_focused: gold,
-            border_normal: Color::Rgb(55, 52, 70),
-            header_desc: Color::Rgb(150, 145, 175),
-        },
-        title: TitleColors {
-            big_title: rose,
-            author: foam,
-            link: pine,
-            license: gold,
-            prompt: Color::Rgb(150, 145, 175),
-            subtitle: fg,
-        },
-        meter: MeterColors {
-            low: foam,
-            mid: gold,
-            high: love,
-            low_rgb: (156, 207, 216),
-            mid_rgb: (246, 193, 119),
-            high_rgb: (235, 111, 146),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (156, 207, 216),
-                (246, 193, 119),
-                (49, 116, 143),
-                (235, 111, 146),
-                (196, 167, 231),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: gold,
-            button_selected_bg: gold,
-            button_selected_fg: bg,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (25, 23, 36),
+        surface: (33, 32, 46),
+        surface2: (42, 39, 63),
+        fg: (224, 222, 244),
+        fg_dim: (144, 140, 170),
+        fg_muted: (110, 106, 134),
+        accent: (235, 188, 186),    // rose
+        red: (235, 111, 146),       // love
+        green: (156, 207, 216),     // foam
+        yellow: (246, 193, 119),    // gold
+        blue: (49, 116, 143),       // pine
+        purple: (196, 167, 231),    // iris
+        cyan: (156, 207, 216),      // foam
+        orange: (246, 193, 119),    // gold
+        tempo_color: (196, 167, 231),
+        bank_color: (156, 207, 216),
+        pattern_color: (49, 116, 143),
+        title_accent: (235, 188, 186),
+        title_author: (156, 207, 216),
+        secondary: (235, 111, 146),
+        link_bright: [
+            (235, 111, 146), (196, 167, 231), (246, 193, 119),
+            (156, 207, 216), (49, 116, 143),
+        ],
+        link_dim: [
+            (75, 45, 55), (60, 50, 75), (75, 60, 45),
+            (50, 65, 70), (30, 50, 55),
+        ],
+        sparkle: [
+            (156, 207, 216), (246, 193, 119), (49, 116, 143),
+            (235, 111, 146), (196, 167, 231),
+        ],
+        meter: [(156, 207, 216), (246, 193, 119), (235, 111, 146)],
     }
 }

crates/ratatui/src/theme/tokyo_night.rs

@@ -1,277 +1,39 @@
-use super::*;
-use ratatui::style::Color;
+use super::palette::Palette;
 
-pub fn theme() -> ThemeColors {
-    let bg = Color::Rgb(26, 27, 38);
-    let bg_light = Color::Rgb(36, 40, 59);
-    let bg_lighter = Color::Rgb(52, 59, 88);
-    let fg = Color::Rgb(169, 177, 214);
-    let fg_dim = Color::Rgb(130, 140, 180);
-    let comment = Color::Rgb(86, 95, 137);
-    let blue = Color::Rgb(122, 162, 247);
-    let purple = Color::Rgb(187, 154, 247);
-    let green = Color::Rgb(158, 206, 106);
-    let red = Color::Rgb(247, 118, 142);
-    let orange = Color::Rgb(224, 175, 104);
-    let cyan = Color::Rgb(125, 207, 255);
-    let yellow = Color::Rgb(224, 175, 104);
-
-    let darker_bg = Color::Rgb(22, 23, 32);
-
-    ThemeColors {
-        ui: UiColors {
-            bg,
-            bg_rgb: (26, 27, 38),
-            text_primary: fg,
-            text_muted: fg_dim,
-            text_dim: comment,
-            border: bg_lighter,
-            header: blue,
-            unfocused: comment,
-            accent: purple,
-            surface: bg_light,
-        },
-        status: StatusColors {
-            playing_bg: Color::Rgb(45, 60, 50),
-            playing_fg: green,
-            stopped_bg: Color::Rgb(60, 40, 50),
-            stopped_fg: red,
-            fill_on: green,
-            fill_off: comment,
-            fill_bg: bg_light,
-        },
-        selection: SelectionColors {
-            cursor_bg: purple,
-            cursor_fg: bg,
-            selected_bg: Color::Rgb(70, 60, 90),
-            selected_fg: purple,
-            in_range_bg: Color::Rgb(55, 55, 75),
-            in_range_fg: fg,
-            cursor: purple,
-            selected: Color::Rgb(70, 60, 90),
-            in_range: Color::Rgb(55, 55, 75),
-        },
-        tile: TileColors {
-            playing_active_bg: Color::Rgb(70, 60, 45),
-            playing_active_fg: orange,
-            playing_inactive_bg: Color::Rgb(60, 60, 50),
-            playing_inactive_fg: yellow,
-            active_bg: Color::Rgb(45, 60, 75),
-            active_fg: blue,
-            inactive_bg: bg_light,
-            inactive_fg: fg_dim,
-            active_selected_bg: Color::Rgb(70, 55, 85),
-            active_in_range_bg: Color::Rgb(55, 55, 75),
-            link_bright: [
-                (247, 118, 142),
-                (187, 154, 247),
-                (224, 175, 104),
-                (125, 207, 255),
-                (158, 206, 106),
-            ],
-            link_dim: [
-                (80, 45, 55),
-                (65, 55, 85),
-                (75, 60, 40),
-                (45, 70, 85),
-                (55, 70, 45),
-            ],
-        },
-        header: HeaderColors {
-            tempo_bg: Color::Rgb(65, 50, 70),
-            tempo_fg: purple,
-            bank_bg: Color::Rgb(45, 55, 75),
-            bank_fg: blue,
-            pattern_bg: Color::Rgb(50, 65, 50),
-            pattern_fg: green,
-            stats_bg: bg_light,
-            stats_fg: fg_dim,
-        },
-        modal: ModalColors {
-            border: blue,
-            border_accent: purple,
-            border_warn: orange,
-            border_dim: comment,
-            confirm: orange,
-            rename: purple,
-            input: blue,
-            editor: blue,
-            preview: comment,
-        },
-        flash: FlashColors {
-            error_bg: Color::Rgb(65, 40, 50),
-            error_fg: red,
-            success_bg: Color::Rgb(45, 60, 45),
-            success_fg: green,
-            info_bg: bg_light,
-            info_fg: fg,
-            event_rgb: (55, 50, 70),
-        },
-        list: ListColors {
-            playing_bg: Color::Rgb(45, 60, 45),
-            playing_fg: green,
-            staged_play_bg: Color::Rgb(60, 50, 75),
-            staged_play_fg: purple,
-            staged_stop_bg: Color::Rgb(70, 45, 55),
-            staged_stop_fg: red,
-            edit_bg: Color::Rgb(45, 55, 70),
-            edit_fg: blue,
-            hover_bg: bg_lighter,
-            hover_fg: fg,
-        },
-        link_status: LinkStatusColors {
-            disabled: red,
-            connected: green,
-            listening: yellow,
-        },
-        syntax: SyntaxColors {
-            gap_bg: darker_bg,
-            executed_bg: Color::Rgb(45, 45, 60),
-            selected_bg: Color::Rgb(70, 60, 50),
-            emit: (fg, Color::Rgb(70, 50, 65)),
-            number: (purple, Color::Rgb(55, 50, 70)),
-            string: (green, Color::Rgb(50, 60, 50)),
-            comment: (comment, darker_bg),
-            keyword: (purple, Color::Rgb(60, 50, 70)),
-            stack_op: (cyan, Color::Rgb(45, 60, 75)),
-            operator: (red, Color::Rgb(65, 45, 55)),
-            sound: (blue, Color::Rgb(45, 55, 70)),
-            param: (orange, Color::Rgb(70, 55, 45)),
-            context: (orange, Color::Rgb(70, 55, 45)),
-            note: (green, Color::Rgb(50, 60, 45)),
-            interval: (Color::Rgb(180, 220, 130), Color::Rgb(50, 65, 45)),
-            variable: (green, Color::Rgb(50, 60, 45)),
-            vary: (yellow, Color::Rgb(70, 60, 45)),
-            generator: (cyan, Color::Rgb(45, 60, 75)),
-            default: (fg_dim, darker_bg),
-        },
-        table: TableColors {
-            row_even: darker_bg,
-            row_odd: bg,
-        },
-        values: ValuesColors {
-            tempo: orange,
-            value: fg_dim,
-        },
-        hint: HintColors {
-            key: orange,
-            text: comment,
-        },
-        view_badge: ViewBadgeColors { bg: fg, fg: bg },
-        nav: NavColors {
-            selected_bg: Color::Rgb(65, 55, 80),
-            selected_fg: fg,
-            unselected_bg: bg_light,
-            unselected_fg: comment,
-        },
-        editor_widget: EditorWidgetColors {
-            cursor_bg: fg,
-            cursor_fg: bg,
-            selection_bg: Color::Rgb(60, 60, 80),
-            completion_bg: bg_light,
-            completion_fg: fg,
-            completion_selected: orange,
-            completion_example: cyan,
-        },
-        browser: BrowserColors {
-            directory: blue,
-            project_file: purple,
-            selected: orange,
-            file: fg,
-            focused_border: orange,
-            unfocused_border: comment,
-            root: fg,
-            file_icon: comment,
-            folder_icon: blue,
-            empty_text: comment,
-        },
-        input: InputColors {
-            text: blue,
-            cursor: fg,
-            hint: comment,
-        },
-        search: SearchColors {
-            active: orange,
-            inactive: comment,
-            match_bg: yellow,
-            match_fg: bg,
-        },
-        markdown: MarkdownColors {
-            h1: blue,
-            h2: orange,
-            h3: purple,
-            code: green,
-            code_border: Color::Rgb(70, 75, 95),
-            link: red,
-            link_url: Color::Rgb(110, 120, 160),
-            quote: comment,
-            text: fg,
-            list: fg,
-        },
-        engine: EngineColors {
-            header: blue,
-            header_focused: yellow,
-            divider: Color::Rgb(65, 70, 90),
-            scroll_indicator: Color::Rgb(80, 85, 110),
-            label: Color::Rgb(130, 140, 175),
-            label_focused: Color::Rgb(160, 170, 200),
-            label_dim: Color::Rgb(100, 110, 145),
-            value: Color::Rgb(190, 195, 220),
-            focused: yellow,
-            normal: fg,
-            dim: Color::Rgb(80, 85, 110),
-            path: Color::Rgb(130, 140, 175),
-            border_magenta: purple,
-            border_green: green,
-            border_cyan: cyan,
-            separator: Color::Rgb(65, 70, 90),
-            hint_active: Color::Rgb(210, 180, 100),
-            hint_inactive: Color::Rgb(65, 70, 90),
-        },
-        dict: DictColors {
-            word_name: green,
-            word_bg: Color::Rgb(45, 55, 60),
-            alias: comment,
-            stack_sig: purple,
-            description: fg,
-            example: Color::Rgb(130, 140, 175),
-            category_focused: yellow,
-            category_selected: blue,
-            category_normal: fg,
-            category_dimmed: Color::Rgb(80, 85, 110),
-            border_focused: yellow,
-            border_normal: Color::Rgb(65, 70, 90),
-            header_desc: Color::Rgb(150, 160, 190),
-        },
-        title: TitleColors {
-            big_title: purple,
-            author: blue,
-            link: green,
-            license: orange,
-            prompt: Color::Rgb(150, 160, 190),
-            subtitle: fg,
-        },
-        meter: MeterColors {
-            low: green,
-            mid: yellow,
-            high: red,
-            low_rgb: (158, 206, 106),
-            mid_rgb: (224, 175, 104),
-            high_rgb: (247, 118, 142),
-        },
-        sparkle: SparkleColors {
-            colors: [
-                (125, 207, 255),
-                (224, 175, 104),
-                (158, 206, 106),
-                (247, 118, 142),
-                (187, 154, 247),
-            ],
-        },
-        confirm: ConfirmColors {
-            border: orange,
-            button_selected_bg: orange,
-            button_selected_fg: bg,
-        },
+pub fn palette() -> Palette {
+    Palette {
+        bg: (26, 27, 38),
+        surface: (36, 40, 59),
+        surface2: (52, 59, 88),
+        fg: (169, 177, 214),
+        fg_dim: (130, 140, 180),
+        fg_muted: (86, 95, 137),
+        accent: (187, 154, 247),    // purple
+        red: (247, 118, 142),
+        green: (158, 206, 106),
+        yellow: (224, 175, 104),
+        blue: (122, 162, 247),
+        purple: (187, 154, 247),
+        cyan: (125, 207, 255),
+        orange: (224, 175, 104),
+        tempo_color: (187, 154, 247),
+        bank_color: (122, 162, 247),
+        pattern_color: (158, 206, 106),
+        title_accent: (187, 154, 247),
+        title_author: (122, 162, 247),
+        secondary: (224, 175, 104),
+        link_bright: [
+            (247, 118, 142), (187, 154, 247), (224, 175, 104),
+            (125, 207, 255), (158, 206, 106),
+        ],
+        link_dim: [
+            (80, 45, 55), (65, 55, 85), (75, 60, 40),
+            (45, 70, 85), (55, 70, 45),
+        ],
+        sparkle: [
+            (125, 207, 255), (224, 175, 104), (158, 206, 106),
+            (247, 118, 142), (187, 154, 247),
+        ],
+        meter: [(158, 206, 106), (224, 175, 104), (247, 118, 142)],
     }
 }

crates/ratatui/src/theme/transform.rs

@@ -0,0 +1,96 @@
+use super::palette::{Palette, Rgb};
+use super::build::build;
+use super::ThemeColors;
+
+fn rgb_to_hsv(r: u8, g: u8, b: u8) -> (f32, f32, f32) {
+    let r = r as f32 / 255.0;
+    let g = g as f32 / 255.0;
+    let b = b as f32 / 255.0;
+    let max = r.max(g).max(b);
+    let min = r.min(g).min(b);
+    let delta = max - min;
+    let h = if delta == 0.0 {
+        0.0
+    } else if max == r {
+        60.0 * (((g - b) / delta) % 6.0)
+    } else if max == g {
+        60.0 * (((b - r) / delta) + 2.0)
+    } else {
+        60.0 * (((r - g) / delta) + 4.0)
+    };
+    let h = if h < 0.0 { h + 360.0 } else { h };
+    let s = if max == 0.0 { 0.0 } else { delta / max };
+    (h, s, max)
+}
+
+fn hsv_to_rgb(h: f32, s: f32, v: f32) -> (u8, u8, u8) {
+    let c = v * s;
+    let x = c * (1.0 - ((h / 60.0) % 2.0 - 1.0).abs());
+    let m = v - c;
+    let (r, g, b) = if h < 60.0 {
+        (c, x, 0.0)
+    } else if h < 120.0 {
+        (x, c, 0.0)
+    } else if h < 180.0 {
+        (0.0, c, x)
+    } else if h < 240.0 {
+        (0.0, x, c)
+    } else if h < 300.0 {
+        (x, 0.0, c)
+    } else {
+        (c, 0.0, x)
+    };
+    (
+        ((r + m) * 255.0) as u8,
+        ((g + m) * 255.0) as u8,
+        ((b + m) * 255.0) as u8,
+    )
+}
+
+fn rotate(c: Rgb, degrees: f32) -> Rgb {
+    let (h, s, v) = rgb_to_hsv(c.0, c.1, c.2);
+    let new_h = (h + degrees) % 360.0;
+    let new_h = if new_h < 0.0 { new_h + 360.0 } else { new_h };
+    hsv_to_rgb(new_h, s, v)
+}
+
+fn rotate5(arr: [Rgb; 5], d: f32) -> [Rgb; 5] {
+    [rotate(arr[0], d), rotate(arr[1], d), rotate(arr[2], d), rotate(arr[3], d), rotate(arr[4], d)]
+}
+
+fn rotate3(arr: [Rgb; 3], d: f32) -> [Rgb; 3] {
+    [rotate(arr[0], d), rotate(arr[1], d), rotate(arr[2], d)]
+}
+
+pub fn rotate_palette(palette: &Palette, degrees: f32) -> ThemeColors {
+    if degrees == 0.0 {
+        return build(palette);
+    }
+    let d = degrees;
+    build(&Palette {
+        bg: rotate(palette.bg, d),
+        surface: rotate(palette.surface, d),
+        surface2: rotate(palette.surface2, d),
+        fg: rotate(palette.fg, d),
+        fg_dim: rotate(palette.fg_dim, d),
+        fg_muted: rotate(palette.fg_muted, d),
+        accent: rotate(palette.accent, d),
+        red: rotate(palette.red, d),
+        green: rotate(palette.green, d),
+        yellow: rotate(palette.yellow, d),
+        blue: rotate(palette.blue, d),
+        purple: rotate(palette.purple, d),
+        cyan: rotate(palette.cyan, d),
+        orange: rotate(palette.orange, d),
+        tempo_color: rotate(palette.tempo_color, d),
+        bank_color: rotate(palette.bank_color, d),
+        pattern_color: rotate(palette.pattern_color, d),
+        title_accent: rotate(palette.title_accent, d),
+        title_author: rotate(palette.title_author, d),
+        secondary: rotate(palette.secondary, d),
+        link_bright: rotate5(palette.link_bright, d),
+        link_dim: rotate5(palette.link_dim, d),
+        sparkle: rotate5(palette.sparkle, d),
+        meter: rotate3(palette.meter, d),
+    })
+}

crates/ratatui/src/waveform.rs

@@ -0,0 +1,197 @@
+use crate::scope::Orientation;
+use crate::theme;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::style::Color;
+use ratatui::widgets::Widget;
+use std::cell::RefCell;
+
+thread_local! {
+    static PATTERNS: RefCell<Vec<u8>> = const { RefCell::new(Vec::new()) };
+}
+
+pub struct Waveform<'a> {
+    data: &'a [f32],
+    orientation: Orientation,
+    color: Option<Color>,
+    gain: f32,
+}
+
+impl<'a> Waveform<'a> {
+    pub fn new(data: &'a [f32]) -> Self {
+        Self {
+            data,
+            orientation: Orientation::Horizontal,
+            color: None,
+            gain: 1.0,
+        }
+    }
+
+    pub fn orientation(mut self, o: Orientation) -> Self {
+        self.orientation = o;
+        self
+    }
+
+    pub fn color(mut self, c: Color) -> Self {
+        self.color = Some(c);
+        self
+    }
+
+    pub fn gain(mut self, g: f32) -> Self {
+        self.gain = g;
+        self
+    }
+}
+
+impl Widget for Waveform<'_> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        if area.width == 0 || area.height == 0 || self.data.is_empty() {
+            return;
+        }
+
+        let color = self.color.unwrap_or_else(|| theme::get().meter.low);
+
+        match self.orientation {
+            Orientation::Horizontal => {
+                render_horizontal(self.data, area, buf, color, self.gain)
+            }
+            Orientation::Vertical => render_vertical(self.data, area, buf, color, self.gain),
+        }
+    }
+}
+
+fn braille_bit(dot_x: usize, dot_y: usize) -> u8 {
+    match (dot_x, dot_y) {
+        (0, 0) => 0x01,
+        (0, 1) => 0x02,
+        (0, 2) => 0x04,
+        (0, 3) => 0x40,
+        (1, 0) => 0x08,
+        (1, 1) => 0x10,
+        (1, 2) => 0x20,
+        (1, 3) => 0x80,
+        _ => unreachable!(),
+    }
+}
+
+fn render_horizontal(data: &[f32], area: Rect, buf: &mut Buffer, color: Color, gain: f32) {
+    let width = area.width as usize;
+    let height = area.height as usize;
+    let fine_width = width * 2;
+    let fine_height = height * 4;
+    let len = data.len();
+
+    let peak = data.iter().map(|s| s.abs()).fold(0.0f32, f32::max);
+    let auto_gain = if peak > 0.001 { gain / peak } else { gain };
+
+    PATTERNS.with(|p| {
+        let mut patterns = p.borrow_mut();
+        patterns.clear();
+        patterns.resize(width * height, 0);
+
+        for fine_x in 0..fine_width {
+            let start = fine_x * len / fine_width;
+            let end = ((fine_x + 1) * len / fine_width).max(start + 1).min(len);
+            let slice = &data[start..end];
+
+            let mut min_s = f32::MAX;
+            let mut max_s = f32::MIN;
+            for &s in slice {
+                let s = (s * auto_gain).clamp(-1.0, 1.0);
+                if s < min_s {
+                    min_s = s;
+                }
+                if s > max_s {
+                    max_s = s;
+                }
+            }
+
+            let fy_top = ((1.0 - max_s) * 0.5 * (fine_height - 1) as f32).round() as usize;
+            let fy_bot = ((1.0 - min_s) * 0.5 * (fine_height - 1) as f32).round() as usize;
+            let fy_top = fy_top.min(fine_height - 1);
+            let fy_bot = fy_bot.min(fine_height - 1);
+
+            let char_x = fine_x / 2;
+            let dot_x = fine_x % 2;
+
+            for fy in fy_top..=fy_bot {
+                let char_y = fy / 4;
+                let dot_y = fy % 4;
+                patterns[char_y * width + char_x] |= braille_bit(dot_x, dot_y);
+            }
+        }
+
+        for cy in 0..height {
+            for cx in 0..width {
+                let pattern = patterns[cy * width + cx];
+                if pattern != 0 {
+                    let ch = char::from_u32(0x2800 + pattern as u32).unwrap_or(' ');
+                    buf[(area.x + cx as u16, area.y + cy as u16)]
+                        .set_char(ch)
+                        .set_fg(color);
+                }
+            }
+        }
+    });
+}
+
+fn render_vertical(data: &[f32], area: Rect, buf: &mut Buffer, color: Color, gain: f32) {
+    let width = area.width as usize;
+    let height = area.height as usize;
+    let fine_width = width * 2;
+    let fine_height = height * 4;
+    let len = data.len();
+
+    let peak = data.iter().map(|s| s.abs()).fold(0.0f32, f32::max);
+    let auto_gain = if peak > 0.001 { gain / peak } else { gain };
+
+    PATTERNS.with(|p| {
+        let mut patterns = p.borrow_mut();
+        patterns.clear();
+        patterns.resize(width * height, 0);
+
+        for fine_y in 0..fine_height {
+            let start = fine_y * len / fine_height;
+            let end = ((fine_y + 1) * len / fine_height).max(start + 1).min(len);
+            let slice = &data[start..end];
+
+            let mut min_s = f32::MAX;
+            let mut max_s = f32::MIN;
+            for &s in slice {
+                let s = (s * auto_gain).clamp(-1.0, 1.0);
+                if s < min_s {
+                    min_s = s;
+                }
+                if s > max_s {
+                    max_s = s;
+                }
+            }
+
+            let fx_left = ((min_s + 1.0) * 0.5 * (fine_width - 1) as f32).round() as usize;
+            let fx_right = ((max_s + 1.0) * 0.5 * (fine_width - 1) as f32).round() as usize;
+            let fx_left = fx_left.min(fine_width - 1);
+            let fx_right = fx_right.min(fine_width - 1);
+
+            let char_y = fine_y / 4;
+            let dot_y = fine_y % 4;
+
+            for fx in fx_left..=fx_right {
+                let char_x = fx / 2;
+                let dot_x = fx % 2;
+                patterns[char_y * width + char_x] |= braille_bit(dot_x, dot_y);
+            }
+        }
+
+        for cy in 0..height {
+            for cx in 0..width {
+                let pattern = patterns[cy * width + cx];
+                if pattern != 0 {
+                    let ch = char::from_u32(0x2800 + pattern as u32).unwrap_or(' ');
+                    buf[(area.x + cx as u16, area.y + cy as u16)]
+                        .set_char(ch)
+                        .set_fg(color);
+                }
+            }
+        }
+    });
+}

demos/04.cagire

@@ -0,0 +1 @@
+{"version":1,"banks":[],"tempo":120.0,"playing_patterns":[[0,0]],"prelude":""}

demos/05.cagire

@@ -0,0 +1 @@
+{"version":1,"banks":[],"tempo":120.0,"playing_patterns":[[0,0]],"prelude":""}

demos/06.cagire

@@ -0,0 +1 @@
+{"version":1,"banks":[],"tempo":120.0,"playing_patterns":[[0,0]],"prelude":""}

demos/07.cagire

@@ -0,0 +1 @@
+{"version":1,"banks":[],"tempo":120.0,"playing_patterns":[[0,0]],"prelude":""}

demos/08.cagire

@@ -0,0 +1 @@
+{"version":1,"banks":[],"tempo":120.0,"playing_patterns":[[0,0]],"prelude":""}

demos/09.cagire

@@ -0,0 +1 @@
+{"version":1,"banks":[],"tempo":120.0,"playing_patterns":[[0,0]],"prelude":""}

demos/10.cagire

@@ -0,0 +1 @@
+{"version":1,"banks":[],"tempo":120.0,"playing_patterns":[[0,0]],"prelude":""}

docs/about_forth.md

@@ -1,115 +0,0 @@
-# About Forth
-
-Forth is a _stack-based_ programming language created by Charles H. Moore in the early 1970s. It was designed with simplicity, directness, and interactive exploration in mind. Forth has been used for many years to do scientific work and program embedded systems: it was used to control telescopes and was running on some devices used in space missions among other things. Forth quickly evolved into multiple implementations targetting various computer architectures. None of them really took off and became popular. Nonetheless, the ideas behind Forth continue to garner the interest of many different people in very different (often unrelated) fields. Nowadays, Forth languages are used by hackers and artists for their peculiarity. Forth is simple, direct and beautiful to implement. Forth is an elegant and minimal language to learn. It is easy to understand, to extend and to apply to a specific task. The Forth we use in Cagire is specialized in making live music. We think of it as a DSL: a _Domain Specific Language_. 
-
-## Why Forth?
-
-Most programming languages nowadays use a complex syntax made of `variables`, `expressions` and `statements` like `x = 3 + 4`. Forth works differently. It is way more simple than that, has almost no syntax and performs computations in a quite unique way. You push values onto a `stack` and apply `words` that transform them:
-
-```forth
-3 4 +
-```
-
-This program leaves the number `7` on the stack. There are no variables, no parentheses, no syntax to remember. You just end up with words and numbers separated by spaces. For live coding music, this directness is quite exciting. All you do is think in terms of transformations and add things to the stack: take a note, shift it up, add reverb, play it.
-
-## The Stack
-
-The stack is where values live. When you type a number, it goes on the stack. When you type a word, it usually takes values off and puts new ones back.
-
-```forth
-3       ( stack: 3 )
-4       ( stack: 3 4 )
-+       ( stack: 7 )
-```
-
-The stack is `last-in, first-out`. The most recent value is always on top. This means that its often better to read Forth programs from the end to the beginning: from right to left, from the bottom to the top.
-
-## Words
-
-Everything in Forth is either a `number` or a `word`. Words are like functions but conceptually simpler. They have no arguments or return values in the traditional sense. They just manipulate the stack directly.
-
-```forth
-dup     ( duplicate the top value )
-drop    ( discard the top value )
-swap    ( swap the top two values )
-```
-
-Words compose naturally on the stack. To double a number:
-
-```forth
-3 dup +   ( 3 3 +)
-```
-
-There are a lot of words in a Forth and thus, Cagire has a `Dictionary` embedded directly into the application. You can also create your own words. They will work just like the already existing words. There are good reasons to create new words on-the-fly:
-
-- To make synth definitions.
-- To abstract _some piece of code_ that you use frequently.
-- To share data and processes between different steps.
-
-## Values
-
-Four types of values can live on the stack:
-
-- **Integers**: `42`, `-7`, `0`
-- **Floats**: `0.5`, `3.14`, `-1.0`
-- **Strings**: `"kick"`, `"hello"`
-- **Quotations**: `{ dup + }` (code as data)
-
-Quotations are special. They let you pass code around as a value. This is how conditionals and loops work. Think nothing of it for now, you will learn more about how to use it later on.
-
-## Stack Notation
-
-Documentation uses a notation to show what words do:
-
-```
-( before -- after )
-```
-
-For example, `+` has the signature `( a b -- sum )`. It takes two values and leaves one.
-
-## The Command Register
-
-Traditional Forth programs print text to a terminal. Cagire's Forth builds sound commands instead. This happens through an invisible accumulator called the command register. The command register has two parts:
-- a **sound name** (what instrument to play)
-- a list of **parameters** (how to play it)
-
-Three types of words interact with it:
-
-```forth
-kick sound      ;; sets the sound name
-0.5 gain        ;; adds a parameter
-.               ;; emits the command and clears the register
-```
-
-The word `sound` (or its shorthand `s`) sets what sound to play. Parameter words like `gain`, `freq`, `decay`, or `verb` add key-value pairs to the register. Nothing happens until you emit with `.` (dot). At that moment, the register is packaged into a command and sent to the audio engine.
-
-This design lets you build sounds incrementally:
-
-```forth
-"sine" sound
-c4 note
-0.5 gain
-0.3 decay
-0.4 verb
-.
-```
-
-Each line adds something to the register. The final `.` triggers the sound. You can also write it all on one line:
-
-```forth
-"sine" s c4 note 0.5 gain 0.3 decay 0.4 verb .
-```
-
-The order of parameters does not matter. You can even emit multiple times in a single step. If you need to discard the register without emitting, use `clear`:
-
-```forth
-"kick" s 0.5 gain clear    ;; nothing plays, register is emptied
-"hat" s .                  ;; only the hat plays
-```
-
-This is useful when conditionals might cancel a sound before it emits.
-
-## More details
-
-- Each step has its own stack and independant runtime.
-- Word definitions and variable definitions are shared by all steps.

docs/banks_patterns.md

@@ -1,51 +0,0 @@
-# Banks & Patterns
-
-Cagire organizes all your patterns and data following a strict hierarchy:
-
-- **Projects** contain **Banks**.
-- **Banks** contain **Patterns**.
-- **Patterns** contain **Steps**.
-
-## Structure
-
-```
-Project
-└── 32 Banks
-    └── 32 Patterns (per bank)
-        └── 128 Steps (per pattern)
-```
-
-A single project gives you 32 banks, each holding 32 patterns. You get 1024 patterns in each project, ~131.000 steps.
-
-## Patterns
-
-Each pattern is an independent sequence of steps with its own properties:
-
-| Property | Description | Default |
-|----------|-------------|---------|
-| Length | Steps before the pattern loops (`1`-`128`) | `16` |
-| Speed | Playback rate (`1/8x` to `8x`) | `1x` |
-| Quantization | When the pattern launches | `Bar` |
-| Sync Mode | Reset or Phase-Lock on re-trigger | `Reset` |
-
-Press `e` in the patterns view to edit these settings.
-
-## Patterns View
-
-Access the patterns view with `Ctrl+Up` from the sequencer. The view shows all banks and patterns in a grid. Indicators show pattern state:
-
-- `>` Currently playing
-- `+` Staged to play
-- `-` Staged to stop
-
-### Keybindings
-
-| Key | Action |
-|-----|--------|
-| `Arrows` | Navigate banks and patterns |
-| `Enter` | Select and return to sequencer |
-| `Space` | Toggle pattern playback |
-| `e` | Edit pattern properties |
-| `r` | Rename bank or pattern |
-| `c` / `v` | Copy / Paste |
-| `Delete` | Reset to empty pattern |

docs/editing.md

@@ -1,62 +0,0 @@
-# Editing a Step
-
-Each step in Cagire contains a Forth script. When the sequencer reaches that step, it runs the script to produce sound. This is where you write your music. Press `Enter` when hovering over any step to open the `code editor`. The editor appears as a modal overlay with the step number in the title bar. If the step is a linked step (shown with an arrow like `→05`), pressing `Enter` navigates to the source step instead.
-
-## Writing Scripts
-
-Scripts are written in Forth. Type words and numbers separated by spaces. The simplest script that makes sound is:
-
-```forth
-sine sound .
-```
-
-Add parameters before words to modify them:
-
-```forth
-c4 note 0.75 decay sine sound .
-```
-
-Writing long lines is not recommended because it can become quite unmanageable. Instead, break them into multiple lines for clarity:
-
-```forth
-c4 note
-0.75 decay
-sine sound
-0.4 verb
-.
-```
-
-## Saving
-
-- `Esc` - Save and close the editor
-- `Ctrl+E` - Save without closing
-
-When you save, the script is compiled and sent to the sequencer. If there's an error, a message appears briefly at the bottom of the screen. You will also receive visual feedback in the form of a flashing window when saving / evaluating a script.
-
-## Completion
-
-As you type, the editor suggests matching Forth words. The completion list shows all built-in words that start with your current input. Press `Tab` to insert the selected suggestion, or `Esc` to dismiss the list. Use arrow keys to navigate between suggestions.
-
-Completion helps you discover words without memorizing them all. Type a few letters and browse what's available. For example, typing `ver` will suggest `verb` (reverb), typing `fil` will show filter-related words.
-
-## Debugging
-
-Press `Ctrl+S` to toggle the stack display. This shows the stack state evaluated up to the cursor line, useful for understanding how values flow through your script. Press `Ctrl+R` to execute the script immediately without waiting for the sequencer to reach the step.
-
-## Keybindings
-
-| Key | Action |
-|-----|--------|
-| `Esc` | Save and close |
-| `Ctrl+E` | Save without closing |
-| `Ctrl+R` | Execute script once |
-| `Ctrl+S` | Toggle stack display |
-| `Ctrl+F` | Search |
-| `Ctrl+N` | Find next |
-| `Ctrl+P` | Find previous |
-| `Ctrl+A` | Select all |
-| `Ctrl+C` | Copy |
-| `Ctrl+X` | Cut |
-| `Ctrl+V` | Paste |
-| `Shift+Arrows` | Extend selection |
-| `Tab` | Accept completion |

docs/engine/audio_modulation.md

@@ -0,0 +1,82 @@
+# Audio-Rate Modulation
+
+Any parameter can be modulated continuously using modulation words. Instead of a fixed value, these words produce a modulation string that the engine interprets as a moving signal.
+
+All time values are in **steps**, just like `attack`, `decay`, and `release`. At 120 BPM with speed 1, one step is 0.125 seconds. Writing `4 lfo` means a 4-step period.
+
+## LFOs
+
+Oscillate a parameter between two values.
+
+```forth
+saw s 200 4000 4 lfo lpf .         ( sweep filter over 4 steps )
+saw s 0.3 0.7 2 tlfo pan .         ( triangle pan over 2 steps )
+```
+
+| Word | Shape | Output |
+|------|-------|--------|
+| `lfo` | Sine | `min~max:period` |
+| `tlfo` | Triangle | `min~max:periodt` |
+| `wlfo` | Sawtooth | `min~max:periodw` |
+| `qlfo` | Square | `min~max:periodq` |
+
+Stack effect: `( min max period -- str )`
+
+## Slides
+
+Transition from one value to another over a duration.
+
+```forth
+saw s 0 1 0.5 slide gain .         ( fade in over half a step )
+saw s 200 4000 8 sslide lpf .      ( smooth sweep over 8 steps )
+```
+
+| Word | Curve | Output |
+|------|-------|--------|
+| `slide` | Linear | `start>end:dur` |
+| `expslide` | Exponential | `start>end:dure` |
+| `sslide` | Smooth (S-curve) | `start>end:durs` |
+
+Stack effect: `( start end dur -- str )`
+
+## Random
+
+Randomize a parameter within a range, retriggering at a given period.
+
+```forth
+saw s 200 4000 2 jit lpf .         ( new random value every 2 steps )
+saw s 200 4000 2 sjit lpf .        ( same but smoothly interpolated )
+saw s 200 4000 1 drunk lpf .       ( random walk, each step )
+```
+
+| Word | Behavior | Output |
+|------|----------|--------|
+| `jit` | Sample & hold | `min?max:period` |
+| `sjit` | Smooth interpolation | `min?max:periods` |
+| `drunk` | Random walk | `min?max:periodd` |
+
+Stack effect: `( min max period -- str )`
+
+## Envelopes
+
+Define a multi-segment envelope for a parameter. Provide a start value, then pairs of target and duration.
+
+```forth
+saw s 0 1 0.1 0.7 0.5 0 8 env gain .
+```
+
+This creates: start at `0`, rise to `1` in `0.1` steps, drop to `0.7` in `0.5` steps, fall to `0` in `8` steps.
+
+Stack effect: `( start target1 dur1 [target2 dur2 ...] -- str )`
+
+## Combining
+
+Modulation words return strings, so they compose naturally with the rest of the language. Use them anywhere a parameter value is expected.
+
+```forth
+saw s
+  200 4000 4 lfo lpf
+  0.3 0.7 8 tlfo pan
+  0 1 0.1 0.7 0.5 0 8 env gain
+.
+```

docs/engine/settings.md

@@ -22,7 +22,6 @@ Navigate with arrow keys, adjust values with left/right:
 - **Channels**: number of output channels (2 for stereo).
 - **Buffer Size**: audio buffer in samples (64-4096).
 - **Max Voices**: polyphony limit (1-128, default 32).
-- **Lookahead**: scheduling lookahead in milliseconds (0-50, default 15).
 
 ### Buffer Size
 

docs/forth/about_forth.md

@@ -0,0 +1,111 @@
+# About Forth
+
+Forth is a _stack-based_ programming language created by Charles H. Moore in the early 1970s. It was designed with simplicity, directness, and interactive exploration in mind. Forth has been used for scientific work and embedded systems: it controlled telescopes and even ran on hardware aboard space missions. It evolved into many implementations targeting various architectures, but none of them really caught on. Nonetheless, the ideas behind Forth continue to attract people from very different, often unrelated fields. Today, Forth languages are used by hackers and artists for their unconventional nature. Forth is simple, direct, and beautiful to implement. Forth is an elegant, minimal language, easy to understand, extend, and tailor to a specific task. The Forth we use in Cagire is specialized in making live music. It is used as a DSL: a _Domain Specific Language_. 
+
+## Why Forth?
+
+Most programming languages rely on a complex syntax of `variables`, `expressions` and `statements` like `x = 3 + 4` or `do_something(()=>bob(4))`. Forth works differently. It has almost no syntax at all. Instead, you push values onto a `stack` and apply `words` that transform them:
+
+```forth
+3 4 +
+```
+
+The program above leaves the number `7` on the stack. There are no variables, no parentheses, no syntax to remember. You just end up with words and numbers separated by spaces. For live coding music, this directness is quite exciting. All you do is think in terms of transformations and add things to the stack: take a note, shift it up, add reverb, play it.
+
+## The Stack
+
+The stack is where values live. When you type a number, it goes on the stack. When you type a word, it usually takes values off and puts new ones back.
+
+```forth
+3 ;; stack: 3
+4 ;; stack: 3 4
++ ;; stack: 7
+```
+
+The stack is `last-in, first-out`. The most recent value is always on top. This means that it's often better to read Forth programs from right to left, bottom to top.
+
+## Words
+
+Everything in Forth is either a `number` or a `word`. Words are like functions but conceptually simpler. They have no arguments or return values in the traditional sense. They just manipulate the stack directly.
+
+```forth
+dup ;; duplicate the top value
+drop ;; discard the top value
+swap ;; swap the top two values
+```
+
+Words compose naturally on the stack. To double a number:
+
+```forth
+;; 3 3 +
+3 dup + 
+```
+
+Forth has a large vocabulary, so Cagire includes a `Dictionary` directly in the application. You can also create your own words. They will work just like existing words. The only difference is that these words will not be included in the dictionary. There are good reasons to create new words on-the-fly:
+
+- To make synth definitions.
+- To abstract _some piece of code_ that you use frequently.
+- To share data and processes between different steps.
+
+## Values
+
+Four basic types of values can live on the stack:
+
+- **Integers**: `42`, `-7`, `0`
+- **Floats**: `0.5`, `3.14`, `-1.0`
+- **Strings**: `"kick"`, `"hello"`
+- **Quotations**: `{ dup + }` (code as data)
+
+Floats can omit the leading zero: `.25` is the same as `0.25`, and `-.5` is `-0.5`.
+
+Parentheses are ignored by the parser. You can use them freely for visual grouping without affecting execution:
+
+```forth
+(c4 note) (0.5 gain) "sine" s .
+```
+
+Quotations are special. They let you pass code around as a value. This is how conditionals and loops work. Don't worry about them for now — you'll learn how to use them later.
+
+Any word that is not recognized as a built-in or a user definition becomes a string on the stack. This means `kick s` and `"kick" s` are equivalent. You only need quotes when the string contains spaces or when it conflicts with an existing word name.
+
+## The Command Register
+
+Traditional Forth programs print text to a terminal. Cagire's Forth builds sound commands instead. This happens through an internal accumulator called the command register. The command register has two parts:
+- a **sound name** (what instrument to play)
+- a list of **parameters** (how to play it)
+
+Three kinds of words interact with it:
+
+```forth
+kick sound      ;; sets the sound name
+0.5 gain        ;; adds a parameter
+.               ;; emits the command and clears the register
+```
+
+The word `sound` (or its shorthand `s`) sets what sound to play. Parameter words like `gain`, `freq`, `decay`, or `verb` add key-value pairs to the register. Nothing happens until you emit with `.` (dot). At that moment, the register is packaged into a command and sent to the audio engine.
+
+This design lets you build sounds incrementally:
+
+```forth
+"sine" sound
+c4 note
+0.5 gain
+0.3 decay
+0.4 verb
+.
+```
+
+Each line adds something to the register. The final `.` triggers the sound. You can also write it all on one line:
+
+```forth
+"sine" s c4 note 0.5 gain 0.3 decay 0.4 verb .
+```
+
+The order of parameters does not matter. You can even emit multiple times in a single step. If you need to discard the register without emitting, use `clear`:
+
+```forth
+"kick" s 0.5 gain clear    ;; nothing plays, register is emptied
+"hat" s .                  ;; only the hat plays
+```
+
+This is useful when conditionals might cancel a sound before it emits.

docs/forth/control_flow.md

@@ -0,0 +1,140 @@
+# Control Flow
+
+Sometimes a step should behave differently depending on context — a coin flip, a fill, which iteration of the pattern is playing. Control flow words let you branch, choose, and repeat inside a step's script. Control structures are essential for programming and allow you to create complex and dynamic patterns.
+
+## if / else / then
+
+The simplest branch. Push a condition, then `if`:
+
+```forth
+coin if 0.8 gain then
+saw s c4 note .
+```
+
+The gain is applied if the coin flip is true. The sound will always plays. Add `else` for a two-way split:
+
+```forth
+coin if
+  c4 note
+else
+  c3 note
+then
+saw s 0.6 gain .
+```
+
+These are compiled directly into branch instructions. For that reason, these words will not appear in the dictionary.
+
+## ? and !?
+
+When you already have a quotation, `?` executes it if the condition is truthy:
+
+```forth
+{ 0.4 verb } coin ?
+saw s c4 note 0.5 gain .    ;; reverb on half the hits
+```
+
+`!?` is the opposite — executes when falsy:
+
+```forth
+{ 0.2 gain } coin !?
+saw s c4 note .              ;; quiet on half the hits
+```
+
+These pair well with `chance`, `prob`, and the other probability words:
+
+```forth
+{ 0.5 verb } 0.3 chance ?      ;; occasional reverb wash
+{ 12 + } fill ?                 ;; octave up during fills
+```
+
+## ifelse
+
+Two quotations, one condition. The true branch comes first:
+
+```forth
+{ c3 note } { c4 note } coin ifelse
+saw s 0.6 gain .                ;; bass or lead, coin flip
+```
+
+Reads naturally: "c3 or c4, depending on the coin."
+
+```forth
+{ 0.8 gain } { 0.3 gain } fill ifelse
+tri s c4 note 0.2 decay .      ;; loud during fills, quiet otherwise
+```
+
+## pick
+
+Choose the nth option from a list of quotations:
+
+```forth
+{ c4 } { e4 } { g4 } { b4 } iter 4 mod pick
+note sine s 0.5 decay .
+```
+
+Four notes cycling through a major seventh chord, one per pattern iteration. The index is 0-based.
+
+## apply
+
+When you have a quotation and want to execute it unconditionally, use `apply`:
+
+```forth
+{ dup + } apply    ;; doubles the top value
+```
+
+This is simpler than `?` when there is no condition to check. It pops the quotation and runs it.
+
+## case / of / endof / endcase
+
+For matching a value against several options. Cleaner than a chain of `if`s when you have more than two branches:
+
+```forth
+iter 4 mod case
+  0 of c3 note endof
+  1 of e3 note endof
+  2 of g3 note endof
+  3 of a3 note endof
+endcase
+saw s 0.6 gain 800 lpf .
+```
+
+A different root note each time the pattern loops.
+
+The last line before `endcase` is the default — it runs when no `of` matched:
+
+```forth
+iter 3 mod case
+  0 of 0.9 gain endof
+  0.4 gain              ;; default: quieter
+endcase
+saw s c4 note .
+```
+
+## times
+
+Repeat a quotation n times. The variable `@i` is automatically set to the current iteration index (starting from 0):
+
+```forth
+3 { c4 @i 4 * + note } times
+sine s 0.4 gain 0.5 verb .      ;; c4, e4, g#4 — a chord
+```
+
+Subdivide with `at`:
+
+```forth
+4 { @i 4 / at sine s c4 note 0.3 gain . } times
+```
+
+Four evenly spaced notes within the step.
+
+Vary intensity per iteration:
+
+```forth
+8 {
+  @i 8 / at
+  @i 4 mod 0 = if 0.7 else 0.2 then gain
+  tri s c5 note 0.1 decay .
+} times
+```
+
+Eight notes per step. Every fourth one louder.

docs/forth/definitions.md

@@ -58,6 +58,19 @@ You can even redefine numbers:
 
 Now `2` pushes `4` onto the stack. The number two no longer exists in your session. This is a classic Forth demonstration: nothing is sacred, everything can be redefined. 
 
+## Removing Words
+
+`forget` removes a user-defined word from the dictionary:
+
+```forth
+: double dup + ;
+3 double           ;; 6
+"double" forget
+3 double           ;; error: unknown word
+```
+
+This only affects words you defined with `:` ... `;`. Built-in words cannot be forgotten.
+
 ## Practical Uses
 
 **Synth definitions** save you from repeating sound design:

docs/forth/dictionary.md

@@ -14,7 +14,7 @@ The dictionary shows every available word organized by category:
 - **Context**: Sequencer state like `step`, `beat`, `tempo`.
 - And many more...
 
-This tutorial will not teach you how to use all words. The syntax is very uniform and you can quickly learn a new word when necessary. We encourage you to explore as you play, this is the best way to learn. The tutorial will remain focused on various topics that require you to apply knowledge to a given task or specific context.
+This documentation will not teach you how to use all words. It would be counterproductive to do so and it would defeat the purpose of having a dictionary. The syntax is very uniform and you can quickly learn a new word when necessary. We encourage you to explore as you play, this is the best way to learn. The tutorial will remain focused on various topics that require you to apply knowledge to a given task or specific context.
 
 ## Navigation
 
@@ -33,6 +33,4 @@ Each word entry shows:
 - **Description**: What the word does
 - **Example**: How to use it
 
-Press `/` to search across all words. The search matches word names, aliases, and descriptions. Press `Esc` to clear and return to browsing.
-
-Use the dictionary while writing scripts to check stack effects and study their behavior. Some words also come with shorter aliases (e.g., `sound` → `s`). You will learn aliases quite naturally, because aliases are usually reserved for very common words.
+Press `/` to search across all words. The search matches word names, aliases, and descriptions. Press `Esc` to clear and return to browsing. Use the dictionary while writing scripts to check stack effects and study their behavior. Some words also come with shorter aliases (e.g., `sound` → `s`). You will learn aliases quite naturally, because aliases are usually reserved for very common words.

docs/forth/oddities.md

@@ -1,4 +1,4 @@
-# Oddities
+# Cagire's Forth VS Classic Forth
 
 Cagire's Forth is not a classic Forth. It borrows the core ideas (stack-based evaluation, postfix notation, word definitions) but adds modern features and domain-specific extensions. If you know traditional Forth, here are the differences.
 
@@ -89,9 +89,10 @@ Cagire uses prefix syntax:
 ```forth
 10 !x    ;; store 10 in x
 @x       ;; fetch x (returns 0 if undefined)
+10 ,x    ;; store 10 in x, keep on stack
 ```
 
-No declaration needed. Variables spring into existence when you store to them.
+No declaration needed. Variables spring into existence when you store to them. `,x` stores and keeps the value on the stack.
 
 ## Floating Point
 
@@ -175,6 +176,20 @@ Classic Forth is deterministic. Cagire has built-in randomness:
 
 These words take a quotation and execute it probabilistically.
 
+## Periodic Execution
+
+Execute a quotation on specific iterations:
+
+```forth
+{ "snare" s . } 4 every        ;; every 4th pattern iteration
+{ "hat" s . } 3 8 bjork        ;; Euclidean: 3 hits across 8 step runs
+{ "hat" s . } 5 8 pbjork       ;; Euclidean: 5 hits across 8 pattern iterations
+```
+
+`every` checks the pattern iteration count. On iteration 0, 4, 8, 12... the quotation runs. On all other iterations it is skipped.
+
+`bjork` and `pbjork` use Bjorklund's algorithm to distribute k hits as evenly as possible across n positions. `bjork` counts by step runs, `pbjork` counts by pattern iterations. Classic Euclidean rhythms: tresillo (3,8), cinquillo (5,8), son clave (5,16).
+
 ## Cycling
 
 Cagire has built-in support for cycling through values. Push values onto the stack, then select one based on pattern state:
@@ -193,21 +208,42 @@ You can also use quotations if you need to execute code:
 
 When the selected value is a quotation, it gets executed. When it is a plain value, it gets pushed onto the stack.
 
-Three cycling words exist:
+Two cycling words exist:
 
 - `cycle` - selects based on `runs` (how many times this step has played)
 - `pcycle` - selects based on `iter` (how many times the pattern has looped)
-- `tcycle` - creates a cycle list that resolves at emit time
 
 The difference between `cycle` and `pcycle` matters when patterns have different lengths. `cycle` counts per-step, `pcycle` counts per-pattern.
 
-`tcycle` is special. It does not select immediately. Instead it creates a value that cycles when emitted:
+## Polyphonic Parameters
+
+Parameter words like `note`, `freq`, and `gain` consume the entire stack. If you push multiple values before a param word, you get polyphony:
 
 ```forth
-0.3 0.5 0.7 3 tcycle gain
+60 64 67 note sine s .    ;; emits 3 voices with notes 60, 64, 67
 ```
 
-If you emit multiple times in one step (using `at`), each emit gets the next value from the cycle.
+This works for any param and for the sound word itself:
+
+```forth
+440 880 freq sine tri s .    ;; 2 voices: sine at 440, tri at 880
+```
+
+When params have different lengths, shorter lists cycle:
+
+```forth
+60 64 67 note           ;; 3 notes
+0.5 1.0 gain            ;; 2 gains (cycles: 0.5, 1.0, 0.5)
+sine s .                ;; emits 3 voices
+```
+
+Polyphony multiplies with `at` deltas:
+
+```forth
+0 0.5 at                ;; 2 time points
+60 64 note              ;; 2 notes
+sine s .                ;; emits 4 voices (2 notes × 2 times)
+```
 
 ## Summary
 

docs/forth/prelude.md

@@ -0,0 +1,78 @@
+# The Prelude
+
+You can define words in any step and they become available to all other steps. But as a project grows, definitions get scattered across steps and become hard to find and maintain. The **prelude** is a dedicated place for this. It is a project-wide Forth script that runs once before the first step plays. Definitions, variables, settings — everything in one place. Press `d` to open the prelude editor. Press `Esc` to save and close. Press `D` (Shift+d) to re-evaluate it without opening the editor.
+
+## Naming Your Sounds
+
+The most common use of the prelude is to define words for your instruments. Without a prelude, every step that plays a bass has to spell out the full sound design or to create a new word before using it:
+
+```forth
+pulse sound 0.8 gain 400 lpf 1 lpd 8 lpe 0.6 width .
+```
+
+Repeat this across eight steps without making a new word and you have eight copies of the same thing. Change the filter? Change it eight times.
+
+In the prelude, define it once:
+
+```forth
+: bass pulse sound 0.8 gain 400 lpf 1 lpd 8 lpe 0.6 width . ;
+```
+
+Now every step just writes `c2 note bass`. Change the sound in one place, every step follows.
+
+A step that used to read:
+
+```forth
+pulse sound c2 note 0.8 gain 400 lpf 1 lpd 8 lpe 0.6 width .
+```
+
+Becomes:
+
+```forth
+c2 note bass
+```
+
+## Building a Vocabulary
+
+The prelude is where you build the vocabulary for your music. Not just instruments but any combination of code / words you want to reuse:
+
+```forth
+;; instruments
+: bass pulse sound 0.8 gain 400 lpf 1 lpd 8 lpe 0.6 width . ;
+: pad sine sound 0.5 gain 2 spread 1.5 attack 0.4 verb . ;
+: lead tri sound 0.6 gain 5000 lpf 2 decay . ;
+
+;; musical helpers
+: octup 12 + ;
+: octdn 12 - ;
+: quiet 0.3 gain ;
+: loud 0.9 gain ;
+```
+
+By using the prelude and predefined words, steps become expressive and short. The prelude carries the design decisions; steps carry the composition.
+
+## Setting Initial State
+
+The prelude also runs plain Forth, not just definitions. You can use it to set variables and seed the random generator:
+
+```forth
+c2 !root
+0 !mode
+42 seed
+```
+
+Every step can then read `@root` and `@mode`. And `42 seed` makes randomness reproducible — same seed, same sequence every time you hit play.
+
+## When It Runs
+
+The prelude evaluates at three moments:
+
+1. When you press **Space** to start playback
+2. When you **load** a project
+3. When you press **D** manually
+
+It runs once at these moments, not on every step. This makes it the right place for definitions and initial values. If you edit the prelude while playing, press `D` to push changes into the running session. New definitions take effect immediately; the next time a step runs, it sees the updated words.
+
+## What Not to Put Here
+
+The prelude has no access to sequencer state. Words like `step`, `beat`, `iter`, and `phase` are meaningless here because no step is playing yet. Use the prelude for definitions and setup, not for logic that depends on timing. The prelude also should not emit sounds. It runs silently — any `.` calls here would fire before the sequencer clock is running and produce nothing useful.

docs/forth/stack.md

@@ -1,6 +1,6 @@
 # The Stack
 
-The stack is the heart of Forth. Every value you type goes onto the stack. Every word you call takes values from the stack and puts results back. There are no variables in the traditional sense, just this pile of values that grows and shrinks as your program runs.
+In most languages, you store values in variables and pass them to functions. Forth has a single shared workspace instead: the stack. You put values on it, words take them off and put results back. Everything flows through the stack. There is no assignment, no named arguments — just a sequence of values waiting to be consumed. Learning to think in terms of the stack is the one skill that makes everything else in Forth click.
 
 ## Pushing Values
 
@@ -49,7 +49,7 @@ The key to Forth is learning to visualize the stack as you write. Consider this
 | `2` | `7 2` | Push 2 |
 | `*` | `14` | Multiply |
 
-This computes `(3 + 4) * 2`. The parentheses are implicit in the order of operations. You can use line breaks and white spaces to keep organized, and the editor will also show the stack at each step for you if you ask it nicely :)
+This computes `(3 + 4) * 2`. The parentheses are implicit in the order of operations. You can use line breaks and whitespace to keep organized, and the editor can show the stack state as you type — press `Ctrl+S` to toggle it.
 
 ## Rearranging Values
 
@@ -86,7 +86,7 @@ Two things can go wrong with the stack:
 
 The fix is simple: make sure you push enough values before calling a word. Check the stack effect in the dictionary if you are unsure.
 
-* **Stack overflow** is the opposite: too many values left on the stack. This is less critical but indicates sloppy code. If your script leaves unused values behind, you probably made a mistake somewhere.
+* **Leftover values** are the opposite problem: values remain on the stack after your script finishes. This is less critical but indicates sloppy code. If your script leaves unused values behind, you probably made a mistake somewhere.
 
 ```forth
 3 4 5 + .    ;; plays a sound, but 3 is still on the stack

docs/getting-started/banks_patterns.md

@@ -0,0 +1,65 @@
+# Banks & Patterns
+
+Cagire organizes all your patterns and data following a strict hierarchy:
+
+- **Projects** contain **Banks**.
+- **Banks** contain **Patterns**.
+- **Patterns** contain **Steps**.
+
+## Structure
+
+```
+Project
+└── 32 Banks
+    └── 32 Patterns (per bank)
+        └── 1024 Steps (per pattern)
+```
+
+A single project gives you 32 banks, each holding 32 patterns. You get 1024 patterns in each project, ~1.048.000 steps. This means that you can create a staggering amount of things. Don't hesitate to create copies, variations, and explore the pattern system thoroughly.
+
+## Patterns
+
+Each pattern is an independent sequence of steps with its own properties:
+
+| Property | Description | Default |
+|----------|-------------|---------|
+| Length | Steps before the pattern loops (`1`-`1024`) | `16` |
+| Speed | Playback rate (`1/8x` to `8x`) | `1x` |
+| Quantization | When the pattern launches | `Bar` |
+| Sync Mode | Reset or Phase-Lock on re-trigger | `Reset` |
+| Follow Up | What happens when the pattern finishes an iteration | `Loop` |
+
+Press `e` in the patterns view to edit these settings.
+
+### Follow Up
+
+The follow-up action determines what happens when a pattern reaches the end of its steps:
+
+- **Loop** — the pattern repeats indefinitely. This is the default behavior.
+- **Stop** — the pattern plays once and stops.
+- **Chain** — the pattern plays once, then starts another pattern. Use `Left`/`Right` to set the target bank and pattern in the edit view.
+
+## Patterns View
+
+Access the patterns view with `F2` (or `Ctrl+Up` from the sequencer). The view shows all banks and patterns in a grid. Indicators show pattern state:
+
+- `>` Currently playing
+- `+` Staged to play
+- `-` Staged to stop
+- `M` Muted
+- `S` Soloed
+
+### Keybindings
+
+| Key | Action |
+|-----|--------|
+| `Arrows` | Navigate banks and patterns |
+| `Enter` | Select and return to sequencer |
+| `p` | Stage pattern to play/stop |
+| `c` | Commit staged changes |
+| `m` / `x` | Stage mute / solo toggle |
+| `e` | Edit pattern properties |
+| `r` | Rename bank or pattern |
+| `Ctrl+c` / `Ctrl+v` | Copy / Paste |
+| `Delete` | Reset to empty pattern |
+| `Esc` | Cancel staged changes |