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.

9 min read • View on GitHub • More from receptron

A drafting table in a white studio where one manuscript fans out into multiple media forms, including a film strip, a podcast waveform, slide thumbnails, a manga page, and a vertical swipe frame. It explains MulmoCast as a compiler that turns one structured story into many outputs.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 treats narrative like source code. One structured script can compile into many different media products without changing the underlying story.
Key Takeaways

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.

A close-up mechanical browser window behaves like a press machine, with HTML panels sliding through a glass stage while audio waves feed a spool and a final film reel clamps shut. It explains that the browser is the production surface, not just a preview layer.
The browser is not a preview. It is the render surface that feeds capture, audio assembly, and final packaging.

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.

receptron, Project Maintainer/Author · receptron/mulmocast-cli README

MulmoScript stays stable while the output format changes. Shared preparation happens once, then each media target takes its own last-mile path.

{
  "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 workflowGraph 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.

ToolPrimary unitTypical outputWhat changes easily
PowerPoint / KeynoteSlideSlidesDesign, not structure
AI presentation toolsDeck promptSlides or exportsVisual style, not narrative model
MulmoCastMulmoScript beatsVideo, podcast, slides, PDF, manga, swipe animationOutput 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.