Is it possible to render self-contained html report that contains interactive plots?

[uriahf]

Hi everyone, thank you for this amazing tool!

Coming from R, I'm trying to find a solution for rendering self-contained interactive plots in an html report.

In R rmarkdown is fairly easy to use for that purpose: I'm leveraging mainly htmlwidgets such as plotly-R and r2d3. Unfortunately plotly-python tends to produce heavy self-contained plots and I didn't find a convenient equivalent of the r2d3 package that allows an easy epi from python to d3.

I wonder if I can use marimo for that purpose.

Thanks!

Uriah

[ideacatlab]

There are two layers here — marimo's own export, and how the plots themselves embed their JS — and the "heavy" problem you hit is really the second one. I tested both on marimo 0.25 / plotly.

marimo's export

• marimo export html notebook.py -o report.html runs the notebook and embeds the rendered outputs. Interactive plotly charts stay interactive. Caveat I confirmed: the marimo frontend shell (its JS/fonts) is pulled from cdn.jsdelivr.net, so this file needs internet to render — it's great for a hosted report, but it is not a truly offline single file. There's no --self-contained/--offline flag today (only --include-code / --sandbox).
• marimo export html-wasm notebook.py -o out/ --mode run gives a fully interactive, re-runnable notebook (Python runs in-browser via WASM). It's self-contained but as a directory of assets you host statically, not a single file.

The plots themselves — this is your rmarkdown/htmlwidgets equivalent

Your "plotly-python produces heavy self-contained plots" is exactly the include_plotlyjs setting. Measured, same figure:

fig.write_html(..., include_plotlyjs=...)	size	offline?
"inline"	4.8 MB	✅ fully self-contained (this is the heavy one you hit)
"cdn"	8 KB	❌ needs internet
"directory"	8 KB + one shared plotly.min.js	✅ offline

The "directory" mode is the r2d3-style answer you're looking for: each plot/report is a tiny HTML file, and they all share one plotly.min.js dropped next to them — so ten reports cost ~8 KB each plus one shared library, not 4.8 MB each. That's the lightweight, self-contained, offline combination.

import plotly.graph_objects as go
fig = go.Figure(...)
fig.write_html("report/plot1.html", include_plotlyjs="directory")
# writes report/plot1.html (tiny) + report/plotly.min.js (shared once)

What I'd actually do for your case (R refugee wanting a self-contained interactive report):

• If you want it to look like an rmarkdown report (prose + several interactive plots) and be genuinely offline: generate the plots with include_plotlyjs="directory" and assemble them into your own HTML template, or embed each fig.to_html(full_html=False, include_plotlyjs=False) fragment into one page that loads plotly.min.js once. That's the closest to htmlwidgets' shared-dependency model and keeps the total size sane.
• If you're happy hosting (not a single file) and want the plots re-computable, marimo export html-wasm is the most "alive" option.
• marimo export html is the quickest if an internet-connected viewer is acceptable.

For truly lightweight offline interactivity, include_plotlyjs="directory" is the key knob — it's what removes the per-plot 4.8 MB weight you ran into.