Smoother init phase and dynamic instrument change (config saved to disk)

README.md

@@ -14,7 +14,9 @@ tags:
 
 ## Overview
 
-Theremini turns Reachy Mini into a music instrument. The robot's head roll sets the pitch, head vertical translation maps to the amplitude, and the right antenna selects the current instrument (FluidSynth GM programs). The runtime now exposes a lightweight dashboard at `http://localhost:8095/index.html` (theremin's `custom_app_url`) so you can monitor pitch, amplitude, pose ranges, and instrument slots without keeping a terminal HUD visible.
+Theremini turns Reachy Mini into a music instrument. The robot's head roll sets the pitch, head vertical translation maps to the amplitude, and the right antenna selects the current instrument (FluidSynth GM programs). The runtime now exposes a lightweight dashboard at `http://localhost:8095/index.html` (theremin's `custom_app_url`) so you can monitor pitch, amplitude, pose ranges, and curate the instrument rotation without keeping a terminal HUD visible.
+
+When the app starts, Reachy performs a short guided motion (center the head, oscillate the roll, sweep the antenna) so musicians immediately hear how gestures map to sound before the motors are relaxed.
 
 ## Controls
 
@@ -23,3 +25,9 @@ Theremini turns Reachy Mini into a music instrument. The robot's head roll sets
 | Head roll          | -60° … +60°               | MIDI notes 48–84   |
 | Head Z translation | -30 mm … +5 mm            | Amplitude 0–100 %  |
 | Right antenna      | -π/3 … +π/3 radians       | Instrument program |
+
+## Dashboard controls
+
+- The top HUD mirrors the old terminal bars for note/pitch/amplitude, but now in the browser.
+- The “Program slots” grid refreshes live to show the currently active instrument order.
+- The “Live instrument set” card lets you search the full FluidSynth GM bank and build up to eight presets (order defines how the antenna scrolls). Changes are saved via the same `/api/config` endpoint the web UI hits, so advanced users can script their own configs too.

Theremini/config.json

@@ -0,0 +1,6 @@
+{
+  "active_instruments": [
+    "accordion",
+    "acoustic_bass"
+  ]
+}

Theremini/config.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import json
+import threading
+from pathlib import Path
+from typing import List
+
+# Complete FluidSynth GM preset names copied from simple_theremini script
+ALL_INSTRUMENTS: List[str] = [
+    "piano_1",
+    "piano_2",
+    "piano_3",
+    "honky_tonk",
+    "e_piano_1",
+    "e_piano_2",
+    "harpsichord",
+    "clavinet",
+    "celesta",
+    "glockenspiel",
+    "music_box",
+    "vibraphone",
+    "marimba",
+    "xylophone",
+    "tubular_bells",
+    "dulcimer",
+    "organ_1",
+    "organ_2",
+    "organ_3",
+    "reed_organ",
+    "accordion",
+    "harmonica",
+    "bandoneon",
+    "nylon_guitar",
+    "steel_guitar",
+    "jazz_guitar",
+    "clean_guitar",
+    "muted_guitar",
+    "overdrive_guitar",
+    "distortion_guitar",
+    "guitar_harmonics",
+    "acoustic_bass",
+    "fingered_bass",
+    "picked_bass",
+    "fretless_bass",
+    "slap_bass_1",
+    "slap_bass_2",
+    "synth_bass_1",
+    "synth_bass_2",
+    "violin",
+    "viola",
+    "cello",
+    "contrabass",
+    "tremolo_strings",
+    "pizzicato_strings",
+    "harp",
+    "timpani",
+    "string_ensemble_1",
+    "string_ensemble_2",
+    "synth_strings_1",
+    "synth_strings_2",
+    "choir_aahs",
+    "voice_oohs",
+    "synth_voice",
+    "orchestra_hit",
+    "trumpet",
+    "trombone",
+    "tuba",
+    "muted_trumpet",
+    "french_horn",
+    "brass_section",
+    "synth_brass_1",
+    "synth_brass_2",
+    "soprano_sax",
+    "alto_sax",
+    "tenor_sax",
+    "baritone_sax",
+    "oboe",
+    "english_horn",
+    "bassoon",
+    "clarinet",
+    "piccolo",
+    "flute",
+    "recorder",
+    "pan_flute",
+    "blown_bottle",
+    "shakuhachi",
+    "whistle",
+    "ocarina",
+    "square_wave",
+    "saw_wave",
+    "synth_calliope",
+    "chiffer_lead",
+    "charang",
+    "solo_voice",
+    "fifth_saw",
+    "bass_lead",
+    "fantasia",
+    "warm_pad",
+    "polysynth",
+    "space_voice",
+    "bowed_glass",
+    "metal_pad",
+    "halo_pad",
+    "sweep_pad",
+    "ice_rain",
+    "soundtrack",
+    "crystal",
+    "atmosphere",
+    "brightness",
+    "goblin",
+    "echo_drops",
+    "star_theme",
+    "sitar",
+    "banjo",
+    "shamisen",
+    "koto",
+    "kalimba",
+    "bagpipe",
+    "fiddle",
+    "shanai",
+    "tinker_bell",
+    "agogo",
+    "steel_drum",
+    "wood_block",
+    "taiko_drum",
+    "melodic_tom",
+    "synth_drum",
+    "reverse_cymbal",
+    "guitar_fret_noise",
+    "breath_noise",
+    "seashore",
+    "bird_tweet",
+    "telephone_ring",
+    "helicopter",
+    "applause",
+    "gunshot",
+    "coupled_harpsichord",
+]
+
+DEFAULT_ACTIVE = [
+    "choir_aahs",
+    "orchestra_hit",
+    "taiko_drum",
+    "trumpet",
+    "french_horn",
+    "soundtrack",
+]
+
+MAX_ACTIVE = 8
+
+CONFIG_PATH = Path(__file__).resolve().parent / "config.json"
+
+_config_lock = threading.Lock()
+_active_instruments: List[str] = DEFAULT_ACTIVE.copy()
+
+
+def _persist_active_instruments() -> None:
+    data = {"active_instruments": _active_instruments}
+    try:
+        CONFIG_PATH.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    except OSError:
+        # Could not persist; keep running with in-memory config.
+        pass
+
+
+def _load_initial_config() -> None:
+    global _active_instruments
+    if not CONFIG_PATH.exists():
+        _persist_active_instruments()
+        return
+
+    try:
+        raw = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        _persist_active_instruments()
+        return
+
+    if isinstance(raw, dict):
+        items = raw.get("active_instruments")
+        if isinstance(items, list):
+            cleaned = _clean_instrument_list(items)
+            if cleaned:
+                _active_instruments = cleaned
+                return
+    _persist_active_instruments()
+
+
+def _clean_instrument_list(items: List[str]) -> List[str]:
+    seen = set()
+    cleaned: List[str] = []
+    for name in items:
+        if not isinstance(name, str):
+            continue
+        low = name.strip()
+        if not low or low not in ALL_INSTRUMENTS or low in seen:
+            continue
+        seen.add(low)
+        cleaned.append(low)
+        if len(cleaned) >= MAX_ACTIVE:
+            break
+    return cleaned or DEFAULT_ACTIVE.copy()
+
+
+def get_active_instruments() -> List[str]:
+    with _config_lock:
+        return list(_active_instruments)
+
+
+def set_active_instruments(new_items: List[str]) -> List[str]:
+    cleaned = _clean_instrument_list(new_items)
+    with _config_lock:
+        global _active_instruments
+        _active_instruments = cleaned
+        _persist_active_instruments()
+        return list(_active_instruments)
+
+
+def get_available_instruments() -> List[str]:
+    return list(ALL_INSTRUMENTS)
+
+
+_load_initial_config()
+
+__all__ = [
+    "get_active_instruments",
+    "set_active_instruments",
+    "get_available_instruments",
+    "ALL_INSTRUMENTS",
+    "DEFAULT_ACTIVE",
+    "CONFIG_PATH",
+    "MAX_ACTIVE",
+]

Theremini/dashboard.py

@@ -8,6 +8,12 @@ import time
 from pathlib import Path
 from typing import Any, Dict
 
+from .config import (
+    get_active_instruments,
+    get_available_instruments,
+    set_active_instruments,
+)
+
 DASHBOARD_PORT = 8095
 
 _status_lock = threading.Lock()
@@ -61,7 +67,7 @@ class DashboardHandler(http.server.SimpleHTTPRequestHandler):
     def do_OPTIONS(self):
         self.send_response(204)
         self.send_header("Access-Control-Allow-Origin", "*")
-        self.send_header("Access-Control-Allow-Methods", "GET, OPTIONS")
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
         self.send_header("Access-Control-Allow-Headers", "Content-Type")
         self.end_headers()
 
@@ -69,8 +75,43 @@ class DashboardHandler(http.server.SimpleHTTPRequestHandler):
         if self.path == "/api/status":
             self._send_json({"ok": True, "status": get_status()})
             return
+        if self.path == "/api/config":
+            self._send_json(
+                {
+                    "ok": True,
+                    "active_instruments": get_active_instruments(),
+                    "available_instruments": get_available_instruments(),
+                }
+            )
+            return
         return super().do_GET()
 
+    def do_POST(self):
+        if self.path == "/api/config":
+            self._handle_config_post()
+            return
+        self.send_error(404)
+
+    def _handle_config_post(self) -> None:
+        try:
+            length = int(self.headers.get("Content-Length", "0"))
+            payload = json.loads(self.rfile.read(length).decode("utf-8"))
+        except Exception:
+            self._send_json({"ok": False, "error": "invalid-json"}, status=400)
+            return
+
+        if not isinstance(payload, dict) or "active_instruments" not in payload:
+            self._send_json({"ok": False, "error": "invalid-payload"}, status=400)
+            return
+
+        incoming = payload["active_instruments"]
+        if not isinstance(incoming, list):
+            self._send_json({"ok": False, "error": "invalid-payload"}, status=400)
+            return
+
+        updated = set_active_instruments(incoming)
+        self._send_json({"ok": True, "active_instruments": updated})
+
 
 class DashboardServer:
     def __init__(self, host: str = "0.0.0.0", port: int = DASHBOARD_PORT) -> None:

Theremini/main.py

@@ -8,9 +8,11 @@ import time
 from typing import Any
 
 from reachy_mini import ReachyMini, ReachyMiniApp
+from reachy_mini.utils import create_head_pose
 from scamp import Session
 from scipy.spatial.transform import Rotation as R
 
+from .config import get_active_instruments
 from .dashboard import DASHBOARD_PORT, DashboardServer, set_status
 
 # ────────────────── mapping constants ───────────────────────────────
@@ -21,15 +23,6 @@ AMP_RANGE = (0.0, 1.0)  # mute…full
 RIGHT_ANT_RANGE = (-math.pi / 3, math.pi / 3)  # raw radians → program index
 
 # ────────────────── available instruments (subset of GM bank) ──────
-AVAILABLE_PARTS = [
-    "choir_aahs",
-    "orchestra_hit",
-    "taiko_drum",
-    "trumpet",
-    "french_horn",
-    "soundtrack",
-]
-
 NOTE_NAMES = ["C", "C♯", "D", "D♯", "E", "F", "F♯", "G", "G♯", "A", "A♯", "B"]
 
 
@@ -60,19 +53,20 @@ class Theremini(ReachyMiniApp):
     def __init__(self) -> None:
         super().__init__()
         self._session = Session(max_threads=1024)
-        self._parts_cache: dict[int, Any] = {}
+        self._parts_cache: dict[str, Any] = {}
+        self._active_parts = get_active_instruments()
         self._theremin = self._get_part_for_prog(0)
         self._note_handle: Any | None = None
         self._current_pitch: int | None = None
         self._current_prog: int | None = None
 
     def _get_part_for_prog(self, prog: int):
-        if prog not in self._parts_cache:
+        name = self._active_parts[prog]
+        if name not in self._parts_cache:
             buf = io.StringIO()
             with contextlib.redirect_stdout(buf):
-                name = AVAILABLE_PARTS[prog]
-                self._parts_cache[prog] = self._session.new_part(name)
-        return self._parts_cache[prog]
+                self._parts_cache[name] = self._session.new_part(name)
+        return self._parts_cache[name]
 
     def _stop_note(self) -> None:
         if self._note_handle:
@@ -82,58 +76,20 @@ class Theremini(ReachyMiniApp):
 
     def run(self, reachy_mini: ReachyMini, stop_event: threading.Event) -> None:
         print("Roll → Pitch\nZ → Volume\nRight antenna → Instrument\n")
-        reachy_mini.disable_motors()
 
         dashboard_server = DashboardServer(port=DASHBOARD_PORT)
         dashboard_server.start()
         set_status(self._build_status_payload(0.0, 0.0, 0.0, 0.0, None, None, False))
 
+        reachy_mini.enable_motors()
         try:
-            while not stop_event.is_set():
-                _, antennas = reachy_mini.get_current_joint_positions()
-                pose = reachy_mini.get_current_head_pose()
-
-                trans_mm = pose[:3, 3] * 1_000
-                roll_deg = math.degrees(R.from_matrix(pose[:3, :3]).as_euler("xyz")[0])
-
-                target_pitch = int(round(_aff(roll_deg, *ROLL_DEG_RANGE, *NOTE_MIDI_RANGE)))
-                amp = max(0.0, min(_aff(trans_mm[2], *Z_MM_RANGE, *AMP_RANGE), 1.0))
-                prog = int(
-                    _aff(antennas[1], *RIGHT_ANT_RANGE, 0, len(AVAILABLE_PARTS) - 0.0001)
-                )
-
-                if prog != self._current_prog:
-                    self._stop_note()
-                    self._theremin = self._get_part_for_prog(prog)
-                    self._current_prog = prog
-
-                if amp == 0.0:
-                    self._stop_note()
-                else:
-                    if self._note_handle is None:
-                        self._note_handle = self._theremin.start_note(
-                            target_pitch, int(amp * 100)
-                        )
-                        self._current_pitch = target_pitch
-                    elif target_pitch != self._current_pitch:
-                        self._stop_note()
-                        self._note_handle = self._theremin.start_note(
-                            target_pitch, int(amp * 100)
-                        )
-                        self._current_pitch = target_pitch
-                    else:
-                        _send_cc(self._theremin, 11, int(amp * 127))
-
-                self._publish_status(
-                    roll_deg=roll_deg,
-                    head_z=trans_mm[2],
-                    amp=amp,
-                    right_ant=antennas[1],
-                    prog=self._current_prog,
-                    pitch=target_pitch,
-                    playing=bool(self._note_handle),
-                )
+            self._perform_intro_demo(reachy_mini, stop_event)
+        finally:
+            reachy_mini.disable_motors()
 
+        try:
+            while not stop_event.is_set():
+                self._tick_from_robot(reachy_mini)
                 time.sleep(0.02)
         finally:
             self._stop_note()
@@ -151,7 +107,7 @@ class Theremini(ReachyMiniApp):
         pitch: int | None,
         playing: bool,
     ) -> dict[str, object]:
-        inst_name = AVAILABLE_PARTS[prog] if prog is not None else "--"
+        inst_name = self._active_parts[prog] if prog is not None else "--"
         note_name = midi_to_name(pitch) if pitch is not None else "--"
         return {
             "instrument_index": prog,
@@ -186,6 +142,209 @@ class Theremini(ReachyMiniApp):
         )
         set_status(payload)
 
+    def _ensure_active_parts_fresh(self) -> None:
+        latest = get_active_instruments()
+        if latest != self._active_parts:
+            previous_name = None
+            if self._current_prog is not None and self._current_prog < len(self._active_parts):
+                previous_name = self._active_parts[self._current_prog]
+
+            self._active_parts = latest
+
+            if previous_name and previous_name in self._active_parts:
+                self._current_prog = self._active_parts.index(previous_name)
+                self._theremin = self._get_part_for_prog(self._current_prog)
+            else:
+                self._current_prog = None
+                self._theremin = self._get_part_for_prog(0)
+
+    def _handle_sound_state(self, target_pitch: int, amp: float, prog: int) -> None:
+        if prog != self._current_prog:
+            self._stop_note()
+            self._theremin = self._get_part_for_prog(prog)
+            self._current_prog = prog
+
+        if amp == 0.0:
+            self._stop_note()
+            return
+
+        if self._note_handle is None:
+            self._note_handle = self._theremin.start_note(target_pitch, int(amp * 100))
+            self._current_pitch = target_pitch
+        elif target_pitch != self._current_pitch:
+            self._stop_note()
+            self._note_handle = self._theremin.start_note(target_pitch, int(amp * 100))
+            self._current_pitch = target_pitch
+        else:
+            _send_cc(self._theremin, 11, int(amp * 127))
+
+    def _tick_from_robot(self, reachy_mini: ReachyMini) -> None:
+        self._ensure_active_parts_fresh()
+        if not self._active_parts:
+            return
+
+        _, antennas = reachy_mini.get_current_joint_positions()
+        pose = reachy_mini.get_current_head_pose()
+
+        trans_mm = pose[:3, 3] * 1_000
+        roll_deg = math.degrees(R.from_matrix(pose[:3, :3]).as_euler("xyz")[0])
+
+        target_pitch = int(round(_aff(roll_deg, *ROLL_DEG_RANGE, *NOTE_MIDI_RANGE)))
+        amp = max(0.0, min(_aff(trans_mm[2], *Z_MM_RANGE, *AMP_RANGE), 1.0))
+        prog = int(
+            _aff(
+                antennas[1],
+                *RIGHT_ANT_RANGE,
+                0,
+                max(0.0, len(self._active_parts) - 0.0001),
+            )
+        )
+        prog = max(0, min(prog, len(self._active_parts) - 1))
+
+        self._handle_sound_state(target_pitch, amp, prog)
+
+        self._publish_status(
+            roll_deg=roll_deg,
+            head_z=trans_mm[2],
+            amp=amp,
+            right_ant=antennas[1],
+            prog=self._current_prog,
+            pitch=target_pitch,
+            playing=bool(self._note_handle),
+        )
+
+    def _perform_intro_demo(self, reachy_mini: ReachyMini, stop_event: threading.Event) -> None:
+        if not self._active_parts:
+            return
+
+        reachy_mini.goto_target(head=create_head_pose(z=0.0, degrees=True), antennas=[0.0, 0.0], duration=0.8)
+        self._demo_pause(reachy_mini, stop_event, 0.3)
+
+        def clamp_idx(idx: int) -> int:
+            if not self._active_parts:
+                return 0
+            return max(0, min(idx, len(self._active_parts) - 1))
+
+        left_idx = clamp_idx(0)
+        right_idx = clamp_idx(1)
+        oscillation_idx = clamp_idx(2)
+
+        current_roll = 0.0
+
+        self._demo_select_instrument(reachy_mini, left_idx, stop_event, dwell=0.3)
+        current_roll = self._demo_roll_linear(
+            reachy_mini,
+            stop_event,
+            current_roll,
+            target_roll=-28.0,
+            duration=1.6,
+        )
+        self._demo_pause(reachy_mini, stop_event, 0.45)
+
+        self._demo_select_instrument(reachy_mini, right_idx, stop_event, dwell=0.28)
+        current_roll = self._demo_roll_linear(
+            reachy_mini,
+            stop_event,
+            current_roll,
+            target_roll=28.0,
+            duration=1.6,
+        )
+        self._demo_pause(reachy_mini, stop_event, 0.45)
+
+        self._demo_select_instrument(reachy_mini, oscillation_idx, stop_event, dwell=0.25)
+        current_roll = self._demo_roll_linear(
+            reachy_mini,
+            stop_event,
+            current_roll,
+            target_roll=0.0,
+            duration=1.0,
+        )
+        self._demo_roll_oscillation(
+            reachy_mini,
+            stop_event,
+            center=0.0,
+            amplitude=10.0,
+            cycles=2,
+            frequency=1.5,
+        )
+
+        reachy_mini.goto_target(
+            head=create_head_pose(z=-0.02, degrees=True), antennas=[0.0, 0.0], duration=1.2
+        )
+        self._demo_pause(reachy_mini, stop_event, 0.6)
+
+    def _demo_select_instrument(
+        self,
+        reachy_mini: ReachyMini,
+        index: int,
+        stop_event: threading.Event,
+        dwell: float,
+    ) -> None:
+        if not self._active_parts:
+            return
+        index = max(0, min(index, len(self._active_parts) - 1))
+        angle = self._angle_for_instrument_index(index)
+        reachy_mini.set_target_antenna_joint_positions([0.0, float(angle)])
+        self._demo_pause(reachy_mini, stop_event, dwell)
+
+    def _angle_for_instrument_index(self, index: int) -> float:
+        if len(self._active_parts) <= 1:
+            return 0.0
+        span = RIGHT_ANT_RANGE[1] - RIGHT_ANT_RANGE[0]
+        ratio = index / (len(self._active_parts) - 1)
+        return RIGHT_ANT_RANGE[0] + span * ratio
+
+    def _demo_pause(
+        self, reachy_mini: ReachyMini, stop_event: threading.Event, duration: float
+    ) -> None:
+        end = time.time() + max(0.0, duration)
+        while time.time() < end and not stop_event.is_set():
+            self._tick_from_robot(reachy_mini)
+            time.sleep(0.02)
+
+    def _demo_roll_linear(
+        self,
+        reachy_mini: ReachyMini,
+        stop_event: threading.Event,
+        start_roll: float,
+        target_roll: float,
+        duration: float,
+    ) -> float:
+        duration = max(0.3, duration)
+        start_time = time.time()
+        while not stop_event.is_set():
+            elapsed = time.time() - start_time
+            ratio = min(1.0, elapsed / duration)
+            roll = start_roll + (target_roll - start_roll) * ratio
+            pose = create_head_pose(z=0.0, roll=roll, degrees=True)
+            reachy_mini.set_target(head=pose)
+            self._tick_from_robot(reachy_mini)
+            if ratio >= 1.0:
+                break
+            time.sleep(0.02)
+        return target_roll
+
+    def _demo_roll_oscillation(
+        self,
+        reachy_mini: ReachyMini,
+        stop_event: threading.Event,
+        center: float,
+        amplitude: float,
+        cycles: int,
+        frequency: float,
+    ) -> None:
+        if frequency <= 0 or cycles <= 0:
+            return
+        total_duration = cycles / frequency
+        start = time.time()
+        while not stop_event.is_set() and time.time() - start < total_duration:
+            elapsed = time.time() - start
+            roll = center + amplitude * math.sin(2 * math.pi * frequency * elapsed)
+            pose = create_head_pose(z=0.0, roll=roll, degrees=True)
+            reachy_mini.set_target(head=pose)
+            self._tick_from_robot(reachy_mini)
+            time.sleep(0.02)
+
 
 if __name__ == "__main__":
     with ReachyMini() as mini:

Theremini/webui/app.js

@@ -11,9 +11,12 @@ const rollValueEl = document.getElementById("rollValue");
 const heightValueEl = document.getElementById("heightValue");
 const antennaValueEl = document.getElementById("antennaValue");
 const playingIndicator = document.getElementById("playingIndicator");
-const updatedAtEl = document.getElementById("updatedAt");
-const latencyInfoEl = document.getElementById("latencyInfo");
-const updatedCard = document.getElementById("updatedCard");
+const programListEl = document.getElementById("programList");
+const availableListEl = document.getElementById("availableList");
+const activeListEl = document.getElementById("activeList");
+const searchInput = document.getElementById("instrumentSearch");
+const saveConfigBtn = document.getElementById("saveConfigBtn");
+const configStatusEl = document.getElementById("configStatus");
 
 const ranges = {
     roll: { min: -60, max: 60, meter: rollMeterEl, display: rollValueEl, unit: "°" },
@@ -28,6 +31,12 @@ const ranges = {
     amplitude: { min: 0, max: 1, meter: ampMeterEl },
 };
 
+const MAX_ACTIVE = 8;
+let availableVoices = [];
+let activeVoices = [];
+let filteredList = [];
+let configDirty = false;
+
 function clamp(value, min, max) {
     return Math.min(Math.max(value, min), max);
 }
@@ -49,20 +58,6 @@ function updatePresence(isPlaying) {
     playingIndicator.querySelector(".label").textContent = isPlaying ? "Playing" : "Silent";
 }
 
-function updateTimestamp(updatedAtSeconds) {
-    if (!updatedAtSeconds) {
-        updatedAtEl.textContent = "--";
-        latencyInfoEl.textContent = "waiting for data…";
-        updatedCard.dataset.state = "fresh";
-        return;
-    }
-    const updatedDate = new Date(updatedAtSeconds * 1000);
-    updatedAtEl.textContent = updatedDate.toLocaleTimeString([], { hour12: false });
-    const age = (Date.now() / 1000) - updatedAtSeconds;
-    latencyInfoEl.textContent = age < 1 ? "live < 1 s" : `lag ${age.toFixed(1)} s`;
-    updatedCard.dataset.state = age > 2 ? "stale" : "fresh";
-}
-
 function updateStatus(status) {
     const programIndex = status.instrument_index;
     instrumentIndexEl.textContent = programIndex ?? "--";
@@ -87,7 +82,6 @@ function updateStatus(status) {
     setMeter(ranges.antenna.meter, antenna, ranges.antenna.min, ranges.antenna.max);
 
     updatePresence(Boolean(status.playing));
-    updateTimestamp(status.updated_at);
 }
 
 async function pollStatus() {
@@ -101,11 +95,211 @@ async function pollStatus() {
             updateStatus(payload.status ?? {});
         }
     } catch (error) {
-        updatedCard.dataset.state = "stale";
-        latencyInfoEl.textContent = "dashboard offline";
         console.error("Theremini dashboard", error);
     }
 }
 
+function renderProgramList() {
+    programListEl.innerHTML = "";
+    if (!activeVoices.length) {
+        const empty = document.createElement("li");
+        empty.textContent = "No voices selected";
+        programListEl.appendChild(empty);
+        return;
+    }
+    activeVoices.forEach((name, index) => {
+        const li = document.createElement("li");
+        const badge = document.createElement("span");
+        badge.className = "badge";
+        badge.textContent = index;
+        const label = document.createElement("span");
+        label.textContent = name;
+        li.appendChild(badge);
+        li.appendChild(label);
+        programListEl.appendChild(li);
+    });
+}
+
+function renderAvailableList() {
+    availableListEl.innerHTML = "";
+    const searchTerm = (searchInput.value || "").trim().toLowerCase();
+    const list = searchTerm
+        ? availableVoices.filter((name) => name.includes(searchTerm))
+        : availableVoices;
+
+    if (!list.length) {
+        const empty = document.createElement("div");
+        empty.className = "list-item";
+        empty.textContent = "No match";
+        availableListEl.appendChild(empty);
+        return;
+    }
+
+    list.forEach((name) => {
+        const item = document.createElement("div");
+        item.className = "list-item";
+
+        const label = document.createElement("strong");
+        label.textContent = name;
+        item.appendChild(label);
+
+        const btn = document.createElement("button");
+        btn.textContent = activeVoices.includes(name)
+            ? "Added"
+            : activeVoices.length >= MAX_ACTIVE
+            ? "Full"
+            : "Add";
+        btn.disabled = activeVoices.includes(name) || activeVoices.length >= MAX_ACTIVE;
+        btn.addEventListener("click", () => addVoice(name));
+        item.appendChild(btn);
+        availableListEl.appendChild(item);
+    });
+}
+
+function renderActiveList() {
+    activeListEl.innerHTML = "";
+    if (!activeVoices.length) {
+        const empty = document.createElement("div");
+        empty.className = "list-item";
+        empty.textContent = "No voices yet";
+        activeListEl.appendChild(empty);
+        return;
+    }
+
+    activeVoices.forEach((name, index) => {
+        const item = document.createElement("div");
+        item.className = "list-item";
+
+        const info = document.createElement("div");
+        info.style.display = "flex";
+        info.style.gap = "0.4rem";
+        const idx = document.createElement("strong");
+        idx.textContent = index;
+        const lbl = document.createElement("span");
+        lbl.textContent = name;
+        info.appendChild(idx);
+        info.appendChild(lbl);
+        item.appendChild(info);
+
+        const controls = document.createElement("div");
+        controls.style.display = "flex";
+        controls.style.gap = "0.3rem";
+
+        const up = document.createElement("button");
+        up.className = "small";
+        up.textContent = "↑";
+        up.disabled = index === 0;
+        up.addEventListener("click", () => moveVoice(index, -1));
+
+        const down = document.createElement("button");
+        down.className = "small";
+        down.textContent = "↓";
+        down.disabled = index === activeVoices.length - 1;
+        down.addEventListener("click", () => moveVoice(index, 1));
+
+        const remove = document.createElement("button");
+        remove.textContent = "Remove";
+        remove.addEventListener("click", () => removeVoice(index));
+
+        controls.appendChild(up);
+        controls.appendChild(down);
+        controls.appendChild(remove);
+        item.appendChild(controls);
+
+        activeListEl.appendChild(item);
+    });
+}
+
+function markDirty() {
+    configDirty = true;
+    configStatusEl.textContent = "Unsaved changes";
+}
+
+function addVoice(name) {
+    if (activeVoices.includes(name) || activeVoices.length >= MAX_ACTIVE) {
+        return;
+    }
+    activeVoices.push(name);
+    renderActiveList();
+    renderProgramList();
+    renderAvailableList();
+    markDirty();
+}
+
+function removeVoice(index) {
+    activeVoices.splice(index, 1);
+    renderActiveList();
+    renderProgramList();
+    renderAvailableList();
+    markDirty();
+}
+
+function moveVoice(index, delta) {
+    const target = index + delta;
+    if (target < 0 || target >= activeVoices.length) {
+        return;
+    }
+    const [voice] = activeVoices.splice(index, 1);
+    activeVoices.splice(target, 0, voice);
+    renderActiveList();
+    renderProgramList();
+    markDirty();
+}
+
+async function fetchConfig() {
+    try {
+        const response = await fetch("/api/config", { cache: "no-store" });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const payload = await response.json();
+        if (payload && payload.ok) {
+            availableVoices = [...(payload.available_instruments || [])].sort();
+            activeVoices = [...(payload.active_instruments || [])];
+            configDirty = false;
+            configStatusEl.textContent = "Synced";
+            renderProgramList();
+            renderAvailableList();
+            renderActiveList();
+        }
+    } catch (error) {
+        configStatusEl.textContent = "Unable to load config";
+        console.error("Theremini config", error);
+    }
+}
+
+async function saveConfig() {
+    try {
+        saveConfigBtn.disabled = true;
+        configStatusEl.textContent = "Saving...";
+        const response = await fetch("/api/config", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ active_instruments: activeVoices }),
+        });
+        const payload = await response.json();
+        if (!response.ok || !payload.ok) {
+            throw new Error(payload?.error || "Failed to save");
+        }
+        configDirty = false;
+        configStatusEl.textContent = "Saved";
+        renderProgramList();
+    } catch (error) {
+        configStatusEl.textContent = `Error: ${error.message}`;
+        console.error("Theremini save", error);
+    } finally {
+        saveConfigBtn.disabled = false;
+    }
+}
+
 pollStatus();
 setInterval(pollStatus, 400);
+fetchConfig();
+setInterval(() => {
+    if (!configDirty) {
+        fetchConfig();
+    }
+}, 5000);
+
+saveConfigBtn.addEventListener("click", saveConfig);
+searchInput.addEventListener("input", renderAvailableList);

Theremini/webui/index.html

@@ -37,15 +37,10 @@
             <article class="card">
                 <p class="label">Amplitude</p>
                 <h2 id="ampPercent">0%</h2>
-                <div class="meter" data-min="0" data-max="1" data-unit="">
+                <div class="meter">
                     <div class="meter-fill" id="ampMeter"></div>
                 </div>
             </article>
-            <article class="card" id="updatedCard">
-                <p class="label">Last update</p>
-                <h2 id="updatedAt">--</h2>
-                <p class="meta" id="latencyInfo">waiting for data…</p>
-            </article>
         </section>
 
         <section class="grid meters">
@@ -96,17 +91,36 @@
             <div>
                 <p class="label">Program slots</p>
                 <h2>FluidSynth voices</h2>
-                <p class="meta">Same subset as <code>simple_theremini.py</code>. Move the right antenna to scroll.</p>
+                <p class="meta">Move the right antenna to cycle through your curated list.</p>
             </div>
-            <ul class="program-list">
-                <li><span>0</span> choir_aahs</li>
-                <li><span>1</span> orchestra_hit</li>
-                <li><span>2</span> taiko_drum</li>
-                <li><span>3</span> trumpet</li>
-                <li><span>4</span> french_horn</li>
-                <li><span>5</span> soundtrack</li>
+            <ul class="program-list" id="programList">
             </ul>
         </section>
+
+        <section class="card config-card">
+            <div class="config-head">
+                <div>
+                    <p class="label">Live instrument set</p>
+                    <h2>Pick the presets Reachy cycles through</h2>
+                    <p class="meta">Choose up to eight voices from the full GM bank. Order matters.</p>
+                </div>
+                <div class="config-actions">
+                    <input id="instrumentSearch" type="text" placeholder="Filter presets..." />
+                    <button id="saveConfigBtn">Save selection</button>
+                </div>
+            </div>
+            <div class="list-grid">
+                <div class="list-panel">
+                    <p class="panel-title">Available voices</p>
+                    <div class="list-box" id="availableList"></div>
+                </div>
+                <div class="list-panel">
+                    <p class="panel-title">Active rotation</p>
+                    <div class="list-box active" id="activeList"></div>
+                </div>
+            </div>
+            <p class="meta" id="configStatus">&nbsp;</p>
+        </section>
     </main>
 
     <script src="app.js" type="module"></script>

Theremini/webui/style.css

@@ -204,7 +204,7 @@ body {
     color: rgba(241, 245, 249, 0.85);
 }
 
-.program-list span {
+.program-list .badge {
     width: 1.8rem;
     height: 1.8rem;
     border-radius: 0.6rem;
@@ -216,6 +216,109 @@ body {
     border: 1px solid rgba(129, 140, 248, 0.5);
 }
 
+.config-card {
+    display: flex;
+    flex-direction: column;
+    gap: 1.2rem;
+}
+
+.config-head {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 1rem;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.config-actions {
+    display: flex;
+    gap: 0.75rem;
+    align-items: center;
+}
+
+.config-actions input {
+    padding: 0.5rem 0.85rem;
+    border-radius: 999px;
+    border: 1px solid rgba(148, 163, 184, 0.4);
+    background: rgba(2, 6, 23, 0.7);
+    color: var(--text);
+    min-width: 220px;
+}
+
+.config-actions button {
+    border: none;
+    border-radius: 999px;
+    padding: 0.55rem 1.4rem;
+    background: linear-gradient(120deg, #6366f1, #c084fc);
+    color: white;
+    font-weight: 600;
+    cursor: pointer;
+}
+
+.list-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 1rem;
+}
+
+.list-panel {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}
+
+.panel-title {
+    text-transform: uppercase;
+    font-size: 0.75rem;
+    letter-spacing: 0.08em;
+    color: var(--muted);
+}
+
+.list-box {
+    border: 1px solid rgba(148, 163, 184, 0.25);
+    border-radius: 16px;
+    background: rgba(9, 9, 21, 0.65);
+    padding: 0.75rem;
+    max-height: 320px;
+    overflow-y: auto;
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+}
+
+.list-box.active {
+    border-color: rgba(167, 139, 250, 0.6);
+}
+
+.list-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 0.75rem;
+    padding: 0.4rem 0.6rem;
+    border-radius: 10px;
+    background: rgba(99, 102, 241, 0.08);
+}
+
+.list-item strong {
+    font-size: 0.95rem;
+    color: var(--accent);
+}
+
+.list-item button {
+    border: none;
+    border-radius: 6px;
+    padding: 0.25rem 0.6rem;
+    font-size: 0.75rem;
+    background: rgba(148, 163, 184, 0.25);
+    color: var(--text);
+    cursor: pointer;
+}
+
+.list-item button.small {
+    padding: 0.2rem 0.45rem;
+}
+
 code {
     background: rgba(15, 23, 42, 0.7);
     padding: 0.1rem 0.4rem;
@@ -223,13 +326,10 @@ code {
     border: 1px solid rgba(148, 163, 184, 0.25);
 }
 
-#updatedCard[data-state="stale"] {
-    border-color: rgba(251, 113, 133, 0.6);
-}
-
-#updatedCard[data-state="stale"] h2,
-#updatedCard[data-state="stale"] .meta {
-    color: var(--danger);
+input:focus,
+button:focus {
+    outline: 2px solid rgba(99, 102, 241, 0.4);
+    outline-offset: 2px;
 }
 
 @media (max-width: 640px) {

index.html

@@ -40,7 +40,7 @@
                     <tr>
                         <td>Right antenna</td>
                         <td>-π/3 ⇢ +π/3 rad</td>
-                        <td>Instrument index 0 ⇢ 5</td>
+                        <td>Instrument index 0 ⇢ (#active−1)</td>
                     </tr>
                 </tbody>
             </table>
@@ -48,7 +48,7 @@
 
         <section class="card">
             <h2>Instrument Programs</h2>
-            <p class="caption">Theremini cycles through a curated subset of FluidSynth GM presets. The robot crossfades by reusing CC 11 just like the original script.</p>
+            <p class="caption">Theremini cycles through a curated subset of FluidSynth GM presets. The dashboard lets you swap presets live; these are the defaults.</p>
             <ul class="instrument-list">
                 <li><span class="label">0</span>choir_aahs</li>
                 <li><span class="label">1</span>orchestra_hit</li>

pyproject.toml

@@ -27,4 +27,4 @@ include-package-data = true
 where = ["Theremini"]
 
 [tool.setuptools.package-data]
-Theremini = ["webui/**/*"]
+Theremini = ["webui/**/*", "config.json"]