A library for making reactive notebooks and apps
Project description
Next-generation Python notebooks and apps.
marimo is a Python library for creating reactive notebooks that double as apps. marimo is:
- reactive: run a cell and marimo automatically runs cells that depend on it
- interactive: interact with sliders, dropdowns, tables, and more to automatically run dependent cells
- expressive: parametrize markdown with interactive elements, plots, or anything else
- simple: no callbacks, no magical syntax
- Pythonic: cells only run Python; notebooks stored as
.pyfiles (clean git diffs!) - performant: powered by static analysis, zero runtime overhead
marimo was built from the ground up to solve many well-known problems with traditional notebooks. marimo is not built on top of Jupyter or any other notebook or app library.
Contents.
Getting Started
Installing marimo gets you the marimo command-line interface (CLI), the
entry point to all things marimo.
Installation
In a terminal, run
pip install marimo
marimo tutorial intro
You should see a tutorial notebook in your browser:
If that doesn't work, please open a Github issue.
Tutorials
marimo tutorial intro opens the intro tutorial. List all tutorials with
marimo tutorial --help
Notebooks
Create and edit notebooks with marimo edit.
- create a new notebook:
marimo edit
- create or edit a notebook with a given name:
marimo edit your_notebook.py
Apps
Use marimo run to serve your notebook as an app, with Python code hidden and
uneditable.
marimo run your_notebook.py
Convert Jupyter notebooks
Automatically translate Jupyter notebooks to marimo notebooks with marimo convert:
marimo convert your_notebook.ipynb > your_notebook.py
Because marimo is different from traditional notebooks, your converted
notebook will likely have errors that you'll need to fix. marimo
will guide you through fixing them when you open it with marimo edit.
Concepts
marimo notebooks are reactive: they automatically react to your code changes and UI interactions and keep your notebook up-to-date (like a spreadsheet).
Cells
A marimo notebook is made of small blocks of Python code called cells. When you run a cell, marimo automatically runs all cells that read any global variables defined by that cell. This is reactive execution.
Reactive execution lets your notebooks double as interactive apps. It also guarantees that your code and program state are consistent.
Execution order. The order of cells on the page has no bearing on the order cells are executed in: execution order is completely determined by the variables cells define and the cells they read. You have full freedom over how to organize your code and tell your stories: move helper functions and other "appendices" to the bottom of your notebook, or put cells with important outputs at the top.
No hidden state. marimo notebooks have no hidden state because the program state is automatically synchronized with your code changes and UI interactions. And if you delete a cell, marimo automatically deletes that cell's variables, preventing painful bugs that arise in traditional notebooks.
No magical syntax. There's no magical syntax or API required to opt-in to reactivity: cells are Python and only Python. Behind-the-scenes, marimo statically analyzes each cell's code just once, creating a directed acyclic graph based on the global names each cell defines and reads. This is how data flows in a marimo notebook.
For more on reactive execution, open the dataflow tutorial:
marimo tutorial dataflow
The marimo library
marimo is both a notebook and a library. The marimo library lets you use markdown, interactive UI elements, layout elements, and more in your marimo notebooks.
We recommend starting each marimo notebook with a cell containing a single line of code,
import marimo as mo
Outputs
marimo visualizes the last expression of each cell as its output. Outputs
can be any Python value, including markdown and interactive elements created
with the marimo library, e.g., mo.md(...), mo.ui.slider(...).
You can even interpolate Python values into markdown and other marimo elements
to build rich composite outputs.
Thanks to reactive execution, running a cell refreshes all the relevant outputs in your notebook.
For more on outputs, try these tutorials:
marimo tutorial markdown
marimo tutorial plots
marimo tutorial layout
Interactive elements
The marimo library comes with many interactive stateful elements in
marimo.ui, including simple ones like sliders, dropdowns, text fields, and file
upload areas, as well as composite ones like forms, arrays, and dictionaries
that can wrap other UI elements.
Using UI elements.
To use a UI element, create it with marimo.ui and assign it to a global
variable. When you interact with a UI element in your browser (e.g.,
sliding a slider), marimo sends the new value back to Python and reactively
runs all cells that use the element, which you can access via its value
attribute.
This combination of interactivity and reactivity is very powerful: use it to make your data tangible during exploration and to build all kinds of tools and apps.
marimo can only synchronize UI elements that are assigned to
global variables. You can use composite elements like mo.ui.array and
mo.ui.dictionary if the set of UI elements is not known until runtime.
For more on interactive elements, run the UI tutorial:
marimo tutorial ui
Composite elements
marimo's composite UI elements let you wrap other UI
elements to create powerful UIs. For example,
marimo.ui.form lets you gate elements on submission, while
marimo.ui.dictionary and marimo.ui.array let you batch arbitrary
collections of elements.
Layout
The marimo library also comes with layout elements, including mo.hstack,
mo.vstack, and mo.tabs. See the API reference for more info.
Examples
Examples are available in the examples/ directory. Community examples can be
found and shared in the marimo cookbook.
FAQ
- Choosing marimo
- Using marimo
- Is marimo a notebook or a library?
- How does marimo know what cells to run?
- How do I use sliders and other interactive elements?
- How do I add a submit button to UI elements?
- How do I write markdown?
- How do I display plots?
- How do I display objects in rows and columns?
- What packages can I use?
- What's the difference between a marimo notebook and a marimo app?
- How do I deploy apps?
- Is marimo free?
Choosing marimo
How is marimo different from Jupyter?
marimo is a brand new Python notebook that is both interactive, with UI elements like sliders, dropdowns, etc., and reactive, like a spreadsheet. marimo solves many well-documented problems associated with traditional notebooks like Jupyter [1] [2]:
- no hidden state: running a cell automatically runs all cells that depend on it, and deleting a cell automatically deletes its variables, eliminating hidden state and hidden bugs
- interactive data exploration: UI elements and reactivity make your data tangible
- sharing: use the marimo CLI to run notebooks as apps
- Python, not JSON: stored as executable Python, with clean git diffs and potential for code reuse
- fast, reliable autocomplete: code completion is fast and works out of the box
How is marimo.ui different from Jupyter widgets?
Unlike Jupyter widgets, marimo's interactive elements are automatically synchronized with the Python kernel: no callbacks, no observers, no manually re-running cells.
Using marimo
Is marimo a notebook or a library?
marimo is both a notebook and a library.
- Create marimo notebooks with the editor that opens in your
browser when you run
marimo edit. - Use the marimo library (
import marimo as mo) in marimo notebooks. Write markdown withmo.md(...), create stateful interactive elements withmo.ui(mo.ui.slider(...)), and more. See the docs for an API reference.
How does marimo know what cells to run?
marimo reads each cell once to determine what global names it defines and what global names it reads. When a cell is run, marimo runs all other cells that read any of the global names it defines. A global name can refer to a variable, class, function, or import.
In other words, marimo uses static analysis to make a dataflow graph out of your cells. Each cell is a node in the graph across which global variables "flow". Whenever a cell is run, either because you changed its code or interacted with a UI element it reads, all its descendants run in turn.
How do I use sliders and other interactive elements?
Interactive UI elements like sliders are available in marimo.ui.
- Assign the UI element to a global variable (
slider = mo.ui.slider(0, 100)) - Include it in the last expression of a cell to display
it (
sliderormo.md(f"Choose a value: {slider}")) - Read its current value in another cell via its
valueattribute (slider.value)
If you have many UI elements or don't know the elements
you'll create until runtime, use marimo.ui.array and marimo.ui.dictionary
to create UI elements that wrap other UI elements (sliders = mo.ui.array([slider(1, 100) for _ in range(n_sliders)])).
All this and more is explained in the UI tutorial. Run it with
marimo tutorial ui
at the command line.
How do I add a submit button to UI elements?
Use the form method to add a submit button to a UI element. For
example,
form = marimo.ui.text_area().form()
When wrapped in a form, the
text area's value will only be sent to Python when you click the submit button.
Access the last submitted value of the text area with form.value.
Import marimo (as mo) in a notebook, and use the mo.md function.
Include plots in the last expression of a cell to display them, just like all
other outputs. If you're using matplotlib, you can display the Figure object
(get the current figure with plt.gcf()). For examples, run the plots tutorial:
marimo tutorial plots
How do I display objects in rows and columns?
Use marimo.hstack and marimo.vstack. See the layout tutorial for details:
marimo tutorial layout
You can use any Python package. marimo cells run arbitrary Python code.
What's the difference between a marimo notebook and a marimo app?
You can think of marimo programs as notebooks, apps, or both. Edit a marimo
program as notebook with marimo edit, or run it as an app, rendering cell
outputs without their code, with marimo run.
Use the marimo CLI's run command to serve a notebook as an app:
marimo run notebook.py
Yes!
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 on Discord. Come hang out with us!
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
