A marimo HTML/WASM export turns a single notebook into a complete browser application, including its full interface. It makes the entire notebook easy to share as a standalone page.
But what if you want to publish a collection of notebooks, or weave a few reactive cells into an existing page? Modern tools already handle the site’s layout, navigation, build, and deployment. marimo should fit in.
Today, we’re introducing quarto-marimo, jupyter-book-marimo, and mdx-marimo, three open-source integrations that bring reactive marimo cells to Quarto, Jupyter Book, and wherever MDX runs.
Reactive cells inside a page
This post uses mdx-marimo. Move the slider to change the frequency of the
sine and cosine curves. Prose separates the control from the chart, while the
two marimo cells remain connected.
This paragraph is ordinary MDX. The publishing system can place prose, citations, images, or components here while marimo keeps the cells on either side connected.
Publish with your existing tools
A publication can include one interactive chart, several connected cells woven through an essay, or an entire notebook-backed page. It can start with one example and grow into a collection through the same build.
The surrounding framework keeps control of layout, navigation, components, and delivery. A marimo-backed page can be pre-rendered for Cloudflare Pages or GitHub Pages, sit alongside server-rendered routes, or become part of a hybrid application. Frameworks such as Astro, Next.js, TanStack Start, and Remix can mix these strategies route by route.
Quarto
Quarto turns Markdown into websites, books, presentations, and other publication formats. quarto-marimo brings marimo cells and notebook-backed pages into that workflow. In HTML publications, the cells stay interactive within Quarto’s navigation, cross-references, and theme. Open the quarto-marimo example site, then use the quarto-marimo quick start to add it to a Quarto project.
Jupyter Book
Jupyter Book builds books and documentation sites from Markdown and notebooks. jupyter-book-marimo adds marimo-backed chapters to the book. Readers can use controls and see dependent cells update while Jupyter Book provides sections, cross-references, navigation, and theme. The jupyter-book-marimo documentation is itself a live book. Its jupyter-book-marimo quick start shows how you can register our plugin and build interactive HTML.
MDX
MDX combines Markdown with components. mdx-marimo places marimo cells in that component model, from React and Vue apps built with Vite to Next.js, Astro, Nuxt, and Docusaurus. This post is one such page, and the repository includes examples for each host. The mdx-marimo quick start will help you connect the compiler plugin and browser runtime to an MDX host.
Start from a marimo notebook
All three integrations can start from a .py marimo notebook. The
marimo export md
command writes the host-specific source syntax out of the box:
# Quarto
marimo export md notebook.py -o notebook.qmd --flavor qmd
# Jupyter Book
marimo export md notebook.py -o notebook.myst.md --flavor mystmd
# MDX
marimo export md notebook.py -o notebook.mdx --flavor mdxEach export keeps the notebook source in the syntax its host expects. The command can convert one notebook or become part of a build script or agentic publishing workflow that updates a collection before the site build.
One model across publishing systems
The three integrations share one model. Each uses marimo islands to place cell outputs between host content while preserving one connected notebook program in the browser.
During the site build, the integration collects the page’s marimo cells, runs them once, and places their initial HTML and assets back into the host document. When a reader loads the page, the marimo island runtime reconnects the cells and starts Pyodide, allowing controls to rerun dependent code elsewhere on the page.
The host integration owns source parsing and output placement. marimo owns the notebook program, build-time execution, and browser runtime.
Quarto engine
quarto-marimo starts with Quarto Markdown files (.qmd or .md) and fenced
code blocks marked as marimo cells. Its engine replaces those blocks with their
rendered outputs, then returns the document to Quarto for Pandoc rendering.
Jupyter Book executable plugin
jupyter-book-marimo starts with Jupyter Book pages written in MyST Markdown.
Its executable plugin collects {marimo} directives from the parsed document
and replaces them with native notebook output nodes containing the island HTML.
Jupyter Book renders the sections, cross-references, navigation, and theme
around those outputs.
MDX remark plugin
mdx-marimo starts with MDX pages and code fences such as python marimo. Its
remark plugin collects the cells from the MDX syntax tree
and replaces each fence with an island element. The host then compiles
the resulting MDX with its Markdown, JSX components, and framework integration intact.
Python in the browser
Running Python in the browser has real constraints. Pyodide supports a large part of the Python ecosystem, but it does not have full parity with a local Python installation. Libraries that assume operating-system threads, processes, or native networking may need extra support.
marimo closes some of these gaps with compatibility layers for remote DuckDB queries, Polars file and URL I/O, and browser adapters for common threading and multiprocessing APIs.
On a reader’s first visit, the page’s initial HTML can render before Python is ready. The islands become interactive after the browser initializes Pyodide, marimo, and the notebook’s dependencies. That delay is the price of running Python on the reader’s machine with no Python server to deploy or keep alive.
Those tradeoffs point to a complementary path: our take on a truly Python-free static export of a reactive notebook, built on recent improvements to marimo’s caching and designed for the agentic era. More on that soon.
Conclusion
marimo can now fit into a larger publication as one cell, a full page, or a collection of notebooks, while the surrounding site keeps its own design and publishing workflow. These integrations apply the same island-based model across Quarto, Jupyter Book, and the wider MDX ecosystem. The model can extend to more host formats as new publishing needs emerge.
Try an integration and tell us what you build. We would love to hear your thoughts, the use cases you have in mind, and where you want to bring publishing with marimo next!
