mulmocast-cli: MulmoCast: The Repo That Compiles One Script Into Video, Slides, Podcast, and Manga
An AI-native media engine where MulmoScript becomes the source of truth, the browser becomes the renderer, and the same narrative can ship in multiple formats without rewriting the story.
media compiler, with the source script physically feeding all outputs. The artist uses tightly packed crosshatching lines layered at different angles to build up shadow and form, with clean open areas of white for highlights. The line work has the quality of a classic metal engraving, precise and deliberate, with varied line weights where bold contour lines define shapes and finer interior lines create tonal depth. The overall style evokes vintage newspaper editorial illustrations from The Economist or Wall Street Journal. No color, no gradients, no grey fills. Only black lines on white. The background MUST be pure white #FFFFFF. No paper texture, no cream, no off-white, no noise, no grain. Perfectly clean flat white background." loading="lazy">
- MulmoCast’s core idea is not slide generation but narrative compilation, where one structured script can become several media formats without rewriting the story.
- MulmoScript acts as the source of truth, which separates intent from presentation and makes cross-format rendering possible.
- The browser, Puppeteer, and FFmpeg form a practical render stack that turns HTML into polished video and slide output without a traditional editor.
- Graph-based orchestration matters here because AI media production is non-linear, parallel, and dependency-heavy.
MulmoCast is easiest to understand if you stop calling it a presentation tool. It is a media compiler. One MulmoScript can turn into a video, podcast, slide deck, PDF, manga, or swipe animation, which means the interesting unit is not the deck. It is the narrative.
One Script, Many Media
That shift matters because most tools start with format. PowerPoint thinks in slides. Video editors think in timelines. AI generators often think in a single output and force everything else to be re-authored. MulmoCast starts with the story and treats output as a downstream choice.
The repository’s own framing is blunt about the ambition: receptron/mulmocast-cli is built for AI-powered podcast and video generation, but the same pipeline reaches far beyond those two formats. That is why the project feels less like a creator app and more like a content runtime.
MulmoScript: The Source of Truth
The abstraction that makes this work is MulmoScript. The repo describes it as a JSON-based intermediate language, and that is the key phrase. It is not a finished artifact. It is a structured script that holds the narrative intent before any particular rendering decision is made.
At the core of MulmoCast is MulmoScript, a JSON-based intermediate language that functions like a screenplay or web markup.
{
"title": "A single narrative source",
"beats": [
{
"speaker": "host",
"text": "Introduce the idea",
"visual": "editorial scene"
},
{
"speaker": "host",
"text": "Explain the proof",
"visual": "diagram or slide"
}
]
}
That separation is the whole game. Once story intent lives in a structured source, MulmoCast can render it into different forms without asking the human to rewrite the same argument six times. The article’s own angle follows from this: the repo is not about better decks. It is about durable narrative infrastructure.
The Browser Is the Renderer
The pipeline is practical rather than magical. HTML and Tailwind generate the visual layer. Puppeteer captures it. FFmpeg assembles frames and audio into the final artifact. That stack matters because it preserves the flexibility of the web while still producing finished media.
In other words, the browser is not a live demo surface. It is the production stage. That lets MulmoCast lean on familiar web styling, dynamic layouts, and templated components while avoiding the complexity of a full video editor.
The runtime in assets/html/js/animation_runtime.js adds interpolation and motion primitives like typewriter effects, counters, and pans. So the system does not merely screenshot static pages. It animates structured beats into timed media.
Why GraphAI Matters
This is where the project stops being a conversion tool and starts looking like an AI production system. Generating a finished asset is not a straight line. It is a graph of dependent tasks: script parsing, prompt generation, image generation, TTS, timing, capture, and assembly.
A graph handles that better than a single script because some tasks can run in parallel while others must wait for upstream results. For example, image generation can fan out across multiple beats while audio duration still needs to resolve before the final video timing locks in. That is exactly the sort of workflow GraphAI is built to manage.
| Linear workflow | Graph workflow |
|---|---|
| One step waits for the previous one even when it does not need to. | Independent tasks run in parallel when dependencies allow it. |
| The pipeline is harder to adapt when one output type changes. | The pipeline can branch by output while reusing shared steps. |
| Failures are handled as a single chain of events. | Failures are isolated to the node that actually broke. |
| Human authors usually manage the sequence manually. | The system can coordinate AI tasks as a structured graph. |
Built for Humans, but Optimized for Agents
The repo’s MCP server support makes the strategic bet obvious. MulmoCast is not only for a person sitting in a terminal. It is also for an AI agent acting on that person’s behalf, which is why the .claude/skills tooling matters. The environment is tuned for delegated creation.
That is a meaningful product choice. If the tool is going to generate scripts, visuals, and audio from messy inputs, then the best operator may be a model that can call the right commands, inspect the results, and iterate. MulmoCast is quietly built for that loop.
How It Differs From PowerPoint, Keynote, and AI Presentation Tools
The simplest comparison is this: PowerPoint and Keynote are format-first. AI slide tools are often format-first with a generative layer attached. MulmoCast is intent-first. The script is the stable object, and the output format is a rendering decision.
| Tool | Primary unit | Typical output | What changes easily |
|---|---|---|---|
| PowerPoint / Keynote | Slide | Slides | Design, not structure |
| AI presentation tools | Deck prompt | Slides or exports | Visual style, not narrative model |
| MulmoCast | MulmoScript beats | Video, podcast, slides, PDF, manga, swipe animation | Output format, render path, and presentation style |
That difference is strategic, not cosmetic. If your source of truth is a deck, you are trapped inside the deck. If your source of truth is a script, you can ship the same idea across multiple channels without re-authoring the argument each time.
What This Means for Content Tools Next
MulmoCast points to a broader pattern in AI software: the winning interface may not be the final artifact. It may be the intermediate representation that survives format changes. Once that is true, a story can compile into whatever media the audience needs.
That is a bigger idea than slides, and a cleaner one than one-off generators. It turns narrative into infrastructure.





