Stop Paying for AI Video! KupkaProd Runs 100% Local

Stop Paying for AI Video! KupkaProd Runs 100% Local

What if I told you that everything you hate about AI video generation could disappear overnight? The metered billing that bleeds your budget dry. The vague content policies that shadowban your creative vision. The excruciating upload-download dance that turns a 30-minute project into a 3-day ordeal. What if you could type "make a 10-minute nature documentary about deep ocean life," go to sleep, and wake up to a fully produced film sitting on your hard drive?

This isn't vaporware. This isn't a cloud service with a "free tier" that expires in seven days. KupkaProd Cinema Pipeline is an autonomous AI movie studio that transforms text prompts or full screenplays into complete videos—entirely on your local machine. No API keys to manage. No subscription invoices. No internet connection required once models are downloaded. Built by developer Matt Nicholas and powered by Lightricks' LTX 2.3 video model, this open-source pipeline orchestrates multiple AI systems into a cohesive production workflow that rivals professional studios.

The secret? It treats your GPU like the production powerhouse it actually is, not some remote rental you access through a web portal. And in this guide, I'm exposing exactly how it works, why it matters, and how you can start generating your first local movie tonight.

What Is KupkaProd Cinema Pipeline?

KupkaProd Cinema Pipeline is a Python^{↗ Bright Coding Blog}-based autonomous agent system that functions as a complete film production studio compressed into code. Created by Matt Nicholas and released on GitHub at github.com/Matticusnicholas/KupkaProd-Cinema-Pipeline, it represents a paradigm shift in how developers and creators approach AI-generated video.

The project emerged from a simple but radical premise: cloud-based AI video generation is fundamentally broken for serious creators. Runway charges $35/month for limited credits. Pika meters generations by the second. Every prompt tweak burns through your allocation. KupkaProd rejects this entire model by running everything—script analysis, storyboarding, video generation, audio synchronization, and final assembly—on hardware you already own.

At its core, KupkaProd is an orchestration layer that coordinates three distinct AI systems through a unified workflow:

• Gemma 4 (via Ollama) serves as the creative brain, analyzing scripts, planning scenes, writing character descriptions, and calculating precise timing
• Z-Image Turbo generates storyboard keyframes for visual approval before expensive video rendering begins
• LTX-AV through ComfyUI produces synchronized audio+video takes with multiple variations per scene

The "autonomous" label isn't marketing fluff. Once you provide a prompt or screenplay, the system executes a full production pipeline without human intervention until review checkpoints. It writes scripts if you only provide a concept. It plans camera angles and lighting. It calculates scene duration from actual dialogue word counts at character-appropriate speaking rates—yes, it knows Trump speaks at 170 WPM while Obama clocks 130 WPM.

This is why it's trending now. The convergence of capable local LLMs (Gemma, Qwen, Mistral), efficient video diffusion models (LTX 2.3), and mature orchestration tools (ComfyUI, Ollama) has finally made true local AI filmmaking feasible. Developers are abandoning cloud APIs in droves, and KupkaProd is the most complete implementation of this philosophy yet released.

Key Features That Separate KupkaProd from Everything Else

Full Script Auto-Detection — Drop in anything from a vague concept ("5-minute cyberpunk noir") to a formatted screenplay with INT./EXT. headings, character names in ALL CAPS, and parenthetical stage directions. The parser preserves dialogue verbatim and converts stage directions into visual descriptions automatically.

Intelligent Scene Planning with Real Timing — Unlike cloud tools that guess at duration, KupkaProd calculates scene length from actual content. Dialogue word counts divided by character-appropriate speaking rates, plus action time. Scenes range from 2-second cutaways to 30-second long takes, all mathematically derived.

Character Consistency Through Prompt Injection — Here's where it gets technically sophisticated. During Phase 1, Gemma generates 50-80 word physical descriptions for each character. These descriptions get injected verbatim into every single scene prompt because LTX-Video has zero memory between generations. The system rebuilds the entire scene—character, setting, lighting, camera—from scratch each time. It's computationally expensive but visually essential.

Storyboard Gate with AI Evaluation — Before burning GPU hours on video generation, Z-Image Turbo produces keyframe candidates. An AI evaluator checks each against character descriptions for fidelity. You review and approve/reject with notes. This prevents the nightmare of generating 20 takes of a scene only to discover your protagonist has three arms.

Multi-Take Generation with Smart Review — Configure 1-10 takes per scene (default 3). Each uses different random seeds for visual variety. A built-in take reviewer lets you watch every version scene-by-scene and assemble your final cut with one click. Set to 1 for rapid iteration, crank to 10 for overnight productions.

Bulletproof Resume System — State saves after every single step. Power outage at 3 AM during a 6-hour generation? Crash from VRAM exhaustion? Resume exactly where you left off. The state.json file in your project folder contains complete production status.

Automatic Infrastructure Management — The system detects if ComfyUI isn't running and launches it automatically. It restarts Ollama before each production run to prevent memory hang accumulation. It unloads the heavy LLM from VRAM before starting video generation. These aren't features you'd build for yourself—they're the polish that makes KupkaProd production-ready.

Modern Dark UI with Graceful Degradation — Windows 11-style interface via Sun Valley theming, falling back to standard Tkinter if unavailable. Resolution sliders with automatic snapping to valid dimensions (multiples of 64 for images, 32 for video). No hand-editing configuration files for basic adjustments.

Use Cases Where KupkaProd Absolutely Dominates

Independent Filmmaking on Zero Budget

A solo creator with a gaming PC can now produce content that previously required a team of ten and $50K in equipment. The 10-minute nature documentary demo—generated from under 50 words of prompt—demonstrates this brutally. No location scouting. No camera rental. No crew meals. Just a prompt and patience.

Rapid Prototyping for Professional Productions

Working directors use KupkaProd to generate previz animatics in hours instead of weeks. Shoot a complex scene with multiple camera angles? Generate five versions overnight, review with stakeholders, lock your approach before the real production day. The storyboard-to-take workflow mirrors actual film production pipelines.

Content Creators Escaping Platform Dependency

YouTubers and TikTok creators are building entire channels around AI-generated content. Cloud services throttle you, ban you for ambiguous policy violations, or simply change pricing overnight. Local generation is sovereignty. Your content, your hardware, your rules, your timeline.

Educational and Experimental Media

Film schools can now assign production exercises without equipment room logistics. Students generate, iterate, and learn cinematic language through actual creation rather than theory. Researchers studying AI creativity get a fully transparent, modifiable pipeline where every prompt and parameter is inspectable.

Niche Content Cloud Platforms Reject

Horror creators, political satirists, adult educators, and controversial documentarians face arbitrary content moderation. Local tools have no terms-of-service enforcement layer. The only limit is your own ethical boundaries and local law—not a Silicon Valley moderation team's interpretation of "safe."

Step-by-Step Installation & Setup Guide

Prerequisites Check

Before starting, verify your hardware: NVIDIA GPU with 12GB+ VRAM (tested on RTX 4090 Laptop 16GB), 32GB+ RAM, ~50GB storage for models, and Python 3.10+.

Step 1: Clone the Repository

git clone https://github.com/matticusnicholas/KupkaProd-Cinema-Pipeline.git
cd KupkaProd-Cinema-Pipeline

Or download the ZIP from GitHub and extract.

Step 2: Install Python Dependencies

Double-click setup.bat or run manually:

pip install -r requirements.txt

Step 3: Install Ollama and Pull the AI Brain

Download Ollama from ollama.ai, then pull Gemma 4:

ollama pull gemma4:e4b

This ~5GB model handles all script analysis, scene planning, and evaluation. You can substitute Qwen, Mistral, or any Ollama-compatible model in Settings later.

Step 4: Download Video and Image Models for ComfyUI

Your ComfyUI models folder location depends on installation type:

• Windows portable: C:\ComfyUI\ComfyUI_windows_portable\ComfyUI\models\
• Manual install: ComfyUI/models/

Video Models (LTX-AV): Download from ComfyUI-LTXVideo releases:

Image Model: Download Z-Image Turbo to ComfyUI/models/checkpoints/. Any fast image model works as substitute.

Step 5: Install ComfyUI Custom Nodes

Install via ComfyUI Manager or clone directly into ComfyUI/custom_nodes/:

• ComfyUI-LTXVideo — LTX-AV video generation nodes
• ComfyUI-VideoHelperSuite — Video output and preview nodes

Restart ComfyUI after installation.

Step 6: Critical Dry Run Testing

This step prevents 6-hour debugging nightmares. KupkaProd includes workflows in the workflows/ folder.

Test Video Workflow:

1. Open ComfyUI at http://localhost:8188
2. Drag workflows/ltx2.3t2v.json into the window
3. Fix any red nodes (missing custom nodes)
4. Click Queue Prompt for test generation

Test Keyframe Workflow:

1. Drag workflows/keyframegenerator.json into ComfyUI
2. Verify image model loads, generate test image

Optional Image-to-Video Workflow:

1. Drag workflows/ltxv_i2v_transformersCUSTOMSIGMAS.json into ComfyUI
2. Load test image, generate video from it
3. Enables using approved keyframes to guide actual video generation

Export Modified Workflows (Only if you changed defaults):

# Video workflow export
python -c "import json, urllib.request; r = urllib.request.urlopen('http://127.0.0.1:8188/history?max_items=1'); history = json.loads(r.read()); wf = list(history.values())[0]['prompt'][2]; open('video_director_agent/workflow_template.json','w').write(json.dumps(wf,indent=2)); print(f'Saved video workflow ({len(wf)} nodes)')"

# Keyframe workflow export
python -c "import json, urllib.request; r = urllib.request.urlopen('http://127.0.0.1:8188/history?max_items=1'); history = json.loads(r.read()); wf = list(history.values())[0]['prompt'][2]; open('video_director_agent/keyframe_template.json','w').write(json.dumps(wf,indent=2)); print(f'Saved keyframe workflow ({len(wf)} nodes)')"

# Optional I2V export
python -c "import json, urllib.request; r = urllib.request.urlopen('http://127.0.0.1:8188/history?max_items=1'); history = json.loads(r.read()); wf = list(history.values())[0]['prompt'][2]; open('video_director_agent/i2v_template.json','w').write(json.dumps(wf,indent=2)); print(f'Saved i2v workflow ({len(wf)} nodes)')"

KupkaProd auto-detects controllable nodes—no code editing required.

Step 7: Launch and Configure

python video_director_agent/gui.py

Or double-click start.bat. First launch prompts for:

• ComfyUI root folder (e.g., C:\ComfyUI\ComfyUI_windows_portable)
• Launch script (your usual .bat file for starting ComfyUI)
• LLM models (defaults work for most users)

Settings persist in user_settings.json and are adjustable anytime.

Step 8: Generate Your First Movie

Type: "make a 2 minute nature documentary about ocean life" and click Start Production. Or paste a full screenplay—auto-detection handles formatting.

REAL Code Examples from the Repository

Let's examine the actual technical implementation that makes this system tick. These aren't toy examples—they're production code from the repository, annotated for clarity.

Example 1: Workflow API Export Commands

The repository includes precise commands for capturing your validated ComfyUI workflows into API templates that KupkaProd consumes:

# Capture the video generation workflow from ComfyUI's execution history
python -c "import json, urllib.request; r = urllib.request.urlopen('http://127.0.0.1:8188/history?max_items=1'); history = json.loads(r.read()); wf = list(history.values())[0]['prompt'][2]; open('video_director_agent/workflow_template.json','w').write(json.dumps(wf,indent=2)); print(f'Saved video workflow ({len(wf)} nodes)')"

What's happening here? This one-liner connects to ComfyUI's REST API, retrieves the most recent execution history, extracts the complete workflow graph (node index [2] contains the prompt definition), and serializes it to JSON. The max_items=1 parameter ensures we get only the latest execution—critical since you're running this immediately after a successful test. The indent=2 formatting makes the output human-readable for debugging. This exported template is what KupkaProd's comfyui_client.py manipulates programmatically, replacing text prompts and seed values while preserving your validated node topology.

Example 2: The Complete Production Pipeline

The README documents the orchestration flow that agent.py implements:

[Your Script/Prompt]
        |
        v
PHASE 1: SCENE BREAKDOWN (Gemma via Ollama)
  - Parse script or generate scenes from prompt
  - Write character descriptions (50-80 words each)
  - Plan settings, lighting, camera angles per scene
  - Calculate duration from dialogue word count + action time
  - Unload heavy model from VRAM
        |
        v
PHASE 2: STORYBOARD (Z-Image Turbo) [skipped in T2V Only mode]
  - Generate keyframe candidates per scene (stops early on first PASS)
  - AI evaluates each against character descriptions
  - >>> YOU REVIEW: approve/reject keyframes <<<
        |
        v
PHASE 3: VIDEO PRODUCTION (LTX-AV via ComfyUI)
  - 1-10 takes per scene (configurable), different seeds
  - Full 2-pass pipeline with latent upsampling
  - >>> YOU REVIEW: pick best take per scene <<<
        |
        v
FINAL ASSEMBLY (FFmpeg)
  - Stitch selected takes into final video
  - Lossless concat (no re-encode)

Why this architecture matters: The explicit phase separation enables resumability—each phase completion updates state.json. The VRAM unload between Phase 1 and Phase 3 is essential; Gemma 4 E4B consumes significant GPU memory that would starve LTX-Video's 22B parameter model. The early-stopping in Phase 2 (stops early on first PASS) optimizes for the common case where the first candidate meets quality thresholds. The two-pass pipeline with latent upsampling in Phase 3 refers to LTX-AV's native quality enhancement: initial generation at lower resolution, then refinement. Finally, FFmpeg's lossless concatenation preserves generation quality—no generational loss from re-encoding.

Example 3: Prompt Engineering Philosophy

The system generates prompts of 200-400 words, each completely self-contained:

Every video prompt includes:
- Complete character physical description (copied verbatim from planning)
- Full setting/environment description
- Lighting direction and atmosphere
- Camera angle and movement
- Exact dialogue in quotes
- Sound effects and ambient audio

The technical insight: Video diffusion models like LTX-Video process each generation independently—they maintain no state about previous scenes. This is fundamentally different from language models with context windows. KupkaProd's response is prompt reconstruction: every scene rebuilds the entire visual world from scratch. The "verbatim" copying of character descriptions ensures consistency without relying on model memory. This explains the 200-400 word prompt lengths—they're not bloated; they're architecturally necessary for coherent multi-scene narratives.

Example 4: Duration Calculation Implementation

Scene duration calculation:
- Dialogue words counted and divided by character-appropriate WPM
- Known speaking rates: Trump (170 WPM), Obama (130 WPM), default (140 WPM)
- Action time added on top of dialogue time
- Scenes range from 2 seconds (quick cutaway) to 30 seconds (long take)

This is sophisticated media engineering. Most AI video tools accept a duration parameter as raw user input. KupkaProd derives it from content analysis. The character-specific speaking rates (hardcoded for known voices, defaulting to 140 WPM) demonstrate attention to performative reality—dialogue feels natural when paced correctly. The 2-30 second bounds prevent pathological outputs: sub-2-second scenes confuse narrative comprehension, while exceeding 30 seconds strains LTX-Video's temporal coherence and VRAM constraints simultaneously.

Advanced Usage & Best Practices

Fast Iteration Protocol: Set TAKES_PER_SCENE=1, enable T2V Only mode to skip keyframes entirely. This transforms KupkaProd into a rapid prompt-testing engine. Verify your concept works before committing to full production.

Overnight Production Strategy: Crank takes to 8-10 for maximum variety. Long productions (10+ minutes) can consume 6+ hours. The resume system handles crashes, but also consider: close unnecessary applications to free VRAM, disable Windows sleep mode, and verify your power supply can sustain sustained GPU load.

Model Substitution for Speed: If gemma4:e4b planning feels sluggish, use it for creative writing only and a lighter model for evaluation tasks. Or switch both to faster models like Qwen 2.5 for draft productions, reserving Gemma for final polish.

VRAM Optimization Chain: The system automatically unloads models, but you can manually optimize by reducing VIDEO_HEIGHT to 432 (default) rather than chasing 1080p. LTX-Video's quality at lower resolutions often surprises—test before assuming you need maximum pixels.

Custom Workflow Integration: The auto-detection in comfyui_client.py handles most cases, but power users can manually specify node IDs in config.py for exotic ComfyUI setups. This enables integration with custom upscalers, alternative VAEs, or experimental LTX-Video forks.

Comparison with Alternatives

The verdict: Cloud tools win on convenience for single clips under 10 seconds. KupkaProd dominates for narrative content, long-form production, budget sustainability, creative control, and privacy. The gap widens exponentially with project complexity—a 20-minute film is economically absurd on cloud platforms but routine for KupkaProd.

FAQ

Q: Can I run KupkaProd on AMD or Apple Silicon GPUs? Currently NVIDIA-only due to CUDA dependencies in LTX-Video and ComfyUI's optimized paths. AMD support would require ROCm-compatible builds of all dependencies. Apple Silicon lacks the 12GB+ unified memory bandwidth for practical LTX-Video operation.

Q: How does this compare to Sora or other closed models? Sora generates higher fidelity in isolated clips but offers no production pipeline, no multi-scene coherence, no audio, and no local execution. KupkaProd trades absolute pixel quality for systematic narrative capability and creative sovereignty.

Q: What's the realistic output quality? Demo-linked 10-minute nature documentary shows production-ready results with light post-production trimming. Quality improves with prompt specificity and iteration. It's not Pixar—it's accessible independent filmmaking.

Q: Can I use my own ComfyUI workflows? Absolutely. The API export system captures any workflow. Auto-detection finds controllable nodes, or manual ID specification in config.py handles edge cases.

Q: Is commercial use permitted? Non-commercial free per the license. Contact matt.kupka@gmail.com for commercial licensing—this supports continued development.

Q: How much does a typical 10-minute film cost in electricity? Rough estimate: 6-8 hours at 400W GPU draw = 2.4-3.2 kWh. At $0.15/kWh, approximately $0.36-0.48. Compare to cloud API costs that would exceed $50 for equivalent duration.

Q: What if Gemma outputs malformed JSON during planning? The parser handles most cases automatically. Persistent issues indicate model temperature too high or context overflow—reduce scene count or switch to a more robust model like Qwen 2.5.

Conclusion: The Future of AI Video Is Local

KupkaProd Cinema Pipeline isn't merely a tool—it's a declaration of independence from cloud AI economics. In an industry racing to meter every creative impulse through subscription APIs, Matt Nicholas has built something radical: a complete production studio that respects your hardware investment, your creative autonomy, and your budget.

The technical achievement is substantial. Orchestrating Ollama, ComfyUI, and multiple model pipelines into a coherent autonomous agent with resume capability, VRAM management, and human-in-the-loop review points represents genuine systems engineering. The prompt reconstruction strategy for character consistency, the mathematically derived scene timing, the lossless FFmpeg assembly—this is craft, not hackery.

But the strategic implication is larger. As AI video quality asymptotically approaches professional output, the differentiator becomes control: control over cost, control over content, control over iteration speed. KupkaProd delivers all three.

My recommendation? Install it this weekend. Start with a 1-minute test. Experience the visceral satisfaction of generating complete narrative video without watching a credit counter deplete. Then scale to ambition—because with KupkaProd, your only limit is GPU time you already own.

Star the repository, clone it, and start your first production tonight →

The cloud had its moment. The future runs on your desk.