showreel-041-github-9.6mb.mp4

_{The 0.4.1 showreel: 55 seconds, rendered by showtime 0.4.1 in 2 min 23 s on a 64-core CPU with no GPU; seven real showtime films, then the features behind them (about the film).
Download the showreel (full quality, 107 MB). Music: “Supernova” by Scott Buckley, CC BY 4.0. Footage: NASA (public domain); photo: “Godafoss 3” by Tord Dellsen, CC0 (credits).}

A local video studio for your coding agent.
Describe a video. Your agent directs. Your machine renders.

Motion graphics, voice-over, music, sound design, captions, footage editing and platform exports, with no cloud AI services, no API keys and no uploads. Works in Claude Code, Codex, Cursor, Devin, OpenCode and any agent that supports Agent Skills.

Quick start · X-ray · Works with · Gallery · How it works · The crew · Studio · Formats · Docs · Site · Requirements

Quick start

New here? Make your first video: a 5-second test that checks the install and shows every step a bigger video goes through.

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.5 to 0.75 GB to download and 1.4 to 1.8 GB in ~/.showtime once installed, depending on your system, usually 2 to 6 minutes; outside that folder only uv's and npm's download caches change) and runs setup once you say yes. If your agent's sandbox blocks the download, run setup once in a terminal (Troubleshooting). 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:

_{An illustration of a session in Claude Code; other agents show the same steps in their own style. The card's figures are example 01's; render time depends on your machine.}

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. Questions about cost, GPUs, disk, languages or what leaves your machine: the FAQ. Something went wrong: Troubleshooting. A word you don't know: the glossary.

Tip

Two separate settings. Quick or studio decides how much your agent asks before building: quick (the default) states its assumptions and starts; studio (say "show me options first") shows a concept, a look, a music bed and a storyboard on a local board first. Quality or lean decides how much it checks afterwards: quality (the default) has a critic review every finished video; lean skips the critic unless the video is going to be published. Say "no crew" to keep the whole job in one session.

What's new in 0.4.4 (the list is below, and What's new has a short paragraph for each):

• X-ray. Film a real thing doing its thing and showtime draws its inside on the frames its own sound says; a score, a guitar tab or a drum sheet from the sound; a receipt that reads the finished film back.
• A live page you play. Pads that play the real clip with its sound, your keyboard typing on the typewriter, drag to scrub, #hit4 links, the request that made it, and an embed.
• Living diagrams you touch. Type on a typewriter, follow a key press to the screen, drag the heat pump's weather.

What's new in 0.4.3 (the list is below, and What's new has a short paragraph for each):

• Living diagrams. showtime new diagram explains a system over time as an isometric figure that builds itself: parts arrive in the order that explains them, and flows, packets and labels move through them.
• Live figures. showtime export html <project> --interactive turns the same scene into one offline page people poke: hover a part, pick a step, turn a knob, and the numbers answer (try one).
• A recap of your agent's session. showtime recap --latest turns a Claude Code session into a 30-60 s narrated film of what the agent did, built only from allow-listed facts, never the transcript's text.
• A failing test as a bug-report video. showtime repro turns a Playwright trace into a narrated film of the steps and the failure, with a Markdown summary for the issue; typed values are never shown.
• Steadier renders, quieter cuts. Every render worker now captures from a page set up like the first one; recap and repro pick their music per session or test, and generated videos no longer put a sound on every cut.

On the behaviour scoreboard, 14 one-sentence requests were run 3 times each (42 runs). The same model did the right thing 35 times with showtime and 25 times without. The cases check that it starts on video requests and stays out of others, that it is honest about missing inputs and unsupported claims, and that it keeps to the plan and the delivery card. Anyone can rerun it.

X-ray

Film a real thing doing its thing, a typewriter typing or a music box playing, and showtime draws its inside moving on the exact frames the clip's own sound says: on the object as the camera moves, or beside it, as a dark radiograph or a light blueprint. Instruments get their music written out from the sound too (a score, a guitar tab, a drum sheet), and every film ends with a receipt that proves it.

_{An Underwood 315 typing, seen through. Clip: Erik Pålsson / Sounds of Changes, CC BY 3.0.}

Say "X-ray this clip of my typewriter" to your agent, or run the three steps yourself:

showtime xray analyze clip.mp4 --job xray-typewriter        # every event in the sound, with its frame
showtime new xray xray-typewriter/project --mechanism typewriter --theme dark
showtime xray verify xray-typewriter                        # after the render: reads the film back

19 of 19 events on their frame · audio 0.0 ms from the original

The mechanisms come from a library that grows with every verified X-ray, and anyone can add one. The X-ray gallery plays every verified film with its receipt and the commands that made it, and shows how to post yours; the X-ray guide walks through filming, mechanisms, music and drums, and what the receipt checks.

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.

Agent	Install route	Crew agents	Tested with
Claude Code	plugin	yes	the primary host
OpenAI Codex	plugin	with showtime install	CLI 0.158.0, plugin route
Cursor	plugin (reads .claude-plugin/)	yes	CLI 2026.09.28
Devin	plugin (reads .claude-plugin/)	yes (local only)	CLI 3000.11.3
OpenCode	showtime install	yes	1.18.33, a free model

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.4.4.mcpb from the v0.4.4 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). Ten core tools are listed by default (doctor, status, guide, new_project, render, check, qa, export_html, deliver_exports, receipt), which keeps the list short. Add "env": { "SHOWTIME_MCP_TOOLS": "all" } to the server entry to list the voice, music, sound-effect, transcription, stills and studio-board tools too; the .mcpb sets it for you. Some features have no MCP tool yet and run from the command line: adopt, footage cutout, edit cards, edit moments, edit clips, pr-video, review open and review notes, and export html's link-preview flags (showtime.json "share" works through export_html).

Now showing

_{▶ Watch the 0.2.0 launch film (40 s, MP4; made with showtime, every frame from a real example, about the film). Every example plays in the gallery on the showtime site.
Music: “With These Hands” by Scott Buckley, CC BY 4.0 (credits).}

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

Data story · 30 s 146 years of NASA temperature from a CSV. Every number on screen comes from the data.

Energy report · 60 s, narrated How the US power mix changed, from EIA data. Also an HTML video.

PDF to summary · 75 s, English + Spanish A two-page USGS PDF on Kīlauea 2018, with the agency's own footage, stabilized.

Explainers

How a heat pump heats a home · 45 s A procedural canvas film, narration fitted to the length, a synthesized score. Also an HTML video.	The same film, in Spanish · 51 s Spanish voice and on-screen text, every cut moved to the new narration. Also an HTML video.
A Wikipedia article, explained · 60 s, English + French The honey bee waggle dance, with real research footage. Also as HTML videos. (CC BY-SA, like its source.)	Why a circle's area is πr² · 70 s + Shorts cut A narrated Manim proof with real animated equations.
An explainer that stops and asks · 2:38, narrated The 2026 Nobel Prize in Physics: three questions that stop the HTML video until you answer.	Nobel Chemistry, in English and Spanish · 2:30 + 2:34 A lab-notebook explainer of the 2026 Nobel Prize in Chemistry, then every word of it in Spanish.

Product and brand

Launch video · 20 s A (fictional) notes app: hook cards, its landing page, a scripted recording of the real app.	showtime's own launch video · 30 s + square cut Real renders, real terminal output, narration made on the rendering machine.
Product promo, 1:1 · 20 s + 6 s bumper A museum's CC0 photos of a Christopher Dresser teapot, only facts from the record. Also an HTML video.	Brand motion pack · sting, lower thirds, stingers A 3D logo sting in three layouts, lower thirds with alpha for an editor, made in studio mode. Also as HTML.
Claude Design to MP4 · 12 s + a 20 s loop Two exported designs adopted as they are, sharp at 1080p, each on a music bed that ends on a phrase.

Footage and audio

Interview, tightened · 72 s, 9:16 + 16:9 A public-domain NASA interview cut by transcript, face-tracked to vertical, graded and captioned.	Podcast audiogram · 45 s, 9:16 A NASA podcast clip for Reels, TikTok and Shorts, with speaker names and captions.
Talking head, dressed · 55 s, 16:9 + 9:16 Cards that appear as the words are said: name tag, list, data callout, side panel, pull-quote, caption emphasis.	A long panel, its best moments · 3 clips, 9:16 A 58-minute NASA panel ranked by edit moments; three vertical clips with captions, each through qa.

Tutorials

Recorded tutorial · 50 s Recorded from a running app; each click lands on the word that names it.

Tutorial series · 2 × 90 s Two canvas episodes sharing one kit. Also as HTML videos.

Tutorial of a real app · 75 s + Shorts cut How to use the showtime studio board, recorded from the real board.

Social

Vertical short · 15 s, 9:16 Three shortcuts: a hook in the first second, karaoke captions, effects on every cut.

Travel slideshow · 45 s + 9:16 Eight CC0 photos cut to the music, with a live map inset. The vertical is a re-layout, not a crop.

Trailers and montage

Beat-synced montage · 20 s Public-domain NASA photos cut on the beat of a library track; its CC-BY credit written automatically.

Studio-mode trailer · 20 s Four concepts on a local board, picks and notes, a storyboard and an animatic, then the final.

Book trailer · 30 s + 15 s vertical teaser The War of the Worlds, from public-domain illustrations and lines from the novel.

Looks and motion

The showreel template in four shapes · 4 × 15 s showtime new showreel as it ships, rendered in four shapes with no edits.	Twelve looks, one project · 24 s loop One dom project in all twelve look signatures, the look changing every 2 s.
Seven looks, no GPU · 18 s demo The seven WebGL looks, one scene each, drawn in showtime's own WebGL on the CPU.	Shutter blur on fast moves · 7.5 s demo data-st-blur on the word that moves: smeared while it is fast, sharp when it lands.

For developers

	Open-source release video · 35 s, no voice What changes in people's code with Black 26.1.0's 2026 stable style: real before-and-after diffs, the install line and the changelog. Point showtime at a repo, a pull request or a changelog and it makes the same kind of video. (An unofficial summary, made as an example.)
	A pull request becomes a video · 40 s, one command showtime pr-video 7 on showtime's own pull request: the PR's title and words, the files it changed with their +/- counts, a real hunk and its URL, secrets masked, a copy under GitHub's 10 MB attachment limit and the Markdown to paste.
	A recap of an agent's session · 37 s, narrated showtime recap on showtime's test session: 17 minutes of an agent fixing a parser test as the numbers, a minute-by-minute timeline, the edit, the tests red to green and the commit, built from allow-listed facts only.
	A failing test as a bug-report video · 34 s, narrated showtime repro on a Playwright trace: each step on the trace's screenshots, the failure slowed down with expected and received, the typed values covered, and repro.md for the issue.

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 a pull request, showtime pr-video <N> reads it (with gh, or from GitHub's API for a public one) and renders a video under 10 MB to drag into its description (example 29). For release notes and pull requests with no agent at all, showtime release-video and the GitHub Action make a short film in CI.

_{All 22 examples, with their projects and full-quality videos, live in showtime-examples.}

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, links to a moment or to a part that loops, questions that pause the video until the viewer answers, and no network requests. Make one from any project with showtime export html. On GitHub, download the file to play it. A living diagram also exports as a live figure (--interactive): no player, a board people hover, step through and tune, in one offline file.

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

#	Prompt
01	Make a 20-second launch video for Tidepool from its landing page and the real app UI, with music and subtle sound effects, no voice-over.
02	Make a 45-second explainer video with voiceover about how a heat pump heats a home in winter.
03	Now make the Spanish version of the heat pump explainer.
04	Make a 40-60 second tutorial showing how to create a note, tag it and find it with search in Tidepool.
05	Make a 15-second vertical short for Reels: 3 keyboard shortcuts that make Tidepool fast.
06	Cut the ums and long pauses out of this interview clip, add captions, and make a vertical 9:16 version for Reels plus a 16:9 version.
07	Make a 30-second data story from this CSV.
08	Make a 20-second beat-synced montage of space photos.
09	Let's brainstorm a trailer for Tidepool first. Show me options.
10	Make a 30-second launch video for showtime itself. Show real things: real renders, real terminal commands, the studio board. Plus a square cut-down.
11	Build a two-episode tutorial series for Tidepool as canvas films: "Capture a note in seconds" and "Find anything with search and tags".
12	Make a one-minute narrated video from the EIA's electricity generation data showing how the US power mix changed: coal, gas, wind and solar.
13	Turn the Wikipedia article on the waggle dance into a 60-second animated explainer, and make a French version too.
14	Here's a USGS PDF about the 2018 Kīlauea eruption. Make a 75-second narrated summary video, and a Spanish version with subtitles.
15	Make a 35-second what's-new video for Black 26.1.0: show what the 2026 stable style actually changes in people's code.
16	Cut a 40-second vertical audiogram from this NASA podcast episode for Reels, TikTok and Shorts, with captions and the speakers' names.
17	Make a 20-second square product promo from these museum photos of Christopher Dresser's teapot: sleek, but only facts from the museum record. Plus a 6-second bumper.
18	Make a 30-second cinematic book trailer for The War of the Worlds using public-domain illustrations and lines from the novel, plus a vertical 15-second teaser.
19	Make a 45-second travel slideshow of an Iceland ring-road trip from these CC0 photos, cut to the music, with a little map showing where each place is. Also a vertical version for Reels.
20	Using our brand, give me a motion pack: a 3D logo sting in wide, square and vertical, four lower thirds my editor can drop into Premiere, and a couple of branded transitions. Show me concepts first.
21	Record a 75-second narrated tutorial showing how to use the showtime studio board: open it, compare concepts, react, pick one, and send feedback. And a vertical cut for Shorts.
22	Make a narrated 70-second math explainer showing why the area of a circle is pi r squared, with real animated equations.
23	Dress up this NASA interview with Sarah Jones about the GOLD mission: name tag, a data callout, a pull-quote, a list or chapter, a side panel and captions with emphasis; a 16:9 and a 9:16 cut.
24	Find the best 30-60 s moments of this 58-minute NASA panel (Apollo 17 legends and Artemis leaders) and make three vertical clips with captions
25	Physics 2026 explainer for nobel-2026-lab: a telescope made of ice, ~2 min, three stop-and-ask questions, interactive export, 60 s vertical cut; publish today
26	Full Chemistry 2026 explainer (~2:10, 16:9) for the nobel-2026-lab: Frank's recipe, Kagan's bend, Soai's copier, the 2003 staircase, the coin flip, our mirror-race toy, caveats, medicines. NOT socratic: no questions to the viewer. American voice (af_bella; not the British female). Paperback lab-notebook look, CC0 bed, showtime credited (corner mark, end card, closing line). Must look great; post soon.
28	Make 'Showtime Test (12s, 16 9)-html.zip' an MP4, with a music bed.
29	Turn showtime's pull request #7 into a short video I can paste into its description.
30	Render the showreel template as it ships, with no edits, at 16:9, 9:16, 1:1 and 4:5.
32	Show one project in each of the twelve look signatures: a contact sheet of all twelve, and a 24-second loop that changes look every 2 seconds.
_looks	Show the seven WebGL looks in one short page, one scene each, rendered without a GPU.
_blur	Show the shutter blur on four snaps: a whip, a slam, a scale punch, and the same whip without and with it.
_diagram	Show what happens when you press Enter in a coding agent, as a diagram that builds itself, and a live version people can poke.
_recap	Make a short video of what my agent did in this Claude Code session.
_repro	Turn this failing Playwright test into a video I can attach to the bug report.

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

Every job follows the same order: check the project, render once, then fix only the seconds that changed. Output stays short and images stay out of your agent's context, so a video costs fewer tokens without skipping a check. Here is how (most of it came in 0.3.0, after the 0.2.0 benchmark showed where an agent's budget went):

• 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).
• Faster fixes (0.4.1). The encoder runs while the frames are captured and an unchanged soundtrack is reused: on a busy 6-core Intel Mac a 1 s fix spliced into a 15-30 s video went from 31-54 s to 13-21 s, and whole renders from 54-115 s to 56-81 s (best of 2, other jobs running).
• 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/.

Behaviour scoreboard

A cheaper check anyone can rerun with one command: 14 one-sentence requests run through claude plugin eval, each with showtime and with no plugin at all (same model). Does the skill fire on video requests and stay out of unrelated ones, does it report a missing file or an unsupported claim instead of inventing around it, and does it keep its contract? Regex and tool-call checks first, a model grader only where a pattern cannot decide; tokens and cost per run, and every failure in plain words, are in SCOREBOARD.md.

Behaviour	Cases	With showtime	Without (same model, no plugin)
Skill fires on a video request	12	36/36 (100%)	-
Stays out of unrelated requests	2	6/6 (100%)	6/6 (100%)
Honest about inputs and limits	7	18/21 (86%)	10/21 (48%)
Keeps the contract (questions, card, plan shape)	7	16/21 (76%)	11/21 (52%)
All cases	14	35/42 (83%)	25/42 (60%)

claude plugin eval, 2026-10-05, showtime 0.4.0, agent claude-opus-5-5, judge sonnet, 3 runs per case per arm; median tokens per run 65.3k with showtime, 34.7k without; the whole run cost $36.00 at list price. Every case, every failure and how to rerun it: SCOREBOARD.md.

Meet the crew

Your agent is the director. It can hand parts of the job to ten specialist sub-agents that ship with the plugin. Every finished video gets a critic by default (quality mode); say "lean" to skip it (a video you will publish still gets one). A researcher joins when the video states facts or you will publish it, a sound designer when you will publish it and it has music or effects, and scene builders when it is long. The rest come with studio mode, or when you say "full crew". 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.

_{▶ Watch the crew at work (45 s, plays on the showtime site; made with showtime, about the film, download).
Music: “Artemis” by Scott Buckley, CC BY 4.0. Bee footage: Su et al. 2008, CC BY 3.0 (credits).}

Who hands what to whom

Let your agent cast it (the usual way). Studio mode brings in the company; for a quick video, your agent adds the critic on its own, the researcher when the video states facts or you will publish it, and the sound designer when you will publish it and it has music or effects. Say "full crew" to get every member the job can use without the pitch step, or "no crew" to keep everything in one session. The words that set each mode:

You say	Mode	Crew
(nothing special)	quick, quality review	critic; researcher for facts or publish-bound; sound designer for publish-bound with music or effects; motion designers at 6+ scenes
"lean", "quick draft", "don't review"	quick, lean	none; a critic only when publish-bound
"full crew", "use the whole crew"	quick, full crew	every member the job can use, critic twice
"studio", "show me concepts first", "storyboard it first"	studio	pitch, storyboard gate, full crew
"no crew"	any	done inline

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.

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. Before the job is marked delivered, every blocker and should-fix the critics raised is fixed or waived with a one-line reason (showtime review-respond), and the receipt lists each waiver (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{"Facts, or will you publish it?"}
  P -->|"yes"| RS["A researcher joins"]
  P -->|"no"| D["Checked by showtime qa"]
  RS --> D
  SM --> CR["The crew joins"]
  CR --> D
  D --> RC["A critic reviews it (say lean to skip)"]
  classDef st fill:#15100E,stroke:#E9B949,color:#F5EBDC
  classDef hot fill:#B3121F,stroke:#E9B949,color:#FFF7EC
  class R,Q,QM,SM,P,RS,CR,RC st
  class D hot

Loading

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. A link can open a moment (#t=18) or loop a part (#t=10-20; Shift + drag on the scrubber picks one), and questions listed in showtime.json pause the video until the viewer answers (guide).

The player's keys

Keys	Action
Space or K	play / pause
← / →	back / forward 1 s
, / .	one frame back / forward
J / L	back / forward 5 s
1 to 9	jump to a chapter
[ / ]	previous / next chapter
M	mute
F	fullscreen
C	copy a link to this moment (#t=), or to the picked range (#t=a-b)
Shift + drag on the scrubber	pick a range to loop and link (Shift + click: from the playhead); Esc clears it
A-C or 1-3, Enter	while a question is asked: answer it, then continue

What is in the box

Voice-over Kokoro, Piper and Supertonic voices, English, Spanish and 30+ more languages, with exact word timings for captions and kinetic type.	Music and sound 297 produced tracks (Scott Buckley, Kevin MacLeod, a dozen more composers, public-domain recordings) with the credit written for you, a composer that hits exact lengths, 56 synthesized effect types, 1,334 permissively licensed sounds, beat grids, ducking, mastering.	Captions Five styles, burned in or as SRT/VTT, placed inside each platform's safe zone; karaoke from the voice's word times.
Footage editing Word-level local transcripts that keep the ums; cut fillers and pauses by editing text; speakers, scenes, face-tracked 9:16, stabilize, denoise, grade.	Math with Manim Equations, proofs, graphs and grid transforms, timed to the narration, as an optional extra.	Studio boards Concepts, style frames, music beds, a storyboard and an animatic on local pages you click through; picks are logged.
A crew of ten Optional specialist sub-agents from creative director to critic; your agent stays the director and the only one who talks to you.	HTML videos One self-contained file per video: chapters, keyboard control, links to a moment or a looping part, questions that wait for the viewer's answer, zero network requests.	QA before done Pre-render checks and a phone check, then showtime qa on the final: loudness, black or frozen frames, captions, platform specs, and a hearing pass (a voice buried under the music, long quiet stretches, jumps in level at a cut, sound cut off at the end).
Looks and motion blur Seven WebGL looks (fluted glass, tilt-shift, liquid metal, mesh gradient, god rays, marble, metaballs) and a shutter blur on fast moves, all rendered without a GPU (demo).	Talking heads Cards that appear as the words are said (name tag, list, data callout, pull-quote, side panel), caption emphasis, and a big word behind the speaker, cut out on the CPU.	Long recordings to clips A podcast, talk or panel ranked for its best moments on your machine, then the ones you pick as captioned vertical clips, each checked by qa.

Also: 30 motion components (seven of them WebGL looks), 26 transitions (15 CSS, 11 WebGL) and 6 themes, 12 look signatures that new dom, launch, short and data projects start in (a palette, a type pair and a motion feel, picked away from your recent videos; showtime signature), a showreel template for a dense 15-second reel, living diagrams (a system as an isometric figure that builds itself, also exported as a live figure people poke), 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 or a Claude Design export (showtime adopt), and a receipt for every job.

Every command

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

Group	Commands
Make	new (templates: data, diagram, dom, film, launch, series, short, showreel, tutorial, manim), adopt, release-video, pr-video, recap, repro, retime, data, preview, render, export, check, snap, look, score, motion, code, server, manim
Audio	audio compose, sfx, lib, beats, fit, mix, meter, master
Voice	voice say, voice script (narration with word timings, fitted to a length)
Footage	transcribe, pack, edit (cut, check, render, view, cards, moments, clips), captions, footage (scenes, reframe, cutout, denoise, stabilize, grade and more), autozoom
Capture and assets	site, demo, doc, assets (font --css <Google Fonts link> copies a stylesheet's fonts with their licences)
Studio	studio, brand (init, capture, apply, skip)
Job and QA	status, qa, review-pack, review-findings, review-verdict, review-respond, review (open, notes: notes on the finished video), receipt, history, reference, job, clean
Deliver	deliver (posters, platform exports, thumbnails, README loops)
Setup	setup, doctor, config, install, report, paths, version, mcp, guide, help
More	series (a tutorial series sharing one kit), signature (the look signatures: list, apply)

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 adopt design-html.zip               # a Claude Design animation's HTML export to a 1080p video, its fonts local
showtime release-video notes.md -o my-video  # release notes to a ready-to-render project, no agent needed
showtime pr-video 123                        # a pull request to a video under 10 MB for its description
showtime recap --latest                      # this folder's newest Claude Code session as a short film: script.md first, then --yes
showtime repro -- npx playwright test tests/login.spec.ts   # a failing test as a bug-report video: script.md first, then --yes
showtime new diagram how-it-works --example enter          # a living diagram: a system that builds and explains itself
showtime export html how-it-works --interactive            # the same scene as a live figure people poke, one offline file
showtime review open my-job                  # a local page to leave notes on frames or stretches of the finished video
showtime edit cards suggest edit/transcripts/talk.json   # moments in a talking head for cards (name tag, quote, list)
showtime footage cutout talk.mp4             # the speaker cut out on the CPU: a video with alpha, a matte, a sheet
showtime edit moments my-job                 # a long recording's best moments for short clips, ranked locally
showtime edit clips my-job --pick m1,m3      # the picked moments as finished 9:16 clips, each through qa
showtime assets font --css "https://fonts.googleapis.com/css2?family=Anton" --copy-to my-video/fonts

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.

Command	What it does
audio compose	procedural music to an exact length in 18 styles, with stems, MIDI and a beat map; restrained beds for explainers and data, livelier styles on request
audio sfx	56 synthesized effect types (whooshes, hits, UI clicks, risers), with the hit time printed
audio music	the produced-music catalog: 297 tracks, each measured for quality and tagged by mood, energy and tempo; audio music pick --for launch --dur 45 chooses one, and the credit lands in credits.txt and the post copy by itself
audio lib	the local library, 1,334 sounds: CC0 effects and ambiences, CC-BY music beds credited automatically, and beds rendered on your machine; audio packs adds 35 more sound packs (34 CC0, 1 CC BY) on demand
audio beats	beats, downbeats, onsets, energy, sections and key, so cuts land on the music
audio fit	loops or trims music to a length on bar lines
audio mix	one mix file: ducking under the voice, effects aligned to hits, loudness
audio meter, audio master	LUFS, true peak and loudness range; mastering to -14 LUFS / -1 dBTP by default

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.4.4

What's new has a short paragraph for each.

X-ray

• showtime xray. analyze finds every event (a keystroke, a pluck, a hit) in a clip's sound with its frame; showtime new xray --mechanism <object> draws the inside moving on those frames, on the object (through), beside it (split) or as an isometric diagram (diagram), as a dark radiograph or a light blueprint, 16:9 or 9:16; the library has a typewriter, a music box, a switch, a piano, a guitar and a drum kit. notes writes a score, a guitar tab or a drum sheet from the sound; verify reads the finished film back and qa fails a missing or extra event or audio more than 20 ms off. The receipt and the clip's credit go on the end card (guide, xray).
• The live page. showtime export html <xray project> --interactive writes one offline page: pads play the next event of their kind with the clip's sound, your keyboard types on the typewriter, drag scrubs, #hit4 and #t2.5 link to a moment, --prompt puts the request that made it on the page next to the commands, and <showtime-xray src="you-live.html"> or an iframe embeds it.
• The gallery. The X-ray page plays ten films with their receipts and plays each one live in place.

Living diagrams

• You touch them. A scene can take typing (interactive.type), a click on a part (parts[].press) and a drag that turns a knob (parts[].drag). --example typewriter and --example computer are new, and the heat pump's outdoor unit drags to set the weather (guide).

New in 0.4.3

What's new has a short paragraph for each.

Living diagrams and live figures

A recap of your agent's session

A failing test as a video

Explain a system

• Living diagrams. showtime new diagram draws a system as an isometric figure that builds itself over time: parts arrive in the order that explains them, pipes and links join them, flows, packets and state changes move through them, labels land when their part matters, and the camera chooses what to look at. Light, dark or white; --example enter (a coding agent's loop), --example market and --example econ-lab start from finished scenes. showtime check reports a label that collides or never shows whole (diagram, issue #51).
• Live figures. showtime export html <project> --interactive writes the same scene as one offline file, <slug>-figure.html: no play button, the board is live from the first frame. Hover a part to light it and read its value, pick a step to run it as an experiment on the board, turn a knob and the levels and numbers answer at once; untouched, a short tour plays. Keys, deep links to a state (#step=cost&rule=3), reduced motion, a phone layout and no network requests. showtime check walks every step, knob value and hovered part for cut or overlapping text and broken readouts (html-export § Live figure, the demo, live on the site).

From your agent's work

• showtime recap. A Claude Code session becomes a 30-60 s narrated film of what the agent did: the time, turns and tool calls, a timeline of the files it read and edited and the commands and tests it ran, the tests red to green and the diff from git. It reads the session log on your machine through an allow-list of facts (repository-relative paths, program names from a fixed list, test counts, git stats), never the transcript's own text; a filter drops anything that still looks like a key, a path, a URL or an e-mail address, and nothing renders until you have read script.md (recap).
• showtime repro. A failing Playwright test (its trace.zip, or the test command) becomes a narrated bug-report video: each step on the trace's screenshots with a cursor and the target boxed, then the failure slowed down with expected and received, plus repro.md to paste into the issue. Typed values are never shown or spoken (their fields are covered); paths are shortened to the file name, URLs lose their query strings, and secrets are masked (repro).

Render, sound and the site

• Every render worker captures from a page set up like the first one. Under load, a worker whose page opened while one of its modules got no reply could render bare frames. Each page's setup is now compared with the first page's, and a page that differs is opened again; if the first page was the broken one, the render stops with an error instead of shipping its frames (issue #52).
• Music per video, and quiet cuts. Recap and repro pick their bed from the music catalog (or a composed style offline) per session or test, so two films do not sound the same; a rerun keeps its bed, --music pins one, and a CC BY track's credit is written for you. A catalog track is downloaded once from its creator's site and cached; nothing is sent, and --music <style> or SHOWTIME_OFFLINE=1 keeps the whole film local. Recap, repro, release-video and pr-video no longer put a sound on every cut (--cut-sounds adds a soft swoosh back), and the transition sounds are softer everywhere.
• How showtime is built. A new page on the site, how showtime is built, is the crew's operating manual: who does what, and how a task becomes a merged pull request or a film (issue #53). The site and the repository share one link-preview image (issue #54).

New in 0.4.2

What's new has a short paragraph for each group of them.

Render

• Chapter mode. showtime render --chapters plans the pieces from your chapters (or the film's acts), --chapter N --job J renders one, and --join --job J joins them and builds the soundtrack once for the whole video, so there are none of the loudness steps (2.6 and 0.7 dB) that joining separately mastered sections gave. Every seam is checked against a master before the file is named final.mp4, and after a whole render or a join a later fix to one chapter re-renders exactly its frames. On one machine a whole render is faster: use chapters for a second machine (not measured), a later fix of one chapter, or a long film (render § Speed, issue #22).
• A browser window resized late no longer ruins a render. With 3 workers, 7 of 40 renders on a 6-core Intel Mac with a GPU had a wrong-sized capture lane under heavy load, and 0 of 30 do after the fix; the same fix makes --scale 2 real on a Mac. A page with the wrong size is set again and render.log says so (render, issue #49).
• A frame that never comes no longer stalls a render (when the browser reports its processes' work; otherwise the 10-minute cap stays): the frame is drawn again in a new browser, or the check ends with an error (issue #24). A WebGL canvas that loses its context on the GPU renders again without the GPU (--gpu off) instead of shipping white.
• More browsers without a GPU. Without a GPU, --workers auto uses CPU threads - 2 from 8 threads up (at most 8, within the frame, memory and SHOWTIME_MAX_WORKERS limits): on an 8-thread machine it picks 6 browsers instead of 3; with a GPU nothing changes (issue #41, FAQ).

Footage and voice

• edit render keeps the sound in sync on showtime's own renders: a range could come out with its sound up to 21 ms early (issue #38).
• Narration that fits. showtime voice script narration.md -o voice --fit 15 --estimate says up front whether the narration can fit before it synthesizes a single line.
• Your own local voice engine. Extra engines load by name, and doctor no longer fails on Kokoro when you chose another (voice, issue #8).

Help

• A first-video guide, troubleshooting by symptom and a glossary; showtime doctor ends with a link to the troubleshooting page when a check fails, and the site's docs start on "Start here" (your first video, troubleshooting, glossary).

New in 0.4.1

What's new has one sentence and a picture for each.

Look and motion

• Seven WebGL looks, no GPU needed: fluted glass, tilt-shift, liquid metal, mesh gradient, god rays, marble and metaballs. Each adds less than 50 ms to a 1080p frame at its default size (one browser on a 64-core machine without a GPU), renders the same frames with any number of browsers, and has a designed fallback where WebGL is missing (components § 7, the demo).
• Shutter blur. data-st-blur smears an element the way a camera shutter would, only on the frames it moves fast; it lands sharp (stage-api, the demo, the flash words of example 30).

Footage

• Cards over a talking head: a name tag, a list that builds as it is said, a data callout, a pull-quote, a side panel, anchored to the words so a re-cut moves them, and caption emphasis on key terms (example 23).
• A word behind the speaker. showtime footage cutout cuts a person out on the CPU (MODNet, Apache-2.0), and the EDL card behind puts a big word between the background and the speaker.
• A long recording to its best clips. showtime edit moments ranks whole-sentence moments by local signals (a hook, a complete thought, energy, laughter and applause, one topic) and showtime edit clips renders the picked ones as face-tracked 9:16 clips with captions, each through qa: a 58-minute panel took about 7 minutes end to end on a 64-core machine (example 24).

New ways in, and sharing

• Claude Design to MP4. showtime adopt <export.zip>: the artboard fills a 1080p frame with sharp text, its Google Fonts are copied in with their licences, and a looping design renders exactly one loop (adopt, example 28).
• Link previews. showtime export html --share-url <address> (or "share" in showtime.json) adds the tags that show a title, a description and the poster when the link is pasted; --folder exports are ready for GitHub Pages (example 25's HTML video).

Review and resume

• Notes on a stretch of time (Shift + drag on the notes page's scrubber), and showtime review notes names the scene and the elements under each note.
• Since you last looked. showtime status <job> lists the files you edited by hand, your unread notes and open findings, so your agent keeps your changes.
• The voice-over is heard back: showtime transcribes it on your machine and flags a name, an acronym or a number said wrong, with the fix to try; qa and the critic see it too. It runs when the local recognizer is installed: it arrives with the first transcription, or showtime setup --fetch parakeet-tdt-0.6b-v3-int8.
• check catches more: a fading text is judged at its clearest frame, caption_zone warns about anything where the captions go, a WebGPU page is tried again without WebGPU, and each look's cost is estimated.

Faster

• The encoder runs while the frames are captured, a finished browser takes over half of the largest part left, and an unchanged soundtrack is reused: on a busy 6-core Intel Mac a 1 s fix went from 31-54 s to 13-21 s.
• Without a GPU, the number of browsers follows the cores (CPU threads - 2 from 8 threads up, at most 8, and 3 below that, at most CPU threads - 2), and waits stretch on a slow page instead of failing: on a 64-core Linux machine with no GPU a 30 s launch film went from 42.0 s to 17.6 s and a 15 s DOM page from 31.8 s to 16.4 s. Do I need a GPU?

The full list is in the changelog.

New in 0.4.0

Videos that ask, and notes on the finished video

• Videos that stop and ask. List questions in showtime.json and the HTML export pauses on that frame, asks, marks the answer, replies and plays on; the MP4 gets a "pause and think" beat with a countdown and the answer. A question can sit on a narration line, so a re-voice moves it with the line (guide, example 25).
• Notes on the finished video. showtime review open <job> serves a local page that plays the latest render: pause, click a spot or drag a box on the frame, type a note. Your agent reads them with showtime review notes, fixes, and replies on the same note.
• Range links in the HTML player: video.html#t=10-20 plays that part on a loop.

New ways in

• showtime pr-video <N | URL>: a pull request becomes a short video for its own description in one command, with a copy under GitHub's 10 MB attachment limit. A public PR works without a GitHub login, and values that look like secrets never reach the video (example 29).
• A storyboard from another skill becomes a project: showtime new <template> <dir> --from-storyboard FILE reads a Markdown table (Shot | Length | Visual | Narration, in any order, English or Chinese headers; examples 25 and 26).
• Go all out: the showreel tone. A "showreel" or "go all out" brief turns it on: 12-14 shots in 15 s, no technique twice, flash words allowed, the name landing late and short; qa judges density, the ending and repeats. The showreel template renders at 16:9, 9:16, 1:1 and 4:5 with no edits (example 30).

A stricter quality gate

• The critic watches as a first-time viewer before it reads the brief: for each part, does a newcomer know why it is there? Explainers default to a cold open with the stakes, a roadmap, bridges and a close that answers the opening.
• Findings gate delivery. A job is not marked delivered while a critic's Blocker or Should-fix is neither fixed nor waived (showtime review-respond --fixed | --waive), and every waiver keeps its reason in the receipt.
• A hearing pass next to the visual critic: music over the voice, a rushed or cut-off line, a long silence, a late or loud effect, a jump in level at a cut, music that stops dead.
• One delivery card with a mandatory Look: line saying what was opened, at what size, and what was seen.

Better-looking by default

• Twelve look signatures. showtime new dresses the page templates in one of twelve curated looks (palette at the contrast rules, a type pair, a motion feel), picked away from your recent videos (--look <id> to choose; example 32 shows one project in all twelve).
• No blank or late first frames after a cut or in a <video>: every video is drawn on a canvas in renders, and check warns late_first_frame.

Proof

• A behaviour scoreboard anyone can rerun (above): 35/42 with showtime, 25/42 without.
• A blind rematch on the round-1 showreel prompt (round notes): showtime 0.4.0 lost round 5; after the density fix its two takes ranked first and second in round 6, ahead of the plain take that had won round 1. One voter (me, showtime's author), partly blind: an anecdote, not a result.

Limits: the hearing pass and the checks measure the file; whether a video is good is still the critic's and your call. The full list is in the changelog.

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, about 490 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

No GPU needed. Without one, the browser draws every frame on the CPU, WebGL included; how long that takes, and other common questions, are in the FAQ.

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.

	macOS 14+	Windows 10/11 (x64)	Linux (glibc 2.28+: Ubuntu 20.04+, Debian 10+)
Status	Intel: tested Apple Silicon: tested (CI, end to end)	Server 2025 x64: tested 11 on Arm: run in CI, rerun pending 10/11 x64 desktop: not yet run	x86_64: tested arm64: tested (CI, end to end)
uv	install script	install script or winget	install script
Node.js 24 or 22 LTS (20+)	installer	installer or winget	fnm or NodeSource

Chrome, Edge or Chromium is found automatically; if none is installed, setup downloads Chrome's headless shell (100 to 120 MB to download). Disk: the default install downloads about 0.73 GB on Linux x64 (0.67 GB on Linux arm64) and 0.53 to 0.59 GB on macOS and Windows, and once unpacked it takes about 1.4 GB on macOS and Windows and 1.7 to 1.8 GB on Linux (Python packages 0.65 to 0.9 GB, Node packages 0.34 GB, ffmpeg 0.13 to 0.33 GB, models 0.22 GB), with a browser already installed; the headless shell adds 0.2 to 0.3 GB, and a system ffmpeg 6.0 or newer saves the ffmpeg part. showtime setup --estimate prints yours, showtime setup --plan lists every download. What a video needs only sometimes arrives the first time it is used, with its size announced: the transcription model (Parakeet, about 490 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). On Windows that is one PowerShell line adding %USERPROFILE%\.showtime\bin to your user PATH: run it once, then open a new terminal (or restart your agent) to type just showtime. 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.

In ~/.showtime (move it with SHOWTIME_HOME)	Contents
bin/	static ffmpeg / ffprobe for your OS and CPU
venv/	Python 3.12 environment with pinned packages
node/	pinned Node packages: Playwright, animation, charts, math, icons, fonts
browsers/	Chrome's headless shell, only when no Chrome/Edge/Chromium is installed
models/	the Kokoro voice, face detection and denoise models at setup; transcription models on the first transcription; the portrait-matting model on the first speaker cutout
soundfonts/	the FluidR3Mono General MIDI bank (MIT) and its license
library/	the audio library, fetched in parts: CC0 effects and ambiences, CC-BY music beds (credited automatically), plus effects and beds rendered locally; showtime audio lib fetch --tier extended adds about 200 MB more music
music/	produced-music catalog tracks, each fetched from its creator the first time a mix uses it

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, the speaker cutout) 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

Extra	What it adds
asr-turbo	Whisper large-v3-turbo, transcripts for languages outside Parakeet's 25
parakeet	Parakeet-TDT 0.6B v2, English only; fetched on first use when asked for
diarize	speaker labels for interviews and podcasts
events	audio event tags (laughter, applause, music)
supertonic	Supertonic 3 voices (Spanish and 30 more languages)
sf-generaluser	the GeneralUser GS SoundFont, a richer General MIDI bank (its own free license)
sf-musescore	the MuseScore General orchestral SoundFont
deepfilter	DeepFilterNet3 speech denoiser
rife	RIFE frame interpolation (GPU, Vulkan)
chromium	Playwright's Chromium even when Chrome is installed
manim	Manim Community for math and diagram animation, showtime manim (needs cairo/pango on macOS/Linux; LaTeX only for equations)
manimgl	ManimGL 1.7.2, an optional OpenGL engine for scene files written for it (own venv; needs OpenGL 3.3; a Linux server without a display also needs xvfb)
musicgen	MusicGen draft music; its weights are non-commercial, so outputs are labelled

Parakeet-TDT 0.6B v3 (the default verbatim transcription, 25 languages) and the UVR MDX-Net vocal separator (speech under loud music) are not extras: they are fetched the first time a transcription needs them, or now with showtime setup --full.

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:

What	From	Size
ffmpeg 9.0.2 and ffprobe, static builds (GPL), skipped when a capable ffmpeg is already installed	macOS Intel: evermeet.cx (fallback ffmpeg.martin-riedl.de); Apple Silicon: ffmpeg.martin-riedl.de; Windows: gyan.dev builds from github.com/GyanD/codexffmpeg (fallback github.com/BtbN/FFmpeg-Builds); Linux: github.com/BtbN/FFmpeg-Builds (x64 fallback ffmpeg.martin-riedl.de)	52 to 194 MB, one build
Python packages, in a Python 3.12 environment (uv downloads Python 3.12 if you do not have it)	PyPI through uv; versions pinned in setup/requirements.txt	about 1.5 GB installed
Node packages: Playwright, anime.js, D3, three.js, KaTeX, Shiki, Lottie, icon sets and 16 Fontsource font packages	registry.npmjs.org, npm ci from setup/package-lock.json (integrity hashes, no install scripts)	about 250 MB installed
Kokoro 82M text-to-speech, two model files and the voices (Apache-2.0)	huggingface.co/onnx-community, github.com/thewh1teagle/kokoro-onnx	679 MB
Whisper small.en transcription (MIT)	huggingface.co/Systran	486 MB
Silero VAD (MIT), the YuNet face detector (MIT), arnndn denoise models, the FluidR3Mono SoundFont (MIT)	github.com/k2-fsa/sherpa-onnx, github.com/opencv/opencv_zoo, raw.githubusercontent.com (richardpl/arnndn-models, musescore/MuseScore), pinned to a release or commit	27 MB
Chromium, only when no Chrome, Edge or Chromium is installed (or with --with chromium)	Playwright's download server, through playwright install	not in the 2.9 GB

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

Symptom	Try
Anything looks wrong with the install	showtime doctor: real checks with a one-line fix for each problem (--json for scripts)
A command says setup has not been run	showtime setup; it prints the size and time first
A feature asks for an extra	run the showtime setup --with <name> it prints (or set SHOWTIME_AUTO_INSTALL=1)
An error needs more detail	re-run with --debug for the full traceback; the last one is also saved in ~/.showtime/logs/last-error.log
You want to report a bug	showtime doctor --report <job folder> writes a redacted bug-report.md there; read it, then share it if you like. showtime never uploads anything
Linux: the browser does not start	install Chromium's system libraries once: sudo "$(command -v node)" ~/.showtime/node/node_modules/playwright/cli.js install-deps chromium
uv/node not found right after installing them	restart your coding agent (or open a new terminal) so it sees the new PATH
Your agent's sandbox blocks the download or ~/.showtime	showtime doctor names the setting to change for that agent; or run showtime setup yourself once in a normal terminal; or SHOWTIME_HOME=.showtime showtime setup to install inside the project
Your agent looks for bin/showtime and cannot find it	the entry point is ~/.showtime/bin/showtime (written by setup) or <skill folder>/bin/showtime; the plugin's top folder has no bin/
showtime doctor takes minutes right after a restart	normal on the first run: the OS (macOS especially) checks the native libraries as they load for the first time. doctor says so and shows what it is checking; later runs take seconds
Claude Code says the showtime MCP server timed out	usually the first start after a reboot, while the OS checks the Node.js binary; run /mcp and reconnect, or start Claude Code with MCP_TIMEOUT=60000. The showtime skill works without it
Setup was interrupted	run it again; downloads resume and finished items are skipped
Files look corrupt	showtime setup --verify re-hashes everything; --force reinstalls
You want your own binaries	set SHOWTIME_FFMPEG, SHOWTIME_CHROME, SHOWTIME_NODE or SHOWTIME_PYTHON
Output colours or progress bars clutter logs	NO_COLOR=1; progress is plain lines automatically when not in a terminal

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, qa, export_html, deliver_exports, receipt, guide and status by default, and with SHOWTIME_MCP_TOOLS=all also snap, voice_say, voice_script, transcribe, audio_compose, audio_sfx, audio_mix, audio_search, studio_open and studio_feedback (the Claude Desktop bundle lists them all). 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

For people: fifteen task guides (what to say to your agent, what it runs, what you get, how long it takes), What's new (each release in one sentence a feature) and the FAQ (GPUs, cost, agents, privacy, licences, disk, time, platforms, languages).

The documentation map is the way in: every guide, grouped by what you are making, from workflows (launch, explainer, tutorial, social, data, footage, trailer, diagram, recap, repro, X-ray) 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; MODNet (the speaker cutout behind a big word, footage cutout) is Apache-2.0, code and weights, by Zhanghan Ke and co-authors; 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

_{Status: 0.4, early. Commands and file formats may still change before 1.0 (see CHANGELOG.md).}