marimo Blog

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/blueskyposter.py

Run in your browser: https://marimo.app/?src=https%3A%2F%2Fraw.githubusercontent.com%2FJMB-Technology-Limited%2Fblueskyposter%2Frefs%2Fheads%2Fmain%2Fblueskyposter.py

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.

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

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

(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-caching

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-expensive-uis

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

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.