bipluk: Web MIDI SysEx Librarian & Vintage Hardware Synth Vault

The open-source browser-native SysEx librarian, patch decapsulator, and cloud vault for vintage hardware synthesizers.
Zero software installation. Zero legacy 32-bit drivers. Sample-accurate Web MIDI packet pacing. 110+ synthesizers supported.

---

🎹 Table of Contents

• Why bipluk?
• The Dying Battery Crisis
• Key Capabilities
• System Architecture
• Mathematical & Physical Foundations of SysEx
  • UART Serial Timing & Slew Rate Physics
  • The 7-bit to 8-bit Data Packing Theorem
  • Casio Phase Distortion Mathematical Model
  • Roland Modulo-128 Checksum Proof
  • Lithium CR2032 Discharge Chemistry
• Synthesizer Hardware Matrix (110+ Models)
  • Yamaha (FM & AWM Synthesis)
  • Roland (Analog DCO, LA & PCM Workstations)
  • Korg (Workstations, Digital Waves & Analog Hybrids)
  • Sequential Circuits & Dave Smith Instruments (VCO Polyphonics)
  • Oberheim (Curtis CEM Modulation Monsters)
  • Casio (Phase Distortion CZ-Series)
  • Waldorf, Moog, Ensoniq, Alesis, Access, & More
• Interactive Synthesizer Wiki Directory
• Technical Deep Dive
  • Packet Pacing vs Buffer Overflow
  • Base-8 Hardware Addressing
• Comparison Matrix
• Repository Structure
• Quick Start & Local Setup
• Adding New Synth Adapters
• API & AI Agent Discovery
• First-Party Research
• Corporate & Legal Entity
• License

---

Why bipluk?

If you own vintage hardware synthesizers (from a 1983 Yamaha DX7 or a 1984 Roland Juno-106 to a Sequential Prophet-5 or Korg M1), managing your patch banks has historically been painful:

1. Abandonware Utilities: Legacy tools like MIDI-OX, Snoize SysEx Librarian, SoundTower, and MIDI Quest were programmed for 32-bit operating systems. Every major macOS update and Windows security update threatens to break legacy USB-MIDI drivers and 20-year-old desktop executables.
2. Buffer Overflows on 1980s Hardware: Vintage synthesizers run on 8-bit microprocessors (Intel 8031, Motorola 6809, Zilog Z80) clocked at 2 to 12 MHz, receiving MIDI over a physical 31.25 kbaud optoisolated serial line. Modern multi-gigahertz computers blast SysEx packets faster than vintage UART input FIFO buffers can process them, leading to corrupted patches, memory checksum errors, and frozen synthesizers.
3. Desktop Clutter & Driver Conflicts: Soundcheck and studio recording sessions are no place for driver troubleshooting, COM port configurations, and USB permission crashes.

[!NOTE] bipluk runs entirely inside modern web browsers using the open W3C Web MIDI API. Open a tab, connect your 5-pin DIN or USB-MIDI interface, back up your soundbanks, search patch names by text, and flash banks back to your instrument in one click.

---

The Dying Battery Crisis

Inside nearly every 1980s and 1990s hardware synthesizer sits a soldered 3-Volt lithium battery (typically a CR2032, BR2325, or rechargeable NiCad/Varta cell) keeping internal static RAM (SRAM) energized while the power switch is off.

[!WARNING] CRITICAL VOLTAGE CLIFF

• 3.2V to 3.0V: Healthy nominal battery voltage.
• 2.8V to 2.6V: Unstable threshold. RAM bit-rot begins, patch names corrupt, and parameters scramble.
• Below 2.5V: Instant memory wipe. The moment voltage collapses or a technician desolders the battery during service, every custom sound designed over the past 10 to 30 years is permanently erased.

flowchart LR
    A["🔋 Factory Battery (3.0V)"] --> B["⚠️ Voltage Drops (< 2.6V)"]
    B --> C["💥 SRAM Power Collapses"]
    C --> D["❌ Custom Soundbanks Wiped Forever"]
    
    B -.->|"Emergency bipluk Web MIDI Dump"| E["☁️ Safe Cloud Vault (.syx)"]
    E --> F["🔧 Solder New Battery"]
    F --> G["⚡ One-Click Restore to Hardware"]

bipluk provides an instant, zero-install emergency backup flow to capture raw .syx binary snapshots before opening the chassis or servicing the motherboard.

---

Key Capabilities

• Zero-Install Web MIDI Bridge: Connect physical synthesizers directly to modern browsers (Google Chrome, Microsoft Edge, Brave, Opera) with Web MIDI System Exclusive permissions. No background daemons or drivers required.
• Hardware-Paced Microsecond Scheduling: Transmits SysEx packets using performance.now() + offset timestamp scheduling rather than unreliable JavaScript setTimeout(), eliminating UART packet loss and buffer overflow errors on classic instruments.
• Instant Binary .syx Decoding: Automatically extracts ASCII patch names, algorithm configurations, filter routing, and oscillator data directly from raw System Exclusive binary dumps in memory.
• Base-8 Hardware Addressing: Native bank-and-patch indexing (e.g. Roland Bank 11 through 88) matching the front-panel switches on vintage synthesizers instead of confusing 1 to 64 decimal lists.
• Diagnostic Memory Protect Guides: Embedded interactive walkthroughs showing the exact front-panel button combinations to disable memory protect and write-enable RAM on 110+ instruments.
• Lossless Export Guarantee: Zero proprietary lock-in. Back up to the cloud, download industry-standard uncompressed .syx files at any time, or send banks back to your gear with one click.
• Global Purchasing Power Parity (PPP): Automated regional pricing calibrated to local economies across 150+ countries.

[!TIP] Lossless Guarantee: bipluk never converts your soundbank into a proprietary closed format. Your data remains 100% standard uncompressed System Exclusive binary (.syx), downloadable anytime.

---

System Architecture

flowchart TD
    subgraph Hardware ["Physical Studio Rig"]
        Synth["🎹 Vintage Hardware Synth<br>(DX7, Juno-106, Prophet-5, M1)"]
        MIDI_IF["🔌 Hardware MIDI Interface<br>(5-pin DIN to USB)"]
        Synth <-->|"31.25 kbaud Serial UART"| MIDI_IF
    end

    subgraph Browser ["Modern Browser (Client)"]
        WebMIDI["🌐 W3C Web MIDI API<br>(sysex: true)"]
        Scheduler["⏱️ Microsecond Pacing Engine<br>(performance.now offsets)"]
        Decoder["🔍 Binary Stream Decapsulator<br>(ASCII, 7-bit unpack, Checksums)"]
        UI["💻 bipluk Web Interface<br>(Oscilloscope, Bank Slots, Search)"]
        
        MIDI_IF <-->|"USB-MIDI Packets"| WebMIDI
        WebMIDI --> Decoder
        Decoder --> UI
        UI --> Scheduler
        Scheduler -->|"Paced F0...F7 Chunks"| WebMIDI
    end

    subgraph Cloud ["bipluk Cloud Services"]
        Server["🚀 FastAPI Backend Application"]
        Vault[("💾 Encrypted Soundbank Vault<br>SQLite / PostgreSQL")]
        PPP["🌍 Live Purchasing Power Parity Engine"]
        Stripe["💳 Stripe Payment Gateway"]
        Resend["📬 CAN-SPAM Email System"]

        UI <-->|"HTTPS JSON / REST"| Server
        Server <--> Vault
        Server <--> PPP
        Server <--> Stripe
        Server --> Resend
    end

---

Mathematical & Physical Foundations of SysEx

UART Serial Timing & Slew Rate Physics

The physical MIDI specification operates as a 5 mA current loop over shielded twisted pair cable with standard DIN 41524 connectors. The baud rate is defined exactly as:

$$f_{\text{baud}} = 31,250\text{ bits per second} \implies T_{\text{bit}} = \frac{1}{31,250} = 32\ \mu\text{s}$$

Because MIDI transmission is asynchronous, every transferred byte is framed by 1 start bit (logic 0), 8 data bits, and 1 stop bit (logic 1), totaling 10 bit periods per byte frame:

$$T_{\text{frame}} = 10 \times T_{\text{bit}} = 320\ \mu\text{s per byte}$$

The theoretical maximum continuous bandwidth of a physical MIDI line is:

$$\text{Throughput}_{\max} = \frac{31,250\text{ bits/s}}{10\text{ bits/byte}} = 3,125\text{ bytes/second} = 3.125\text{ KB/s}$$

For a standard Yamaha DX7 bulk patch dump (4,096 bytes):

$$T_{\text{transfer}} = \frac{4096\text{ bytes}}{3125\text{ bytes/s}} = 1.31072\text{ seconds}$$

Optocouplers used in 1980s synthesizer inputs (such as the Sharp PC-900 or HP 6N138) have finite rise and fall times:

$$t_r \approx 1.5\ \mu\text{s} \text{ to } 3.0\ \mu\text{s}, \quad t_f \approx 0.5\ \mu\text{s} \text{ to } 1.5\ \mu\text{s}$$

When modern multi-gigahertz host computers blast packets without inter-byte pacing, optocoupler slew asymmetry combined with 1-byte FIFO buffers on vintage microcontrollers (Intel 8031, Zilog Z80) induces frame framing errors and buffer overrun interrupts. bipluk schedules packet dispatches with microsecond timestamps calibrated to vintage receive envelopes.

---

The 7-bit to 8-bit Data Packing Theorem

The MIDI 1.0 standard reserves any byte with the Most Significant Bit (MSB) set to 1 (values $128 \le B \le 255$ or 0x80 to 0xFF) exclusively for Status Bytes (Note On, CC, SysEx start 0xF0, SysEx end 0xF7).

Therefore, all parameter data bytes must satisfy:

$$\text{MSB}(D) = 0 \iff 0 \le D \le 127 \quad (\text{hex: } 0\text{x}00 \text{ to } 0\text{x}7\text{F})$$

To transmit unconstrained 8-bit binary integers ($0 \le X \le 255$) or 12-bit DAC modulation values, synthesizer manufacturers developed distinct data-packing theorems:

1. Nibblization (Roland, Korg, Ensoniq)

Each 8-bit byte $X$ is partitioned into two 4-bit nibbles, with each nibble transmitted in a 7-bit data byte:

$$D_{\text{low}} = X \land 0\text{x}0\text{F}, \quad D_{\text{high}} = (X \gg 4) \land 0\text{x}0\text{F}$$

Reconstruction at receiver:

$$X = (D_{\text{high}} \ll 4) \lor D_{\text{low}}$$

This incurs a data expansion factor of:

$$\text{Expansion Ratio} = \frac{2\text{ transmitted bytes}}{1\text{ source byte}} = 200%$$

2. 4-to-5 Bit Packing (Yamaha DX7, TX81Z)

Yamaha engineers avoided the 200% overhead by grouping four 8-bit bytes ($B_0, B_1, B_2, B_3$, totaling 32 bits of parameter data) into five 7-bit MIDI bytes ($M_0, M_1, M_2, M_3, M_4$, totaling 35 bits):

$$M_k = B_k \land 0\text{x}7\text{F} \quad \text{for } k \in {0, 1, 2, 3}$$

The fifth byte $M_4$ accumulates the Most Significant Bits of all four source bytes:

$$M_4 = \sum_{k=0}^{3} \left(\frac{B_k \land 0\text{x}80}{0\text{x}80}\right) \cdot 2^k$$

This achieves an efficient transmission ratio:

$$\text{Expansion Ratio} = \frac{5}{4} = 125%$$

bipluk implements automated bidirectional decapsulation for both schemes in real time.

---

Casio Phase Distortion Mathematical Model

Unlike subtractive analog synthesizers that filter harmonics with operational transconductance amplifiers (OTAs), Casio CZ synthesizers (CZ-101, CZ-1000, CZ-5000) employ Phase Distortion (PD) synthesis.

The output waveform $y(t)$ is generated by reading a pure sine wave look-up table at an angle driven by a piecewise-distorted phase accumulator $\phi_d(t)$:

$$y(t) = \sin(\phi_d(t))$$

The normalized phase accumulator $\phi(t)$ runs linearly from $0$ to $2\pi$ over fundamental period $T = 1/f_0$:

$$\phi(t) = 2\pi f_0 t \pmod{2\pi}$$

Under Casio PD synthesis, an inflection knee $t_k \in (0, T)$ dynamically warps the phase angle:

$$\phi_d(t) = \begin{cases} \left(\frac{\pi}{t_k}\right) t & 0 \le t < t_k \ \pi + \left(\frac{\pi}{T - t_k}\right) (t - t_k) & t_k \le t < T \end{cases}$$

flowchart TD
    LinearPhase["Linear Phase Accumulator: φ(t)"] --> DistortionBlock["Phase Distortion Transfer: φ_d(t)"]
    DistortionBlock --> SineLUT["Sine Look-Up Table: sin(φ_d(t))"]
    SineLUT --> OutputWaveform["Synthesized Waveform: y(t)<br>(Saw, Resonant, Square)"]

When $t_k = T/2$, the phase is undistorted, generating a pure sine wave. When $t_k \to 0$, the phase slope approaches infinity at the start of each cycle, generating a sawtooth harmonic series. Modulating $t_k$ via an 8-stage envelope generator replicates the resonant frequency sweeps of analog VCF filters without physical capacitors or inductors.

---

Roland Modulo-128 Checksum Proof

Roland GS and LA System Exclusive protocol specifications mandate that the payload data packet (address bytes plus data bytes) satisfies an exact modulo-128 parity condition:

$$\left(\sum_{i=1}^{k} \text{PayloadByte}_i + \text{Checksum}\right) \bmod 128 = 0$$

To derive the required checksum byte from the data payload:

$$\text{Checksum} \equiv -\sum_{i=1}^{k} \text{PayloadByte}_i \pmod{128}$$

Using two's complement arithmetic within a 7-bit field:

$$\text{Checksum} = \left(128 - \left(\sum_{i=1}^{k} \text{PayloadByte}_i \bmod 128\right)\right) \land 0\text{x}7\text{F}$$

If the remainder of the sum is zero, the checksum simplifies to zero:

$$\text{If } \sum \text{PayloadByte}_i \equiv 0 \pmod{128} \implies \text{Checksum} = 0$$

bipluk re-computes and verifies this checksum on every Roland patch transfer to guarantee soundbank integrity before sending byte streams to physical hardware.

---

Lithium CR2032 Discharge Chemistry

The coin cell powering synthesizer volatile SRAM utilizes Lithium Manganese Dioxide chemistry:

$$\text{Li} + \text{Mn}^{\text{IV}}\text{O}_2 \longrightarrow \text{Li}\text{Mn}^{\text{III}}\text{O}_2$$

The terminal cell voltage $V_{\text{terminal}}$ as a function of drawn capacity $Q(t) = \int I(t) dt$ follows:

$$V_{\text{terminal}}(t) = V_{\text{open}} - I_{\text{load}} \cdot R_{\text{internal}}(Q) - \frac{RT}{F} \ln\left(\frac{C_{\text{active}}}{C_0 - Q(t)}\right)$$

Cell Voltage (V)
3.2V |-------------------\
3.0V |                    \
2.8V |  SAFE RETENTION     \  UNSTABLE REGION
2.6V |                      \
2.4V |-----------------------\================== MEMORY LOSS
2.0V |                                          \
0.0V +---------------------------------------------> Time (Years)

For over 90% of the battery service life (typically 10 to 20 years with typical SRAM standby currents of $0.5\ \mu\text{A}$ to $2.0\ \mu\text{A}$), $V_{\text{terminal}}$ remains above 2.8V. When remaining capacity drops below 5%, the internal resistance $R_{\text{internal}}$ escalates exponentially from $20\ \Omega$ to over $1,000\ \Omega$.

Once voltage drops beneath the SRAM transistor holding voltage $V_{\text{hold}} \approx 2.4\text{V}$, cross-coupled inverter gates randomly toggle state, corrupting patch data irrevocably.

---

Synthesizer Hardware Matrix (110+ Models)

bipluk includes hardware decoders and SysEx adaptations for historic synthesizers across all major manufacturers:

Yamaha (FM & AWM Synthesis)

Roland (Analog DCO, LA & PCM Workstations)

Korg (Workstations, Digital Waves & Analog Hybrids)

Sequential Circuits & Dave Smith Instruments (VCO Polyphonics)

Oberheim (Curtis CEM Modulation Monsters)

Casio (Phase Distortion CZ-Series)

Waldorf, Moog, Ensoniq, Alesis, Access, & More

• Waldorf: Blofeld, Microwave 1, Microwave II/XT, Pulse, Pulse 2, Waldorf M, Wave.
• Moog: Minimoog Voyager, Sub 37, Subsequent 37, Minitaur, Sirin, Little Phatty.
• Ensoniq: ESQ-1, SQ-80, VFX, VFX-SD (8-bit wavetable synthesis).
• Alesis: Andromeda A6 (16-voice discrete analog), Quadraverb, D4, DM5.
• Access: Virus A, Virus B, Virus Classic, Virus C, Virus TI (Snow/Desktop/Keyboard).
• Black Corporation: Deckard's Dream (CS-80 inspired), Kijimi, Xerxes.
• Kawai: K1, K1m, K3, K3m, K4, K5000 (Additive synthesis).
• Behringer: Deepmind 6/12, Pro-800, Wave, BCR-2000, RD-8, RD-9.
• Generic Synthesizers: Any MIDI 1.0 instrument supporting standard SysEx bulk dump transfers (F0 ... F7).

---

Interactive Synthesizer Wiki Directory

Explore in-depth technical specifications, factory patch listings, filter schematics, and memory protect guides on the live bipluk wiki:

---

Technical Deep Dive

Packet Pacing vs Buffer Overflow

Standard JavaScript setTimeout() and setInterval() run on an unprioritized browser event loop clamped to 4ms with significant jitter. Blasting a 4096-byte Yamaha DX7 bank or a 32KB Roland D-50 dump without exact inter-packet delays chokes the synthesizer UART buffer, resulting in checksum errors.

sequenceDiagram
    autonumber
    actor User as Musician / Producer
    participant Browser as bipluk Engine (Browser)
    participant Driver as Web MIDI Output Queue
    participant Synth as Vintage Synth UART (8031 CPU)

    User->>Browser: Click "Send Soundbank to Synth"
    Note over Browser: Calculate microsecond offsets via performance.now()
    Browser->>Driver: output.send(Chunk 0, T0)
    Driver->>Synth: 256 bytes over 31.25 kbaud
    Note over Synth: Process into SRAM & calculate checksum
    Browser->>Driver: output.send(Chunk 1, T0 + 40ms)
    Driver->>Synth: 256 bytes (Buffer safe!)
    Browser->>Driver: output.send(Chunk 2, T0 + 80ms)
    Driver->>Synth: 256 bytes (Buffer safe!)
    Note over Synth: Bank Write Complete (0 Errors)

// Sample-accurate Web MIDI packet pacing implementation
function sendSysExWithPacing(midiOutput, bytes, chunkSize = 256, delayMs = 40) {
    const startTime = performance.now();
    let offset = 0;

    for (let i = 0; i < bytes.length; i += chunkSize) {
        const chunk = bytes.slice(i, i + chunkSize);
        const targetTimestamp = startTime + offset;
        
        // Dispatched directly to the OS MIDI scheduler
        midiOutput.send(chunk, targetTimestamp);
        offset += delayMs;
    }
}

Base-8 Hardware Addressing

Synthesizers like the Roland Juno-106, Juno-60, and Sequential Prophet-5 feature front panels with 8 bank buttons and 8 patch buttons (numbered 1 to 8). Decimal indexing (0 to 63) confuses musicians during live sets. bipluk natively converts these to physical labels:

$$\text{Display Number} = \left(\left\lfloor \frac{\text{index}}{8} \right\rfloor + 1\right) \times 10 + \left((\text{index} \bmod 8) + 1\right)$$

(Index 0 maps to Patch 11, Index 63 maps to Patch 88).

---

Comparison Matrix

---

Repository Structure

.
├── main.py                          # FastAPI backend application, routing, and discovery
├── ppp_pricing.py                   # Dynamic Purchasing Power Parity (PPP) engine
├── synth_seo_catalog.py             # Programmatic SEO matrix for 110+ synthesizers
├── faq_knowledge.py                 # Structured FAQ and technical knowledge base
├── settings.py                      # Environment configuration & credential management
├── database.py                      # Database models, soundbank vault & user sessions
├── sysex_adapters/                  # Hardware-specific SysEx decoding test suites & parsers
│   ├── testData/                    # Authentic raw .syx dumps from vintage synthesizers
│   └── test_*.py                    # Automated test suites for DX7, Juno, M1, OB-6, etc.
├── knobkraft_src/                   # KnobKraft Orm integration adaptations
├── templates/                       # Modern Jinja2 templates (Lapis & Studio themes)
│   ├── landing.html                 # High-converting homepage & live Web MIDI demo
│   ├── index.html                   # Authenticated user dashboard & soundbank manager
│   ├── wiki_detail.html             # Programmatic synthesizer wiki documentation
│   ├── blog_web_midi.html           # Technical engineering log on Web MIDI pacing
│   ├── blog_sysex_7bit_packing.html # Guide to 7-bit MIDI byte packing & decapsulation
│   └── email_*.html                 # 13 CAN-SPAM compliant transactional email templates
└── static/                          # High-resolution pixel art, SVGs, and brand assets
    ├── logo.svg                     # Pixelated brand mark
    └── llms.txt                     # AI agent context discovery documentation

---

Quick Start & Local Setup

Prerequisites

• Python 3.12 or 3.13
• Google Chrome, Microsoft Edge, Brave, or any Chromium browser with Web MIDI support
• A USB-to-MIDI interface (e.g. Roland UM-ONE mk2, iConnectivity mio)

Installation

1. Clone the repository:

   git clone https://github.com/maxcomperatore/bipluk.com.git
   cd bipluk.com
   

2. Create and activate a virtual environment:

   python -m venv venv
   # On Windows:
   .\venv\Scripts\Activate.ps1
   # On macOS/Linux:
   source venv/bin/activate
   

3. Install dependencies:

   pip install -r requirements.txt
   

4. Configure environment variables:

   cp .env.example .env
   

5. Start the local server:

   uvicorn main:app --reload --host 127.0.0.1 --port 8000
   

6. Open in browser: Navigate to http://localhost:8000 and allow Web MIDI permissions when prompted.

[!IMPORTANT] Web MIDI requires secure context (https:// or http://localhost). Browsers will not permit System Exclusive access over insecure HTTP connections on external IP addresses.

---

Adding New Synth Adapters

To add support for a new hardware synthesizer:

1. Place a raw SysEx binary test dump into sysex_adapters/testData/<Manufacturer>_<Model>/.
2. Define the parameter decoding map in sysex_adapters/:

   class NewSynthAdapter:
       MANUFACTURER_ID = 0x41  # e.g., Roland
       MODEL_ID = 0x16        # e.g., Juno-106
       
       @classmethod
       def parse_patch_name(cls, raw_bytes: bytes) -> str:
           # Extract ASCII character string from header offset
           return raw_bytes[16:26].decode("ascii", errors="ignore").strip()
   

3. Add the instrument profile, year, polyphony, filter chips, and memory protect steps to synth_seo_catalog.py.
4. Run the automated parser verification test:

   pytest sysex_adapters/test_<synth_model>.py
   

---

API & AI Agent Discovery

bipluk exposes discovery endpoints for Large Language Models and AI web agents:

• AI Discovery Document: /static/llms.txt: Plain-text engineering specification and feature summary.
• OpenAPI Schema: /openapi.json: Complete machine-readable API definitions with Stripe x-payment-info declarations.
• Live GeoIP & Region Pricing: GET /api/geoip: Resolves client country and active currency catalog.
• Live PPP Pricing Engine: GET /api/ppp-price?country=AR: Returns dynamic exchange rates, GDP discounts, and Stripe line items for any ISO country code.

---

First-Party Research

If you are researching Web MIDI implementation, synthesizer memory decay, or musical instrument software longevity, you may cite our published field studies:

• 2026 Vintage Synth Owner Survey: Half Radiation LLC, 2026 Vintage Synth Owner Survey, bipluk, July 2026. (First-party survey of 2,417 synthesists regarding battery failure, driver extinction, and Web MIDI reliability).
• Lessons from Launching a Browser SysEx Vault: Half Radiation LLC, Lessons from Launching a Browser SysEx Vault, bipluk, June 2026. (Analysis of Web MIDI packet pacing, UART bottlenecks, and pricing psychology).

---

Corporate & Legal Entity

bipluk is engineered and operated by Half Radiation LLC, an independent technology studio organized under the laws of the State of New Mexico, United States.

Half Radiation LLC
1209 Mountain Road PL NE STE N
Albuquerque, NM 87110
United States
Contact: support@bipluk.com

• Terms of Service: https://bipluk.com/terms
• Privacy Policy: https://bipluk.com/privacy

---

License

• License: Released under the GNU General Public License v3.0 (GPLv3).
• KnobKraft Orm: Special thanks to Christof (@christofmuc) and the KnobKraft open-source community for collaborative SysEx parameter reverse-engineering across vintage instruments.
• W3C Audio Working Group: Grateful acknowledgement to the authors and maintainers of the W3C Web MIDI API specification.

_{Built for the love of hardware synthesizers. Keep the analog fires burning.}