marimo

Create or edit notebooks by starting a marimo server

$ marimo edit

$ marimo edit [[-p|--port]] [port_number] --headless

$ marimo edit [path/to/notebook.py]

$ marimo run [path/to/notebook.py]

$ marimo tutorial [intro|components|dataflow|io]

$ marimo [edit|run|tutorial|config|new|...] --help

marimo <command> [options] [arguments]

--version
    Displays the installed marimo version and exits.

--port <INTEGER>
    Specifies the port number on which the marimo server will run. Defaults to a randomly assigned available port.

--host <TEXT>
    Sets the host address for the marimo server (e.g., 0.0.0.0 for public access, 127.0.0.1 for local only).

--headless
    Starts the marimo server without automatically opening a web browser tab.

--quiet
    Suppresses most standard output messages from the marimo server, useful for scripting or background tasks.

--log-level <LEVEL>
    Sets the logging verbosity for the server (e.g., info, debug, warning, error, critical).

--install-reqs
    (Specific to edit command) Automatically installs Python packages listed in a requirements.txt file if present in the notebook's directory.

--development-mode
    (Specific to edit command) Enables additional developer-focused features and more verbose logging for debugging during notebook creation.

Marimo is an open-source, reactive Python notebook framework designed for creating interactive data applications, dashboards, and sharable documents. Unlike traditional notebooks, Marimo automatically re-executes only the necessary cells when dependencies change, ensuring outputs are always consistent and up-to-date with minimal effort. It focuses on making notebooks more robust, deployable, and easier to maintain by embracing a programming paradigm where the order of cells doesn't dictate execution, but rather data flow and dependency.

This reactivity simplifies complex workflows and reduces common errors found in traditional, stateful notebooks. Marimo runs a web server that provides a rich, interactive environment directly in the browser for development and consumption of data products. It enables users to build powerful user interfaces directly with Python, facilitating rapid prototyping and deployment of data-driven insights for a wide range of applications.

Marimo is a Python-based application that requires a Python installation and is typically installed via pip, not as a standard system package. It runs a local web server, so potential port conflicts may occur with other services. Unlike traditional Jupyter notebooks, Marimo uses standard .py files for its notebooks, which is a key design choice impacting workflow and tooling. As a relatively newer tool in the data science ecosystem, its features and APIs are actively evolving.

The marimo command functions through several key subcommands:
edit: Used for developing and interactively editing marimo notebooks. This command starts the server and opens the notebook in your browser.
run: Executes a marimo notebook as a static, read-only application. Ideal for deploying finished data applications or dashboards.
tutorial: Launches an interactive marimo tutorial directly in your browser, providing a guided introduction to the framework.
docs: Opens the official marimo documentation website in your browser.

A fundamental difference of marimo is its reactive execution model. Instead of sequential cell execution, marimo analyzes the dependencies between cells. When data or code in one cell changes, only the cells that depend on it are automatically re-executed. This ensures that the notebook's state is always consistent and outputs are automatically updated, eliminating manual re-runs and common errors associated with out-of-order execution in traditional notebooks.

Marimo notebooks are plain .py files, not JSON-based .ipynb files. This design choice offers significant advantages, including easier version control (Git-friendly), compatibility with standard Python linters and IDEs, and the ability to directly use Python modules and packages without conversion. Marimo uses special decorators (e.g., @marimo.cell) within these .py files to define notebook cells and their reactive behavior.

Marimo was developed by the marimo-team as a modern approach to interactive computing and data application building. It emerged to address common challenges in traditional notebooks, such as state management, reproducibility, and deployment complexity. Its core innovation lies in its reactive execution model, which ensures consistency and simplifies the development of complex data applications. Since its open-source release, it has been gaining recognition for its fresh perspective on interactive Python environments and reproducible data applications.

python(1), pip(1), jupyter(1), streamlit(1), panel(1)