We're open-sourcing the successor of Jupyter notebook

I saw this on LinkedIn earlier and literally closed it after “ Let’s be frank the single‑player notebook has felt outdated for a while now”

I think it must be messaging for “leadership” as opposed to practitioners, there are lots of real pain points but they don’t seem to be mentioning them

I do not often make a point after upvoting but instead of writing more or less the same: this ^. If not for the open source, I would have closed the the page after that blurb thinking something is off and I do not need it.

Simple explanation, they used AI as a voice for their writing instead of using it as a tool for writing in their own voice.

LLMs are good to proofread, check your tone, generate ideas, etc.

Letting them take over your connection with an audience or be a substitute for gut checks or taste is not helping anyone.

The whole article felt very dishonest and frankly quite rude towards Jupyter. Self-declaring themselves to be the successor to a project that's still alive and that they seemingly have absolutely no legitimate claim to, and then going on to bash it by saying it's dying because job postings are decreasing and commits are decreasing, the latter point is especially dishonest considering Jupyter is already quite complete and fully featured so maybe it doesn't need constant daily commits?

Maybe they should focus less on bashing Jupyter and more of showing what's good about them, for example they stated multiple times that Jupyter is messy JSON but they never showed off their own format... Just some vague hand-wavy "perfect for AI!"

TIL "Hello world!" has been put out to pasture.

When we stand on the shoulders of giants, we don’t do so to dump on them.

Why is "View source" listed here as if it's some outdated feature of the past?

>If you're trying to reach out to the Python community this is not the way to do it. Completely unnecessary hostile language there! Have some respect.

The note sounds as written by some manager/marketing guy that has 20 years to touch a line of code...

For sure it put my off even checking what their shit is (from initially interested upon seeing the HN post).

People don't want that. This article is largely empty marketing. Claiming they have "the successor" is all you need to read before you can infer it's hot air.

All standards are ultimately controlled by private companies. Even non-profits require funding.

Open source always depended on a viable business model (of one or many companies) that can sustain not just the release, but also an ongoing maintenance of the standard.

I'd argue the opposite.

There is plenty of AI extensions, but the experience matters. The depth of integration matters. When you execute queries against production warehouses and you make decisions based on the results of AI-generated code, accuracy matters. We had our first demo of an AI agent running in 2 days, it took us another 2 years to build the infrastructure to test it, monitor it, and integrate it into the existing data source.

You'd be surprised how many people collaborate together. Software engineering is solitary, collaboration happens in GitHub. But data analysis is collaborative. We frequently have 300+ people looking at the same notebook at the same time.

.py never worked for data exploration. You need to mix code, text, charts, interactive elements. And then you need to add metadata: comments, references to integrations, auth secrets. There are notebooks that are several pages long with 0 code. We are building a computational medium of the future and that goes beyond a plaintext file, no matter how much we love the simplicity of a plaintext file.

This is the first time I'm hearing about marimo and i have to say their landing page is excellent! Immediately makes me want to try it

But doesn't marimo force certain workflows that jupyter does not? For example its website states that "Notebooks are executed in a deterministic order, with no hidden state — delete a cell and marimo deletes its variables while updating affected cells." This appeals to people doing development work in notebooks, but it breaks workflows where people use notebooks as notebooks, where state is entirely separate from the in-notebook presentation of cells. Do people using notebooks these days hate this fundamental feature of notebooks?

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

Will github render a Marimo notebook as if it has already been executed, like they do for Jupyter notebooks?

I actually mostly use Jupyter for non-Python code (e.g. Julia or Ruby). How is Marimo's support for other languages?

Marimo has been acquired (last week), does the SaaS enshitification pattern give you any pause?

https://marimo.io/blog/joining-coreweave

Have to say marimo is excellent and is a breath of fresh air compared to Jupyter!

How hard would it be to add creatine collaboration to Marimo?

One thing I like about marimo is the autocompletion's much faster than Jupyter.

And that graph they show has an offset y axis (hides the scale from 0 to exaggerate the "downward trend") _and_ has a non-uniform x axis. Each tick mark represents a different scale of time (1yr, 3 mos, 1 mo)

Wtf

I would recommend not making any career pivots to sales or marketing.

I agree with this. I have no problem with a technical discussion comparing the features and discussing Jupyter’s shortcomings. But the Jupyter job postings and contribution graph screenshots felt both ill-spirited and not particularly relevant.

There was interesting stuff here: the human readable format, auto publication. But the tone and framing bashing a reliable open source project really turned me off.

It isn't even a successor. A successor would be open source from the start!

I've found that notebooks are great for ad hoc reporting and analysis scripts. Once you have your quick and dirty script, it is trivial to convert to a notebook and you get a lot for little. Being able to change one cell and rerun just that is a godsend for getting reports "just right", and the "show your work" and visual aspect make them much more consumable and trusted by other people.

Notebooks aren't competing with scripts, they're competing with REPLs.

ML and scientific applications in particular tend to have segments that run for a long time, but then you'd like the resulting script to be in a state where you can mess with it, maybe display some multimedia output, etc, without re-running the long-running segment. Notebooks fit this need to a tee.

Notebooks are closer to using a repl than a script.

One key feature is that you can run a long data-prep/processing step and then iterate on whatever comes after without having to re-run the compute intensive steps to get the data (i.e.) you want to graph

Another key feature is learning and sharing knowledge. Images, markdown, graphs, links, code... all interwoven. Scripts do not have affordances for these things. In this sense, Notebooks can be closer to reproducible blog posts.

I do think notebooks are very flawed right now even if the concept is sound. Right now they are essentially an IDE without the ability to produce publishable output (you are literally expected to ship the project in the form the IDE works with) and they are not a very good IDE at that.

They need reliable dedicated published output fit for general public consumption. This means a static (no backend host required) sharable .html file where end users can view all the data and run the code samples that doesn't try to present as an IDE. I actually wrote https://rubberduckmaths.com/eulers_theorem in Jupyter but had to manually copy and paste to a new well formatted static html file and re-paste the code blocks into Pyodide enabled text areas within that html since the export functionality is a mess. The result of the manual work means i now have an easily sharable and easily hosted static html file with working Python code samples as it should be but... Why don't Notebooks have a published form like this already? It seems pretty obvious that Notebooks are your IDE, they shouldn't be the output you present. We're literally asking users today 'to view this notebook install Jupyter/Marimo/whatever and open from there' when the Notebook is designed to create the publication rather than a place to view it. In general the output i demonstrate above should be the minimum bar that Notebook 'export' features should hit. Export as a static .html file with working code. As someone who manually 'compiles' notebooks it's not hard to do yet Notebooks simply don't have an actual working html export right now (i know there's technically a 'html' export option in Jupyter but it will strip out your code and create a terribly poorly formatted document as output).

The IDE aspects themselves, at least for Jupyter (the one I've tried out the most), are a bit too simple too. Yes it's nice to have alternating 'text' blocks followed by 'code' blocks but that's really all they are right not. I want something more complex. I want the code blocks shown to actually be windows to a full python project. Users should be able to change the code shown and view the larger, well structured Python code. Right now it's text, followed by simple code. Not much more honestly. As it is right now i feel Notebooks only work for really simple projects.

If you have a complex Python project i agree the way to only share it is to share the Python project as is. Notebooks could be a wonderful explanatory wrapper to a larger project but right now they just aren't good at doing much more than the simple 'here's some data' followed by 'here's the code i used to process that data' and they don't even present that particularly well.

notebook are great when you wanna see the intermediate results and not just the final result (in case last step takes time and you wanna double check the data) or when you just wanna better understand what the code does (yes, you can set up a debugger and debug a script etc but that is just more pain)

I have no real qualms with the idea of a notebook, as long as it's not adding a lot of custom magic. I should be able to share what I'm working on, iterate in a notebook with someone, then extract it into a standalone program without much thought.

*anywhere that has the python runtime installed

ironically that makes jupyter more portable via colab

notebooks are great for sharing code with people who might have only a cursory knowledge of coding. It also helps highlight specific sections of code. Graphs and other outputs immediately proceeding the block of code that generates them can be really helpful as well

If a "script" gets too long and complicated, and it's a project I intend to present to others, I often reach for a notebook to organize the code in a more digestible format