faviovazquez/showtime

https://github.com/user-attachments/assets/1132aa71-7fe5-4345-a925-790d80462fda

Quick start

1. Install the two prerequisites (details in Requirements): uv and Node.js 24 or 22 LTS (20 or newer works). Restart your coding agent afterwards so it sees them.

2. Add showtime to your agent. In Claude Code:

/plugin marketplace add FavioVazquez/showtime
/plugin install showtime@showtime

Using Codex, Cursor, Devin, OpenCode or another agent? Works with has the exact install for each, and npx skills add FavioVazquez/showtime covers any agent that supports Agent Skills.

3. Ask for a video:

Make a 20-second launch video for this repo, with a voice-over and upbeat music.

The first time, your agent checks what is missing, tells you the download size and time (about 0.6 to 0.8 GB into ~/.showtime, depending on your system, usually 2 to 6 minutes; nothing outside that folder changes) and runs setup once you say yes. Bigger pieces (the transcription model, Manim, music tracks) come the first time a video needs them, announced with their size. After that, a request in Claude Code looks like this:

Your agent states its assumptions in one line (it asks only when a request is genuinely open), shows you a first look (stills or a fast draft) before the full-quality render, then checks the result with showtime qa. Every request gets its own folder, showtime-out/<name>-<timestamp>/, with final.mp4, poster.jpg, share.txt, exports/ and work/. Nothing is ever overwritten.

Tip

Say "show me options first" (or "studio") and your agent opens a local board where you pick a concept, a look, a music bed and a storyboard before anything is built. Say "no crew" to keep the whole job in one session.

What's new in 0.3.0 (the full list is below):

• A full review on every video, and quieter runs. Each finished video gets looks, qa and a critic round before delivery; say "lean" for a lighter pass. Commands print a short verdict and keep the detail in a file, references are read by the piece (showtime guide), and looks at frames go to a disposable reviewer, so less piles up in your agent's context.
• Videos that differ from each other. A local look history warns when a video repeats a recent one, and showtime reference learns pace and type scale from a video you like, never its content.
• Checks for what viewers complain about. A phone check (text you can read at phone size, held long enough), and pairwise review, where a new version ships only if the critic prefers it in both orders.
• New kinds of video. Repo and paper explainers, release and PR videos (showtime release-video, and a GitHub Action), launches that start from your product's real brand, and showtime adopt for video code you already have.
• A receipt for every job: your request as typed, the rounds, renders and time, and tokens and cost where your agent reports them.

In my blind vote in benchmark round 4, 0.3.0 in lean mode was preferred to 0.2.0 on 4 of 6 tasks and to plain Claude Code on 7 of 8; the full-review default came after that round and was not part of it.

Works with

showtime is a skill, a command line and an MCP server, so it runs in any coding agent that reads Agent Skills and can run shell commands. MCP adds typed tools on top, and the ten crew agents are an optional speed-up for hosts that have custom sub-agents.

Tested with. A real run passed: the agent installed showtime from this repository and made a 5-second test video ("make a 5-second test video that says hello", empty folder), ending in a final.mp4 whose showtime qa verdict had no FAIL.

Should work with any agent that supports Agent Skills: GitHub Copilot (CLI and VS Code), Gemini CLI, Antigravity, Cline, Kilo Code, Kiro, Zed, Goose, Amp, Factory Droid and Qwen Code. The files each one reads are packaged and were checked with the agent's own tools where possible, but no real video has been made in them yet. If you try one, an issue with what happened helps everyone. Exact steps for every agent, and what the tests covered: docs/agents.md.

Claude Code

/plugin marketplace add FavioVazquez/showtime
/plugin install showtime@showtime

Everything is included: the skill, the ten crew agents, the MCP server and the plugin settings (/config).

Any agent that supports Agent Skills

npx skills add FavioVazquez/showtime

This installs the skill for the agents you pick. Then run setup once from the installed skill folder (<skills folder>/showtime/bin/showtime setup), and add the MCP server if you want it (below).

Other agents

Agents often run in a sandbox that blocks a large download, so run setup yourself once, in a normal terminal (it prints the size first and resumes if interrupted):

git clone --depth 1 https://github.com/FavioVazquez/showtime ~/showtime
~/showtime/skills/showtime/bin/showtime setup      # Windows: ~\showtime\skills\showtime\bin\showtime.cmd setup
~/showtime/skills/showtime/bin/showtime doctor     # every line PASS (SKIP is fine)

Setup also writes the stable command ~/.showtime/bin/showtime (Windows: showtime.cmd), which keeps working when a plugin update moves the skill folder. In the commands below, showtime means that command. showtime install --agent <name> links the skill where the agent looks, writes the ten crew agents in the agent's own format and adds a showtime MCP server entry; it merges config files (one backup, never a replacement), and --print, --project and --uninstall are there too.

OpenAI Codex · tested

codex plugin marketplace add FavioVazquez/showtime
codex plugin add showtime@showtime
showtime install --agent codex --no-skill --no-mcp   # optional: the ten crew agents (~/.codex/agents)

Codex reads the root plugin.json and mcp.json; the skill appears as showtime:showtime. In its default sandbox, allow network access and write access to ~/.showtime (the exact config.toml lines are in docs/agents.md). Headless: codex exec --skip-git-repo-check "make a 5-second test video that says hello".

Cursor · tested

git clone --depth 1 https://github.com/FavioVazquez/showtime ~/.cursor/plugins/local/showtime   # then restart Cursor
agent --plugin-dir ~/.cursor/plugins/local/showtime                                             # the CLI

Cursor reads .claude-plugin/plugin.json: the skill, the crew and the MCP server all load. Without the plugin: showtime install --agent cursor.

Devin · tested

devin plugins install FavioVazquez/showtime        # add --local to keep it off your Devin Cloud plugins
devin plugins info showtime                         # skill, 10 agents, MCP server "showtime"

Devin reads .claude-plugin/. The crew works in the CLI and Devin Desktop, not in Devin Cloud.

OpenCode · tested

showtime install --agent opencode

The skill goes to ~/.agents/skills/showtime, the crew to ~/.config/opencode/agents and the MCP server to ~/.config/opencode/opencode.json. Check with opencode agent list and opencode mcp list.

GitHub Copilot (CLI and VS Code) · should work

copilot plugin marketplace add FavioVazquez/showtime
copilot plugin install showtime@showtime

VS Code: run Chat: Install Plugin From Source with https://github.com/FavioVazquez/showtime. Without the plugin: showtime install --agent copilot.

Gemini CLI · should work

showtime install --agent gemini

Adds the skill, the crew in Gemini's format and the MCP server. The repository is also a Gemini extension (gemini extensions install https://github.com/FavioVazquez/showtime), which brings the skill and the MCP server without the crew.

Antigravity · should work

git clone --depth 1 https://github.com/FavioVazquez/showtime ~/showtime
agy plugin install ~/showtime                     # skill, crew and MCP server

Or, without the plugin: showtime install --agent antigravity.

Cline, Kilo Code, Kiro, Zed, Goose, Amp, Qwen Code · should work

showtime install --agent cline      # skill + MCP server (no crew: Cline's sub-agents cannot use MCP)
showtime install --agent kilo       # skill; add the MCP server in Kilo's settings with the command it prints
showtime install --agent kiro       # skill, crew and MCP server
showtime install --agent zed        # skill; it prints the context_servers entry to paste into settings.json
showtime install --agent goose      # skill; it prints the extension block for config.yaml
showtime install --agent amp        # or: amp mcp add showtime -- ~/.showtime/bin/showtime mcp
showtime install --agent qwen       # Qwen reads skills only from ~/.qwen/skills

In the Cline VS Code extension, add the MCP server under MCP Servers > Configure MCP Servers (the command prints the entry), or let Cline follow llms-install.md.

Factory Droid · should work

droid plugin marketplace add FavioVazquez/showtime
droid plugin install showtime@showtime

Factory translates the .claude-plugin/ layout. Without the plugin: showtime install --agent factory.

MCP only

Any client that starts local (stdio) servers can use showtime's MCP server on its own, without the skill. After setup:

{
  "mcpServers": {
    "showtime": { "command": "/home/<you>/.showtime/bin/showtime", "args": ["mcp"] }
  }
}

(Use the full path to that file in your home folder; on Windows it is showtime.cmd in %USERPROFILE%\.showtime\bin, written out in full.) Two more routes need no clone at all:

{ "command": "npx", "args": ["-y", "@faviovazquez/showtime-mcp"] }

is the same server from npm (@faviovazquez/showtime-mcp, also listed in the MCP Registry as io.github.FavioVazquez/showtime and on Smithery), and showtime-0.3.0.mcpb from the v0.3.0 release opens in Claude Desktop with a double click. Setup still runs once on your machine: the models and tools never travel inside a package. Long tools answer with a task id after about 20 seconds when a client stops calls early; the status tool reports progress and the result. Besides the tools that mirror the commands, guide reads a reference by the piece and receipt writes a job's receipt (tokens and cost are "not reported by this agent" through MCP).

Now showing

Every example was made by an agent acting as a user, and ships with its project sources and a README that tells the story: the request, the assumptions, the commands, what the critic found and what changed. Click a preview to open the example. Each one has a card with its prompt and links in examples/. Previews are silent; the videos have sound.

Data and reports

Explainers

Product and brand

Footage and audio

Tutorials

Social

Trailers and montage

For developers

Two more kinds of developer video have a workflow but no example in this gallery yet: a repo explainer (what the code does, a map of it, one request traced through real files and lines, every claim tied to a file and a commit) and a paper explainer (claims tied to pages, figures shown only when their license allows, Manim for the math). Say "explain this repo" or give your agent a paper's PDF or arXiv link. For release notes and pull requests with no agent at all, showtime release-video and the GitHub Action make a short film in CI.

Note

The HTML videos are single files you can open in any browser, offline: the same frames as the MP4, a player with chapters, keyboard shortcuts and links to a moment, and no network requests. Make one from any project with showtime export html. On GitHub, download the file to play it.

The 22 prompts behind the examples: copy one into your agent

How it works

Motion graphics are written as HTML, CSS and canvas and rendered frame-exactly in headless Chrome: every frame is a pure function of time, so a render, its preview and its HTML video show the same picture. Math scenes use Manim, and real footage is cut by transcript with ffmpeg.

What runs where

showtime adds no cloud service of its own: no API keys, no accounts, nothing you make is uploaded. Every model and tool is downloaded once into ~/.showtime, the small ones at setup and the bigger ones the first time a video needs them. After that it goes online only when you ask for something from the web: public-archive media search (Openverse, Wikimedia Commons, NASA) and website capture fetch pages and files, and send nothing of yours.

Quiet, checked and on the record

The 0.2.0 benchmark showed where an agent's budget goes with showtime: images kept in its context, long command output and reference files read whole. 0.3.0 trims those without removing a check:

• Check first, then one render. showtime check (with the phone check and the look-repeat warning) runs before the full render, and a fix re-renders only the seconds that changed (render --from S --to S).
• One picture per look. showtime look makes a single 1280 px composite of the key frames plus a brief for a disposable reviewer that answers in text; your agent never has to open the image itself. About 12 images per job is the budget (looking guide).
• Short output. Without a terminal, check, qa, doctor and render print the verdict, the findings with their fixes and the paths; the full report is in a file. --verbose prints everything.
• References by the piece. Every guide opens with its rules, and showtime guide <topic> [section] prints just that part.
• A receipt. Each job ends with receipt.md and receipt.json: the request as typed, assumptions, review rounds, full and partial renders, images made for looking, wall time, and tokens and cost when your agent's session log is named. Anything unknown says "not reported by this agent"; nothing is estimated. Claude Code costs are labelled API-equivalent, since a plan does not pay per video (format).

Every finished video gets the full review by default (quality mode: looks, qa and a critic round before delivery). Say "lean" (or run showtime config mode lean) for a cheaper draft pass without the critic, and "show me options first" for the full studio.

Benchmark

A small benchmark: one-sentence video tasks, one run each, scored by automatic checks, an AI judge that must prove it looked at every frame, and a blind vote by me. Round 4 compared showtime 0.3.0 in lean mode (the lighter review setting, which was the default when the round ran) with 0.2.0 in its default mode, plain Claude Code on Opus 5.5 and, for the launch video, an open-source tool built only for launch videos.

In my blind vote, 0.3.0 was preferred to 0.2.0 on 4 of 6 tasks and to plain Claude Code on 7 of 8, and its launch video beat the launch-only tool for the first time in four rounds. The AI judge preferred 0.2.0's polish on most tasks; that is why 0.3.0 ships with the full review (a critic round on every video) as the default, and that default was not part of the round. I'm showtime's author, so treat these as anecdotes, not a result. Every number, limit and loss is in the benchmark report, with each earlier version a click away; the method and the code to rerun it are in benchmarks/.

Meet the crew

Your agent is the director. For studio work and videos you will publish, it can hand parts of the job to ten specialist sub-agents that ship with the plugin. They are optional: a quick video uses none of them, except a researcher and a critic when you say it will be published (and scene builders for long videos). Each member gets a written brief, works only in its own folder, never asks you anything, never uploads, and reports back with a short status.

Who hands what to whom

Let your agent cast it (the usual way). Studio mode brings in the company; for a quick video you will publish, your agent adds the researcher and the critic on its own. Say "no crew" to keep everything in one session.

Let's make a launch trailer for this repo. Show me options first.

Or call one member yourself, by name (Claude Code syntax; in other agents, ask it to "spawn the researcher agent"):

@agent-showtime:researcher check the claims in narration.md against the README
@agent-showtime:critic showtime-out/<job>/review/round-1/CRITIC.md

The agents live in agents/; their briefs, in skills/showtime/references/crew/, work on any agent host, and the crew guide has the dispatch rules.

For a video you will publish, a fix is judged by preference, not by a score. After a fix, showtime review-pack --against best sets the new render beside the best one so far as a blind pair, and two fresh critics judge it, one in each order. showtime review-verdict applies the rule: the new render wins only when it is preferred both times; a tie or a split keeps the older one. There are up to three rounds, then the best version ships with its open findings listed (review guide).

Studio mode

Quick mode is the default: one request in, a video out. Studio is opt-in ("show me options first").

flowchart LR
  R["Your request"] --> Q{"Options first?"}
  Q -->|"no, the default"| QM["Quick mode"]
  Q -->|"yes, studio"| SM["Studio mode"]
  QM --> P{"Will you publish it?"}
  P -->|"yes"| RC["Researcher and critic join"]
  P -->|"no"| D["Checked by showtime qa"]
  RC --> D
  SM --> CR["The crew joins"]
  CR --> D
  classDef st fill:#15100E,stroke:#E9B949,color:#F5EBDC
  classDef hot fill:#B3121F,stroke:#E9B949,color:#FFF7EC
  class R,Q,QM,SM,P,RC,CR st
  class D hot

Quick mode is one sentence in and a video out; studio mode opens a local board first, then builds.

In studio you talk about facts and goals in chat; everything about look, sound and timing is shown on a board, a local page served on 127.0.0.1 with a token, with lettered options, one recommendation and buttons you click.

See example 09 and example 21, which is a tutorial of the board itself.

What you get

HTML videos

showtime export html writes one file that plays offline in any browser, with the same frames as the render. Press ? in the player for the key map.

The player's keys

What is in the box

Also: 20 motion components, 23 transitions (CSS and WebGL) and 6 themes, website capture (screenshots, copy, brand colours and fonts), scripted app recordings with smooth auto-zoom, cursor and keycaps, PDF import, CSV and JSON to charts, a brand kit, posters baked into frame 0, exports for YouTube, X, LinkedIn, Reels, TikTok, Shorts and square feeds, README loops (animated WebP and GIF, like the previews on this page), credits written automatically when an asset needs attribution, a look history so videos do not repeat, style references, adopting video code you already wrote (showtime adopt), and a receipt for every job.

Every command

showtime --help lists them grouped, with examples; showtime <command> --help has the details.

showtime new dom my-video --duration 20     # a project from a template
showtime voice script my-video/narration.md -o my-video/voice --fit 18   # local narration, fitted to 18 s
showtime retime my-video --from-voice my-video/voice/timeline.json         # scenes follow the narration
showtime data import signups.csv my-video --x month --y signups --scene bars   # a CSV becomes a chart
showtime preview my-video                    # live player with scrubber and audio
showtime render my-video --preview           # fast draft
showtime render my-video -o final.mp4        # full quality
showtime qa final.mp4                        # PASS/WARN/FAIL: loudness, black/frozen frames, captions, platform
showtime deliver exports final.mp4 --targets youtube,reels,square
showtime export html my-video                # a single-file interactive HTML video
showtime look my-video                       # one composite of the key frames, for a quick visual check
showtime reference clip.mp4 --job my-job     # a video's pace, shots and type scale, as a brief (never its content)
showtime adopt my-page/                      # a page that already has seek(t) gets check, sound, qa and export
showtime release-video notes.md -o my-video  # release notes to a ready-to-render project, no agent needed

The audio toolkit

Everything is local and license-gated: no sample leaves your machine, and an asset that needs attribution writes itself into credits.txt. Catalog tracks are downloaded from their creators on first use (with the size announced) and never re-hosted here.

Math with Manim

showtime manim new|render|check|cues makes equations, proofs, graphs and grid transforms with Manim Community (the manim extra; LaTeX is needed only for equations), and times them to the narration. Example 22 cuts a circle into rings, unrolls them into a triangle and lands on

$$A = \tfrac{1}{2} \cdot 2\pi r \cdot r = \pi r^2$$

with a vertical cut for Shorts from the same scenes. An optional OpenGL engine (the manimgl extra) runs scene files written for it. showtime manim check also renders a draft and runs qa's black-frame and frozen-frame detectors on it, so a near-black scene or a barely visible change is reported before the full render.

New in 0.3.0

Quieter runs, full review by default

• Lean mode, when you ask for it. The full review stays the default; say "lean" (or run showtime config mode lean) for a lighter pass without the critic round. In both modes showtime look makes one composite image that a disposable reviewer reads (your agent does not), render says when a project was not checked first and names the cheaper --from/--to fix after a second full render, and check, qa, doctor and render print a short summary by default (--verbose for everything). Every reference opens with its rules (showtime guide <topic> prints them). No check was removed. In benchmark round 4, lean runs read a median of 4.5 images into the agent's context and made a median of one full render per job.
• showtime job init checks your setup and prints setup: ready or the failures with their fixes, so it is the one command to start with.

Better videos

• Variety guard. Each finished job's look (template, theme, palette, type pair, transitions, camera moves, music, structure, tone) goes into a local history that never leaves your machine (showtime history off turns it off). showtime check warns look_repeat when a project repeats one of the last five, with two concrete alternatives.
• Style references. showtime reference <video> writes a brief with the video's cut rhythm, shot lengths, how scenes change, palette, camera moves, rough type scale and loudness curve, and a contact sheet. The storyboard borrows the grammar, never the words, logos or shots; the credit "Style reference: ..." is written for you, and showtime qa fails a render that copies the reference's pictures (guide).
• Phone check. showtime check ends with phone check: PASS or FAIL with timestamps: each text held long enough to read (per language), a minimum type size at phone width (16:9 5 pt, 1:1 10, 4:5 11, 9:16 15) and nothing under a platform's buttons or at the edge. In qa, a failure is a warning, never a FAIL.
• Brand first for launches. showtime brand capture <repo|url> --job <job> takes the product's palette with roles, fonts, logo, wordmark, real copy (with file and line) and real UI before the storyboard, and showtime new launch applies it. A launch job with no kit says why (showtime brand skip), and check warns when it does not.
• Pairwise review. See the crew: a new version ships only if the critic prefers it in both orders.
• Fixes where agents tripped: a clip's frames no longer depend on the order the frames were asked for, retime --from-voice --total works when every scene is narrated, Manim silent films and --mix paths work, doctor warns when the showtime command on your path is not the agent's, and font errors name the exact missing characters and the fix.

New kinds of video

• Repo explainers and paper explainers (workflows repo-explainer and paper-explainer), described above.
• showtime release-video turns release notes, a CHANGELOG section or a PR description into a ready-to-render project with no agent: the notes' own words, reading-time holds, the people credited.
• A GitHub Action that renders a release or PR video on the runner, checks it, exports an HTML video and a copy under 10 MB, and uploads them (guide). It needs no API key unless you choose the mode that runs your own agent.
• showtime adopt <folder | page | script> takes a video someone already wrote as a function of time (an HTML page with seek(t), a canvas draw(t), a CSS-animated page, a Python frame function) and gives it showtime's checks, sound, captions, qa, HTML export and review, without a rewrite. The originals are never changed (guide).

Honesty

• Receipts. Every job ends with receipt.md, receipt.json and a line in share.txt (see above).

In progress (landing before the release):

• A fix to a few seconds (render --from A --to B --job <job>) splices into a complete new final: only those frames change, the audio is mastered again, and a span is never mistaken for the video.
• Every Manim template passes its own check, and a scene's first element is on screen at frame 0.

Limits: the phone check and the look history read the project files and cannot judge whether a video is good; a model reviewer's preference is steadier than its score but is still an opinion; tokens and cost appear only for agents that expose their session log (Claude Code and Codex, as numbers only), and everything else says "not reported by this agent". The full list is in the changelog.

New in 0.2.0

• Works in your coding agent. One repository for every agent: Claude Code, Codex, Cursor, Devin and OpenCode are tested, and Copilot, Gemini CLI, Antigravity, Cline, Kilo Code, Kiro, Zed, Goose, Amp, Factory Droid and Qwen Code are packaged (Works with). showtime install --agent <name> puts the skill, the crew and the MCP server where an agent looks. A stable ~/.showtime/bin/showtime command survives plugin updates, long commands can run in the background (--background, showtime status), and showtime doctor knows the sandboxes of the common agents and says which setting to change.
• A lighter first run. The default download is about 770 MB on Linux x64 (about 560 to 610 MB on macOS and Windows) instead of 2.9 GB. showtime setup --plan lists every component with its size and when it is fetched, and showtime setup --full installs everything up front. Nothing was removed: a piece that left the default install (the transcription model, Manim, the audio library beyond its 41 MB starter, browser and icon extras) is fetched the first time a video needs it, announced with its size. Homes made by 0.1 keep working; setup --prune clears what is no longer used.
• A real music catalog. 297 produced tracks (Scott Buckley, Kevin MacLeod, a dozen more composers and public-domain recordings), each downloaded and measured for hiss, clipping, mono, dead gaps and loudness swings, tagged by mood, energy, tempo and use, and picked with showtime audio music pick. Tracks are fetched from their creators on first use and never re-hosted. Every render that uses one writes the credit into credits.txt and the post copy by itself, and prints a note. 35 more sound packs (34 CC0) install when a search needs them.
• Platforms. Apple Silicon and Linux arm64 now run end to end in CI, Windows 11 on Arm runs with an x64 Python under Windows' emulation (Requirements), and scripts/e2e.py repeats the whole path on any machine.
• A safer preview server. showtime preview and showtime server answer only requests that carry a random per-session key from the printed link; before, any web page open in your browser could read a project's files over 127.0.0.1.
• Footage edits that hear the ums. The default transcription is now Parakeet-TDT 0.6B v3 (25 languages including English and Spanish; fetched on first use, 465 MB; Whisper stays for other languages and with --model). It keeps "um" and "uh" as words, and a scan after it hears the hesitations no word covers. On a public, human-labelled podcast set (20 episodes, 495 labelled fillers) it found 81% of them at 83% precision against the labels, where 0.1.0's default found 11% at 78%; on the benchmark interview it cuts all five known "uh" (the benchmark's scorer credits 4 of 5; 0.1.0's default commands cut none). Cuts get 20 ms crossfades. Speech under music is heard better because showtime transcribes its own dry narration stem, and separates the voice only when the music is loud: word errors at equal loudness fell from 19.7% to 7.3% on a small test set. These are local evaluations on a few sets, not a guarantee for your footage; label-based precision understates it, since the labels miss some real fillers. CrisperWhisper is available as an opt-in model under its non-commercial licence (not on Intel Macs).
• Launch videos by default. Ask for a launch, promo or release video and the default is a calm short film of four to six scenes: a big still hook, one smooth fly-through into the product, the same window carried across the cuts, and a produced track whose swell lands on the end card. The camera only moves when it has a reason; the motion comes from the product itself. Terminals and code shrink to fit every size, and showtime check stops a render when text would be cut off.

The full list is in the changelog.

Requirements

showtime is built for macOS (Apple Silicon and Intel), Windows 10/11 and Linux (x86_64 and arm64). What has actually been run, and where ("end to end" means setup, doctor, a voiced render with qa, HTML export, transcription, captions and the MCP server):

• Intel Mac (a physical machine): end to end, plus the fast test suite.
• Apple Silicon: end to end on GitHub's macos-14 (M1) runners, plus the fast suite. A run on a physical Apple Silicon Mac is still welcome.
• Linux x86_64: end to end on Ubuntu 24.04 (AWS), plus the fast suite.
• Linux arm64: end to end on GitHub's ubuntu-24.04-arm runners.
• Windows Server 2025 x64: end to end as a standard user (AWS) and on GitHub's windows-2025 runners.
• Windows 11 on Arm: end to end on GitHub's windows-11-arm runners, plus the fast suite. showtime's Python and ffmpeg run as x64 under Windows' emulation there (some packages have no Windows arm64 build, and the native arm64 ffmpeg build did not start on the runner), so it is slower than on x64.
• Windows 10/11 x64 desktop as a standard user: not yet run on a real machine. If you have one, scripts/e2e-windows.ps1 runs everything and zips the result to attach to an issue.

CI runs the fast test suite on Linux, Windows and Apple Silicon for every change, and on an Intel Mac nightly. Expect rough edges on anything marked not yet run, and please open an issue when something breaks.

Chrome, Edge or Chromium is found automatically; if none is installed, setup downloads Chrome's headless shell (about 100 MB). Disk: the default install is about 770 MB on Linux x64 (700 MB on Linux arm64) and 560 to 610 MB on macOS and Windows, with a browser already installed and about 100 MB more without one, instead of 2.9 GB in 0.1; showtime setup --plan prints yours, component by component. What a video needs only sometimes arrives the first time it is used, with its size announced: the transcription model (Parakeet, 465 MB, once), Manim (60 MB), the audio library's starter part (41 MB), a music track or a sound pack (each a few MB to a few dozen). showtime setup --full fetches all of it now, for a machine that will be offline (about 5.1 to 5.7 GB, mostly the 1.6 GB Whisper large-v3-turbo model and 0.9 GB of the music catalog; Scott Buckley asks for no bulk downloads, so his tracks still download one at a time, the first time a video uses them).

Install commands for uv and Node.js

macOS and Linux:

curl -LsSf https://astral.sh/uv/install.sh | sh
# Node.js: the installer from nodejs.org (macOS), or on Linux fnm (distribution packages are often older than 20):
curl -fsSL https://fnm.vercel.app/install | bash && fnm install 22

Windows (PowerShell):

winget install --id=astral-sh.uv -e      # or: powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
winget install OpenJS.NodeJS.LTS --source winget   # or the installer from nodejs.org

On Linux, if the browser does not start, install Chromium's system libraries once (after setup): sudo "$(command -v node)" ~/.showtime/node/node_modules/playwright/cli.js install-deps chromium. NodeSource packages work too.

ffmpeg is downloaded as a static build, so a system ffmpeg is not needed. Installing uv or Node.js updates PATH for new terminals only: restart your coding agent afterwards (showtime also looks in the installers' default folders if the new PATH has not reached it yet).

Setup from a terminal, and what it installs

The first time showtime is used, your agent tells you the size and time and runs the setup once you agree. The first time a video needs a bigger piece (library sounds, a music track, the transcription model, Manim), showtime fetches just that piece and prints its size first; showtime setup --full fetches everything up front. To run setup yourself, use a clone (both share ~/.showtime).

macOS and Linux (bash, zsh):

git clone https://github.com/FavioVazquez/showtime
showtime/skills/showtime/bin/showtime setup
showtime/skills/showtime/bin/showtime doctor
showtime/skills/showtime/bin/showtime setup --plan     # what setup and first use download, with sizes
showtime/skills/showtime/bin/showtime audio lib fetch  # optional: the whole sound library now (about 249 MB)

Windows PowerShell (showtime.cmd also works from cmd; showtime.ps1 is there too):

git clone https://github.com/FavioVazquez/showtime
& .\showtime\skills\showtime\bin\showtime.cmd setup
& .\showtime\skills\showtime\bin\showtime.cmd doctor
& .\showtime\skills\showtime\bin\showtime.cmd setup --plan
& .\showtime\skills\showtime\bin\showtime.cmd audio lib fetch   # optional: the whole sound library now

Setup also writes ~/.showtime/bin/showtime (Windows: showtime.cmd), a command that keeps working when a plugin update moves the skill folder, and prints how to put it on your PATH (it never changes PATH itself). Without it, skills/showtime/bin/showtime is the entry point (the skill's folder, not the plugin's top folder). On Windows that runs showtime.cmd (from cmd or PowerShell); call showtime.ps1 directly only where the PowerShell execution policy allows scripts.

Downloads resume after an interruption and are skipped when already present, so re-running setup is always safe. Setup's downloads, the optional extras, the core audio library, the music catalog, the sound packs and the models fetched on first use (the English aligner, Piper voices) are pinned by URL, size and SHA-256. Two are not pinned yet: the extended audio-library tier records each file's SHA-256 on its first download and verifies every re-download against it (trust on first use), and the background-removal engine used outside macOS (rembg, a pinned package version) fetches its model with its own downloader. Features that need an optional extra say so and print the exact command; nothing is installed behind your back.

showtime setup --list                     # tiers, extras and their sizes
showtime setup --plan                     # every component: size, source, when it is fetched (--platform X for another OS)
showtime setup --estimate                 # what this run would download, and how long it takes
showtime setup --full                     # everything now, nothing fetched later (offline machines; --seed DIR reuses files)
showtime setup --prune                    # remove files from older versions that nothing uses any more
showtime setup --with asr-turbo,diarize   # add extras (keeps what is already installed)
showtime setup --tier full                # core + the common extras

What showtime runs and downloads: every download, and what goes over the network

What runs. Installing the plugin downloads this repository and nothing else. It adds the showtime skill (Claude runs skills/showtime/bin/showtime, a Python and Node command line, in your terminal), a local MCP server (node skills/showtime/mcp/server.mjs over stdio; it makes no network calls of its own), a progress monitor while the skill is in use (node skills/showtime/mcp/progress-monitor.mjs, which reads ~/.showtime/logs/progress.jsonl), and ten optional sub-agents. No hooks. Setup runs only after Claude has told you the size and time and you agree, or when you run it yourself. Files go to ~/.showtime (or SHOWTIME_HOME, or the plugin's home setting) and each video to showtime-out/<slug>-<timestamp>/ in your project.

Setup downloads (the default core tier, about 2.9 GB). Every model and ffmpeg file is checked against a size and SHA-256 pinned in skills/showtime/setup/manifest.json:

On macOS, setup removes the download quarantine flag from the ffmpeg binaries (xattr -d com.apple.quarantine) so Gatekeeper does not block them.

Downloaded later, only when a feature needs it. The command or Claude says so first.

• The audio library, showtime audio lib fetch: the core set is 87 files (about 250 MB, CC0 and CC BY 4.0) from kenney.nl, opengameart.org, incompetech.com and archive.org, pinned by SHA-256. --tier extended adds 218 files (about 1 GB) from incompetech.com, archive.org and opengameart.org; those are not pinned yet, so each file's SHA-256 is recorded at its first download and checked on every re-download.
• The English word aligner, wav2vec2 (95 MB, Hugging Face, pinned), the first time narration is aligned; a Piper voice (67 to 116 MB, github.com/k2-fsa/sherpa-onnx releases, pinned) when you choose one.
• Another Whisper model (Hugging Face, 150 MB to 3 GB, not pinned) when you transcribe with --model, or speech that is not English (small, about 480 MB).
• Outside macOS, background removal installs the rembg package from PyPI, and rembg downloads its own model (about 170 MB) the first time.
• Optional extras, only with showtime setup --with <name> (the list and sizes: showtime setup --list): larger Whisper and Parakeet transcription, speaker labels, audio event tags, Supertonic voices, DeepFilterNet, RIFE, two more SoundFonts and Manim/ManimGL (from Hugging Face, GitHub releases, OSU OSL and PyPI, pinned by SHA-256 except the Python packages), and MusicGen (PyPI, PyTorch's package index on Linux, and Meta's non-commercial weights from Hugging Face).

SHOWTIME_OFFLINE=1 stops the web asset lookups and the voice-model downloads.

What goes over the network. showtime adds no cloud service: no accounts, no telemetry (Hugging Face's is switched off too) and no uploads. Every request it makes is a download. Rendering is offline: the headless browser that draws the frames blocks every request that is not local, and an HTML video carries a content security policy that allows no network access. The web is used only when you ask for something from it:

• web assets: fonts (api.fontsource.org, cdn.jsdelivr.net), icons and emoji (cdn.jsdelivr.net, raw.githubusercontent.com), and openly licensed photos and video (Openverse, Wikimedia Commons, NASA, the Cleveland Museum of Art, the Met, the Art Institute of Chicago, or a URL you give);
• a web page you name, loaded in a local browser to capture it (showtime site capture <url>, showtime demo record --url, showtime brand init --url), with cookie banners declined and trackers blocked;
• the optional researcher sub-agent, which checks facts with Claude Code's web tools.

Those requests carry the search words or the URL and a showtime/<version> user agent; your files and videos are never sent. The studio board and the preview server listen on 127.0.0.1 only, and the board's link carries a random key.

Troubleshooting

Platform notes (by design; see the status above): Apple Silicon runs everything natively and renders WebGL through Metal; Intel Macs get the last x86_64 builds of ONNX Runtime and numba automatically; on Windows, drive letters, spaces and parentheses in paths are handled everywhere, including inside ffmpeg filters; Linux machines without a GPU render WebGL through SwiftShader. Hardware encoders and macOS-only features are used only when present, with portable fallbacks.

Use showtime from other tools (MCP)

showtime ships an MCP server (skills/showtime/mcp/server.mjs, Node only, no extra install) with a small set of coarse tools: doctor, new_project, render, check, snap, qa, voice_say, voice_script, transcribe, audio_compose, audio_sfx, audio_mix, audio_search, export_html, studio_open, studio_feedback, deliver_exports, receipt and status. Each runs the matching showtime command on your machine and answers with a short summary and the paths it wrote; a tool that runs longer than about 20 seconds answers with a task id, and status reports progress and the result. The plugins register it for you. For Claude Desktop or any other MCP client, run ~/.showtime/bin/showtime mcp (see MCP only for the snippet and the npm and .mcpb routes); the snippet for each client is in references/mcp.md, next to the plugin settings (default voice and language, a CPU limit) and the render progress monitor.

Docs

The documentation map is the way in: every guide, grouped by what you are making, from workflows (launch, explainer, tutorial, social, data, footage, trailer) to story and craft, sound and voice, rendering, and QA. The glossary is in CONTEXT.md, and what showtime deliberately does not do, and why, is in .out-of-scope/.

Installing in a particular agent: docs/agents.md has the exact steps for each, and what each test covered. The same guides are also a searchable site, with the gallery playing every example: faviovazquez.github.io/showtime.

License and credits

showtime's own code is MIT licensed (LICENSE). Setup downloads third-party tools and models under their own licenses, recorded per item in skills/showtime/setup/manifest.json. Notable ones: the static ffmpeg builds are GPL; Kokoro is Apache-2.0; Whisper models are MIT; Parakeet (NVIDIA) and TitaNet are CC-BY-4.0; the vocal separator UVR-MDX-NET-Voc_FT is MIT, by the Ultimate Vocal Remover project (UVR) and its developers; CrisperWhisper 2.0 weights (opt-in only, --model crisper) are non-commercial and ask for your acceptance first; Supertonic weights are OpenRAIL-M; FluidR3Mono and MuseScore General are MIT; GeneralUser GS (optional) has its own free license; MusicGen weights (optional) are CC-BY-NC-4.0, non-commercial. The brand (Curtain Call) is described in assets/brand/. The produced-music catalog is by Scott Buckley and Kevin MacLeod (CC BY 4.0) plus CC0 and public-domain recordings; the tracks stay on their creators' sites, are fetched on first use, and every render that uses one writes its credit into credits.txt and the post copy (a track that needs a credit and has none stops the mix). Each example credits its sources in its own folder, and example 13 is CC BY-SA 4.0, like the article it adapts. The videos you make are yours; when a render uses an asset that needs attribution, showtime writes credits.txt next to it.

Contributing

See CONTRIBUTING.md and the glossary in CONTEXT.md.

python3 skills/showtime/tests/run_all.py --fast     # what CI runs on every pull request (py on Windows)
python3 skills/showtime/tests/run_all.py --changed  # only the tests your change can affect
python3 scripts/check_release.py --check            # release hygiene