marimo is a next-generation Python notebook that replaces Jupyter, Streamlit, and Jupytext by combining reactive execution, Git-friendly .py storage, and built-in data tools. It’s designed for data scientists, ML engineers, and developers who need reproducible, interactive workflows without the fragility of traditional notebooks. With deterministic execution, no hidden state, and seamless integration with SQL, AI assistants, and package managers, marimo bridges the gap between exploratory analysis and production-grade applications.
Built on pure Python and powered by a reactive execution engine, marimo integrates with GitHub Copilot, VS Code, and modern editors while supporting DuckDB, SQLite, Postgres, and more via SQL cells. Notebooks can be executed as scripts, deployed as web apps via WebAssembly, or shared as interactive dashboards—all while maintaining version control through Git and managing dependencies with uv or PEP 723 metadata.
What You Get
- Reactive Execution - Automatically runs dependent cells when a cell is modified or run, eliminating manual cell re-execution and hidden state issues.
- SQL Cells - Execute SQL queries directly in notebooks against dataframes, databases (Postgres, MySQL, SQLite, DuckDB), CSVs, and Google Sheets, with results returned as Python dataframes.
- Interactive UI Elements - Bind sliders, dropdowns, dataframes, plots, and chat interfaces to Python variables without callbacks or boilerplate code.
- Git-Friendly .py Storage - Notebooks are stored as plain Python files (.py), enabling seamless version control with Git, code reviews, and integration with CI/CD pipelines.
- AI-Powered Code Generation - Generate cells or entire notebooks using context-aware AI assistants with support for GitHub Copilot, custom API keys, and local LLMs.
- Built-in Package Management - Install packages on import, serialize dependencies into notebook files, and auto-create isolated virtual environments with uv or pip.
- Deploy as Web Apps - Convert notebooks into interactive web applications with a single CLI command, optionally serving them via WebAssembly for browser-based access.
- Execute as Scripts - Run notebooks as standard Python scripts from the command line with CLI parameterization and no modifications required.
- Deterministic Execution Order - Cells execute based on variable dependencies, not cell order, ensuring consistent and predictable behavior regardless of layout.
- VS Code & Neovim Integration - Use marimo as a full-featured editor extension in VS Code, Cursor, neovim, Zed, or any text editor with live editing and debugging support.
- Interactive Dataframe Viewer - Page, filter, search, and sort millions of rows with an intuitive, code-free interface built into the notebook environment.
- Testable Notebooks - Run pytest directly on notebooks to validate logic, outputs, and data transformations as part of automated testing workflows.
Common Use Cases
- Running reproducible data analysis pipelines - A data scientist uses marimo to build a notebook that queries a PostgreSQL database, filters data with SQL, visualizes trends, and exports results—all while ensuring every run produces identical outputs.
- Deploying ML model dashboards - An ML engineer converts a Jupyter notebook into a marimo app to share model performance metrics with stakeholders via a web interface, with interactive sliders to adjust model parameters.
- Collaborative research documentation - A research team at SLAC National Accelerator Lab uses marimo to document computational experiments, embed SQL queries for data extraction, and version control all code and outputs in Git.
- Automating internal analytics tools - A finance team at DNB Cyber Defense replaces Databricks notebooks with marimo to build self-contained, deployable analytics apps that run in the browser with no infrastructure overhead.
- Teaching data science with reproducible examples - A university professor creates marimo notebooks with embedded AI-generated explanations and interactive visualizations, ensuring students can run and modify code without environment setup issues.
- Building AI-powered data exploration tools - A data analyst uses marimo’s AI assistant to generate SQL queries and Python code from natural language prompts, accelerating exploratory data analysis without writing boilerplate.
Under The Hood
Architecture
- Clear separation of concerns between a Python backend handling reactivity and execution, and a React-based frontend managing UI and real-time rendering
- Modular block system with abstractions like MarimoBlocksExtension and CellInfo enabling pluggable notebook elements and extensible behavior
- Configuration-driven inversion of control via mkdocs.yml and pnpm overrides, eliminating tight coupling while supporting dynamic extension
- Clean RPC-style communication layer decoupling UI components from backend logic, with state managed through React hooks and externalized data processors
- Monorepo orchestration with Turbo ensures cohesive build and test pipelines across interconnected packages
Tech Stack
- Python backend powered by FastAPI and Starlette with Pydantic for validation and Msgspec for high-performance serialization
- Frontend built with React 19, TypeScript, and Vite (via Rolldown fork), leveraging Codemirror 6 for advanced editing and DnD-Kit for interactive cell manipulation
- Comprehensive monorepo tooling using Turbo, pnpm, and custom patches to maintain control over third-party dependencies
- LSP integration via python-lsp-server and python-lsp-ruff for real-time code analysis, with OpenAPI-driven frontend code generation
- Testing ecosystem combining Vitest, Playwright, and pytest with uv for comprehensive coverage across frontend and backend
Code Quality
- Extensive test coverage spanning unit, integration, and edge cases with snapshot and mock-based validation
- Strong type safety enforced across both Python and TypeScript codebases through explicit annotations and generic interfaces
- Clean, layered architecture with well-defined boundaries between UI, runtime, and tooling components
- Consistent naming, documentation, and linting practices supported by automated pipelines for type checking, formatting, and security
- Robust error handling with structured logging, though custom exception types are underutilized in favor of built-ins
What Makes It Unique
- Native execution environment that eliminates separate kernel processes by embedding Python execution directly within the UI
- Dynamic dependency graph with automatic re-execution and lineage tracking, enabling true reactive notebook behavior
- Built-in caching layer that intelligently invalidates based on function inputs and dependencies, without requiring manual decorators
- Advanced table features with stateful, column-aware hover metadata integrated seamlessly into TanStack Table
- Zod-based form utilities that extract deep defaults and unwrap union types, enabling type-safe form generation directly from validation schemas