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/a11e9613-efd3-490b-a3ec-5583ac65a5d2

_{▶ Watch the 40-second launch film (sound on). Every frame is from a real showtime example.
Music: “With These Hands” by Scott Buckley, CC BY 4.0 (credits).}

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

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 · Works with · Gallery · How it works · The crew · Studio · Formats · Docs · Site · Requirements

Quick start

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

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

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

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

3. Ask for a video:

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

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

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

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

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.2.0.mcpb from the v0.2.0 release opens in Claude Desktop with a double click. Setup still runs once on your machine: the models and tools never travel inside a package. Long tools answer with a task id after about 20 seconds when a client stops calls early; the status tool reports progress and the result.

[Now showing: 22 examples, every frame rendered by showtime.]

Now showing

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

Data and reports

Explainers

Product and brand

Footage and audio

Tutorials

Social

Trailers and montage

For developers

_{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 and links to a moment, and no network requests. Make one from any project with showtime export html. On GitHub, download the file to play it.

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

Meet the crew

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

[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 (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 (casting, pronunciation, voice-over, other 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 you will publish, your agent adds the researcher and the critic on its own. Say "no crew" to keep everything in one session.

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

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

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

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

Studio mode

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

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

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

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

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

[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: 20 motion components, 23 transitions (CSS and WebGL) and 6 themes, website capture (screenshots, copy, brand colours and fonts), scripted app recordings with smooth auto-zoom, cursor and keycaps, PDF import, CSV and JSON to charts, a brand kit, posters baked into frame 0, exports for YouTube, X, LinkedIn, Reels, TikTok, Shorts and square feeds, README loops (animated WebP and GIF, like the previews on this page), and credits written automatically when an asset needs attribution.

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 video

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. 249 produced tracks (Scott Buckley, Kevin MacLeod and public-domain recordings), each downloaded and measured for hiss, clipping, mono, dead gaps and loudness swings, tagged by mood, energy, tempo and use, and picked with showtime audio music pick. Tracks are fetched from their creators on first use and never re-hosted. Every render that uses one writes the credit into credits.txt and the post copy by itself, and prints a note. 35 more sound packs (34 CC0) install when a search needs them.
• Platforms. Apple Silicon and Linux arm64 now run end to end in CI, Windows 11 on Arm runs with an x64 Python under Windows' emulation (Requirements), and scripts/e2e.py repeats the whole path on any machine.
• A safer preview server. showtime preview and showtime server answer only requests that carry a random per-session key from the printed link; before, any web page open in your browser could read a project's files over 127.0.0.1.
• Footage edits that hear the ums. The default transcription is now Parakeet-TDT 0.6B v3 (25 languages including English and Spanish; fetched on first use, 465 MB; Whisper stays for other languages and with --model). It keeps "um" and "uh" as words, and a scan after it hears the hesitations no word covers. On a public, human-labelled podcast set (20 episodes, 495 labelled fillers) it found 81% of them at 83% precision against the labels, where 0.1.0's default found 11% at 78%; on the benchmark interview it cuts all five known "uh" (the benchmark's scorer credits 4 of 5; 0.1.0's default commands cut none). Cuts get 20 ms crossfades. Speech under music is heard better because showtime transcribes its own dry narration stem, and separates the voice only when the music is loud: word errors at equal loudness fell from 19.7% to 7.3% on a small test set. These are local evaluations on a few sets, not a guarantee for your footage; label-based precision understates it, since the labels miss some real fillers. CrisperWhisper is available as an opt-in model under its non-commercial licence (not on Intel Macs).
• Launch videos by default. Ask for a launch, promo or release video and the default is a calm short film of four to six scenes: a big still hook, one smooth fly-through into the product, the same window carried across the cuts, and a produced track whose swell lands on the end card. The camera only moves when it has a reason; the motion comes from the product itself. Terminals and code shrink to fit every size, and showtime check stops a render when text would be cut off.

The full list is in the changelog.

Requirements

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

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

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

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

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: twelve workflows (launch video, explainer, tutorial, social short, data story, footage edit, trailer, slideshow, changelog video, music video, voice-over only, localize), then five acts and a finale of guides, from onboarding to qa and review.]

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

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

License and credits

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

Contributing

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

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

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