Turn a script into a finished episode

Everything in Studio hangs off one file per episode — a manifestthat lists your cues, who says what, which voice they use, the shots, the title cards, the music. You don’t hand-write that file; Studio builds it from your script and lets you tune it with buttons.

The top bar holds the six stages — Script · Audio · Graphics · Video · Assembly · Publish — plus a Docsreference tab. Each stage tab shows a little number that flips to a ✓ when it’s done. Work left to right and you’ll end up with a finished, publishable video.

Brand-new to it? Open the in-app tour any time from the Project menu → Tutorial— it’s a quick walk through the same screens you’ll see below.

1. Make a show or an episode — Project menu → New show… / New episode…. Studio scaffolds a starter manifest + script from your show’s defaults.
2. Write the script in Markdown on the Script tab. It autosaves.
3. Generate the manifest — one button turns your script into cues the pipeline can render.
4. Audio — assign each character a voice, regenerate any line, drop in sound effects and music.
5. Graphics — render your title cards, lower-thirds, and the YouTube thumbnail.
6. Video — generate the shot list, tune prompts and seeds, render the missing shots.
7. Assembly — hit Render full episode and watch the eight-stage pipeline build the video.
8. Subtitles & localize — edit the auto-generated SRT, optionally dub into other languages.
9. Ship it — Git sync your text, Publish to this site, push captions to YouTube.

The rest of this page is just those steps, one screen at a time.

The writers’ room. Write the episode in Markdown; speaker names and stage directions are all it needs.

• Type the episode in the Edit view — it autosaves on blur, or hit Ctrl/Cmd+S. The pill reads ● SAVED / ○ UNSAVED.
• Flip to Preview to see cues laid out with each speaker in their own color, or Diff to compare against the last synced version.
• When it reads right, click Generate manifest.

The dialog previews the change: how many cues are new or being re-shot, any speakers that still need a voice, and a per-line diff. Happy? Apply — write manifest.json commits it (and keeps a timestamped backup). Your voices, seeds, and style settings are preserved.

Generate manifest is a heuristic parser — it always previews a diff before writing, so you can experiment freely. The whole grammar is four building blocks:

• ## COLD OPEN — a segment boundary; groups the cues under it.
• **RON:** Good evening. — one cue (a spoken line). The colon goes inside the bold. Dialogue can wrap across lines until the next », blank line, **, or ##.
• » Ron core → b-roll: lemonade_stand — the shots for the cue above, in order (chain them with →). No » line = one character shot of the speaker.
• ### Shot tally — ends the body; everything below is ignored, so park notes there.

On a » line: Name core is a character shot (seed from the manifest), b-roll: key a b-roll, and … card/bumper a title card — each matched against the manifest, with unmatched references flagged in the diff. Delivery notes in _(parens)_ are stripped from the spoken line.

The full reference lives inside Studio too — Docs tab → Script_Style_Guide.

Every line of dialogue, one row at a time. Play it, regenerate it, and tuck sound effects into the gaps.

• Play any line, edit its text inline, or Regenerate it — solo, or with notes for a specific read.
• Regen missing queues every line that doesn’t have audio yet; Play all auditions the whole episode in sequence.
• Assign who sounds like whom under Voices, and clone a brand-new voice with Create voice.

Sound effects and music live here too: drag CC0 effects into the gaps between cues, add a music bed, or let the local model propose an effects list from the script as if it were a radio play.

Title cards, lower-thirds, and the YouTube thumbnail — the on-screen text that sells the bit.

• Click a card to preview it; Regen re-renders from its saved layout, or Edit… to change the words and the layout.
• + New title card walks a three-step wizard: name it, pick a layout (or have the AI design a fresh one from a brief), fill in the text.
• Render missing renders everything that’s new or out of date in one go.
• The YouTube thumbnail panel renders, versions, and lets you promote your favorite — with an optional AI-written hook.

The shot list — every character and b-roll clip the episode needs. Tune the prompts, render the missing ones.

• Edit a shot’s prompt or seed inline and save it to the manifest; Play the rendered master, or Regen a single shot (with notes if you want a specific look).
• Generate shot list has the local model plan shots straight from the script and reuse recurring characters.
• Render all missing/stale sends everything that isn’t done to the render queue.

The render room. A timeline and dope sheet on the left, and the eight-stage pipeline on the right.

• Hit RENDER FULL EPISODE and watch it build: voiceover → masters → frame-interp → assemble → music → transcription → subtitles → burn-in, with a live log.
• Run from any stage, or re-run a single one with the per-stage ▶.
• The Subtitles panel has an inline SRT editor — click a line, fix it, hit enter — and a Re-burn subs button.
• When it’s done, the Final output player shows the finished video with Download and Localize….

You’ve got a video. Three ways out the door:

• Git sync (top bar) commits and pushes the episode’s text — script, manifest, metadata. Your generated media stays local; the text is the portable source of truth.
• Publish to MACU Web (Project menu) wires Studio to this site with a connect token, then pushes your episodes — checked ones go public, unchecked ride along as hidden drafts.
• Localize… (Assembly) makes dubbed videos and translated subtitles in 48 languages, reusing the picture you already rendered — translation is built in and runs locally.

The YouTube tab matches your episodes to their uploads and pushes localized caption tracks. (Uploading the video itself is a separate step.)

Publish to MACU Webpushes an episode’s text — title, description, script, the YouTube video id — to your show’s page on this site. Video isn’t hosted here; the page embeds your YouTube upload (and uses its thumbnail), so “publishing” is just syncing the words and the link. You connect once with a token, then it’s one click.

One-time connect

1. On mayorawesome.com, open your show and click Manage. In the Connect MACU Studio card, click Generate connect token and Copyit. (It’s one-time — it won’t be shown again. You can revoke it later from your account.)
2. In Studio, go to the Publish tab (stage 6). Paste the token into the connect box and click Connect. Already connected to a different site? Click Change connectionfirst to reveal the box.

Publish an episode

• On the Publish tab, set the title, description, and the hosted video URL/id (paste a YouTube link — the id is extracted for you).
• Choose the episode’s visibility: Public (listed), Unlisted (reachable by link), or Hidden (kept in Studio, not shown on the web).
• Click Publish. Studio pushes the text and the site re-reads it — your episode page updates with the new title, description, and embedded video. The thumbnail follows the video id.

Visibility is owned by the web after the first publish, so hides you make on the site stick even if you republish. Change it any time from the show’s Manage page.

• Everything autosaves. Edits to the script, manifest, and SRT write as you go.
• The manifest drawer (braces icon, top right) is the power-user escape hatch — every setting in a form, with a raw-JSON toggle.
• Stuck a render? The red ■ Stop button kills the active job and frees the GPU.
• The Docs tab keeps your canon — character bible, prompt notes — one click away while you work.
• Lost? Project menu → Tutorial re-runs the guided tour any time.

Studio is free and open source — it runs on your machine, on your GPU. The demo above is the real app with a fake backend; this is how you get the real backend too.

Then it’s three commands:

git clone https://github.com/AugustWasilowski/macu-studio
cd macu-studio
./deploy/install.sh        # doctor → pull GPU images → fetch models (~8 GB) → build
./deploy/start-studio.sh   # then open http://localhost:8774

deploy/doctor.shchecks your hardware first and warns if your VRAM is low. Full prerequisites and the staged install live in the repo’s INSTALL.md.