Music Studio

Create a hosted music share link only when the user asks to share or store a piece online. Uploads the supplied score or pattern to MCP Music Studio for 30 days; anyone with the link can view and play it without signing in. Creating the same share again refreshes its expiry. Playback does not require this tool, and a play result's '▶ Play in browser' link already opens the piece for anyone when it fit in the link; this tool gives a short stored link. Provide kind 'score' with score, or kind 'play' with pattern. Never include private information or secrets.

{
  "type": "object",
  "properties": {
    "kind": {
      "type": "string",
      "enum": [
        "score",
        "play"
      ]
    },
    "score": {
      "type": "object",
      "properties": {
        "abcNotation": {
          "type": "string",
          "minLength": 1,
          "maxLength": 65536,
          "description": "The ABC notation, as for play-sheet-music."
        },
        "title": {
          "type": "string"
        },
        "instrument": {
          "description": "General MIDI instrument name, as for play-sheet-music.",
          "type": "string"
        },
        "style": {
          "type": "string",
          "enum": [
            "rock",
            "jazz",
            "bossa",
            "waltz",
            "march",
            "reggae",
            "folk",
            "classical"
          ]
        },
        "tempo": {
          "type": "number",
          "minimum": 40,
          "maximum": 240
        },
        "swing": {
          "type": "number",
          "minimum": 0,
          "maximum": 75
        },
        "drumIntro": {
          "type": "integer",
          "minimum": 0,
          "maximum": 8
        },
        "transpose": {
          "type": "integer",
          "minimum": -12,
          "maximum": 12
        }
      },
      "required": [
        "abcNotation"
      ],
      "description": "The arguments you gave play-sheet-music."
    },
    "pattern": {
      "type": "object",
      "properties": {
        "code": {
          "type": "string",
          "maxLength": 65536,
          "description": "The Strudel code, as for play-live-pattern."
        },
        "title": {
          "type": "string"
        },
        "bpm": {
          "type": "number",
          "minimum": 40,
          "maximum": 300
        },
        "autoplay": {
          "type": "boolean"
        },
        "visuals": {
          "type": "string",
          "enum": [
            "none",
            "pianoroll",
            "punchcard",
            "scope",
            "spectrum",
            "hydra-kaleid",
            "hydra-pulse",
            "hydra-wash",
            "hydra-feed"
          ]
        }
      },
      "required": [
        "code"
      ],
      "description": "The arguments you gave play-live-pattern (theme and session are not carried)."
    }
  },
  "required": [
    "kind"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Write a score in ABC notation and play it as sheet music: a melody, a harmonized piece, a multi-voice arrangement or a well-known tune, on any of the 128 General MIDI instruments. Put chord symbols above the notes and add a style (rock, jazz, bossa, waltz, folk...) for drums, bass and chords. The user can edit the score in the player, change its style and instrument, and download WAV or MIDI. The result confirms the parse; it returns no audio. Start with get-music-guide topic 'genres'; 'abc-syntax' and 'instruments' for the rest. The music player renders inline with interactive playback controls.

{
  "type": "object",
  "properties": {
    "abcNotation": {
      "default": "X:1\nT:Twinkle, Twinkle Little Star\nM:4/4\nL:1/4\nK:C\nC C G G | A A G2 | F F E E | D D C2 |\nG G F F | E E D2 | G G F F | E E D2 |\nC C G G | A A G2 | F F E E | D D C2 |",
      "description": "ABC notation string. Include chord symbols (\"C\", \"Am7\") above notes for auto-accompaniment with style presets.",
      "type": "string",
      "maxLength": 65536
    },
    "title": {
      "description": "Piece title (overrides T: in ABC). Shown in the widget header and used as the filename stem for the WAV/MIDI downloads.",
      "type": "string"
    },
    "instrument": {
      "description": "Default instrument for the main voice — any of the 128 General MIDI names (e.g. 'Flute', 'Cello', 'Banjo', 'Alto Sax'). Matching is fuzzy and picks the lowest GM program among the hits, so 'sax' gives Soprano Sax; the result text names what you actually got whenever it isn't what you asked for. Use get-music-guide with topic 'instruments' for the full list, or %%MIDI program N in the ABC to set a program per voice.",
      "type": "string"
    },
    "style": {
      "description": "Accompaniment style. Adds drums, bass, and chord patterns automatically. Your ABC needs chord symbols (\"C\", \"Am\") for accompaniment to work. Options: rock, jazz, bossa, waltz, march, reggae, folk, classical.",
      "type": "string",
      "enum": [
        "rock",
        "jazz",
        "bossa",
        "waltz",
        "march",
        "reggae",
        "folk",
        "classical"
      ]
    },
    "tempo": {
      "description": "Tempo in BPM (40-240). Overrides Q: in ABC notation.",
      "type": "number",
      "minimum": 40,
      "maximum": 240
    },
    "swing": {
      "description": "Swing as the share of the beat given to its first half. 50 = straight, 60 ≈ 3:2, 66 = triplet swing, 75 = maximum (dotted eighth + sixteenth). Anything at or below 50 is treated as no swing. Only takes effect in an x/4 or x/8 meter.",
      "type": "number",
      "minimum": 0,
      "maximum": 75
    },
    "drumIntro": {
      "description": "Bars of count-in before the melody starts (0-8). Needs a style preset — the count-in is played by that style's drum kit, so without a style you get silent bars instead.",
      "type": "integer",
      "minimum": 0,
      "maximum": 8
    },
    "transpose": {
      "description": "Transpose by semitones (-12 to 12). Positive=higher, negative=lower. Rewrites the notation and the key signature, so the printed score matches what plays.",
      "type": "integer",
      "minimum": -12,
      "maximum": 12
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Live-code music in Strudel (TidalCycles mini-notation in JavaScript) and play it in a player the user can edit. Layer drums, bass and melody with stack(): 71 drum-machine banks, 128 GM instruments, synths and a full effects chain. Add .pianoroll() for a live piano roll (or .punchcard()/.scope()/.spectrum(), one per pattern), pass `visuals` for a ready-made animation and `theme` for the editor colours. Each call creates a NEW player. Optional, when you want more (get-strudel-guide topic in brackets): shader backgrounds that follow the music — start with `await initHydra()`, lock to the beat with H(pattern), react to the sound with () => a.fft[0] ('hydra'); canvases, scenes and spoken lines for music videos and films ('stage', 'film'); taps, faders, pads and controls you draw, played by the user; tilt and mic, which follow the phone on the browser player (a chat's frame usually blocks them) ('interactive'); complete pieces ('gallery'). To jam back and forth, or to change a piece while it plays, pass session: true, then use update-session and get-session. The Strudel REPL renders inline with an editable code editor, visualizations, and playback controls.

{
  "type": "object",
  "properties": {
    "code": {
      "type": "string",
      "maxLength": 65536,
      "description": "Strudel pattern code. Uses TidalCycles mini-notation in JavaScript. Use stack() to layer drums, bass, and melody. Set tempo with setcps(bpm/60/4) or use the bpm parameter. The REPL plays the LAST expression: setup lines (await initHydra(), all(), setcps()) go BEFORE the pattern. Double quotes are mini-notation — use single quotes for plain strings and URLs. One draw method per pattern; pass a.fft values as functions (() => a.fft[0])."
    },
    "title": {
      "description": "Pattern title displayed in the widget header (e.g. 'Midnight Rain').",
      "type": "string"
    },
    "bpm": {
      "description": "Tempo in BPM (40-300). Converts to setcps() automatically.",
      "type": "number",
      "minimum": 40,
      "maximum": 300
    },
    "autoplay": {
      "description": "Start playing immediately (default: true). May require user click due to browser autoplay policy.",
      "type": "boolean"
    },
    "visuals": {
      "description": "A ready-made visual for code that has none of its own: pianoroll, punchcard, scope or spectrum (drawn behind the code), or hydra-kaleid, hydra-pulse, hydra-wash or hydra-feed (shader backgrounds). It only fills a layer the code leaves empty, and shaders are skipped for viewers who prefer reduced motion. Your own visual is the better result (topics 'visuals' and 'hydra').",
      "type": "string",
      "enum": [
        "none",
        "pianoroll",
        "punchcard",
        "scope",
        "spectrum",
        "hydra-kaleid",
        "hydra-pulse",
        "hydra-wash",
        "hydra-feed"
      ]
    },
    "session": {
      "description": "Optional: keep this player open as a live session. update-session then swaps new code in on the bar, and get-session reports what played and what the user did. For a jam, or a piece you change while it plays. Give the user something to play — taps, a fader, a grid (topic 'interactive') — or they answer by editing the code and pressing Pass. The log is kept until 2 hours idle.",
      "type": "boolean"
    },
    "theme": {
      "description": "Editor colour scheme. It also sets the ground the visuals sit on, so pick a dark one when the visual is the point (e.g. 'nord', 'sonicPink', 'tokyoNight').",
      "type": "string",
      "enum": [
        "strudelTheme",
        "algoboy",
        "archBtw",
        "androidstudio",
        "atomone",
        "aura",
        "bbedit",
        "blackscreen",
        "bluescreen",
        "bluescreenlight",
        "CutiePi",
        "darcula",
        "dracula",
        "duotoneDark",
        "eclipse",
        "fruitDaw",
        "githubDark",
        "githubLight",
        "greenText",
        "gruvboxDark",
        "gruvboxLight",
        "sonicPink",
        "materialDark",
        "materialLight",
        "monokai",
        "noctisLilac",
        "nord",
        "redText",
        "solarizedDark",
        "solarizedLight",
        "sublime",
        "teletext",
        "tokyoNight",
        "tokyoNightDay",
        "tokyoNightStorm",
        "vscodeDark",
        "vscodeLight",
        "whitescreen",
        "xcodeLight"
      ]
    }
  },
  "required": [
    "code"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Only for a live session (play-live-pattern session: true). Reads whether the player is up and what it played, its errors and silences, and what the human did since your last read: taps, changes to remember() state, code they ran, a Pass to you, or End. Read it before assuming a piece played. With wait: 'pass' it listens until the human presses Pass, so a whole back-and-forth set fits in one turn: update-session, get-session(wait: 'pass'), answer, listen again.

{
  "type": "object",
  "properties": {
    "session": {
      "type": "string",
      "pattern": "^[a-z2-7]{16}$",
      "description": "The session id from play-live-pattern's result (16 lowercase letters/digits)."
    },
    "wait": {
      "description": "Listen instead of just reading: 'pass' until the listener presses Pass, 'activity' until they play. Returns at once if that already happened since your last read, else after ~40 s — call again to keep listening.",
      "type": "string",
      "enum": [
        "pass",
        "activity"
      ]
    }
  },
  "required": [
    "session"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Only for a live session. Swaps new code into the session's player while the music keeps playing. Send the WHOLE pattern, as for play-live-pattern. It lands on the next bar (quantize 1, the default), the next multiple of n bars, or at once (0): set quantize to your phrase length (8-bar phrase → 8). If the player answers within a few seconds, the result says whether it ran the code, or its error. To change a piece's remember() state, ship a merge, not a new start value (get-strudel-guide topic 'interactive').

{
  "type": "object",
  "properties": {
    "session": {
      "type": "string",
      "pattern": "^[a-z2-7]{16}$",
      "description": "The session id from play-live-pattern's result (16 lowercase letters/digits)."
    },
    "code": {
      "type": "string",
      "maxLength": 65536,
      "description": "The complete new Strudel pattern (same rules as play-live-pattern's code)."
    },
    "quantize": {
      "description": "Land on the next multiple of this many cycles (bars). 1 = next bar (default), 4/8 = phrase, 0 = now.",
      "type": "integer",
      "minimum": 0,
      "maximum": 32
    }
  },
  "required": [
    "session",
    "code"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Reference for ABC sheet music. Topics: genres (complete templates: jazz, blues, folk, rock, bossa, a 3/4 minuet, a lullaby), styles (what each accompaniment preset does), instruments (GM list + combos), drums (patterns + percussion notes), abc-syntax (notation reference), arrangements (multi-voice patterns), midi-directives (%%MIDI reference).

{
  "type": "object",
  "properties": {
    "topic": {
      "type": "string",
      "enum": [
        "instruments",
        "drums",
        "abc-syntax",
        "arrangements",
        "genres",
        "styles",
        "midi-directives"
      ],
      "description": "Reference topic. Start with 'genres' for complete examples, 'styles' to understand presets, or 'instruments' for the full instrument list."
    }
  },
  "required": [
    "topic"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Reference and recipes for Strudel live coding. Music: genres (complete templates: techno, house, dnb, ambient, jazz, lofi, synthwave), mini-notation, sounds (synths, 71 drum banks, 128 GM instruments, vcsl samples), effects, patterns, tips (tempo, common mistakes), advanced (samples, wavetables, signals, chord voicings). Visuals: visuals (draw methods, presets, themes), hydra (shader backgrounds, H(pattern), the audio-reactive a.fft). Optional modules — the code is real browser JavaScript: stage (your own canvases, onFrame/onEvent/onTap, say), film (scenes on bars, text, narration), interactive (taps into notes, faders/pads/xy, tilt/mic, remember() for controls you draw, live sessions), craft (what makes a piece land), debugging (what the player reports back), gallery (complete pieces; fetch one with `piece`).

{
  "type": "object",
  "properties": {
    "topic": {
      "type": "string",
      "enum": [
        "mini-notation",
        "sounds",
        "effects",
        "patterns",
        "genres",
        "tips",
        "visuals",
        "hydra",
        "advanced",
        "stage",
        "film",
        "interactive",
        "craft",
        "debugging",
        "gallery"
      ],
      "description": "Reference topic. Start with 'genres' for working templates, 'sounds' for instruments, 'visuals' for draw methods and presets, 'hydra' for shader backgrounds, 'advanced' for sample loading. For a music video or film: 'craft', 'stage', 'film', then gallery piece 'first-light'. For taps, controls, a drawn grid or a jam: 'interactive' alone (take only the sections you need), then gallery piece 'weather-machine' or 'trade-a-beat'."
    },
    "piece": {
      "description": "With topic 'gallery': the complete code of one piece (the index lists them).",
      "type": "string",
      "enum": [
        "first-light",
        "duet",
        "petri-dish",
        "lossy-terminal",
        "signal-corruption",
        "weather-machine",
        "two-decks",
        "trade-a-beat",
        "still-water",
        "lullaby"
      ]
    }
  },
  "required": [
    "topic"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Search detailed documentation for Strudel live coding or ABC/ABCJS notation. Returns relevant code examples and explanations from the official docs. Use this when the curated guides (get-strudel-guide, get-music-guide) don't cover what you need — for specific functions, advanced techniques, or when you're unsure about syntax. Powered by semantic search over strudel.cc and ABCJS docs.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "maxLength": 500,
      "description": "What you want to know. Be specific. Good: 'how to use FM synthesis with envelope' or 'chop and slice sample manipulation'. Bad: 'effects' or 'help'."
    },
    "library": {
      "default": "strudel",
      "description": "Which library to search: 'strudel' for live coding patterns, 'abcjs' for sheet music notation.",
      "type": "string",
      "enum": [
        "strudel",
        "abcjs"
      ]
    }
  },
  "required": [
    "query"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Music theory helper: name a chord from notes, guess the key, get a progression, or list what fits a key. Returns both the ABC chord-symbol spelling (for play-sheet-music) and the Strudel form (for play-live-pattern). Tasks: detect-chord (notes -> chord name + what to play next), detect-key (notes or chords -> best key + diatonic chords), suggest-progression (key [+ romanNumerals] -> chord symbols), scale-for-chord (chords -> the scale to improvise over each), key-chords (key -> every diatonic triad, seventh, and chord scale). Use it before writing chord symbols for a style preset, or to check a harmonization.

{
  "type": "object",
  "properties": {
    "task": {
      "type": "string",
      "enum": [
        "detect-chord",
        "detect-key",
        "suggest-progression",
        "scale-for-chord",
        "key-chords"
      ],
      "description": "What to work out. detect-chord needs notes; detect-key needs notes or chords; scale-for-chord needs chords; suggest-progression/key-chords need a key."
    },
    "notes": {
      "description": "Note names, e.g. [\"c4\",\"e4\",\"g4\",\"b4\"] or [\"C\",\"Eb\",\"G\"]. For detect-chord/detect-key.",
      "maxItems": 64,
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "chords": {
      "description": "Chord symbols, e.g. [\"Dm7\",\"G7\",\"Cmaj7\"]. For detect-key/scale-for-chord.",
      "maxItems": 64,
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "key": {
      "description": "Key, e.g. \"C\", \"A minor\", \"F# major\". For suggest-progression/key-chords.",
      "type": "string"
    },
    "romanNumerals": {
      "description": "Roman numerals to render in the key, e.g. [\"ii7\",\"V7\",\"Imaj7\"] or [\"I\",\"V\",\"vi\",\"IV\"]. Optional for suggest-progression — omit it to get common progressions instead.",
      "maxItems": 64,
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "task"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}

Turn an ABC melody into Strudel mini-notation so a scored piece can be remixed live. Returns runnable code — setcps() from the Q: tempo, one [...] bar group per bar inside note("<...>"), with a chord("<...>").voicing() layer stacked alongside it when the ABC has chord symbols (one stack(), because Strudel plays only the last expression) — then pass it to play-live-pattern. Durations become @ weights, rests become ~, triplets nest, the key signature is folded into the note names, and %%MIDI program picks the sound. Lists what was lost (grace notes, dynamics, repeats, lyrics, other voices, inline tempo changes, a short final bar, ABC's own gchord/drum accompaniment). Pick a single voice with `voice`; re-run per voice and stack() them for a full arrangement.

{
  "type": "object",
  "properties": {
    "abcNotation": {
      "type": "string",
      "maxLength": 65536,
      "description": "ABC notation to convert (the same string you'd pass to play-sheet-music)."
    },
    "voice": {
      "description": "Which voice to convert, 1-based, counted across all staves (default 1). Multi-voice tunes report how many voices there are.",
      "type": "integer",
      "minimum": 1,
      "maximum": 9007199254740991
    },
    "sound": {
      "description": "Strudel sound for the melody (defaults to the tune's %%MIDI program, else \"gm_piano\"). Use a GM soundfont name like gm_flute or gm_epiano1 — see get-strudel-guide topic 'sounds'.",
      "type": "string"
    }
  },
  "required": [
    "abcNotation"
  ],
  "$schema": "http://json-schema.org/draft-07/schema#"
}