Start here. Returns tempo, time signature, length, edit cursor, time selection, transport state, markers and regions, the master track, every track (volume, pan, mute/solo, FX chain, item count) and the user's selected items.

Everything about one track: its items (with ids, positions and note counts), FX chain with presets, sends and receives.

Lists an FX's parameters with their current value (0-1) and displayed value (e.g. '-18.0 dB'). Switches and menus show how many positions they have, and their options when the plugin can name them. Synths can have hundreds of parameters, so search narrows it.

Browses the user's installed plugins. Each appears once (the same plugin in several formats is listed as one) with its kind, format, developer, category and output channels. 'categories' counts every match by category, which helps answer 'what reverbs do I have?'. Pass the name to add_fx or create_track's instrument.

Lists the presets REAPER can see for a plugin (factory programs and presets saved in REAPER), then puts the plugin back exactly as it was. Many commercial plugins keep their presets in their own browser instead; the result says so.

Note names the track's instrument reports (drum kits and samplers often name their notes: 'Kick', 'Snare Rim'...), plus any saved drum map for it.

Reads the notes in a MIDI item (positions in quarter notes from the item start).

Sets the project's starting tempo and/or time signature.

Adds a track, optionally with an instrument so MIDI on it makes sound. For instruments creaper knows, the result includes what they are and how they behave.

Changes a track's name, fader, pan, mute, solo, color or selection.

Deletes a track and everything on it (undoable). Confirm with the user first.

Adds a marker, or a region when end_bar is given (e.g. 'Chorus' from bar 17 to 25).

Plays, stops, pauses or moves the edit cursor. play with start_bar/end_bar lets the user hear a section ('play bars 9 to 17').

Undoes the most recent changes in REAPER (Claude's or the user's).

Runs any action from REAPER's action list. Use it for things the other tools don't cover, and only when the user wants that action. Some actions can't be undone (saving, deleting media files), so name the action to the user first.

Opens a new, empty project tab and makes it the active project, leaving the user's other projects open and untouched. Use it to start a new song (instead of run_action, which asks the user first).

Creates an empty MIDI item (default 4 bars) and returns its item_id for adding notes, chords or drums.

Writes notes into a MIDI item: melodies, basslines, arpeggios, anything. The item grows to fit notes past its end.

Programs drums step-sequencer style on whatever drum instrument the track has. The result's 'lanes' shows which note each lane landed on and why.

Remembers which notes an instrument's drums are on, so add_drum_pattern gets them right on every track that uses it, in this and future sessions. Replaces any map with the same name.

Lists drum maps: the user's saved ones and the instruments creaper knows already.

Deletes a saved drum map (built-in maps can't be deleted, only overridden).

Deletes notes from a MIDI item; with no filters, all of them.

Adds controller events: sustain pedal, mod wheel, expression swells, pitch bend.

Adds a plugin to a track's FX chain (use 'master' for the master bus). For plugins creaper knows, the result includes how they work.

Sets one FX parameter in the plugin's own terms; creaper finds the setting that displays that number or text. Returns what the plugin now displays.

Sets several parameters of one plugin as a single undo step, e.g. shaping a synth patch or dialing in a compressor. Each change reports its result or its own error.

Bypasses or enables an FX, loads a preset, or opens its window for the user.

Gives each stereo output of a multi-output instrument its own track (drum machines, Elektron Overbridge, multitimbral synths, samplers). The main pair stays on the instrument's track; new tracks are named after the plugin's outputs.

Saves the plugin's current sound to the user's sound library, so it can be loaded on any track in any project. Works for sounds picked in a plugin's own preset browser (Arturia, etc.), which REAPER can't otherwise see.

Browses the user's sound library. Check here before designing a sound from scratch.

Recalls a saved sound. Reuses the same plugin if it's already on the track, otherwise adds it; an instrument sound replaces a different instrument unless replace_instrument is false. Undoable.

Renames a saved sound or changes its tags or description.

Deletes a sound from the library. This can't be undone.

Removes an FX from a track's chain.

Creates or adjusts a send (e.g. vocals to a reverb bus), or removes it.

Renders the mix or one track and measures it: integrated/short-term loudness (LUFS), loudness range, true peak, RMS, crest factor, clipping, stereo correlation (including the low end), and frequency balance by band and octave. Rendering runs faster than real time but takes a moment for long ranges.

Writes automation: volume rides, pans, filter sweeps, wobbles. Give points, a ramp or an lfo (they can be combined). The envelope is created and shown if needed, and the change is one undo step.

Reads a track's automation points (bars/beats with values in real units), or lists which envelopes it has.

Removes automation points in a range (default: all of them). Undoable.

Moves, trims, fades, re-pitches or otherwise edits an audio or MIDI item.

Splits an item in two at a bar/beat; returns both halves' ids.

Copies an item (e.g. repeat a 4-bar loop, or reuse the chorus). Copies are placed back to back.

Deletes an item (undoable).

Imports an audio or MIDI file onto a track.

Edits existing MIDI notes: quantize (with swing), humanize, transpose, snap to a scale, set or ramp velocities, strum chords, make legato, and develop motifs (diatonic transposition, inversion, retrograde, augmentation, harmony lines, sequences, negative harmony). Filters pick which notes; the rest stay as they are. One undo step.

Sets up side-chain compression in one go: routes the source into the target's compressor sidechain (channels 3/4), switches the compressor to listen to it, then measures the source and sets the sidechain level (and ReaComp's threshold) so it actually ducks by about the depth asked for.

Creates a submix bus: the tracks send to it (post-fader) instead of straight to the master, so they can be processed and leveled together.

New York-style parallel compression: a bus with a heavily compressed copy of the track, blended underneath the untouched original.

A starting vocal chain: high-pass and tone EQ, then a compressor. With REAPER's ReaEQ/ReaComp it's set up for you; with other plugins they're added and you set them with set_fx_parameters. A starting point to tweak by ear; no de-esser.

Masters the mix: optional EQ, then a glue compressor and ReaLimit on the master (reusing ones already there). Plugins with a built-in profile (REAPER's ReaComp, Arturia's Bus FORCE, Comp VCA-65, FET-76, TUBE-STA) are set up and calibrated by measurement so the glue takes about glue_db off the peaks. Then the limiter and master fader are adjusted until the integrated loudness is within 0.5 LU of the target, and the true peak is checked against the ceiling. Each step renders the range, so a short loud section is much faster than the whole song.

How a plugin works, for plugins creaper knows: its role, signal flow quirks, setup it needs and which controls do what. For others, inspect it with get_fx_parameters and save_note what you learn.

Measures the mix and compares it with a style profile: loudness, true peak, dynamics and low-end mono get verdicts; low end and tone are reported to judge by ear.

Remembers something for future sessions: a plugin quirk, the user's taste, a mix lesson. Save lasting lessons only, not one-off details of this song.

Recalls saved notes. Check for the user's preferences and plugin notes before designing sounds or mixing.

Deletes a saved note.

A key or mode explained: its notes spelled correctly, intervals, sound and uses, the chords on each degree (triads and 7ths with Roman numerals and functions), and the modes that share its notes.

The scales and modes creaper knows, with what each sounds like.

Names the chord some notes make (with inversion or slash bass), most likely first, and, with a key, its Roman numeral and function.

Roman-numeral analysis of a progression: the key (detected if not given), each chord's numeral, function and spelling, secondary dominants, borrowed chords, tritone subs, Neapolitan and augmented sixths, cadences, and famous progressions it matches.

Chord progressions for a key: the genre's own idioms, famous named progressions that fit the mood, and fresh ones generated from functional harmony. Each comes with numerals, chord symbols in the key and what makes it work.

Reharmonizes a progression with jazz, soul, classical and film techniques, keeping its length, and explains each change.

Common-practice voice leading. Given chords, writes a four-part SATB realization that avoids parallel fifths/octaves, hidden octaves, crossings, bad spacing and unresolved leading tones/sevenths. Given voicings, lists every rule they break.

How to change key: how close the keys are, pivot chords they share, and chord routes from smoothest to most dramatic (pivot, ii-V, common tone, chromatic mediant, truck-driver, diminished pivot).

Rhythm patterns as step strings ready for add_drum_pattern (x = hit, . = rest): named timelines (clave, tresillo, bell patterns), Euclidean rhythms and polyrhythms.

Browse the genre library: every profile covers composition (modes, progressions, voicings, bass, melody), rhythm (groove, swing, feel), arrangement (form, instruments, sound design) and mixing (loudness, tone, width).

Everything creaper knows about a genre: history and touchstones, tempo, feel and swing, modes and favourite keys, progressions (spelled in a key), harmony habits, voicing and comping, bass, melody, drum groove (ready for add_genre_groove), form, instruments, sound design, production, mix targets and theory notes.

Writes a chord part from chord symbols or Roman numerals (with a key), in any voicing and comping rhythm, with smooth voice leading. Returns the notes chosen.

Writes a bassline that follows the chords in a chosen style.

Composes a melody over chords: a rhythmic motif developed in phrases, chord tones on strong beats, stepwise lines with leaps recovered, a high point, a half-close at the end of the first phrase and the tonic at the end. Try several seeds.

Programs a genre's signature drum groove (from its profile) on the track's drum instrument, with the genre's swing.

Reads a MIDI item and explains its harmony: the key (detected), chords over time, Roman numerals and functions, cadences, notes outside the key, and (with a melody item) passing tones, suspensions, appoggiaturas and other non-chord tones.

Finds chords for an existing melody (strong-beat melody notes become chord tones, chords move tonic-predominant-dominant, the end cadences home), and optionally writes them.

Builds a genre sketch in one call: tempo, then tracks with a drum groove, bassline, voiced and comped chords and a melody, all following the genre's profile (progression, harmonic rhythm, voicing, comping, bass style, melody density and scale, swing). Every part is ordinary MIDI to edit afterwards. It's one loop repeated: a starting point for a song, not the arrangement.

Works out a drum kit by ear: plays every key in the range through the track's instrument (offline, in a temporary item that's removed afterwards), measures each sound and identifies it (kick, snare, clap, rim, closed/open hat, crash, ride, toms, shaker, cowbell, percussion). Saves the layout as a drum map so add_drum_pattern and genre grooves land on the right sounds. Use it whenever a kit's layout is unknown, instead of asking the user. Kits inside one plugin can differ: map again after changing kit.

Listens to the track's current sound: plays notes across the range offline (in a temporary item that's removed afterwards) and reports its playable range, whether it follows pitch (and any transposition), attack, sustain, release, brightness and character (bright/dark, plucky/sustained, pad-like, noisy). Use it to check a patch you designed, or to find out what an unfamiliar sound or preset is.

Tests installed plugins to learn what they actually do, at their default settings: instruments (makes sound? pitched or drum kit, range, character, late starts) and effects (reverb, delay, compressor/limiter, gate, EQ curve, saturation, modulation, pitch, stereo width, latency). Each test runs on a hidden temporary track after the end of the project and is removed again. Results go into the plugin catalog (get_plugin_catalog, list_installed_fx). Long scans stop after max_seconds and report what's left; call again to continue.

What creaper has learned about the user's plugins by testing them (scan_plugins): each plugin's roles and a summary of what it does at default settings.

The project's tempo and time-signature changes, with where each happens and whether it ramps to the next.

Adds, changes or removes tempo and time-signature changes: tempo jumps between sections, ramps (accelerando/ritardando), odd-meter bars. One undo step. Items stay at their bar positions; the starting tempo is set with set_tempo.

Switches the sound of a MIDI instrument that follows program changes (General MIDI synths, hardware synths through ReaControlMIDI, multitimbral plugins), with an optional bank select first.

Reads a MIDI item's controller events: CCs (mod wheel, sustain, expression...), pitch bend, program changes and aftertouch, with positions in QN.

Deletes controller events matching the filters (all of them if none are given), e.g. clear the sustain pedal (cc=64) or old pitch bends. One undo step.

How audio and MIDI flow through the project: folders, which tracks go to the master or their folder, every send (destination, level, pan, pre/post, channels, sidechain inputs, MIDI) and hardware outputs. Read it before changing routing.

Groups tracks in a folder: a new folder track above them that they play through, so the group can be leveled, muted and processed together (effects on the folder track act like a bus). Use create_bus instead to keep tracks where they are and send them.

Turns a track's direct output to the master (or its parent folder) on or off.

Lists, adds or removes the folders creaper searches for samples and loops (by default the ones it finds: Arturia's sample library, SILA's, Music, REAPER Media).

Searches the user's sample folders by name, role, loop tempo and key, and (by default) listens to the top results to say what each actually is.

Listens to one sample: loop or one-shot, what drum it sounds like or what pitch it plays, a loop's tempo and length in bars and its key, and whether it starts late.

Puts a loop on a track in time: stretched from its own tempo to the project's (pitch preserved), optionally moved into the project's key, and repeated to fill a number of bars.

Builds a drum kit from sample files in REAPER's own sampler (one ReaSamplOmatic5000 per drum, on the General MIDI keys), so drum patterns and genre grooves land on the right sounds and every sample can be swapped by name later. Works with any samples, including the ones other instruments ship with.

Builds a playable instrument from pitched sample files (strings, brass, pizzicato, choir, a sampled synth...): each sample covers a stretch of keys and follows the keyboard, tuned from the pitch it actually plays (measured by ear, with cents; sample file names are sometimes an octave off), with velocity response, note-offs and a release. Better than build_drum_kit for melodic parts, which plays each sample on one key at its own pitch.

Saves the project: in place when it already has a file, as a new file the first time (or with a new name), or as a snapshot copy before big changes. A first save or save-as reopens the saved file in the same tab, so the undo history starts fresh.

Exports the finished mix (the master, with its effects) to an audio file and reports its loudness and true peak. Use master_to_target first for a release master.

Exports each track as its own audio file (post-fader, with its effects but not the master's), all the same length so they line up from the same start: for mixing elsewhere, remixes, or sharing parts.

Lists the exported files in the export folder (newest first).

The audio inputs of the user's audio interface (as REAPER names them) and the MIDI input devices, for setting what a track records from.

Sets what a track records and whether it's armed: an audio input (a mic, a guitar, a hardware synth's outputs on the interface) or a MIDI device (a keyboard, a hardware synth's MIDI out), input monitoring, and the record mode.

Starts recording on every armed track, from a bar (default: the edit cursor), optionally stopping by itself at a bar. Without an end it records until stopped (transport stop). The performer hears the count-in and metronome as set in REAPER.

Whether REAPER is recording or playing, where the playhead is, and when it'll stop. If recording just stopped and REAPER is asking the user which files to keep, this waits for them to answer.

The takes in an item (each recording pass over the same spot), and which is active.

Makes a take the one that plays (for picking the best performance).

Puts each take of an item on its own new track, to compare or comp them side by side.

Sets or clears the time selection and loop points, and turns repeat on/off: for looping a section while working on it, or for actions that use the selection.

Renames, moves, resizes or recolors a marker or region (e.g. rename 'Chorus' to 'Chorus 1', or extend the bridge region to bar 49).

Deletes a marker or region (not the audio or MIDI under it).

Saves tracks (with their plugins, sends between them, settings and items) as a REAPER track template, to reuse in any project.

The user's REAPER track templates.

Adds a track template's tracks to the project.

Freezes tracks: renders them to audio and takes their plugins offline to save CPU (heavy synths, long effect chains), or unfreezes them to edit again.

The text-to-speech voices on this computer, best first, for add_robot_vocal's voice. Piper voices (if installed) sound the most natural; each shows its license, and only public domain, CC0 or CC BY ones may go in released music.

Makes a voice the user's default for robot vocals (used whenever no voice is named), remembered across sessions.

Makes a synth sing words: the computer's text-to-speech voice speaks each word under its note of a melody item (top note of each chord), each word's vowel held over its notes while its consonants keep their natural speed. talkbox (default) shapes a sawtooth playing the melody with the speech's formants, with noise for the consonants, and puts the result on one audio track after the melody's track. vocoder builds three tracks (the vocal with ReaVocode, its voice, and a carrier synth that can play the melody's chords). Robot vocals are only understood when they're sparse: a short hook of a few words, repeated (think "one more time", "around the world"), at most one syllable per beat, on quarter notes or longer. Dense, fast verses turn to mush. The result includes a measured clarity score (alone and in the mix): act on it rather than guessing.

Turns a real vocal sample into rhythmic vocal chops, the house / future-bass way: slices it at its syllables, lays the slices on a 16th-note pattern, and shifts each one (at most a tritone, correcting its tuning) onto the chord or key. Real voices beat robot vocals, so use this first when the user's samples have vocals. One item per chop, all ordinary audio to edit afterwards.

For a real singing voice: writes a melody item and its lyrics as a MIDI file that singing synths (Synthesizer V, ACE Studio, VOCALOID, OpenUtau) import with the words on the notes, at the song's tempo and positions. Says which singers are installed and how to load it. The singer renders the vocal; then insert_audio_file it at bar 1 (the file starts at the song's start) and mix it like any vocal.

How understandable a robot vocal's words are, alone and in the full mix, using STOI (the standard intelligibility measure) against the clean spoken words. Use it instead of guessing: if it's clear alone but not in the mix, the mix is burying it; if it's unclear alone, change the words, notes, voice or style.

Is a part in tune? Renders the track and measures what actually sounds. For a MIDI part: each held note's pitch against the note played (cents off; a detuned patch, vibrato or glide shows up). For audio (vocals, samples, chops): how far its pitches sit from the nearest semitone (a detuned sample) and how many fall outside the key or chords. Mono lines measure best; chords are judged by their top note.

A picture of the sound to look at, since you can't hear it: time left to right, frequency bottom (30 Hz) to top (16 kHz, log scale), loudness as colour (black quiet, purple/orange mid, yellow loud). Faint horizontal lines mark 100 Hz, 1 kHz and 10 kHz; white vertical lines mark section starts. Read it for: mud (a solid band at 200-500 Hz), harshness (bright 2-5 kHz), empty or crowded sections, clipping or pumping, a vocal masked by other parts, sections that look identical.

Checks how the song ends against how it will be used, by rendering its last 16 seconds (plus the export tail) and measuring the level: a fade-out, a quiet or silent end, a tail cut off mid-ring, or a stinger that lingers. Also reports the song's length. With region, checks that region (its length and its end) instead.

Measures many tracks in one render pass and returns a compact table: each track's loudness while it plays (max short-term LUFS), its peak, how bright it is, and where its energy sits (low / mid / high). Use it instead of analyze_audio track by track when balancing a mix: one call instead of dozens.

A whole first mix in one call: measures every track (one render pass), works out each one's role, then sets levels for the genre, high-passes everything that isn't bass and cuts low-mid mud, compresses vocals/bass/leads that need it, pans the wide parts, sends to a reverb return, ducks bass under the kick (dance styles), and sets -6 dBFS of headroom for mastering, then measures robot vocals' clarity in the mix and, if other parts cover the words, raises the vocal and ducks the parts covering it. Saves a copy of the project first when it has a file. Leaves tracks the user already set up (EQ, compression, panning) alone on those points. Then check it: show_spectrogram, check_vocal_clarity, compare_mix_to_style.

Saves a motif (a theme's notes and rhythm) to reuse in other songs and projects, like a film or game score's leitmotif: place_motif puts it back in any key.

The motifs saved with save_motif, for place_motif.

Puts a saved motif into a MIDI item (existing notes stay): in the song's key and mode, at an octave and speed that fit the moment.

Exports each region of the project as its own file named after the region (for sound effects and their variations: shot_01, shot_02 ...), in one render pass. One-shots: mono unless listed in stereo, DC removed, the silence before the sound cut so it starts within a millisecond of the file start, trailing silence dropped, peak set to peak_db, and a warning when the region cuts the sound off before it dies away. Loops: seamless (crossfaded seam, no fade at either end), their length reported. 16-bit files are dithered; 24-bit aren't. Put each sound in its own region with a little room after it (for its tail), then call this once.