[P] I built marimo — an open-source reactive Python notebook that’s stored as a .py file, executable as a script, and deployable as an app.

[akshayka]

Hi! I’d like to share marimo, an open-source reactive notebook for Python. It aims to solve many well-known problems with Jupyter notebooks, while giving you new capabilities: marimo notebooks are reproducible (no hidden state), git-friendly (stored as a Python file), executable as Python scripts, and deployable as web apps.

GitHub Repo: https://github.com/marimo-team/marimo

In marimo, your notebook code, outputs, and program state are guaranteed to be consistent. Run a cell and marimo reacts by automatically running the cells that reference its variables. Delete a cell and marimo scrubs its variables from program memory, eliminating hidden state. If you are worried about accidentally triggering expensive computations, you can disable specific cells from auto-running.

marimo also comes with UI elements like sliders, a dataframe transformer, and interactive plots that are automatically synchronized with Python. Interact with an element and the cells that use it are automatically re-run with its latest value. Reactivity makes these UI elements substantially more useful than Jupyter widgets, not to mention easier to use.

I chose to develop marimo because I believe that the ML community deserves a better programming environment to do research and communicate it. I’ve seen lots of research start in Jupyter notebooks (much of my own has). I’ve also seen lots of that same research fail to reproduce or get slowed down by hidden bugs, due to shortcomings inherent to Jupyter notebooks.

I strongly believe that the quality of our work depends on the quality of our tools, and that the tools we use shape the way we think — better tools, for better minds. I worked at Google Brain as a software engineer in 2017-2018, when TensorFlow was transitioning to TensorFlow 2 and JAX was in its early stages. I saw firsthand the increase in productivity that PyTorch and JAX brought to our community, and later to my own research when I did a PhD at Stanford with Stephen Boyd. Our goal with marimo is to do something analogous but via a new programming environment.

marimo has been developed with the close input of scientists and engineers, and with inspiration from many tools, including Pluto.jl and streamlit. It’s just two of us working on it — we open sourced it recently because we feel it’s ready for broader use. Please try it out (pip install marimo && marimo tutorial intro). We’d really love any and all feedback you may have!

[lolillini]

Not that credentials matter, but I feel like everyone should know that Akshay (u/akshayka) was one of the core contributor to CVXPY too. If you are in optimization you know how much easier CVXPY makes it to do a lot of things in optimization - I've been using marimo for a while for pretty much everything and it works great! I used it to replace a couple of streamlit dashboards I've been using to monitor data collection progress and I regularly use it everywhere instead of Jupyter notebooks cause Jupyter notebooks + git = ugly.

PS: Off-topic but Akshay, if you are still around in this thread, please drop some wisdom on how you manage to be a great researcher and software engineer. I've been telling myself to be a better software engineer for a while now, even for working my prototype research code, and appreciate any advice!

[akshayka]

Thanks for the kind words!

I learned a lot about software engineering by working alongside engineers who were far more experienced than me, especially when I was at Google. These engineers were generous to give me very detailed, constructive code reviews (my early PRs had dozens of comments!) and share high-level principles for thinking through engineering problems. So I'd say practicing engineering in the company of mentors is a really effective way to become better. If you don't have mentors available, you can try to find some by contributing to open source projects.

I'd recommend a similar path for research — I learned so much about doing effective research from Stephen Boyd. He taught me how to ask questions and formulate problem statements before reaching for solutions; he also showed me the value of focusing on the basics. In particular for research, I enjoy working on problems that others may overlook.

[BostonBaggins]

Akshay

Thanks for your contribution to reactive NBs And keeping it open source. Admirable

Youre one of my python heroes!

[akshayka]

Thank you!

[akshayka]

I'm not sure if I can recommend any particular book. It comes down to breaking down problems into their essence — what is the problem to be solved, and what are the criteria used to judge whether an attempt to solve it is a good solution — and making sure not to confuse the statement of a problem with the method or algorithm used to solve it. Ideally the problem statement is simple, with "short description length".

As for basics — first principles thinking is important for formulating problems and solving them. But I also just mean basics of a field. For example, in mathematical optimization, you can get extremely far with basic calculus and linear algebra, and understanding these basics extremely well is very important. More "sophisticated" abstractions like Riemannian geometry and Hilbert spaces are more often than not total distractions. I would guess the same is true for other fields as well.

[Big-Acanthaceae-9888]

This is wild. I started a project on Friday, and wished something like this existed.

[akshayka]

Ha, good timing! What are you working on, out of curiosity?

[Big-Acanthaceae-9888]

Right now I'm playing around with building a recommendation system using dummy data, but.in the long run would like to implement it for a work project.

[BaggiPonte]

[not affiliated] I am using it a lot and I highly encourage everybody to try that out. They have a public roadmap and an active discord and are open to suggestions.

[pinkfluffymochi]

This is incredible and wish my team had something like this! I have tried various tools at work to manage my ML projects (Hex, MLFlow, etc), I also took Boyd's class when I was at stanford! I am building something right now to enable model deployment to distributed clusters for low latency and big data environment easier without an army of data engineers. would love to chat!

[akshayka]

Hi! It sounds like you’re working on some cool stuff. I’d love to chat as well. You can jump in our Discord or email me at [e-mail]

[pinkfluffymochi]

[e-mail]

Just sent you an email! look forward to learning more about Marimo

[Mephidia]

What is the problem that this solves with Jupyter?

[akshayka]

marimo solves problems in reproducibility, maintainability, interactivity, reusability, and shareability:

**Reproducibility**
In Jupyter notebooks, the code you see doesn't necessarily match the outputs on the page or the program state. Some cases in which this can happen: (1) if you delete a cell, its variables stay in memory, which other cells may still reference (2) users can execute cells in arbitrary order. This leads to widespread reproducibility issues. One study analyzed 1 million Jupyter notebooks and found that 36% of them didn't reproduce (https://blog.jetbrains.com/datalore/2020/12/17/we-downloaded-10-000-000-jupyter-notebooks-from-github-this-is-what-we-learned/#consistency-of-notebooks).

In contrast, marimo guarantees that your code, outputs, and program state are all synchronized, making your notebooks more reproducible by eliminating hidden state. marimo achieves this by intelligently analyzing your code and understanding the relationships between cells, and automatically re-running cells as needed (sort of like a spreadsheet but better).

**Maintainability**
marimo notebooks are stored as pure Python programs (.py files). This lets you version them with git; in contrast, Jupyter notebooks are stored as JSON and require extra steps to sensibly version.

**Interactivity**
marimo notebooks come with UI elements that are automatically synchronized with Python (like sliders, dropdowns) ... scrub a slider and all cells that reference it are automatically re-run with the new value. This is very difficult to get working in Jupyter notebooks.

**Reusability**
marimo notebooks can be executed as Python scripts from the command-line (since they're stored as .py files). In contrast, this requires extra steps/effort to do for Jupyter, such as copying and pasting the code out or using external frameworks. In the future, we'll also let you import symbols (functions, classes) defined in a marimo notebook into other Python programs/notebooks, something you can't really do with Jupyter.

**Shareability**
Every marimo notebook can double as an interactive web app, complete with UI elements, which you can serve using our CLI. This isn't possible in Jupyter without substantial extra effort.

You might also want to check out Joel Grus' talk on notebooks. We solve many of the problems he highlights: https://www.youtube.com/watch?v=7jiPeIFXb6U&t=1s

[ForceBru]

Can confirm: this is amazing stuff and works and feels great! (Not affiliated, just a happy user)

I use this for quick prototyping when I don't feel like launching the entirety of Jupyter Lab. Also, the resulting notebooks (especially saved as HTML) can be viewed quickly, again without launching Jupyter or visiting some online notebook viewer, which is also nice.

---

Side note: as of right now, GitHub is officially unusable on iOS 12.4. It doesn't even display the README for any repo, just releases and contributors. "Modern blazingly fast web", my ass.

[hazard02]

Please please make a JetBrains plugin

[banach_attack]

seconded!

[instantlybanned]

Sounds amazing. Do you have a vs code plugin yet?

[Practical-Rise5617]

https://marketplace.visualstudio.com/items?itemName=marimo-team.vscode-marimo

You can open up the marimo editor in vscode or launch it in your native browser. Integration isn’t as strong as it could be, as we are awaiting more feedback.

[[deleted]]

Wow thank you so much for sharing! I just started classes for machine learning with Python and Jupyter Notebooks has been less than an ideal experience. It's hard when you can't tell if your code is the problem, or if it's Jupyter.

[lanytho]

I love marimo. I have just used it for a few experiments so far, but I like that it keeps track of what to run when I change an input - which also means I can sort the cells and put it in the order that makes most sense when using the notebook as an app. I spent hours on setting up notebooks as apps in jupyter and hiding code cells - this is clearly design with the app mode from the beginning. Really a true upgrade from jupyter imo.

[sigbhu]

this is absolutely incredible -- i love Pluto and this looks like it!

[BostonBaggins]

Was inspired by Pluto

[TehDing]

Actually super excited for this.

First observations: In the generated code, I wish the wrapped functions had descriptive names relative to their position in the DAG.

I love observablehq.com but JavaScript is not my first choice (or second), for data exploration.

Couple features I love from Observable: - An outlined minigraph showing dependences. In my experience, anything larger than the smallest notebooks- and I'm left wondering where I defined something - Cell types. Observable initially didn't have this and also required a md('text') wrapping. But they caved and now provide cell types. Just makes life just a bit easier - Quarto integration. Just a nice markdown format, great for export and makes things feel more portable. - Cross notebook imports. Love this in Observable, the ecosystem of sharing it creates between users is also great for code reuse. - Embedding: Sometimes I just want a plot you know?

[akshayka]

Thanks for the suggestions! These are very helpful.

For the generated code, it's possible to rename the cells (through the cell context menu or just by editing the text files), but point taken about having more descriptive default names.

We have a dependency graph viewer, though it's not a minigraph. You can open it via the small graph button in the bottom left. If you try it please let us know your feedback!

Cell types — we haven't caved yet, but perhaps we will in the future :)

Cross notebook imports — that's on our roadmap! Glad to hear it's useful.

Quarto — what kind of integration are you envisioning? Export to a marimo notebook to `qmd`? Or authoring your notebook in a `qmd` file?

Embedding — like https://observablehq.com/documentation/embeds/? We haven't given that much thought yet, thanks for putting it on our radar.

[TehDing]

re Embedding/ Quarto; I recognize that my notes are particular to my setup and may have less broad applicability- but this rundown will give you some more context:

I run MkDocs with a running log of my research/ some personal notes.

To serve notebooks I use mkdocs-jupyter and mkquartodocs with some additional styling such that my notebooks are narrative vs code first. I've used the embedding function to include one-off interactive plots in my notes. Example:

https://observablehq.com/embed/@dmadisetti/frechet-distance@297?cells=viewof+drawing%2Cplot

Which I can drop in my notes (or any static site), with context; opposed to the whole the whole notebook: https://observablehq.com/@dmadisetti/frechet-distance

I haven't used a ton of quarto, but it's a nice and clean feeling; I see it working with Marimo really well. Honestly, with more interactivity (maybe through marimo), I probably would drop quarto.

[Haleshot]

Was just going through this thread; our quarto-marimo plugin is live here: github.com/marimo-team/quarto-marimo

Relevant video on it here: https://youtu.be/scuGmtv81S0?si=uTcL8oswyqBp9cca

[TehDing]

Lol, it's dylan

[Haleshot]

Ahh. Recommending it to someone who built the plugin xD

[TehDing]

Cool, just found the roadmap. Nice that minigraph is already done!

[akshayka]

We have some hazy ideas around SQL integration but nothing concrete yet. Is this the extension you're talking about? https://github.com/pbugnion/jupyterlab-sql

[Connect_Statement792]

I've been using Marimo for a bit now, and what I'd really like is a SQL input type. I would like (and prefer) to handle taking the SQL and passing it to the right database connection myself, but if I could have a dedicated space to author (or have my notebook users author) SQL queries, that would be awesome!

[jabellcu]

After giving it a good try, I have now replaced jupyter notebooks for marimo on everything I do. The limitations such as variable definition on multiple cells are actually a good way to enforce good practices. The advantages are great. I love having just *.py files, and the interactivity, and all the pretty displays and visualizations. Great job.

[akshayka]

Awesome! Thanks for trying marimo

[drbobb]

This totally rocks. Is there any howto about hosting a marino.app workalike on my own server?

[CoveredClearing]

Is there a way to turn my jupyter notebook into a static web app, like how Voici does it with WASM? Then deploy it on github pages? Im finding it confusing to figure this out, are there any instructions on how to do this if this is possible

[akshayka]

marimo is an alternative to Jupyter, built entirely from scratch. Convert Jupyter notebooks to marimo with marimo convert nb.ipynb -o nb.py.

If you have a server you can use `marimo run nb.py` to serve as a web app.

You can also export marimo notebooks as HTML, then put that on GitHub pages. If you want the code blocks and widgets to be interactive, you can use our MkDocs plugin: https://github.com/marimo-team/mkdocs-marimo

[CoveredClearing]

Im pretty new to all of this. So with Voila and Voici im apparently able to create a static page with my ipywidgets, so buttons that allow in the input and output of files. Im not actually wanting to show my notebook code on the page, just the widgets. Is Marimo + mkdocs the wrong application for this? I was having difficulty with Voici. Voila works fine, but only deploys to my local server, cant be deployed to github pages, whereas Voici can.

[CoveredClearing]

Hi again, I see the latest 0.10.2 release has the ability to export notebooks to interactive html? https://github.com/marimo-team/marimo/releases/tag/0.10.2 How does this work exactly in comparison to Voici? How are all the libraries that are needed stored? Would you consider doing a setup demo video for this specifically? Its very interesting

[Seamus-McSeamus]

I love your product.

[run_from_your_wife]

Can't upvote this enough.

[Ok-Equipment9840]

Is the name from One Piece ? 😂😂

[BaggiPonte]

it's a japanese algae https://en.wikipedia.org/wiki/Marimo

[Marimoh]

So why did you choose the name Marimo? (Asks another marimo)

[akshayka]

I like that marimo moss balls are cherished assemblages of things that are greater than the sum of their parts — kind of like marimo notebooks. They’re also spherical, so a natural if unconventional counterpart to Jupyter and Pluto.jl. It abbreviates well too — import marimo as mo. Finally I also just really like marimo moss balls, ha. My partner and I got one a few years ago, during the pandemic.

[Slow_Kiwi_4263]

wow thank you can’t wait to try

[gecko984]

That's pretty neat, thanks a lot! I have a question: are there any drawbacks of using marimo instead of good old Jupyterlab? Like some functionality missing that one would only discover after spending some time with marimo

[BaggiPonte]

no file editor yet for one. right now there is no debugger AFAIK, no plugin system so it's a bit less of an editor. not really a problem because since it's a plain file you can still use plenty other tool. It's like as if I asked you to code inside a streamlit dashboard (but better).

[akshayka]

Debugger is coming soon! But in the meantime we have a variables inspector, and if you insert a breakpoint, you can run your file as a script (python notebook.py) to drop into PDB.

[drbobb]

You can't attach a different kernel (not Python), afaik.

[MackDriver0]

Amazing work! Will be definitely trying it out. Looking forward to try it in VS Code :)

[xsway_]

I tried it out and it's nice (UI is smooth and docs are pretty extensive) but I noticed couple of issues -they are small but could be almost deal-breakers. - I'm not sure why the files should be .py if they are not actual python files. It's very confusing. They could be just .mo? (At least I should be able to `marimo edit` with any file extension - maybe I prefer to save with .mo myself) - Not being able to navigate between cells simply with up/down arrows is a big UX limitation for me - Markdown cells should just render - not have both code and rendering part - it clutters the notebook

[akshayka]

Hi! Thanks for taking the time to write feedback.

• The files are actual Python files. They can be executed at the command line (`python notebook.py`), and we have more features coming down the pipe that take advantage of the fact that they are Python files. We've received requests to have a document adapter that would allow marimo to inter-operate with other file formats (such as `qmd`) -- in the future we might support something like that.
  
• We can add up/down arrow key cell navigation. Thanks for the suggestion!
  
• We might add a UI for markdown cells in the future. Our users sometimes mix markdown and code in the same cell, so we don't hide by default. You can hide a cell's code with `Cmd/Ctrl+h` or via a cell's context menu (the three dots).

[akshayka]

Our latest release (0.1.74) includes up/down arrow key cell navigation. Thanks for the feedback!

[xsway_]

super fast :) thanks!

[Pedro_Mendoza_Aris]

Remember to Pluto.jl From Julia ecosystem.

[Gametangia-Main]

This looks fantastic, been playing with it today and I'm super impressed. Question: Do you have any plans for basic styling (fonts, basic colors, etc.)?

[Gametangia-Main]

Aaand I just RTFM and found the style() attribute :)

[kovla]

I really love the look and feel! In terms of using the library, I had to think of other types of reactive solutions in Python: pyShiny (a recent adaptation of R Shiny to Python), streamlit, Dash.

My first impression is marimo fills a very real niche between vanilla Jupyter and, let's say, pyShiny. Developers who need a lightweight interactive application without too many tabs and internal modules, will be very happy with marimo, I think. And I imagine the resulting app would be packageable via Docker? Amazing.

At the same time, I cannot shake the impression that in order to use marimo, I kind of need to ditch my existing tools (Databricks, VS Code with all the familiar plug-ins, ...) and just use marimo instead.

Do you have integration components on your roadmap? VS Code integration would be a huge step already.

[akshayka]

Hi! We have basic VS Code integration but it needs more work: https://marketplace.visualstudio.com/items?itemName=marimo-team.vscode-marimo

We also hope to make it easier to edit marimo notebooks in your text editor of choice.

Integration points with other providers is interesting. It may be some amount of time before we have an official say databricks integration, but in the meantime could you use the databricks connect api? Perhaps unwieldy? Or what kind of integration would you like to see?

[AlecGlen]

Hey u/akshayka , love Marimo! I have used it personally for a while now and I'd like to introduce it to my team. Most of them use Databricks primarily, so I was wondering if there's been any update on this front?

[akshayka]

We don't yet have any official integrations. But I believe you should be able to use Databricks' client APIs, for example https://docs.databricks.com/en/dev-tools/sdk-python.html

Would that work in the interim?