marimo Blog

Pluto is great. I use it all the time. If you like the reactivity/reproducibility but are wedded to Python, you might want to check out Marimo, which is also great. [https://marimo.io/] It too puts the output of a cell above the code so if you're unable to adapt to things that are different it's also probably not for you. FWIW, Observable's Notebooks (Javascript) work the same way: output above the code that produces it. [https://observablehq.com/] I too did not like having the output above the code but got over it pretty quickly. For plots, it's arguably better: usually, I want to see the plot before I see the 15 line invocation of some plot command. The thing that bugs me the most about Pluto now is that it really wants you to only have a single evaluating statement per cell. You have to wrap stuff in "block......end" if you want to e.g. define more than one variable in a cell.

marimo notebooks give you the best of both worlds (https://marimo.io)

Looks interesting! We recently started using https://marimo.io/ as a replacement for Jupyter notebooks, as it has a number of great improvements, and this seems like a movement in a similar direction.

It's probably an unrelated post (apologies in advance) but I wanted to shoutout to the Marimo (https://marimo.io), it's the only Jupyter alternative that really got me excited, it's like Streamlit and Jupyter had a kid (and the kid took the best genes from both).

This is an emerging pattern that’s surprisingly powerful: thick clients that embed wasm query engines (pglite, duckdb) and do powerful analytics (with or without AI agents writing the queries). Below are two examples using duckdb under the hood for similar purposes. Like the author, excited for this type of architecture making semi-advanced analytics more attainable if you’re not a data engineer. - https://pandas-ai.com/ - https://marimo.io/

If you haven't yet do check out Marimo [0] https://marimo.io/

I’m not familiar with Deepnote, but I have quite a lot of experience with Jupyter, and if someone were to ask me if there are more modern alternatives I would immediately point them to marimo (https://marimo.io/). For me marimo is already a successor to Jupyter, it has replaced it entirely for me.

The successor to Jupyter notebook is Marimo, https://marimo.io/ because they are pure code, not code in json. First class everywhere.

I thought it should be extremely portable ("everything just works, it's native"), but it doesn't work on iOS 9.3.6. It doesn't even let me input text into the textarea... A natural extension seems to be a source code editor with syntax highlighting, like those used in https://marimo.io/, Jupyter, https://plutojl.org/ and other notebook-like Web editors.

I think marimo is a python version of the same idea: https://marimo.io/

Marimo does this for python, by tracking dependencies. https://marimo.io/

Ever since Marimo launched, I haven't looked back at Jupyter: https://marimo.io/ https://news.ycombinator.com/item?id=38971966 On top of their reactive goodness, Marimo notebooks are .py files, which makes it very suitable for this kind of (ab)use.

We use Textual as an interactive way to explore compilation pipelines in xDSL [0]. As our compiler is written in Python, it was the perfect tool to build a UI in the same language as the existing codebase. After starting the `xdsl-gui` project, we found Marimo [1], a reactive notebook for Python, which also lets users build apps in Python. It's been interesting to compare these two, especially in the way they handle state and propagate updates. For now we're using both tools, but it might make sense to centralise at some point. Both of these frameworks like immutable data structures, which I find is a positive incentive to use immutability throughout the code, and has been good for the rest of the project. [0]: https://xdsl.dev/ [1]: https://marimo.io/

Python notebooks such as https://marimo.io/ seems to provide many of the same benefits

People have used marimo for production web apps. They won't get you as far as writing HTML/JS. But great for internal tools or external showcases, tutorials, interactive blogs, etc. Our friends at SLAC use marimo for their internal exploration experiments and publishing interactive apps. He is an example: https://marimo.io/@public/signal-decomposition

there is https://marimo.io/ that does all this and more

This looks like many LLM assisted data projects which help and are flexible, but aren't repeatable and aren't fast enough to be interactive. Nao is a good execution of the concept. I built Buckaroo as a data table UI for Jupyter and Pandas/Polars, that first lets you look at the data in a modern performant table with histograms, formatting, and summary stats. Yesterday I released autocleaning for Buckaroo. This looks at data and heuristically chooses cleaning methods with definite code. This is fast (less than 500ms). Multiple cleaning strategies can be cycled through and you can choose the best approach for your data. For the simple problems we shoudn't need to consult an LLM to do the obvious things. All of this is open source and extensible. [1] https://youtube.com/shorts/4Jz-Wgf3YDc [2] https://github.com/paddymul/buckaroo [3] https://marimo.io/p/@paddy-mullen/buckaroo-auto-cleaning Live WASM notebook that you can play with - no downloads or installs required

I noticed that when you post on Bluesky with a URL in, the client says "uploading thumbnail". That's odd, I thought, why is the client doing that and not the server? So I looked up the API and it turns out the client can set whatever it wants as the preview! API Docs: https://docs.bsky.app/blog/create-post Here's an example: https://bsky.app/profile/jarofgreen.co.uk/post/3llj76ouqsr2u Here's a Python Marimo notebook where you can do the same thing too: Code: https://github.com/JMB-Technology-Limited/blueskyposter/blob/main/blue… Run in your browser: https://marimo.app/?src=https%3A%2F%2Fraw.githubusercontent.com%2FJMB-… This seems ... not great? Users would expect the preview to come from the website, I think. Also, I assume that means if you update your website and change the info that you want shown in that embed card (the OG tags) it won't change on any old posts that link to your website? ps. Also this is the first time I've tried using Marimo Python Notebooks for anything real, a few rough edges but pretty nice! https://marimo.io/ If anyone knows how to link to a note book and have it open in app mode, please let me know.

(someone from the marimo team here) The `export` command can generate a rendered artifact if that's what you're after but there is also another avenue here, have you seen the caching feature? The one that caches to disk and persists? https://docs.marimo.io/guides/expensive_notebooks/?h=cache#disk-cachin… This can automatically store the output of expensive functions, keeping the previous state of the cells in mind. If a re-compute ever needs to happen it will just load it straight from cache. Another option is to run in lazy mode, documented here: https://docs.marimo.io/guides/expensive_notebooks/?h=cache#lazy-load-e… This will prevent the notebook from rerunning cells by accident. We're thinking about adding features that would make marimo great for running long running batch work but there's not a whole lot I can share about it yet. If you have specific thoughts or concerns though, feel free to join our discord! https://marimo.io/discord?ref=nav

You might like https://marimo.io/pair, it turns marimo into less of a notebook and more of a shared data/computational canvas for you and your agent

seems you completely missed the point. marimo does everything you're looking for in plain .py files that render as notebooks. https://marimo.io/blog/python-not-json

Yup, Marimo seems perfectly gittable and Deepnote looks more of the status quo. > Human-readable format: The .deepnote YAML format replaces .ipynb's messy JSON with clean, version-control and human-friendly structure for projects and notebooks. You can organize multiple notebooks, integrations, and settings into a single .deepnote project for better structure and collaboration. https://marimo.io/blog/python-not-json

Marimo has been acquired (last week), does the SaaS enshitification pattern give you any pause? https://marimo.io/blog/joining-coreweave

Drawing canvas: https://excalidraw.com/ Drawing canvas: https://www.tldraw.com/ Code playground: https://replit.com/ Supabase dashboard: https://supabase.com/ Vercel dashboard: https://vercel.com/ Workout tracking: https://workout.lol/ Chatbot: https://chatgpt.com Note-taking: https://www.usememos.com/ Tax filing: https://ustaxes.org/start Python notebook: https://marimo.io/ LoL info: https://www.op.gg/ Sports matches: https://www.sofascore.com/ Trading news: https://seekingalpha.com/ Website builder: https://mmm.page/ Podcast maker: https://podcastle.ai/

Appreciate the nice words. If you want to explore the data in more depth, you might enjoy poking around in this Marimo app: https://marimo.io/p/@sumble/gen-ai?show-code=false You can see the full list of corporate use cases.

Just to add to this: Marimo notebooks are set up in a way that ends up being easier/more-token-efficient for agents to work in. They're just python files with some custom formatting to be read by their front-end UI, sort of like cell notation in (# %%) but with a lot of QoL bells and whistles built in. Jupyter notebooks in comparison, are mostly json and are pretty messy to work with as far as git diffs goes, which is annoying. VS-Code's Github Copilot actually had pretty good Jupyter integration, letting you refer to specific cells, and allowed the agent to run individual cells and read their output before writing subsequent cells etc etc. I suspect there are vs-code specific tool calls for jupyter notebooks being used that I haven't bothered trying to replicate with claude. A month or two ago, Marimo released Marimo Pair, which works about as well as that. It appears to be a skill that just points claude code (perhaps other harnesses, haven't tried) at whatever localhost the Marimo UI is worked off of, and tells it the structure of a Marimo notebook (very necessary since I imagine there isn't as much training data on them compared to Jupyter etc). https://marimo.io/blog/marimo-pair

This year's projects are very exciting - here is a list of the projects: Unsloth AI - Bending the cost curve of finetuning models Aframe (https://aframe.io/) - Making AR/VR more performant in the broswer Giskard (https://lnkd.in/gpmnjxs8) - Enterprise Testing platform for AI models Langdrive (https://addy.so/ and https://docs.langdrive.ai/) - Easy to train LLM with API - Plug and play APIs for LLMs LLMWare (by Ai Bloks) (https://lnkd.in/geS_nJu3) - Simplifying the way enterprises use Small Language Models Open WebUI (https://openwebui.com/) - Making LLMs available to anyone locally via UI to bring privacy, security and performance talkd.ai (https://lnkd.in/gg5GPQ) - Optimizing LLMs with Easy RAG deployment and management Web-Check (https://web-check.xyz/) - AI powered security insights bawed on open data from any website HackingbuddyGPT (https://hackingbuddy.ai/) - copilots for security teams with autonomous agents marimo (https://marimo.io/) - raising the bar for ML and data science notebooks Nav2 (https://nav2.org/) - home of robotics navigation