Deployable and Reproducible

One of marimo’s greatest strengths is its flexibility in how notebooks can be executed and deployed. Unlike traditional notebooks that are primarily designed for interactive development, marimo notebooks can seamlessly transition from exploration to production deployment without requiring rewrites or complex packaging steps.

The default behavior is to run it in edit mode, but there are lots more options that make marimo suitable for everything from data pipelines to production web applications.

Run marimo as apps

You can run your marimo notebook as a clean, interactive web application. When you run marimo run notebook.py, marimo strips away the development interface and presents your notebook as a polished app that end users can interact with through widgets and controls you’ve defined.

This is perfect for creating data dashboards, interactive reports, or analytical tools that non-technical stakeholders can use. The same notebook you used for exploration becomes a production-ready application with no additional coding required. Users see only the outputs, visualizations, and interactive elements - not the underlying code or development interface.

Apps made with marimo also supports custom CSS styling, layout control, and the ability to hide or show specific cells. You can create professional-looking applications that feel like purpose-built web apps rather than exposed notebooks.

Run marimo as a script

Script mode allows marimo notebooks to run as standard Python scripts from the command line. Since marimo stores notebooks as Python files, you can execute them directly with python notebook.py, making them perfect for automation, batch processing, or integration into existing workflows.

This capability bridges the gap between interactive analysis and production automation. The same notebook you use for data exploration can be scheduled as a cron job, called from other scripts, or integrated into data pipelines without modification.

Script made with marimo respect the reactive execution model, ensuring that all dependencies are properly resolved even when running non-interactively. This means your automated processes benefit from the same consistency guarantees as your interactive sessions.

Run marimo via WebAssembly

You can choose to share marimo as lightweight notebooks without a backend using WebAssembly by exporting it via marimo export html-wasm. This way you can share marimo notebooks to run entirely in the browser without requiring a Python server. Anyone can run it simply by visiting a URL - no installation, no setup, no server infrastructure required.

WASM mode is powered by Pyodide, which brings the Python scientific stack to the browser. It doesn’t cover all the packages out there, but the most popular ones from the PyData stack are all supported by now. Users can interact with your notebook, modify parameters, and see results update in real-time, all while running completely client-side. This makes marimo notebooks incredibly portable and accessible, and you won’t need to worry about untrusted code for any users.

This mode is particularly valuable for educational content, demonstrations, or situations where you want to share interactive analyses without requiring recipients to install Python or manage dependencies. The notebook becomes a self-contained web application that works anywhere modern browsers are available.

uv makes notebooks reproducible down to the packages

You can embed dependencies in Python scripts via inline script metadata. This is supported by modern Python tools like uv which have made it much more convenient to share self-contained Python scripts. After all, the requirements are part of the script itself! And because marimo notebooks are Python files under the hood, you can expect the same features here.

This inline metadata approach solves one of the biggest challenges in notebook sharing: dependency management. Instead of maintaining separate requirements.txt files or complex environment setups, you can embed dependency information directly in your notebook file:

# /// script
# requires-python = ">=3.12"
# dependencies = [
#     "numpy>=1.20"
# ]
# ///

When someone receives your marimo notebook, tools like uv can automatically create the correct environment and install dependencies based on this embedded metadata. This makes notebooks truly self-contained and eliminates the “it works on my machine” problem that plagues collaborative data science.