The previous article broke down the commercial production pipeline behind Seoul Is A Bit Rough Today (LibTV + JiMeng Seedance 2.5). The question asked most in the comments: what if you don’t want to pay a subscription, don’t want your data leaving the country, and want to customize your own workflow — is there an open-source equivalent?

Yes, and it’s more active than you’d think. As of 2026, the “AI short drama” direction on GitHub has already spawned a batch of projects hitting the 10k-star mark. I read through the READMEs of the top six by activity, verified their licenses and tech stacks, and compiled this selection guide. Star counts as of September 21, 2026, all from real-time GitHub API data.

TL;DR

• Want a “one-liner generates a complete short drama” one-click experience → Huobao Drama (★15,402)
• Want an infinite canvas + three-layer Agent system as a full workstation → Toonflow (★15,850)
• Want to treat “character consistency” as a first-class concern → Jellyfish (★6,465)
• Want to download on Windows with data staying on-machine → LocalMiniDrama (★1,786)
• Already have ComfyUI hardware, want a local render pipeline → DiffuseCut (early alpha)
• Want “methodology crystallized into scripts” rather than software → shuohao-skills (★3,662)
• Just want to run unattended marketing short videos → MoneyPrinterTurbo (★124,913)

Let’s go through each one.

Toonflow (★15,850): The closest thing to an “Open-Source LibTV”

HBAI-Ltd/Toonflow-app · Apache-2.0 · TypeScript · Created 2026-01, still actively updated as of September

Toonflow’s positioning overlaps the most with LibTV: a one-stop workstation for novel/script → animated short drama, cross-platform desktop. A few design choices are worth highlighting separately:

Infinite-canvas production workstation. Scripts, characters, storyboards, assets, and video nodes are all organized on a single infinite canvas, supporting free arrangement, undo, and parallel production. This directly mirrors LibTV’s canvas interaction, running locally as an Electron desktop app.

Three-layer Agent collaboration system. The decision layer decomposes tasks, the execution layer generates content, and the supervision layer handles quality review and revision feedback. This explicitly models the QA step of a “production pipeline” — most similar projects don’t have this layer.

Persistent Agent memory. Cross-session memory powered by local ONNX vector retrieval, with three tiers: short-term messages, long-term summaries, and semantic recall. Multi-turn creation never loses context, which is a hard requirement for serialized drama production.

Programmable provider system. Write TypeScript adapters for models directly in the settings center, active immediately — no source-code changes or restarts needed. Want to plug in a privately deployed model endpoint? This is the place.

Tech stack: Node.js 23+ / TypeScript / Express 5 / SQLite / Electron 40 / Vercel AI SDK. On the model side you supply your own: LLM endpoint (OpenAI/Anthropic/DeepSeek/Zhipu/MiniMax/Tongyi all supported) + video service (Sora or Doubao) + image model (Nano Banana Pro). Three mirrors across GitHub/Gitee/GitCode — no need to VPN to download in China.

Note that it follows a “local software + cloud API” approach: the software is open source, but generation capabilities depend on your own model accounts. This is a different philosophy from LibTV’s “all-inclusive credit package” business model.

Huobao Drama (★15,402): The Ceiling for Automation

chatfire-AI/huobao-drama · CC BY-NC-SA 4.0 (non-commercial) · Vue/Nuxt · Created 2026-01

“Generate a complete short drama from a single sentence — full automation from script to final cut” — the first line of the README sounds ambitious, but the pipeline is genuinely end-to-end: LLM parses the script → extracts characters/scenes/storyboard → AI generates images for character designs and scene backgrounds → text-to-video/image-to-video produces storyboard clips → auto-composite.

Two details reveal its maturity: first, the AI Agent framework uses Mastra, with task orchestration following a proper agent paradigm rather than hardcoded flows; second, the desktop client uses Electron’s utilityProcess to host the backend and esbuild to bundle it into a single file — the release artifact is very clean. Data is stored in SQLite (WAL mode), and generated outputs stay local.

But there’s a big catch: the license is CC BY-NC-SA 4.0, non-commercial only. Anyone looking to plug this into a commercial production line should rule it out immediately. Also, it nudges you to sign up for the author’s API aggregation service (api.firemux.com) for one-click configuration of three recommended models. You can use other models, but the default path carries conversion intent — use your own judgment.

Jellyfish (★6,465): Treating “Consistency” as a First-Class Citizen

Forget-C/Jellyfish · Apache-2.0 · React + FastAPI · Docker deployment

The thing that most impressed me about Jellyfish is how it frames the problem. The README states “Treat consistency as a first-class problem” — characters, scenes, props, and costumes are managed centrally, and cross-shot drift is treated as a systemic issue rather than a matter of luck. The approach from my previous article on Seoul, where character assets come first, is exactly what Jellyfish has turned into a software architecture.

The workflow is five stages: script breakdown → shot prep → candidate confirmation → shot ready → generation workspace. Every step is reviewable and reusable: shots, candidate assets, dialogue, prompts, and generation tasks are all persisted as retrievable assets.

Two more engineering highlights: text/image/video generation all go through a unified async task system with state tracking, cancellation, and resume; model management, prompt templates, files, and OpenAPI collaboration interfaces are all independent modules at the infrastructure layer. Python backend (FastAPI) + React frontend + Docker — three-piece setup with a GHCR image and CI deployment, ideal for self-hosting and sharing across a small team.

LocalMiniDrama (★1,786): Data Never Leaves Your Machine

xuanyustudio/LocalMiniDrama · MIT · Vue3 + Node.js + Electron · Windows-first

“Download and run, fully open source, data stays on your machine” — this is the project with the strongest privacy narrative among the six. Project data, generated images and videos, SQLite — everything lives locally, and model calls go through your own keys.

Its storyboard production page supports professional video parameters (shot size/camera movement/lighting/depth of field), and v1.2.8 added canvas mode and Volcano Ark ModelArk private asset library (SD2 character certification, AK/SK and Bearer dual authentication). The model integration table covers Alibaba DashScope, Volcano Doubao/Seedance 2.0, Kling (including Omni), Vidu, Gemini, NanoBanana, and local Ollama — the widest model support I’ve seen in an open-source short drama tool. The three JiMeng 1.0 auto-generated video clips shown in the README demonstrate character consistency across continuous storyboards, and the results are straightforward.

MIT license — commercial modification is hassle-free. The trade-off is that the Windows desktop client dominates (Electron 28 bundled as exe); Linux users need to build from source.

DiffuseCut: The “Control Room” for the ComfyUI Camp

collective-thought-media/DiffuseCut · MIT · Released 2026-09, 0.1.0-alpha

All the previous projects follow the “software + cloud API” pattern. DiffuseCut takes a completely different route: local rendering. It’s a control room for ComfyUI — write your story, lock in character and scene visuals, storyboard, generate images and video through ComfyUI, add music (ACE-Step), dialogue and sound effects, optional lip-sync, and finally export to MP4 via FFmpeg.

The core selling point is model agnosticism: point it at your own ComfyUI host, and swap between SDXL, LTX, MiniMax H3, Flux, or anything else; any ComfyUI workflow exported to API format can be imported as a template, with prompt/seed/output bindings, so you don’t need to open the ComfyUI canvas for day-to-day operations.

The trade-off is obvious: alpha stage, star count in single digits, and you need existing ComfyUI + GPU infrastructure. Geared toward players who already have a 4090 and want to keep the entire production local — not for beginners.

shuohao-skills (★3,662): Methodology-First, Not Software-First

eternityspring/shuohao-skills · Agent Skills collection · Runs on Claude Code / Codex

This project is the most unique of the bunch: it’s not software, it’s a collection of skills for AI coding agents. Feed in a novel, and the output is production-ready material that can go straight into a generation pipeline — character breakdown, outline structuring, scene and prop design, script writing, and storyboard slicing.

The pipeline design philosophy is stated on the first screen of the README: the outline converges the structure, while script, scenes, and characters iterate in sync; storyboards only output, they don’t make new decisions. Each skill comes with scripted quality gates (14 for novel-outline, 10 for novel-script, 11 for novel-art), and viral hit patterns like “the first three beats before the hook must deliver on the cold open” are hardcoded as validation rules. The storyboard stage does word-by-word reconciliation of MiniMax H3 prompts.

For anyone who runs Claude Code, this is an attempt to distill the “3+3+3 rule, character assets first” methodology from my previous article directly into executable scripts. Feed the generated material into Jellyfish or LocalMiniDrama for the final output — two legs walking together.

And Also: The OG of Marketing Short Videos

Any roundup would be incomplete without MoneyPrinterTurbo (★124,913): the pioneering project for “one-sentence generate a HD short video,” around since 2024 and still being updated. But it does “asset mashup + TTS narration” style content — no character consistency, no narrative pipeline. It’s a completely different species from short drama production. In the same lane there’s MoneyPrinterPlus (★7,123, auto-publish to Douyin/Kuaishou/Xiaohongshu) and story-flicks (★2,531, children’s story oriented). If your goal is unattended mass production of marketing accounts, follow that thread; if you’re making something with actual narrative like Seoul, stick with the six above.

Selection Decision Matrix

The Real Cost Boundary of Open-Source Solutions

The software is free, but the math changes. In the previous article, LibTV at ¥729/year bundled “software + model calls” into one price; open-source projects only waive the former — model fees still apply:

• Running cloud APIs: The cost structure is no different from using JiMeng or Kling directly (Seedance 2.5 API at 720P is roughly ¥1.5/second). What you save is only the workflow subscription fee.
• Running locally (DiffuseCut + ComfyUI route): Models are free, but a 24GB 4090 is a ¥15,000+ sunk cost, and open-source video models (Wan, LTX) still show noticeable gaps compared to Seedance 2.5 in character micro-expressions.

So the real value ranking of open-source alternatives is: controllability (modify code, integrate private models) > privacy (data stays on machine) > cost savings. The third point mostly doesn’t hold up under total cost calculation.

One closing line: LibTV sells you a “tidy, organized production line”; open-source projects give you “the parts and blueprints for the line.” For someone who knows how to turn a wrench, the parts are more valuable.

Data & Verification

All project data in this article comes from real-time GitHub API queries (2026-09-21). Star counts, licenses, tech stacks, and update times have all been cross-checked against each repository’s README. The non-commercial license on Huobao Drama (CC BY-NC-SA 4.0) and its built-in API aggregation entry, plus Toonflow’s requirement to supply your own models — these are the two most easily missed information gaps when making a selection, already flagged above.