Deepnote, a Jupyter alternative, is going open source
deepnote.com
deepnote.com
> Let’s be frank the single‑player notebook has felt outdated for a while now. We’re open‑sourcing its successor. Jupyter belongs in the hall of great ideas — alongside “Hello, world.” and “View Source.”
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.
My advice to Deepnote is to scrap this launch announcement (ideally with an apology) and try again. They've built something genuinely useful and interesting but it's going go get a lot less attention than it deserves if they introduce the open source version to the world like this.
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 read it originally when it came out, didnt have a chance to respond initially then came back to look through the comments. If there was anything was changed, it's not obviously apparent...
Merely retroactively changing the post doesn't inspire confidence they now 'get' the value of the Jupyter and its community and respect it
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
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).
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!"
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.
Edit: I checked with wayback machine and they definitely modified the article.
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.
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.
Why would people want a standard to be controlled by a private company? I don't think the "Open-Sourcing" of it says enough. How does licensing work with formats or standards?
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.
Take this project for instance. If one day their choice is to forgo all future profits, or to close the source to continue operating, it's very likely they will close the source to continue operating, rather than forgoing profits. We've seen it happen enough to be wary from the project structure alone.
To see the actual standards, you can search for "standard" on https://defacto2.net/search/file
There's a free book that covers that topic:
https://punctumbooks.com/titles/warez-the-infrastructure-and...
It's a great counterexample to "corporate money and influence are required to develop, maintain, and enforce standards", because it shows that it sprang up on its own in the absence of money and has persisted for decades.
> 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.
marimo doesn't support creatine :)
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.
It's one of the things that is the most confusing to people I've worked with. The idea that there is hidden state and you have to re-run cells to get variables to update (or variables still exist when you've deleted those cells) is quite confusing.
If you're trying to have a reproducible workflow, it can be difficult. Jupyter is no different from other notebooks in this regard (RStudio, for example will happily run code and keep variables around that you don't reference any longer in your .R or .Rmd files.)
But I see your point -- if you're using it as a long-term storage notebook, then this is the expected behavior. And you absolutely want to have "historical" data/results kept.
I generally think of / use notebooks as a way to make reports for analyses. So, I want to work with them, draft them, change them, put them in git, etc... then run them all at once to get my output. For me, having a reproducible, documented workflow is more important. I don't want state to be kept outside of those one-off runs. Really until your comment, I didn't understand the other side of the issue, so thanks!
you can say whatever you want, but we have history to help guide us, and it has not been kind to the acquisitioned company's current user base
you're still in the honeymoon phase, check back with us in a year or two
It's sad Marimo got sucked up into this, I fully expect it will not receive the love and support it deserves, especially now that it was shaping up to be an amazing tool. I can only hope it will fail quickly and painfully, so as to spawn an open source fork that will outlast the AI bubble.
Would love to be wrong.
I'd argue the founders made the choice more than they company got sucked up
It might have been convenient for Jupyter notebooks, but that was a side effect of what's essentially a negative feature, the last output of every cell being thoroughly mixed with the source code.
This is incredibly useful for knowledge sharing and learning
With Marimo, the way to achieve the same result is to have it (automatically) export the notebook to a _separate_ static HTML file: https://docs.marimo.io/guides/exporting/#export-from-a-runni...
reactive: this matters, but all the alternatives have it
collaborative: this matters very little in the Figma / Google Docs sense of collaborative in practice. It's very rare you want two people working on the same notebook at the same time. What you really want is git style version control.
AI‑ready: you want something as close to plain python (which is already as AI-ready as it gets) as possible.
if you're measuring across these dimensions, I'd go with marimo.
marimo is saved as plain .py files, easy to version control and has a reactive model.
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.
Wtf
Still skeptical about the data source. Analytics datasets always seem to undercount the most recent few data points.
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 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.
If you are marketing to VCs then disparaging competitors and making grandiose claims can be effective.
But when marketing to developers then constructive criticism and humility may be more effective.
But kudos for going oss
This is a joke, right?
https://github.com/deepnote/deepnote/
What's the equivalent of `jupyerlab run`?
> You'll soon be able to:
> Take the UI you're used to from Deepnote Cloud and run it locally > Edit notebooks with a local AI agent > Bring your own keys for AI services > Run your own compute
ironically that makes jupyter more portable via colab
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.
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.
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.
You can also use .ipynb files as input instead of Markdown files and output to those same formats.
Traditionally, Quarto executes Python code at render time, but there's an extension called Quarto Live that lets you also incorporate Pyodide code blocks for the reader to use. https://r-wasm.github.io/quarto-live/ (I have not used Quarto Live before and have no idea what the limitations are.)
Then there is also the issue that notebooks are too complex to version-control effectively.
That's not how Python imports work. You can import in the notebook just like any other Python script.
For me, it's cringe to borderline painful to read.
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
Marimo is great, but it's good to have competition in the space (especially when both projects are still owned and maintained by VC backed companies).
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.
> worfklows
Observable is already open-sourced and well-respected. Bold and ridiculous to claim your random product is "the successor" of a well-known project, without any obvious relationship to the founders/maintainers of the thing you claim to be aping.
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.
Sincerely, nice.
Otherwise I've followed DeepNote since they started. I agree with other comments that it's icky to announce yourself as a successor to someone else's project, but always nice to have more options for open source
I love notebooks, I use them all the time for teaching, writing (all of my books are written in notebooks), EDA, model development, and more. I've spoken at Jupytercon.
Having said that, I've never played around with other notebook implementations (ok, I've used IPython Notebook, Jupyter Notebook and Lab, Google Colab, ein (emacs), Jupyter in Vscode, and Notebook (.py) files in Vscode).
I've seen Joel's rant about notebooks, and they do have drawbacks.
But I would rather push better programming practices (chaining pandas, using functions, rearranging cells) than have dependent cells written in the horrible piecemeal style that I see all around the industry.
My biggest issue with notebooks is JSON. I've used Jupyter to get around it for years, and now many LLMs are decent at writing Jupyter JSON.
I hope the "founders" go back to the drawing board and retry
The execution model also keeps invisible state in the running kernel, so fairly often if you restart the kernel and re-execute all cells, you'll get a traceback or, worse, subtly different results (and, alarmingly for something called a "notebook", your old results have been erased with no confirmation and no undo). This can happen for a variety of reasons, like deleting the definition of an object you are still using, or defining a new object in the last cell, using it in some subsequent cells, and then going back and changing some earlier cells to use it too.
If you get an .ipynb file from a coworker, you need to read it carefully before hitting "Execute all below" in case there's a cell saying something like "execute this cell to do an emergency shutdown of the production server", because that is a thing people do with entirely good intentions.
Another commenter went on to write a lengthy comment (likening it to an IDE, however, which is an analogy that doesn't really work, and where the Excel comparison is really most apt): <https://news.ycombinator.com/item?id=45815212>
> 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 […] In general the output i demonstrate above should be the minimum bar [for what a notebook is]
Any desktop preparation pipeline for ostensibly sharing research that doesn't leverage the ubiquity of the World Wide Wruntime needing no installation (either that, or able to output self-contained, source-carrying executables supporting decompilation that you're expected to run like a video game rather than open like a PDF—all of which is fraught with other obvious problems) is not really solving the research-sharing problem. Jupyter just repeats what has always plagued the Python world and was never solved despite the existence of e.g. Anaconda.
This morning I was reading a very valuable paper on eutectic points of evaporite salt mixtures from 01972, 53 years ago. If you publish something today in electronic form, how confident are you that it will be readable in 02078? Plain HTML and PNG will probably be readable, but it might not be ideal to depend on Web Workers, WebAudio, or the darker corners of the PDF spec.
The nice thing about jupyter notebooks is that you can run them inside vscode without an explicit server, but I like to just use %% so that I can run it in zed and vs code and it’s just a python file that doesn’t need conversion.
The obvious question is whether Jupyter is being replaced in those postings, whether those types of jobs are proportionally rarer, or whether the whole market is simply hiring less.
Jupyter is still best in class and I can think of a few other explanations for this stat.
Honestly this is worth alone for the fact that there isn't random JSON blobs coming in PR diffs.
I wish more people tried it out instead of complaining about the blog post text.
"AI" has achieved what seemed impossible in 2019: It makes people hate all tech and gets them away from computers.
They put in some effort to remove the egregious / painfully obvious LLM voice.
(Anybody still familiar with "bullshit bingo"?)
> 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.
Didn't expect to see this trending here! We worked hard to execute on our vision of a data notebook and I'm glad we finally got a chance to open source it. We stand on the shoulders of giants. AMA!