MUSE

KO | EN

gitlite — search

#javascript #python #typescript #llm #go #golang #machine-learning #linux #docker #java #nodejs #kubernetes #pytorch #open-source

(★ 33)

An AI-native language for building audio plugins. Write .muse, get VST3/CLAP binaries.

MUSE 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Muse

This is a complete audio plugin:

```muse
plugin "Warm Gain" {
  vendor   "Muse Audio"
  version  "0.1.0"
  category effect

clap { id "dev.museaudio.warm-gain" description "A warm gain stage" features [audio_effect, stereo] }
  vst3 { id "MuseWarmGain1" subcategories [Fx, Dynamics] }

input  stereo
  output stereo

param gain: float = 0.0 in -30.0..30.0 {
    smoothing logarithmic 50ms
    unit "dB"
  }

gui {
    theme dark
    accent "#E8A87C"
  }

process {
    input -> gain(param.gain) -> output
  }

test "silence in silence out" {
    input  silence 512 samples
    set    param.gain = 0.0
    assert output.rms < -120dB
  }
}
```

Run `muse build gain.muse` and get a native VST3 + CLAP binary with a custom GUI that loads in Ableton, Bitwig, Reaper — any DAW. One file in, real plugin out.

## Why

Building audio plugins is brutally hard. You need systems programming (Rust or C++), real-time audio constraints, platform-specific bundle formats, and hundreds of lines of framework boilerplate. A simple gain knob is 200+ lines of Rust. In Muse, it's 30 lines that read like a description of what the plugin does.

But Muse wasn't built to save humans from typing. It was built so that **AI agents can write audio plugins.**

Tell Claude "build me a tremolo effect with rate and depth knobs." It writes a `.muse` file, runs `muse test` to verify the audio processing actually works, runs `muse build` to produce binaries, and hands you a plugin. No human wrote code. No human debugged anything.

The language makes this possible: constrained syntax so there's one obvious way to write any plugin, a type system that catches domain errors at compile time, and in-language tests that let the AI verify its own work before shipping.

## How It Sounds

Audio processing reads left-to-right with the `->` operator:

```muse
input -> lowpass(param.cutoff, param.resonance) -> gain(param.volume) -> output
```

Split into parallel frequency bands:

```muse
input -> split {
  lowpass(400Hz) -> gain(param.drive) -> tanh()
  bandpass(2000Hz) -> gain(0.8)
  highpass(4000Hz) -> gain(0.6) -> tanh()
} -> merge -> gain(param.mix) -> output
```

Build a polyphonic synthesizer — add `voices 8` and the process block runs per-voice:

```muse
voices 8

process {
  let env = adsr(param.attack, param.decay, param.sustain, param.release)
  let osc1 = saw(note.pitch)
  let osc2 = square(note.pitch)
  mix(osc1, osc2) -> lowpass(param.cutoff) -> gain(env) -> output
}
```

The code *is* the signal flow diagram.

## Custom GUI

Add a `gui { }` block and the plugin gets a web-view editor rendered in macOS WebKit:

```muse
gui {
  theme dark
  accent "#7ECCE8"
  size 800 550

layout vertical {
    panel "Analyzer" {
      spectrum
    }
    panel "Controls" {
      layout horizontal {
        xy_pad freq resonance
        knob gain
      }
    }
  }
}
```

Three tiers: auto-generated knobs from just `theme` and `accent`, explicit layout with panels and widgets, or full CSS escape hatch for unlimited visual control.

## Live Preview

Edit a `.muse` file and hear the changes instantly — no DAW required:

```bash
# Preview an effect with live audio
muse preview examples/gui_gain.muse --input mic

# Preview a synth with a MIDI keyboard
muse preview examples/poly_synth.muse --midi-port "MIDI Keyboard"

# Preview an effect with a WAV file
muse preview examples/filter.muse --input file:drums.wav
```

Hot-reload on save — edit the `.muse` file, save, hear the difference in under 2 seconds. Parameter state survives reloads. Connect any CoreMIDI device and play polyphonic instruments in real time.

## Plugins That Test Themselves

Every Muse plugin can prove it works. Inject MIDI notes, feed real audio through the compiled DSP, verify pitch with FFT, check envelope shapes over time, and assert no corrupted output:

```muse
test "A4 plays at correct frequency" {
  note on 69 0.8 at 0
  note off 69 at 4096
  input silence 8192 samples
  assert frequency 440Hz > -20dB
  assert output.rms > -20dB
  assert no_nan
  assert no_denormal
}
```

That test injects a MIDI A4 note into a polyphonic synth, runs 8192 samples, verifies via FFT that 440Hz is present in the output, checks the signal level, and scans every sample for NaN and denormalized values. Not a mock. Real audio through the real compiled plugin.

An AI writes the plugin and the tests. If the tests pass, the plugin works. No human listening required.

## Quick Start

```bash
cargo build --release

# Check syntax and types
./target/release/muse check examples/gain.muse

# Compile, run audio tests
./target/release/muse test examples/gain.muse --format json

# Live preview with hot-reload (edit file, save, hear changes)
./target/release/muse preview examples/gui_gain.muse

# Preview a synth with a MIDI keyboard
./target/release/muse preview examples/poly_synth.muse --midi-port "MIDI Keyboard"

# Build VST3 + CLAP binaries
./target/release/muse build examples/gain.muse --output-dir ./build

# Load in your DAW
cp -R "./build/Warm Gain.vst3" ~/Library/Audio/Plug-Ins/VST3/
cp -R "./build/Warm Gain.clap" ~/Library/Audio/Plug-Ins/CLAP/
```

## Built-in DSP

37 primitives — oscillators, filters, EQ, envelopes, dynamics, delay, modulation, and utilities:

```
sine  saw  square  triangle  noise  pulse  lfo
lowpass  highpass  bandpass  notch
peak_eq  low_shelf  high_shelf
adsr  ar
gain  pan  delay  mod_delay  allpass  comb
mix  crossfade  clip  tanh  fold  bitcrush  soft_clip
chorus  compressor  rms  peak_follow  gate
dc_block  sample_and_hold  semitones_to_ratio
```

Numbers carry domain types. The compiler won't let you pass milliseconds where Hertz belong:

```muse
lowpass(50ms)   // E005: Expected Frequency, got Time
lowpass(500Hz)  // correct
```

## Examples

Twenty-six working plugins in [`examples/`](examples/):

| Plugin | What it does |
|--------|-------------|
| [gain.muse](examples/gain.muse) | Single knob gain stage |
| [filter.muse](examples/filter.muse) | Resonant filter with conditional saturation |
| [synth.muse](examples/synth.muse) | Monophonic subtractive synth |
| [multiband.muse](examples/multiband.muse) | Three-band parallel processor |
| [tremolo.muse](examples/tremolo.muse) | LFO amplitude modulation |
| [distortion.muse](examples/distortion.muse) | Wavefolder + bitcrusher |
| [chorus_effect.muse](examples/chorus_effect.muse) | Modulated delay chorus |
| [dynamics.muse](examples/dynamics.muse) | Compressor with threshold and ratio |
| [pulse_synth.muse](examples/pulse_synth.muse) | Pulse wave MIDI synthesizer |
| [poly_synth.muse](examples/poly_synth.muse) | 8-voice polyphonic synth |
| [mpe_synth.muse](examples/mpe_synth.muse) | MPE-enabled polyphonic synth |
| [unison_synth.muse](examples/unison_synth.muse) | 3-voice unison with detuning |
| [preset_gain.muse](examples/preset_gain.muse) | Gain with factory presets |
| [gui_gain.muse](examples/gui_gain.muse) | Gain with dark-themed web view GUI |
| [gui_layout.muse](examples/gui_layout.muse) | Tier 2 explicit layout with panels |
| [gui_spectrum.muse](examples/gui_spectrum.muse) | Spectrum analyzer + XY pad |
| [gui_styled.muse](examples/gui_styled.muse) | Tier 3 CSS escape hatch demo |
| [gui_compressor.muse](examples/gui_compressor.muse) | Compressor with custom GUI |
| [echo.muse](examples/echo.muse) | Stereo delay effect |
| [phaser.muse](examples/phaser.muse) | Allpass-based phaser |
| [parametric_eq.muse](examples/parametric_eq.muse) | 4-band parametric EQ |
| [gate.muse](examples/gate.muse) | Noise gate |
| [sidechain_compressor.muse](examples/sidechain_compressor.muse) | Sidechain ducker with named buses |
| [drum_machine.muse](examples/drum_machine.muse) | Sample-based drum machine |
| [wavetable_synth.muse](examples/wavetable_synth.muse) | Wavetable synthesizer |
| [looping_sampler.muse](examples/looping_sampler.muse) | Looping sample playback |

Every example compiles to a real plugin binary. Every example has test blocks that pass.

## Under the Hood

```
.muse source
  → Lexer (logos) → Parser (chumsky) → Typed AST
  → Semantic resolver (type checking, function validation)
  → Code generator → standalone Rust/nih-plug crate
    → DSP: allocation-free process loop
    → GUI: HTML/CSS/JS in WebKit web view
    → Tests: #[test] functions with real audio
  → cargo build --release → native binary
  → Bundle assembly → .clap + .vst3
```

The generated audio code is allocation-free and lock-free. No interpreter, no runtime overhead. The output binary is indistinguishable from a hand-written nih-plug plugin.

461 tests. Zero clippy warnings.

## AI Skill File

Muse ships with a [skill file](skill/SKILL.md) that teaches AI agents to write plugins autonomously — language reference, DSP primitive docs, GUI block documentation, plugin recipes, error recovery patterns, and step-by-step workflows. Give it to Claude and ask for a plugin.

## What's Next

Cross-platform builds (Windows/Linux), reverb primitives, oversampling, package system/imports.

## Requirements

- Rust toolchain (stable)
- macOS (binary output is macOS-only for now)

## License

MIT

MUSE

MUSE 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

MUSE

MUSE 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README