A dated snapshot of Showspring — the AI-native production studio behind The Doodle Cast, built by Overdigital. The product lives at showspring.com. This page is the workshop as it stood on July 3, 2026 (release v0.45.409, week 16 of the build): the pipelines, the numbers, what runs underneath, and how a one-person team ships it every day. Every figure and screenshot is pulled from the repository and the live app on that date — nothing estimated. The project moves daily, so treat everything below as a photograph, not a spec.
Veo, Kling, Higgsfield, Firefly — remarkable at generating individual video clips. But producing a complete episode — with narrative structure, multi-character dialogue, consistent visuals, sound design, and music — still takes dozens of hours of manual stitching and editing. Showspring closes that gap.
Three production pipelines (full episodes, shorts, podcasts), a shared show bible, and a render engine built from scratch for AI-native output. Solo build, gated releases shipping daily, tested in production by an actual show — and by early outside testers running their own studios on it.
The full episode pipeline. Each step has its own workspace, its own AI assist, and persists state across reloads. Skip ahead, jump back, regenerate one scene, ship the whole thing.
Competing frontier models pitch episode concepts against each other — a challenger lane and a house lane, eight pitches across four themes — then two judge models score every pitch with full reasoning breakdowns. You pick the winner, or bring your own idea and let the panel pressure-test it. Live web research grounds topical episodes in real facts.
A full script with structured clips, character dialogue, scene descriptions, and image prompts — on the LLM of your choice, grounded in the show bible so characters stay consistent and plots don’t repeat. Scripts are versioned: give feedback in plain language and the writer produces a new version with a changelog explaining how each note was honored — then diff any two versions side by side.
Every character speaks in a distinct synthesized voice. Play through the full episode readout to check pacing, dialogue flow, and structure before committing GPU cycles to visual production. Cheaper to fix a script than a render.
AI extracts every location mentioned in the script and maps them to clips. Each location lives in a reusable library with reference images, descriptions, and default prompts. The studio always looks like the studio — week 9 matches week 1.
Generate images for each clip, informed by character reference sheets, location plates, and scene context. Start and end images per clip enable smooth image-to-video. Full history with undo, AI-assisted editing, and an iPad/PC watcher for hand-drawn or live-camera source frames.
Turn scene images into motion on cloud video models (Veo 3.1) for production quality, or open models (WAN 2.2, LTX 2.3) on a local RTX 5090 for free iteration. Every generation is a take: the version history keeps all attempts per clip — twenty takes on a stubborn shot is normal — with side-by-side compare and one-click switch. A source / program dual-monitor layout previews the assembled episode in real time.
Frame-accurate in/out markers per clip. Adjust durations, preview instantly. The trimmed timeline carries forward to the audio mix and final render — one source of truth from edit through publish.
A browser-native multi-track editor: video reference lane, per-character voice lanes, sound effects, music, and audience reactions. Independent volume with keyframe automation and one-click auto-leveling. SFX, music, and crowd beds are planned by AI against the script, generated from text, and dropped onto the timeline — and the whole session can leave the browser as an OTIO bundle that opens as a native DaVinci Resolve timeline for finishing.
One button, full episode render. The engine trims each clip, applies the audio mix through hand-rolled ffmpeg filter graphs, concatenates everything, and encodes the final MP4. When the local GPU is online it runs on NVENC; otherwise CPU fallback keeps shipping.
AI thumbnails for A/B testing, AI-written metadata with multiple title candidates, then direct publish to YouTube with real-time upload progress. One click turns the finished episode into a fresh shorts batch — speakers auto-detected, reframed to 9:16, captions burned in. The show bible learns from each episode that ships and feeds it back into the next pitch.
Eight shorts at a time from a single theme — each with unique characters, dialogue, image, animation, voice, and music. Publishes across YouTube, TikTok, Instagram, Facebook, and X with scheduled auto-posting and AI-recommended slots.
Eight ideas at once from the character pool, with optional research-report grounding for topical hooks.
Per-clip scene + action prompts, 8–12 word dialogue, visual-coherence rules baked in for clean I2V.
9:16 starting frames grounded in character references, with full image history and per-clip regen.
Image-to-video on cloud models for production runs or local GPU for free iteration. Same operator surface.
Multi-track audio per short — original, voice, and AI-scored music. Batch-replace or fine-tune.
Batch render all eight, or selectively re-render. Outputs land in Drive and are downloadable on the spot.
Five-platform fan-out, OAuth-authenticated, visual calendar, AI-suggested posting times, alerts on misses.
The whole posting plan at a glance — per platform, per day — with the auto-publisher in the loop.
Conversational episodes where the show’s characters discuss real topics — multi-voice dialogue, AI cover art, and direct publish. Same characters, same continuity, different format. 2 to 120 minute targets.
Recommend Something, I Have an Idea, Research & Debate, or Debate an Episode — four ways in, each scored before you commit.
Conversation scripts with character dialogue, word-count tracking, and runtime estimates against your target.
Full script preview with character portraits and color-coded dialogue — click any line to edit before moving on.
Describe the vibe, set a duration, generate the opening jingle. Regenerate until it's right.
Same generator, closing mood — the bookend that wraps every episode.
ElevenLabs Text-to-Dialogue renders every line with voice direction, then assembles with the intro/outro music and silence gaps — one pass, publish-ready audio.
Up to four AI cover variants informed by character refs, full episode metadata for Spotify/Apple Podcasts, and the finished MP3.
Two systems that turn a flat clip sequence into something that feels like a show. A late-night news-desk segment generator, and a per-clip audience reaction track sourced from a multi-take stem library.
Extensible segment templates encode format rules, comedy mechanics, joke structures, and a small visual style guide — baked into the AI script step itself. Anchor solo shots and two-shots are rendered with OTS news graphics composited per character in the render pass.
Per-clip audience-reaction track from a multi-take stem library — thirteen reaction types, density dial, and a multimodal cue planner that listens to the cut and picks where laughs, gasps, and silence land. The audio bed is generated for the episode, not borrowed from a library anyone else can use.
The same show bible that produces the episodes powers two more things: live voice conversations with the cast, and a pipeline that turns viewers’ own dogs into cast members.
Public cast chat on thedoodlecast.com: pick a character, tap the mic, talk. Each persona is assembled from its Showspring show-bible section (auto-refreshing when the bible changes) and speaks through the same ElevenLabs voice ID used in the episode pipeline. New cast members become talkable the moment they get a bible section — no per-character code.
A viewer submits photos and a few lines (multi-dog households supported). A multimodal model turns the photos into structured character drafts; Showspring generates a per-dog portrait, a “Hello” voice line, and a video preview; the submitter picks their dog’s voice through a shareable voice-pick link. On approval the dog is promoted to a cast character with its own bible section and pinned voice — episode-ready, and instantly talkable in the live chat.
Pipelines come and go. The studio that holds them together — characters, episodes, media — persists across every show, every episode, every week.
Personality, visual description, speech style, reference images, voice profile. The cast persists across all episodes and informs every generation.
Every episode across every stage of production. Filter by status, search by title, jump straight into any production step.
Every image and clip across every episode. Browse by model, date, or episode. Drag-and-drop, crop, rotate — with full undo.
First-class sets and props with their own galleries, references, and history. The same desk in episode 14 as in episode 2.
Fifteen sections of living canon — character deep-dives, comedic mechanics, anti-patterns — versioned, scanned against YouTube, and injected into every generation step.
What actually landed, per platform, per episode — routed back into the show bible so the next pitch starts smarter.
The interesting design choices live in how these layers talk to each other — not which logos sit on which row.
Multiple top-tier LLMs and image / video models, each pointed at the step where it’s actually best. Routed through a single internal bridge with usage tracking, budgets, and graceful fallbacks when a vendor blips.
A local RTX 5090 handles the high-volume, low-stakes batch work that would otherwise burn cloud quotas — tagging, triage, draft scoring, image and video iteration. A model router serves Gemma and Qwen for text; SDXL, Qwen-Edit and Z-Image-Turbo cover image iteration; WAN 2.2 and LTX 2.3 cover local video. The same box also runs the HLS transcoder and the NVENC final-render encoder. Same bridge, different destination.
The part nobody else has: the render engine, the show bible, the continuity system, the publish pass, the analytics feedback loop. Deployed nightly, tested in production by a real show.
Why hybrid: production-grade output runs on the best cloud model for the step. Iteration runs on the local box for free. The operator never picks — the studio routes.
The part of the build log most write-ups skip. Showspring ships multiple times a day — 690 commits in the last thirty days, at least one every single day — with a production database real customers sit on. That only works because the release path is a machine, not a habit.
Every push runs the full gauntlet locally before it can leave the machine: an HTML-integrity lint, a seven-layer static gate that catches dropped globals and dangling handlers, 385 integration tests against a real booted server, and a headless-browser runtime smoke whenever the frontend changed. Quality is enforced by ratchets: counters that may only ever go down — type errors (299 → 149), raw error leaks (54 → 0), inline schema changes (capped). A regression fails the push.
Production promotes on a nightly gate: the full suite re-runs on the server against the exact commit being promoted, the database is snapshotted, health is verified after deploy, and a failed check rolls code back automatically. Staging runs on its own fork of the production database — new features and migrations rehearse against a disposable copy of real data, and finished work crosses back through a transactional promote lane. Production data is never the test bed.
The quiet headline: most of those commits were written by AI coding agents — several sessions working the same repository in parallel, coordinated by hooks, with every change forced through the same gates a human would face. The gates are what make that safe: agents don’t get tired, but they also don’t get to skip the test suite.
The project page has the story, the proof, and a way to get in touch if you have a show you’d want to put through it.