CLI

Every command and option, from daemon/src/cli/program.ts and the command groups it adds; rapid <command> --help prints one. Job commands talk to the daemon (rapid video and rapid open start it when none answers); setup, the render commands, rapid projects, and the style and format commands run without it. rapid is the shim rapid setup writes; node daemon/bin/rapid.ts from a checkout is the same.

#Environment

$RAPID_HOME/config.json may hold slots (see lanes), styles_repo (the owner/repo bare style names come from, see sharing styles), and projects, the folders rapid finds projects in (see rapid projects).

Every failure prints one line, rapid: <what went wrong>, and exits 1. When no daemon answers, a job command prints rapid: No rapid daemon is running at http://127.0.0.1:4317. Start one with `rapid serve`.

#Setup and the daemon

#rapid setup

rapid setup [options]

Writes a shim, ~/.local/bin/rapid, that runs this checkout's CLI (a file there that isn't rapid's is left alone), builds the screening page (pnpm --filter @rapid/screen build) when screen/dist is missing, and reports one line per check, ok or missing with its fix: the rapid command and whether its folder is on PATH, Node 24 or newer, ffmpeg, ffprobe, Google Chrome (CHROME_PATH), Claude Code, the Claude sign-in (claude auth status --json, or ANTHROPIC_API_KEY), and the page. It never edits a shell profile or installs a tool. Exits 1 while anything is missing.

Run it the first time as node daemon/bin/rapid.ts setup from the checkout.

#rapid daemon

rapid daemon ensure [--timeout <seconds>]
rapid daemon stop
rapid daemon status

The daemon in the background. It runs detached, logs to $RAPID_HOME/daemon.log, and keeps its PID in $RAPID_HOME/daemon.pid.

#rapid serve

rapid serve [options]

Runs the daemon in the foreground until Ctrl-C.

#rapid mcp

rapid mcp

Serves rapid's tools to a model over MCP on stdio. Claude Code starts it through the plugin; you don't run it yourself. Its eleven tools are in using the MCP tools. Tools that need the daemon start one in the background, as rapid daemon ensure does.

#Videos and jobs

#rapid video

rapid video [options] [project]

Makes a video from a project: storyboard, key frames, scenes, reviews, then the video. Starts the daemon in the background when none answers (started the daemon in the background). Prints the job's id, then (with --brief) project <folder>, then the screening page's address.

#rapid new

rapid new [options]

Starts an empty job, for nodes added through the HTTP API. Prints its id. To start a video, use rapid video.

#rapid jobs

Lists jobs: id, state, title.

#rapid open

rapid open [job] [--print]

Opens the screening page in your default browser, at the job named or the newest one, starting the daemon first when none answers. It prints the address; --print prints it and opens nothing.

#rapid projects

rapid projects
rapid projects add <dir>
rapid projects remove <dir>

The folders rapid finds your projects in, and the projects in each: every folder directly inside one is a project, titled by its brief.md's first heading (or its name), and a chosen folder that holds a brief.md is a project itself (node_modules and dot folders are skipped). With none chosen, it's ~/rapid, where new videos go. add looks in another folder too; remove stops looking in one and leaves the folder as it is. The list is projects in $RAPID_HOME/config.json; the first add writes ~/rapid there with the new folder, so it keeps being found. These commands need no daemon; the screening page's jobs page lists what they find, with each project's jobs, and can add a folder and start a video in one too.

#rapid job

rapid job <id>

A job's nodes: id, state, lane, type, label, wait and run times, and the first line of any error; then each choice the video made without you (chose: …).

#rapid approve

rapid approve <node>

Approves a node that needs you. Only an approval node in needs_you can be approved.

#rapid redo

rapid redo [options] <node>

Runs a node again, whatever its fingerprint says. A redo of a scene's build with a note starts the scene again, with your marks.

#rapid replan

rapid replan --note <text> <job>

Asks a video's storyboarder for the storyboard again, with a note saying what to change. The new storyboard waits for your approval like the first. Every scene whose storyboard entry changes is built again from its key frame, and the video is joined again.

#rapid revise

rapid revise --note <text> [--scene <id> [--at <t> [--to <t>]]] <job>

Acts on your note on a video, done or still running, and runs it to the video again with no stops. With --scene and --at, a mark at that moment (or over the span to --to, in seconds from the scene's start) and a new round of that scene only; with --scene alone, that scene built again to the note; with neither, the storyboard again (pacing, order, length, the story) and the scenes it changes. Each scene round is numbered after the scene's earlier ones, so no earlier render is overwritten. Then the video is joined, mixed, and exported again.

#rapid cancel

rapid cancel <job>

Stops a job's running nodes and marks it cancelled.

#rapid lanes

Slots, running, and queued, per lane.

#rapid events

rapid events [options]

Streams events until Ctrl-C.

#rapid lane

rapid lane <lane> -- <cmd...>

Runs one command through a lane as a one-node job, streams its output, and exits with its code. <lane> is think, gpu, web, encode, or cpu. Ctrl-C cancels the job and exits 130.

#Rendering

These run without a daemon. Each prints one JSON line saying what it wrote. A scene is an .html file or a canvas module (.js, .mjs, .ts). --format and --style take a name (built in, installed, or pinned) or a folder; --project <dir> resolves them through that project's rapid.lock. A scene that links rapid:style needs --style.

#rapid render

rapid render [options] <scene>

Renders a scene to MP4, with its box log (<out>.boxes.json) and cue scan (<out>.cues.json) beside it. An HTML scene whose meta names another frame than the format's is refused.

#rapid still

rapid still [options] <scene>

Writes one frame of a scene as PNG.

#rapid measure

rapid measure [options] <lines...>

Measures lines of type in the style's real faces. Each line is one argument; it prints one JSON line per line of type: text, class, px, width, height, measure (the frame less both margins), fit_px (the size that fills the measure), and fits.

#rapid sheet

rapid sheet [options] <scene>

Writes a contact sheet of a scene; with no times, the review times.

#rapid check

rapid check [options] <scene>

Runs the code checks on a scene's render, or on its key frame's still, and writes them as marks: { "pass": boolean, "marks": Mark[] }. On a still it runs only what a still can answer: placement, fonts, problems, and the layout checks (empty, with a bare top or bottom third; grid; scale) at the scene's meta.key.

#rapid join

rapid join [options] <renders...>

Joins scene renders (MP4s, in order) into one video. When every hand-off is a cut it copies them without re-encoding; otherwise it draws each transition from both scenes' frames, overlapping them by its duration, and encodes once at the render's quality. A match whose element moves across the cut by more than 8 px, or is missing on one side, is reported on stderr.

#rapid video-sheet

rapid video-sheet [options] <scenes...>

The director's sheet of the cut: one row per scene (in video order) with its first, key, and last frames and where it sits in the cut, then every hand-off as the pair a viewer sees across it.

#rapid mix

rapid mix [options] <renders...>

Mixes a video's sound from its scenes' cue scans, each shifted to where its scene starts. Each render is its path without .mp4, in video order.

Cues with no instrument play nothing; the mix counts them by kind on stderr, and fails (exit 1) when the video has cues and none of them could be played.

#rapid mux

rapid mux [options] <video> <wav>

Puts the mix under the picture.

#rapid phone

rapid phone [options] <video>

Makes a copy that fits the format's phone size.

#Music and shots

#rapid listen

rapid listen [options] <track>

Hears a track on this machine (allin1, run through uv in its own environment under $RAPID_HOME/listen, made on first use) and writes its map beside it, <track>.music.json: the tempo, every beat and downbeat, the labelled sections with their energy, and the moments (each build and drop), with a picture of them, <track>.music.png. A track is heard once: what the model heard is kept by the track's hash. A three-minute track takes a few minutes on the CPU.

#rapid beats

rapid beats [options] [scene]

Prints the music under a video's scenes in each scene's own seconds (beats, downbeats, sections, builds, drops), from storyboard.json's music and the track's map, laid out the way the join lays the scenes. One scene, or every scene when none is named.

#rapid shot

rapid shot [options] <recipe>

Renders a Blender product shot from its recipe (shots/<id>.json): turntable, clay-metal, macro, or build. Writes the key stills (stills/front.png, hero.png, side.png, back.png), each pass's frames with alpha (<pass>/0001.png on), each pass as a VP9 clip with alpha (<pass>.webm), and manifest.json. Blender comes from RAPID_BLENDER, else the Mac's /Applications/Blender.app.

#Styles and formats

rapid style and rapid format take the same subcommands; extract and proof are style only. Each acts on packages of its own kind, and a failed one exits 1.

#add

rapid style add [options] <source>

Installs from a folder, a .zip, an https address, github:owner/repo[/path][@ref], or <name>[@ref]: the folder styles/<name> (formats/<name> for a format) of rapid's GitHub repository, at a tag, branch, or commit, else the default branch. Prints <name>@<version> <sha256> and the installed folder.

#list

rapid style list

The installed packages: name, version, the start of the hash, and the source.

#use

rapid style use [options] <spec>

Pins <name>[@ref] in the project's rapid.lock, installing it if needed, as add does.

#check

rapid style check [options] [dir]

Checks a package folder (default .): its schema, hashes, and files, and for a style, that style.css styles the kit. Prints <name>@<version> ok <sha256>, or every reason it failed.

#pack

rapid style pack [options] [dir]

Checks and packs a folder into its zip.

#proof

rapid style proof [options] [dir]

Renders a style's sample scene (proof/scene.html, default dir .) into proof/example.mp4, proof/poster.png, and proof/golden-<n>.png, and records them in the manifest's proof. Prints <name>@<version>: <n> golden frames, example and poster written. See making a style.

#extract

rapid style extract [options] <sources...>

Drafts a style from reference stills and clips, live web pages, and folders of front-end code. See extracting a style.