Is Marimo the New Jupyter Notebook?

I've been using Jupyter notebooks for almost a decade to power everything from quick exploratory data analyses to end-to-end machine learning prototypes. While these notebooks have served their purpose, I'm sure that the majority of data scientists will agree that they also come with some headaches: mysterious hidden state, merge conflicts in version control (don't even bother looking at the commit history), and brittle dependencies that make reproducibility a nightmare.

That’s why I was intrigued when I heard about Marimo, a new interactive Python notebook designed to solve many of these frustrations. After spending some time experimenting with it, here is my review on how Marimo stacks up on three dimensions: 1) onboarding process, 2) documentation, and 3) user experience.

Installation and Getting Started: A+

I was pleasantly surprised by Marimo's onboarding process. To install, you simply need to pip install marimo. To access their tutorials and learning materials, you can spin up their demo notebook with marimo tutorial intro. I wish more packages offered out-of-the-box demos like these.

Marimo also offers more in-depth tutorials like: ui (to learn about UI elements), markdown (to learn how to write markdown and LaTex), plots (to learn how plotting works in Marimo notebooks), and even for-jupyter-users for those who are coming from Jupyter. To explore any of these tutorials, you just need to run marimo tutorial <name of tutorial topic goes here>. Easy peasy!!!

To get started with your first Marimo notebook, you need to call this command in your Terminal:

marimo edit

This will spin up a "launch pad" where you can create a new notebook or check out their many resources:

Documentation: A

I'm incredibly impressed by Marimo's onboarding docs. The tutorials are very well done and a great option for those who learn by doing. 👏

The API documentation is also very thorough. As a visual learner, I really appreciate the Examples section, which does a great job of showing Marimo components in action.

This is not a dealbreaker by any means but I do find that the docs have a lot of whitespace, which makes the layout feel slightly disjointed and harder to visually scan. Then again, maybe that’s the point—perhaps the original docs are meant for AI consumption and the new expectation is that humans use AI chatbots as the interface for documentation. As a human, I would prefer the layout to be a bit more compact and concise.

User Experience: A-

Let me start with the good: I really love how Marimo renders dataframes. It’s so helpful to immediately see the distribution of continuous variables and the number of distinct values for categorical variables at a glance. You can also interact with the dataframe directly such as specifying the datatype of a column or sorting rows by a column in ascending or descending order. This feature saves some time during my exploratory data analysis because it gives me a sense of the dataframe's columns off the bat.

Marimo also has table and dataframe UI functions which allow you to 1) manually select rows and 2) apply transformations to your dataframe via a drag-and-drop interface. While I prefer writing code to transform my dataframes, I can see drag-and-drop being especially helpful for those who aren’t familiar with Pandas or Polars dataframe libraries.

Ok, now for the bad: I find the sheer number of widgets in a Marimo notebook to be very overwhelming. There are 23 different buttons, which feels excessive—especially since many of them aren’t directly relevant to my workflow. It’s not a dealbreaker, but having fewer visible options or a cleaner layout would make it easier to focus on what matters.

One of Marimo's selling points is that its notebooks are plain old Python files. This is super useful when it comes to git (much cleaner commit history compared to Jupyter) but the files themselves are not intuitive to read. Each notebook "cell" is wrapped in a decorator, making the cell reactive and self-contained. This structure tightly couples the notebook's Python file to Marimo, which means it's not straightforward to run outside of the Marimo environment. Here's an example of what a notebook's Python file looks like for context:

import marimo

__generated_with = "0.15.2"
app = marimo.App(width="medium")


@app.cell
def _():
    import marimo as mo
    import pandas as pd
    return (pd,)


@app.cell
def _(pd):
    df = pd.read_csv("data/toronto_child_care_centres.csv")
    return

In an ideal world, the generated Python file would be a simple, standalone script that isn’t directly tied to Marimo. That being said, this is still a huge improvement compared to Jupyter notebook's .ipynb file format.

A few of more pros & cons...

Pro: Interactive UI components for data storytelling. Marimo offers a wide range of UI elements—like radio buttons, checkboxes, date pickers, sliders, and even a microphone input. These components make it easier to share data analyses in a more engaging way with stakeholders.

That being said, I don’t see Marimo replacing dedicated dashboard tools like Streamlit—and that’s okay. Marimo isn’t trying to be a full-fledged app framework. Instead, Marimo shines in that middle ground between exploratory data analysis and data presentation, giving a clean environment for data exploration while still making it easy to share results.

Pro: Reproducibility! With Jupyter notebooks, you can define the same variable multiple times, which means that the result of your notebook can vary depending on the order in which the cells were run. For example, Jupyter will allow you to do something like this:

In the example above, we can see that value of x depends on whether x = 3 or x = 4 was run last. Marimo doesn't tolerate this funny business. It will throw an error if you try to define the same variable more than once:

This ensures reproducibility, which is important when you're sharing your work.

Con: No Github integration. One area where Jupyter has an edge is GitHub support. GitHub renders Jupyter notebooks in a clean, readable format, making them easy to share and review. Marimo notebooks, on the other hand, show up as plain Python files, which aren’t as stakeholder-friendly. If you want to share a Marimo notebook, you’ll need to deploy it yourself as a web app. Marimo provides instructions on how to do this but it would be so much nicer if we could rely on GitHub’s built-in rendering.

Final Verdict

Here’s how I think Marimo performed across the key dimensions I evaluated:

• Onboarding process: A+
• Documentation: A
• User experience: A-

Overall, I’d give Marimo a solid A.

So, will I be using Marimo in place of Jupyter notebooks?

From my initial exploration, Marimo feels like a huge step forward—no more mysterious hidden states or painful merge conflicts in version control. Marimo also offers some cool UI components like sliders, radio buttons, and drop-downs, which makes data exploration more interactive, more fun, and easier to share with stakeholders. I’ve barely scratched the surface of Marimo’s capabilities in this review, and I plan to film a proper video walkthrough to show off everything it has to offer (it’s on my to-do list!).

If you’ve tried Marimo—or are curious about it—I’d love to hear your thoughts. Drop a comment below and tell me what your experience has been like so far. ✌️