marimo¶
marimo is a reactive Python notebook: run a cell or interact with a UI element, and marimo automatically runs dependent cells (or marks them as stale), keeping code and outputs consistent and preventing bugs before they happen. Every marimo notebook is stored as pure Python, executable as a script, and deployable as an app.
Built from the ground up
marimo was built from the ground up to solve well-known problems associated with traditional notebooks.
pip install marimo && marimo tutorial intro
uv pip install marimo && marimo tutorial intro
conda install -c conda-forge marimo && marimo tutorial intro
Developer experience is core to marimo, with an emphasis on reproducibility, maintainability, composability, and shareability.
Highlights¶
🚀 batteries-included: replaces
jupyter,streamlit,jupytext,ipywidgets,papermill, and more⚡️ reactive: run a cell, and marimo reactively runs all dependent cells or marks them as stale
🖐️ interactive: bind sliders, tables, plots, and more to Python — no callbacks required
🔬 reproducible: no hidden state, deterministic execution, built-in package management
🏃 executable: execute as a Python script, parameterized by CLI args
🛜 shareable: deploy as an interactive web app or slides, run in the browser via WASM
🛢️ designed for data: query dataframes and databases with SQL, filter and search dataframes
🐍 git-friendly: notebooks are stored as
.pyfiles⌨️ a modern editor: GitHub Copilot, AI assistants, vim keybindings, variable explorer, and more
A reactive programming environment¶
marimo guarantees your notebook code, outputs, and program state are consistent. This solves many problems associated with traditional notebooks like Jupyter.
A reactive programming environment. Run a cell and marimo reacts by automatically running the cells that reference its variables, eliminating the error-prone task of manually re-running cells. Delete a cell and marimo scrubs its variables from program memory, eliminating hidden state.
Compatible with expensive notebooks. marimo lets you configure the runtime to be lazy, marking affected cells as stale instead of automatically running them. This gives you guarantees on program state while preventing accidental execution of expensive cells.
Synchronized UI elements. Interact with UI elements like sliders, dropdowns, dataframe transformers, and chat interfaces, and the cells that use them are automatically re-run with their latest values.
Interactive dataframes. Page through, search, filter, and sort millions of rows blazingly fast, no code required.
Performant runtime. marimo runs only those cells that need to be run by statically analyzing your code.
Dynamic markdown and SQL. Use markdown to tell dynamic stories that depend on Python data. Or build SQL queries that depend on Python values and execute them against dataframes, databases, CSVs, Google Sheets, or anything else using our built-in SQL engine, which returns the result as a Python dataframe.
Your notebooks are still pure Python, even if they use markdown or SQL.
Deterministic execution order. Notebooks are executed in a deterministic order, based on variable references instead of cells’ positions on the page. Organize your notebooks to best fit the stories you’d like to tell.
Built-in package management. marimo has built-in support for all major package managers, letting you install packages on import. marimo can even serialize package requirements in notebook files, and auto install them in isolated venv sandboxes.
Batteries-included. marimo comes with GitHub Copilot, AI assistants, Ruff code formatting, HTML export, fast code completion, a VS Code extension, an interactive dataframe viewer, and many more quality-of-life features.
Quickstart¶
Installation. In a terminal, run
pip install marimo # or conda install -c conda-forge marimo
marimo tutorial intro
Create notebooks.
Create or edit notebooks with
marimo edit
Run apps. Run your notebook as a web app, with Python code hidden and uneditable:
marimo run your_notebook.py
Execute as scripts. Execute a notebook as a script at the command line:
python your_notebook.py
Automatically convert Jupyter notebooks. Automatically convert Jupyter notebooks to marimo notebooks with the CLI
marimo convert your_notebook.ipynb > your_notebook.py
or use our web interface.
Tutorials. List all tutorials:
marimo tutorial --help
Questions?¶
See our FAQ.
Learn more¶
marimo is easy to get started with, with lots of room for power users. For example, here’s an embedding visualizer made in marimo (video):
Check out our guides, our example
gallery, and our
examples/ on
GitHub to learn more.
|
|
|
|
| Tutorial | Inputs | Plots | Layout |
|
|
|
|
Contributing¶
We appreciate all contributions! You don’t need to be an expert to help out. Please see CONTRIBUTING.md for more details on how to get started.
Questions? Reach out to us on Discord.
Community¶
We’re building a community. Come hang out with us!
💬 [Follow us on Mastodon[(https://mastodon.social/@marimo_io)
Inspiration ✨¶
marimo is a reinvention of the Python notebook as a reproducible, interactive, and shareable Python program, instead of an error-prone JSON scratchpad.
We believe that the tools we use shape the way we think — better tools, for better minds. With marimo, we hope to provide the Python community with a better programming environment to do research and communicate it; to experiment with code and share it; to learn computational science and teach it.
Our inspiration comes from many places and projects, especially Pluto.jl, ObservableHQ, and Bret Victor’s essays. marimo is part of a greater movement toward reactive dataflow programming. From IPyflow, streamlit, TensorFlow, PyTorch, JAX, and React, the ideas of functional, declarative, and reactive programming are transforming a broad range of tools for the better.
