showtime

[showtime: velvet curtains open on a lit stage. A local video studio for your coding agent. Describe a video. Your agent directs. Your machine renders.]

https://github.com/user-attachments/assets/638bfa30-522f-4e7c-ab9e-e77f364e7dc9

_{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).}

[license: MIT] [runs on your machine] [API keys: none] [tested with Claude Code, Codex, Cursor, Devin and OpenCode] [status: 0.4, early] [tested: Intel Mac, Apple Silicon, Linux x64, Linux arm64, Windows x64, Windows 11 on Arm] [still to run: Windows 10/11 desktop]

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:

[A Claude Code session: the request is typed, Claude states its assumptions (quick mode, 20 s, 16:9, English voice, upbeat bed, only claims the README makes), shows a first look, renders on this machine, and showtime prints its completion card: final.mp4 is ready, 20.0 s, 1920x1080, 17.0 MB, qa PASS, the output path and the next step.]
_{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.6 (the list is below, and What's new has a short paragraph for each):

• check reads the text a page draws on its own canvas. Text outside the phone's safe box, text too small to read and text over other text are found between its samples and on any canvas, not only the film API's.
• X-ray on a phone and in sync. At 9:16 the sound strip and the part labels sit where a phone shows them, a new 16:9 project passes its own check, and with "xray".offset_frames the strip and the piano, drums and guitar follow the recording's clock.
• Fixes. export html --interactive packs a page's own fonts, xray verify reads the marker on a draft render, installed files match the repository byte for byte, and setup --home brings its own ffmpeg.

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

• X-ray from data and from a recording. showtime xray import turns event times measured in a data stream into a film; xray analyze takes a WAV with no picture.
• A live page that says what it knows. How the events were measured, your own steps, and what sharing the page shares.
• A shorter skill router. Six families instead of one row per feature, with a routing eval for contributors.
• Safer and smoother. footage trim -o writes the file you name, the embed takes only safe addresses, and living diagrams type properly on a phone.

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.

[A typewriter filmed on a desk, its typebars, ribbon and escapement drawn in glowing lines on the machine itself as it types, with the receipt: 19 of 19 events on their frame, audio 0.0 ms from the original.]

_{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 frameshowtime new xray xray-typewriter/project --mechanism typewriter --theme darkshowtime 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.

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.

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

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

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

showtime install --agent opencode

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

showtime install --agent gemini

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

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 printsshowtime install --agent kiro       # skill, crew and MCP servershowtime install --agent zed        # skill; it prints the context_servers entry to paste into settings.jsonshowtime install --agent goose      # skill; it prints the extension block for config.yamlshowtime install --agent amp        # or: amp mcp add showtime -- ~/.showtime/bin/showtime mcpshowtime install --agent qwen       # Qwen reads skills only from ~/.qwen/skills

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

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.6.mcpb from the v0.4.6 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: 35 videos, every frame rendered by showtime.]

Now showing

[The 0.2.0 launch film: the camera flies through the o of "road", with the Iceland example seen through it.]

_{▶ 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

Explainers

Product and brand

Footage and audio

Tutorials

Social

Trailers and montage

Looks and motion

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

How it works

[How showtime works. One sentence in your coding agent; your agent directs (assumptions, script, scenes, mix); a first look, and your notes loop back; the render runs on your machine (frames, voice, music, encode); showtime qa checks loudness, frames, captions and platform specs; out come an MP4 and an HTML video with poster, exports, captions and credits.]

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

[What runs where. In your coding agent, your agent is the director: it reads your request and sources, states assumptions, writes the script, picks templates, scenes and sound, shows a first look, briefs the crew and checks the result. On your machine, in ~/.showtime, is the studio: headless Chrome, ffmpeg, Kokoro, Piper and Supertonic voices, local transcripts, a composer with 18 styles and 56 effect types, 1,334 sounds and 297 music tracks, Manim, and showtime qa. The web only when you ask: archive search and site capture fetch pages; nothing of yours is sent. No cloud AI service, no API keys, no uploads.]

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.

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.

[The crew film: the critic's catch in example 13, the old caption struck through with a BLOCKER note.]

_{▶ 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).}

[The crew as a cast of ten illustrated cards, all optional: creative director (pitches three concepts and a wildcard, then signs off the storyboard); brand designer (pulls a brand kit from your repo or site, or proposes one); scriptwriter (every word, each fact tied to a source); storyboard artist (turns the concept into shots, timings and an animatic); motion designer (one scene in its own sandbox, several in parallel); sound designer (bed, effects, sound logo, a metered mix); voice director (picks the voice, fixes pronunciation, adds languages); editor (cuts real footage by transcript); researcher (checks every claim and every asset's license); critic (watches the draft like a stranger).]

Who hands what to whom

[How the crew hands work around. The director, your agent in your session, writes a TASK.md brief for each member and merges each RESULT.md. I, pitch, in parallel: creative director (concepts and a wildcard), scriptwriter (facts, claims, hooks), brand designer (a brand kit); you pick a concept. II, plan: scriptwriter (the script), storyboard artist (storyboard and animatic), researcher (checks every claim), creative director (signs off); you sign off. III, build, in parallel: motion designers (one per scene), sound designer (bed, effects, mix), voice director (the voice-over). IV, review: the critic writes findings with frames; fixes go back to the same member. V, deliver: showtime qa, then the MP4 and HTML video. Footage jobs: editor, sound designer, researcher, critic. Members never talk to each other or to you.]

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:

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

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.

[Studio mode, on a local board at 127.0.0.1 with a token. 1 concepts: three and a wildcard, with style frames. 2 look and sound, optional: three looks, three music beds, voices. 3 storyboard: every shot with time, picture, text and voice-over. 4 animatic: a draft with the bed, notes by timecode. 5 build and review: the final, checked with showtime qa. Picks and comments come back as data and are logged.]

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

What you get

[Output formats. One request, every shape: 16:9 for YouTube, X and LinkedIn; 1:1 for square feeds; 9:16 for Reels, TikTok and Shorts, laid out again or face-tracked rather than just cropped. What a job can hand you: final.mp4 (H.264 and AAC, mastered to -14 LUFS), the HTML video, WebP and GIF loops, poster.jpg and thumbnails, SRT and VTT captions, WebM and ProRes with alpha, share.txt with post copy and credits.txt.]

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

[Anatomy of an HTML video: the real player of example 02, heat-pump.html, paused at 0:18 with its chapter menu open (Hook, Heat in cold air, The loop, Evaporator, Compressor, Condenser, Expansion valve, Payoff, End card). 1 one file of about 1 MB with frames, audio and player inside. 2 deep links such as #t=18 or #chapter=4. 3 chapters on the scrubber, in a menu and on keys 1 to 9. 4 keyboard control. 5 zero network requests.]

What is in the box

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.

showtime new dom my-video --duration 20     # a project from a templateshowtime voice script my-video/narration.md -o my-video/voice --fit 18   # local narration, fitted to 18 sshowtime retime my-video --from-voice my-video/voice/timeline.json         # scenes follow the narrationshowtime data import signups.csv my-video --x month --y signups --scene bars   # a CSV becomes a chartshowtime preview my-video                    # live player with scrubber and audioshowtime render my-video --preview           # fast draftshowtime render my-video -o final.mp4        # full qualityshowtime qa final.mp4                        # PASS/WARN/FAIL: loudness, black/frozen frames, captions, platformshowtime deliver exports final.mp4 --targets youtube,reels,squareshowtime export html my-video                # a single-file interactive HTML videoshowtime look my-video                       # one composite of the key frames, for a quick visual checkshowtime 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 exportshowtime adopt design-html.zip               # a Claude Design animation's HTML export to a 1080p video, its fonts localshowtime release-video notes.md -o my-video  # release notes to a ready-to-render project, no agent neededshowtime pr-video 123                        # a pull request to a video under 10 MB for its descriptionshowtime recap --latest                      # this folder's newest Claude Code session as a short film: script.md first, then --yesshowtime repro -- npx playwright test tests/login.spec.ts   # a failing test as a bug-report video: script.md first, then --yesshowtime new diagram how-it-works --example enter          # a living diagram: a system that builds and explains itselfshowtime export html how-it-works --interactive            # the same scene as a live figure people poke, one offline fileshowtime review open my-job                  # a local page to leave notes on frames or stretches of the finished videoshowtime 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 sheetshowtime edit moments my-job                 # a long recording's best moments for short clips, ranked locallyshowtime edit clips my-job --pick m1,m3      # the picked moments as finished 9:16 clips, each through qashowtime assets font --css "https://fonts.googleapis.com/css2?family=Anton" --copy-to my-video/fonts

New in 0.4.6

What's new has a short paragraph for each.

check

• Canvas text outside the safe box. At 9:16, every step of the dense timeline compares each text a page draws on its own canvas with the safe box (x 64-916, y 220-1440 at 1080x1920): one safe_zone warning per text, with its span.
• Canvas text size. Raw fillText/strokeText now feeds the tiny_text rule and the phone check, as DOM text and F.text already did.
• Text over text. Every text a canvas paints and the DOM's are compared on the whole timeline: a pair that overlaps on two steps in a row is a text_overlap warning with when it starts and ends. Text layered on purpose can say so (F.text(..., {layer: true}), F.layer, ST.layer).
• A probe that did not run is a warning (cut_probe_failed, webgpu_probe_failed), so such a check never reads as clean and check --strict fails on it.

X-ray

• 9:16. The sound strip sits above the counters inside the safe box, and the part labels are 44 px in a column at the safe box's edge, with the drawing between the columns. The 9:16 layout change leaves 16:9, 4:5 and 1:1 as they were. A project made with 0.4.5 keeps its copy of the template; showtime new xray gets the new layout.
• 16:9. A new project passes its own check, and the strip's label is 26 px and fits a long mechanism word.
• "xray".offset_frames. The sound strip, track_until and the piano, drums and guitar follow the recording's clock (k.rt, k.frameAt(t) in the drawing kit).
• xray verify reads the sync marker on a --preview or --scale render; the receipt says what "the original" is for a film made from a rendering of data.
• export html --interactive packs a page's own fonts, and export html run from inside a job writes into that job (xray).

Fixes

• Files as installed. The repository stores every file exactly as it is installed (.gitattributes * -text, Windows launchers with CRLF), checked by scripts/check_release.py.
• setup --home X installs ffmpeg into X when a default install exists.
• Living diagrams. Space or Enter on a focused control no longer also fires the scene's key.
• The embed element takes a file: address only on a page opened from disk.
• showtime assets icon suggests the right name at once for a misspelled one.

New in 0.4.5

What's new has a short paragraph for each.

X-ray

• From data. showtime xray import <events.csv|json> --job <job> --time-map SLOW,T0 writes xray.json from event times measured in data (peaks of a signal, a sensor log): film time is (t_data - T0) x SLOW and each event lands on its frame. --source names the sound the film plays, so xray verify can check it.
• From a recording with no picture. xray analyze takes a WAV (events on a frame grid of --fps, default 30) and xray notes takes one too, always at 30 fps; the page draws the picture side.
• The live page. It states how the events were measured, lists your own steps when "xray".made.commands has them, and the page, the gallery and the guide say what sharing a page shares (guide, xray).

The skill and the tools

• Routing by family. SKILL.md sends a request to one of six families at 1,200 words or fewer; flags live in the guides and --help. A routing eval (benchmarks/routing-eval/) and a release check keep a case for every new workflow guide.
• footage trim -o <file> writes that file. An existing file is refused unless --overwrite.
• The embed element loads only a relative, http(s) or file: address.
• Living diagrams on a phone. The Type field takes a paste, an input-method composition and Android Backspace, and no longer zooms the page on iOS.

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.

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.

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

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

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

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

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

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

showtime setup --list                     # tiers, extras and their sizesshowtime 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 takesshowtime 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 moreshowtime setup --with asr-turbo,diarize   # add extras (keeps what is already installed)showtime setup --tier full                # core + the common extras

Docs

[The documentation map: eighteen workflows (launch video, explainer, tutorial, social short, data story, footage edit, trailer, slideshow, changelog video, music video, voice-over only, localize, repo explainer, paper explainer, repro, diagram, recap, x-ray), then five acts and a finale of guides, from onboarding to qa and review.]

For people: seventeen 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 affectpython3 scripts/check_release.py --check            # release hygiene

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