Deepnote, a Jupyter Alternative, Is Going Open Source

> If [you] look at the contributions graph, you’ll see low commit velocity and very few unique contributors, including multi‑month holidays with no commits.

> 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

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

I never really liked Jupyter. I've built a couple of "notebooks", as they have come to be known the days, much better than Jupyter and still switched to marimo, eventually. Quite similar to what I wanted to have.

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.

So what pain point are these new entrants trying to solve?

Sure there is an issue of .ipynb basically being a gnarly json ill suited for git but it is rare that I need to track down a particular git commit. Even then that json is not that hard to read.

Also I'd like an easier way to copy cells across different Jupyter notebooks, but at the end of day it is just Python and markdown not very hard to grok.

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.

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.

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

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.

ironically that makes jupyter more portable via colab

this announcement had such strong gpt-output vibe..

to the "writers": pleeease don't present unedited slop to me. i'm a human, if you want my attention consider using your own voice. i don't want to read what gpt thought would "market" you best.

but this thread did remind me of marimo so that's sweet

Wtf

It's like publications saying "research discipline X is gaining traction in recent years" based on search matches in PubMed, but not normalizing for the total number of articles submitted increasing.

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.

But sending my code over the wire to an LLM along with a prompt that says “please don’t write any bugs” is not a new feature.

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.

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.

I really liked Deepnote the product when I last used it, but the post definitely feels off.

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!"

What they built looks great and I don’t disagree with their take in substance, but you get one chance to make your open source announcement good - don’t blow it like this.

My constructive advice for deepnote: if you don’t have something to say from the heart, don’t ask an LLM to generate something for you. Write less, not more. For a post this important, an LLM is a terrible choice.

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).

This looks less like an "interesting" product, and more like a case of pivoting a commercial product that isn't making enough money into an open source one in the hope of at least gaining some credibility from all that work as well as undercutting the competition.

> They've built something genuinely useful and interesting

This core product has been around for years now. If it was that interesting and useful, more people would have likely paid for the original offering.

I would certainly recommend taking this 'release' with a touch more cynicism.

Edit: I checked with wayback machine and they definitely modified the article.

Not sure that an apology is necessary though. Some overconfident marketing person tried something, and it failed. That's what happens if you try stuff. They should just try harder next time

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

They put in some effort to remove the egregious / painfully obvious LLM voice.

Also, AFAIK, Observable is only JS - this is a Python notebook solution that we are talking here.

I'm just an observer - their claim of being successor to Jupyter is definitely hyperbole.