Show HN: A modern Jupyter client for macOS | Hacker News Reader

Show HN: A modern Jupyter client for macOS

satyrn.app

611 pointsjackhodkinson160 comments

It starts up really fast (faster time-to-execution than VS Code or JupyterLab), you can launch notebooks right from the Finder, and the design is super minimalist. It's got an OpenAI integration (use your own API key) for multi-cell generation with your notebook as context (I'll add other LLMs soon). And many more useful features like a virtual environment management UI, Black code formatting, and easy image/table copy buttons.

Full disclosure: it's built with Electron. I originally wrote it in Swift but couldn't get the editor experience to where I wanted it. Now it supports autocomplete, multi-cursor editing, and moving the cursor between cells just like you'd expect from JupyterLab or VS Code.

Satyrn sits on top of the jupyter-server, so it works with all your existing python kernels, Jupyter configuration, and ipynb files. It only works with local files at the moment, but I'm planning to extend it to support remote servers as well.

I'm an indie developer, and I will try to monetize at some point, but it's free while in alpha. If you're interested, please try it out!

I'd love your feedback in the comments, or you can contact me at jack-at-satyrn-dot-app.

Open articleView on HN

This looks great! Since jupyter notebooks are used by a lot of people (like scientists, business analysts etc) I think there's a genuine niche for just having a jupyter notebook client for folks to get started with quickly.

Adding something like built in .venv support and even python distribution would be immense (I'm thinking of a dream scenario where installing something like this gives a beginner all the tools to get up and running python notebooks with) any plans for that on the roadmap?

Even as a command line power user, I still wish it were easier to install dependencies while working in a notebook. If I'm working on a project I don't want to have to switch to my terminal if I can solve the problem in one command from my notebook.

With a little careful thought into good UX I don't see why it can't be easy for a beginner at the same time useful to a pro user (and still compatible with any virtual environment).

Totally agree with this sentiment. There is definite value in providing an easy to setup fully featured jupyter environment for people who are just starting out.

The company I work at (qBraid) has a qBraid Lab product that does exactly this, but tailored more toward those in the quantum computing ecosystem. We may even be interested in offering Satyrn as another option on our currently platform alongside VSCode and standard Jupyter, if the creator(s) are ever interested in licensing and/or some form of co-selling model.

Thank you for attempting to use swift first. Electron apps are bloated and overused.

Excited to play around with this!

I agree! At the very least I can port this to Tauri to make it have a smaller footprint.

Might be some useful things you can do with the Tauri rust backend too

Since your app is currently Electron I'm surprised it doesn't work with Windows. Would it be hard to get the app to play nicely with Windows?

Agreed about Electron apps!

But...a really good code editor is a good example of something that's extremely hard to implement using native text controls, but there are great ones based on web tech.

I wonder if embedding system WebKit on macOS or using something like NeutralinoJS would be a good alternative?

The pro is your app is much smaller and lighter.

The con is that any bugs in your system web control are out of your control, and certain tight integration with web APIs might not be possible.

From the post:

> Full disclosure: it's built with Electron. I originally wrote it in Swift but couldn't get the editor experience to where I wanted it. Now it supports autocomplete, multi-cursor editing, and moving the cursor between cells just like you'd expect from JupyterLab or VS Code.

Consider taking this as evidence that Electron isn't bad, instead of evidence that you shouldn't use this program.

Except you are really can't use Jupyter notebooks without browser. Because of widgets and interactive elements.

Cool!

Surprised to hear you started with a native UI and pivoted to electron. What was the major blocker there?

I recently got frustrated with OpenSCAD and decided to try CadQuery and Build123d. The modeling backend is a big step forward, but the GUI is not nearly as good as OpenSCAD. I managed to get it working via VSCode with a plugin, but I’m dreaming of embedding everything in a dedicated MacOS app so I can jump into CAD work without hacking through dev setup.

There aren't many great production-ready open-source frameworks for code-editor components in Swift. I assessed quite a few but found that the feature completeness was far from what I needed. I tried to fork [CodeEditSourceEditor](https://github.com/CodeEditApp/CodeEditSourceEditor) and add the extra features I wanted, but I think it would have taken me 6-12 months to get it to an acceptable state, meanwhile not spending any time focusing on the rest of the product experience.

I decided to play around with Typescript and Electron over a weekend and ended up getting a really solid prototype so I made the heart wrenching decision to move over.

I'm messing around with writing my own text editor component in Swift now, but it's quite a big endeavour to get the standard expected for a production ready product.

I'm assuming a pure-swift CAD UI would be equally difficult. Would be really cool to see that tho.

Don't listen to the grinches that stole Swift. Electron is fine. We have lots of RAM. Just make it good. Data scientists won't care.

FWIW I've had good experiences with Tauri so far. It's great being able to call back easily into Rust code and I haven't had any real issues with the wrapped web view.

At this point I'd start with Tauri first and only switch to Electron only if I really need something only Chrome supports or if I need to support Linux. I guess the webview story there is not so good.

Tauri supports linux.

Right but from what I've read the webview it uses there is way less stable and featureful than Windows or Mac. I haven't actually tried it myself.

tauri-apps/tauri: https://github.com/tauri-apps/tauri :

> The user interface in Tauri apps currently leverages tao as a window handling library on macOS, Windows, Linux, Android and iOS. To render your application, Tauri uses WRY, a library which provides a unified interface to the system webview, leveraging WKWebView on macOS & iOS, WebView2 on Windows, WebKitGTK on Linux and Android System WebView on Android. ... Tauri GitHub action: https://tauri.app/v1/guides/building/cross-platform/#tauri-g...

WebView: https://en.wikipedia.org/wiki/WebView

CEF: Chromium Embedded Framework > External Projects: https://github.com/chromiumembedded/cef#external-projects : cefglue, cefpython,: https://github.com/cztomczak/cefpython

(edit)

tauri-apps/wry > Bundle Chromium Renderer; Chromium WebView like WebView2 (Edge (Chromium)) https://github.com/tauri-apps/wry/issues/1064#issuecomment-2...

I love your website design! How did you put that together? What did you use for the app screenshots and logo graphics?

Is your project related to these two other "Satyrn"s ??

Satyrn: A Notebook alternative that supports branching code and local collaboration. https://github.com/CharlesAverill/satyrn

Satyrn: A Platform for Analytics Augmented Generation https://arxiv.org/abs/2406.12069

Thanks! I just used the builtin MacOS screenshot tool to take the screenshots. I used Tailwind to style the page. I really like the default shadow that the "selected window" screenshot adds, but since there are also "selected area" screenshots I decided to take them without the default shadow (by holding option) and then add it in using Tailwind.

The logo was done with ChatGPT and my friend editing it with some graphic design software :)

This project is unrelated to those others. I like the branching code idea tho, would love to have something like that. I'd love it if you could rewind your code execution to a point in time and then play it forward differently. I suppose that would be a pretty big memory overhead tho.

When I first started coding, I wished there was an “app” for it where I just start writing code. Now there is.

I was taught coding on Matlab. It had everything built in, and no package management to worry about. As green freshmen, we were making games in week 2 of the course, and running science simulations soon after.

Similarly, I used Mathematica. I really enjoyed having things just work. I now use mostly Python and spend a bunch of time with dependency issues.

I generally tend to think that complaints about dependency management in Python are way overblown -- it's usually not a problem for me. But lately I've been trying out some off-PyPI projects to investigate time series foundation models, and it would have made my life so much easier if the implementers of these libraries hadn't decided to pin to extremely specific versions of ten or twenty different dependencies. No, your library does not need exactly NumPy 1.22.3. You're just throwing unnecessary obstacles in the way of people using it.

That pinning wouldn't really be a problem ordinarily, where I control the environment, but I'm running this particular code in a managed environment that I can't easily modify.

This is great. I've wanted to build something similar many times, but like you've mentioned, it's tricky to monetize.

Feature request: If I drag a tabular file (e.g. CSV, parquet, etc.) into the UI, do something like:

    temp1 = pd.read_csv('path_to_file')
    temp1.head()

Good luck with it!

Thanks! That's a great idea. I have been thinking of doing something like this.

Can I use it to connect to a remote Jupyter notebook server?

Not yet! But I'm working on this :)

That will be interesting. Happy to test and share feedback. Previously, I was a part of the DataSpell and PyCharm team building notebook support. Now working with dstack, where we support dev environments and super interested in remote support.

Thanks! I'll let you know when it's ready. What do you use now to work with remote environments? JupyterLab or VS Code?

Right now, mostly VSCode - mainly because it’s a desktop IDE and it also supports notebooks.

I use jupyterlab via an SSH tunnel

We use a self-hosted JupyterLab. I would love to have an external tool though our existing workflow isn’t too bad.

ah, I def need remote for my current use case - the web interface just isn't that nice to use!

This is the feature, I want.

Do you have an existing workflow for that? I tried to set up some thing like that a couple years ago and couldn't figure out how to do it without copy-pasting the connection info JSON, which was not a comfortable workflow.

Im working exclusively with a remote connection (although inside the company network, so some security concerns don’t apply). I have Jupyter running as a service on Linux and am using a password instead of the generated token. So the URL stays the same and I don’t have to worry about anything much. The setup is working good for me - there are a couple of nuisances but they’re all related to the rest of my circumstances and use case, not to anything mentioned above.

Ah, so you have Jupyter itself running remotely? I was hoping you had a good workflow for starting or connecting to remote kernels using a local Jupyter frontend. This seems like such an obvious use case, but the ecosystem support for it is surprisingly poor. I've tried and failed several times over the years to figure out a workflow that a regular scientist or industry data analysit could follow.

So, it looks like if you try and add a kernel for a virtualenv that doesn't have ipykernel installed you immediately install it in the virtualenv with `pip`

It would be great if you asked the user before doing this. My environments are usually managed by one of poetry or pipenv or nix, not pip. Which means now my lock files and installed stuff is out of sync.

Great feedback, thank you. I've heard this before. I'm thinking of keeping the default but adding an option in settings to "ask before installation" for users who prefer that behaviour (similar to VS Code).

Maybe the first time it happens you pop up with a confirmation dialog and it has a checkbox that says something like “always ask” (and an option in the settings).

Nice!

Is this loading the same webpage whatever JupyterLab is serving or did you write the JavaScript machinery for cell management etc yourself?

If the latter, are interactive plotly graphs or IPython widgets on your radar?

Thank you :) I did write the entire client. I will add support for those soon! I love interactive widgets.

Anyone else live in a Jupyter QtConsole?

Thank you. I didn't know this existed.

https://qtconsole.readthedocs.io/en/stable/

Yes, I have it set up to launch at OS startup, along with a hotkey to task-switch to it at any time. An incredibly underrated tool.

JupyterLab still has its uses, but it's just too heavyweight for the "calculator replacement" role IMO. QtConsole is perfect. Or at least, it is with a bit of additional startup code.

Yes, very underrated tool.

What were your initial thoughts on tradeoffs on making this a vs code extension vs a separate app ?

The post is literally right here.

> I've always craved a more focused and lighter-weight experience when working in a notebook. That's why I created Satyrn.

> It starts up really fast (faster time-to-execution than VS Code or JupyterLab)

He did not answer the question in your quote.

I do not see a privacy policy nor anything about telemetry, analytics or other data collection by the app. It would be good to clearly state what you’re collecting or not collecting. Without this, running such an app on a desktop OS seems a bit scary.

I also hope you’re able to add something about the business model soon.

yeah this is an immediate show-stopper for me, at least for professional usage

I hope you consider an open source model: code available freely on GitHub & app available for purchase on your website.

I was scared about doing it this way, but it worked out for me: https://videohubapp.com/ for pay-what-you-want-$5-minimum for my app, and https://github.com/whyboris/Video-Hub-App git-clone-and-build for the code. I currently sell about 60 copies per month (same average across the last 4 years too).

> pay-what-you-want-$5-minimum for my app

> I currently sell about 60 copies per month (same average across the last 4 years too).

I'm guessing the median is $5, can you share what the average is?

Only a few people per month pay above asking price. Sometimes it's $6 or $7; usually if it's over $5 it's $10; once I received $25.

From my dashboard right now: Sales - All time $27,732.69

Nice app, I might give it a try for my video collection.

Would you be willing to share the OS breakdown? I'm primarily interested in macOS and am wondering roughly what % of your sales are for that platform?

I've not kept statistics, especially that when people purchase they get access to all the OS versions. I'm guessing it's over 50% Windows but Mac is no less than 20% of the purchases. I don't sell my app through the Apple App store - it's just whoever stumbles across my website (I've shared it on Reddit a bunch of times over the years, but not aggressively). I think I mostly got lucky with naming - where "video hub" is close to "porn hub" and people find it unintentionally :)

Looks great! I'd love to get a notification once you add remote servers support. What channel should I use? Besides discord.

Anybody interested in a Jupyter notebook like experience for Swift and iOS development ML / data science algorithms. Think write on macOS but run on an actual device but send data back to the host and draw charts, etc. Like run computer vision alogirhtms your developing on actual hardware, cameras, etc but with notebook like cells on macOS

My biggest issue with Jupyter is the key bindings, I want to be able to import my Jetbrains keybindings to Jupyter notebooks but havent found a good way. The Jupyter implementation in Pycharm is just terrible so still stuck using jupyter in the browser.

Will your tool allow custom key bindings?

Isn't this better if you use DataSpell from Jetbrains instead of Pycharm?

My experience with DataSpell has not been great. Granted, my workflow leans toward R, and it DataSpell has a Python-first approach, but the app was basically completely broken to even load R, and StackOverflow was full of relatively old posts of people with the same problem. If they really cared about that app that would never happen.

I just do a lot of my R editing in PyCharm now and flip between terminals and RStudio. I was hoping DataSpell could unify that, but it's not ready.

The new RStudio IDE is promising, however.

Oh god, not another 550mb app... there are a lot of lightweight alternatives to electron that can provide the same frontend experience if you don't need nodejs: tauri, wails, pywebview...

Navigation between cells with j/k doesn't seem to work, unfortunately. I'm used to not having to move my hands to use the mouse when editing a Jupyter notebook.

The reason people use an actual IDE instead of Jupyter web is because it allows you to jump in the libraries source code

Agreed, that's a big one. I'd love to add that capability to Satyrn too.

Does it work with Sagemath?

Is this it? https://www.sagemath.org/

This looks like a programming language built on top of Python.

Satyrn only supports the Python programming language right now.

If you are using this on the regular, I'm curious if you have tried Julia or Mathematica, if so why do you use Sagemath over those alternatives?

There are many reasons to use Sagemath.

It unifies multiple existing open source math libraries and packages. It integrates with Octave, Scilab, Maxima, etc. It also integrates well with LaTeX... you can take results, format them as TeX and also render them.

Its objective is to be a replacement for Maple, Mathematica and MATLAB, which are prohibitively expensive for many people. As such, once it's installed it comes with batteries included and you can easily share workbooks that others can run without falling into a DevOps-like situation.

The DSL that is offers can be more convenient than Python.

There are some interesting quickstart tutorials here https://doc.sagemath.org/html/en/prep/quickstart.html

And it was also discussed earlier on HN here, with many comments that are more informed than anything I could say at this moment: https://news.ycombinator.com/item?id=23511183

I tried JetBrains DataSpell as a desktop frontend for Sage and the results were not good.

> If you are using this on the regular, I'm curious if you have tried Julia or Mathematica, if so why do you use Sagemath over those alternatives?

Sagemath has pure math stuff. Julia does not. Sagemath can do lots of cool symbolic calculations like rings, quotient rings, algebraic curves, etc. Mathematica has some of this functionality but it's not free.

To be frank, I don't see any additional features of the app over VSCode, other than it starts up faster, which does not matter much as VSCode starts up faster than the import cell of any notebooks I have. Also, one big reason I use VSCode for notebook is to get the Python LSP.

Good luck to you though, I do think the demographics of scientists who find VSCode confusing is actually sizeable.

I have VSCode open 24/7 so even that feature doesn't help me.

Lots of people use both VSCode and native Jupyter notebooks that would love this app as it develops.

But if you aren't using VSCode (we exist) this looks quite useful. That said, I just open my jupyter sessions in firefox and am pretty happy with that...

Mental separation, I think. It's nice to take a break from the code editor and have a focused app for quick analysis, like a calculator.

I am sorry, but "it's built with Electron" is all I need to know at this point. I appreciate the effort you've put in it, and I am sure that it is a great improvement. After all, I am using VS Code on a daily basis, and it's all about Electron, so I don't think that it will be that much slower than a fully native app. However, there is something about the minimal footprint nature of native macOS that I just can't go around. You just feel the snappiness of it, on a sub-nano-second level.

I use notebooks the whole time, normally in vs-code and with github copilot setup.

I found it quite painful to point it to a couple of environments I have, and confusing how i get it pointing to my gpt4 api keys. Once I did these two I was not sure how to prompt rather than typing a command.

Good luck with this, don't mean this in a critical way, just trying to give some feedback of what I think when I first try it.

I also edit my notebooks in vscode. I wouldn't switch to something that doesn't support GitHub copilot, unless completions are much better.

Thanks for your feedback! I'm looking into this. I'd also really like copilot here.

I'll work on making them easier to configure.

At the moment you press `g` (for generate) while in command-mode to create a "prompt cell". I'll think of ways to make this more obvious.

Appreciate you spending the time to try it out and share your feedback.

Yeah vscode also finds the virtualenv from the current project automatically whihc is probably the biggest thing for me that stops me for using this, alongside copilot support

This sort of high performance minimalism is precisely what makes the Mac app ecosystem great. Not because you can't write the same thing on other platforms, but because everyone who cares about it has condensed on the Mac platform.

Would love to see this adopt the document-based app API and the toolbar API.

> This sort of high performance minimalism is precisely what makes the Mac app ecosystem great. Not because you can't write the same thing on other platforms, but because everyone who cares about it has condensed on the Mac platform.

Meh. Most apps like this are built for the Mac because a lot of programmers use Macs. If anything, Apple makes it difficult to develop for macOS because they keep breaking APIs with each update.

Pretty sure that’s what they’re saying

Pretty sure that's not what they're saying.

> Most apps like this are built for the Mac because

People with Macs have money, and are willing to use it to pay for software.

Not that deep.

> Apple makes it difficult to develop for macOS because they keep breaking APIs with each update.

Like what

Every macOS release breaks a few things, but to be honest it's not much of an issue.

Here are some recent things that required code changes from developers:

- disabling user interaction when trying to request items from the keychain

- views no longer clipping to bounds by default

- installing login items and background services

The latter two were understandable, because they were caused by new features, but some are just caused by a lack of testing.

It's not a big deal, and I'm sure Electron apps have similar issues, but app developers do have to put in some work to make sure their apps keep working properly on macOS.

Ask the developer of BetterDummy (aka BetterDisplay).

Did you read the post at all?

"Full disclosure: it's built with Electron. I originally wrote it in Swift but couldn't get the editor experience to where I wanted it. Now it supports autocomplete, multi-cursor editing, and moving the cursor between cells just like you'd expect from JupyterLab or VS Code"

It's not a native Mac app, it's a standard electron app.

And yet, the Satyrn author created sth that is more minimal and elegant than the options that existed before. And despite being in Electron and therefore not at all Mac specific, the target audience will almost exclusively run a Mac. Not because you need a Mac to run it, but because the kind of person who cares about such detail will have chosen an OS that cares a lot about details.

mac minimalism doesn't even come close to tiling window managers such as i3 or jupyter terminal clients such as euporie. So even your elitism is misinformed.

> because everyone who cares about it has condensed on the Mac platform

This elitist and incorrect viewpoint has plagued macs for a very long time. I wish it would die.

People are excited for less functional app. This is insane.

Looks great! :)

I use Jupyter Lab every day on OSX in scientific/academic work, so I feel I am your target audience. In case it helps you gauge my impression, I spent about two minutes reading the post and scrolling through the website.

I feel I did not understand the main advantages of this notebook aside from the AI integration. I don't understand how "start-up" time is a cost; I have a Jupyter server running at all times and use it as a scratch-pad throughout the day, so it is always available.

I don't understand the "modern command palette". As far as I can tell all the commands are available to regular Jupyter Labs, and either way I always use hotkeys for them.

The code formatting using black isn't bad, but notebooks are for scratchy ideas, not real code. If I'm at the point of formatting code, it's going in an actual IDE. I'd even argue providing formatting inside of a notebook encourages bad habits for scientists, who prefer to stay entirely within a notebook, but are then sometimes unable to reproduce their results.

I don't see the advantage of the copy-paste; I can copy paste directly from Labs to Slack/online editing pages, and certain Latex typesetters.

Pros: it looks pretty, the site has nice demo videos (in terms of quality; I didn't understand the content).

I want to like this but I don't see any benefits for a power user except for the AI integration; if AI is the only selling point then I prefer to get it differently.

Thanks for your feedback!

If you'd be happy to share: I'm curious to know what scientific field you work in? Do you do 100% computational work, or is it a mixture of experimental and computational?

Sure. I do algorithm development at a biotech company, it is 100% computational work. I am not a software developer by training, my background is in mathematics.

I also use notebooks and qtconsole daily so I'd like to chime in.

- I don't have a continuously running notebook server. I start it when I need to and shut it down if I won't be working with it for a while. I do like the idea of clicking an icon and starting an app.

- Modern command palette, I believe, is similar to what you would see in apps like VS code. It doesn't offer more commands but instead make it easier to find and execute commands. I don't use Jupyter Lab so I don't know if it has a command palette but Jupyter Notebook doesn't so that seems like an advantage to me.

- I disagree on the formatting point, too. Even if I am just doing something very quick I cannot stand seeing lines extending some length, no space after a colon, single vs double quote inconsistency etc. So I do spend time formatting them even if I am on IDLE and know for sure I am not going to save it. Thankfully, IPython added support for Black so it is less of an issue for me.

Apps in this area generally focused on extending Jupyter to maybe combine SQL/JS with Python, making data exploration easier but I do appreciate a light app that just gives me a notebook experience with some small advantages, especially considering Classic Notebook is going to go away soon. I'll definitely give it a try.

Thanks for your thoughtful answer.

- Re: continuously running a notebook server, how about an alias in your ~/.*rc file that just launches a new JLab? Personally I don't find the startup time so high, so it doesn't seem to me 'startup time' is the strongest lead to sell the product. (Of course, if most people find that the startup of a notebook is indeed a large cost then it's a fine point to make. )

- Re: command palette, gotcha. As you say, classic notebooks are going away (and I haven't touched one in a while).

- Re: formatting, I take it back. You're right, there's been plenty of times I've wanted to have nicer formatting in a notebook/lab, that's nice.

I switched to Windows/WSL2 a few years back so don't have a fight in this game (though if it's Electron, why only macOS?) - but having to switch between IDE and Jupyter for code formatting seems like unnecessary overhead.

But TBH Quarto is much better in this regard; you can use a VScode together with another IDE if you wish to format/edit/run chunks of code in the same file.

> but having to switch between IDE and Jupyter for code formatting seems like unnecessary overhead.

You're right about this. I don't love my setup (and have not put enough effort into optimizing it -- hence my reticence at learning Yet Another Tool), but the main reason I use notebooks is for objects that persist in memory. I can load up some huge dataset, keep it open, and jump back to it whenever I want over the next day/week/month without having to "reload" it (fetch data from some server and do processing).

I'd love a robust Jupyter-in-Sublime experience, where I have all the editing/hotkeys of Sublime along with this persistence of objects.

Quarto looks cool, might check that out. If there's any specific part of it you think is awesome, please do point it out. Thanks.

Thanks for checking out my project. I'd love your feedback in the comments.

I'm not sure if the post text above is visible (I can't see it on my phone's HN reader) so I'm going to repost it here as a comment too:

I love Jupyter – it's how I learned to code back when I was working as a scientist. But I was always frustrated that there wasn't a simple and elegant app that I could use with my Mac. I made do by wrapping JupyterLab in a chrome app, and then more recently switching to VS Code to make use of Copilot. I've always craved a more focused and lighter-weight experience when working in a notebook. That's why I created Satyrn. It starts up really fast (faster time-to-execution than VS Code or JupyterLab), you can launch notebooks right from the Finder, and the design is super minimalist. It's got an OpenAI integration (use your own API key) for multi-cell generation with your notebook as context (I'll add other LLMs soon). And many more useful features like a virtual environment management UI, Black code formatting, and easy image/table copy buttons.

I'm an indie developer, and I will try to monetize at some point, but it's free while in alpha. If you're interested, please try it out!

I'd love your feedback in the comments, or you can contact me at jack-at-satyrn-dot-app.

I used to use Jupyter and Jupyter Lab, but by far the most able Jupyter interface today is actually VS Code (I use this every day).

The interface is sleek, the language server and debugger are built in (so completions, variable renaming, step-by-step debugging etc. all work seamlessly) and it makes Jupyter a pleasure to use.

How does this compare to the “official” Jupyter desktop app: https://github.com/jupyterlab/jupyterlab-desktop

Looks like a native app vs an Electron app.

Both are web apps sadly.

My question as well. My experience using notebooks with 3rd party Jupyter clients has been poor, eg Nteract and Pycharm. Whereas Jupyterlab Desktop just works. You would have to convince me to switch to anything else.

It's closed source

Is there something like Jupyter for Javascript/Typescript, ideally self hosted? At the moment I just do data science using one off scripts in NodeJS but seeing these notebook style formats recently where different chunks of code appear to be snapshotted and then visualisations can be easily integrated looks quite nice.

Yes. You can use Jupyter notebooks with both JavaScript and TypeScript. Such support is from Deno for example [0]

[0] https://deno.com/blog/v1.37

You might want to check out Observable - not sure about self hosting but js based and has notebooks with inline plots and all that jazz. https://observablehq.com/documentation/notebooks/

Not exactly a notebook but Quokka gives you that REPL playground experience.

We are building one right now. It's very early and we have only "soft launched", but you can check it out here.

https://github.com/srcbookdev/srcbook

Why “modern”? I suggest you use more descriptive adjectives.

I think the approach is a Mac-first app that follows Apple's design language, no?

Yup, that's what "modern" means to me in this context.

Thought it was totally clear.

It looks like and acts like it was built for Sonoma, not for Sierra.

That didn’t occur to me.

As an IPython/Jupyter user for over a decade and Mac user for two decades, it’s not something I personally care about or an issue I’ve felt.

Well sure, plenty of users don't care about aesthetics.

And the Jupyter notebook interface certainly isn't aesthetically pleasing. Colab is not as bad, but it's still not nice.

But some people do care about aesthetics, and this interface is actually aesthetically pleasing.

I always felt that if you have nothing to say about your project you say it's modern. They just coded it, so it must be

For vim users, jupyter-vim [0] coupled with a jupyter QtConsole is hard to beat. The short video [1] is maybe self-explanatory, but in short:

- vim on the left half of the screen, a jupyter QtConsole on the right, showing any plots, possibly interactive.

- the kernel on the jupyter QtConsole can be running on a powerful remote host, e.g., with GPU, but the plots are displayed locally

- Focused window is always vim. From vim editing a .py and without ever leaving vim or touching the mouse, one connects once to the jupyter kernel of the QtConsole. Then one can send a selection of lines, or vim text objects, to be evaluated in the QtConsole with a few keystrokes. Code is shown+evaluated and plots are displayed in the QtConsole as if the code sent from vim had been typed there.

One gets the full power of both vim and jupyter kernels with native plots. No more browser based notebooks or other editors with half-baked vim bindings.

[0]: https://github.com/jupyter-vim/jupyter-vim

[1]: https://www.youtube.com/watch?v=h59cbg4HqpY

Or you could use emacs and have the images displayed inline.

...and you just triggered a holy war :)

The ability to send code to a Jupyter kernel is pretty sweet. I made a python script that starts a kernel in the background that you can pipe commands to/from in your shell, or even open a QtConsole with the current state.

https://github.com/digitalsignalperson/comma-python

Alternatives and innovation in this space are greatly appreciated! I run Linux and Windows so I keep my eyes fixed on https://github.com/zed-industries/zed/pull/12062#issuecommen... - - zed is a cross platform, gpu rendered, rust-based editor.. Jupyter support should arrive soonish

nteract (https://nteract.io/) supports windows and linux.

I still use Atom+Hydrogen most days.. About the same amount of years since the last (major) updates as nteract.

https://github.com/nteract/hydrogen

That contribution to Zed from rgbkrk looks awesome.

Can someone explain their views on Jupyter notebooks? As far as I can tell, the instructor/content creators will set up the "notebook" and students can read the notes and click on the "play" button to see it work in action. Is there anything else besides that?

I guess I'm old school and am used to cutting and pasting and running things in my own terminal, so I'm wondering if there are added benefits that I'm not aware of of Jupyter notebooks. It seems to have a very loyal following so I would love to learn their perspective!

Really good for doing some basic data science, the kind of thing where you want some graphs based on some source data that is variable.

Being able to change functions around and generate new graphs (IE; if I want the mean not the median for a contrived example) is really handy.

Data science / ML are using that. Databricks (data platform, data warehouse) have support to run notebooks in workflows on periodic basis.

There is market of professional use of them.

When I learned to program I was working as a scientist. I was relying on OriginLab (a scientific version of Excel) for my data analysis and it was a real pain. I decided to start using python for analysis and plotting and started with scripts and terminal interactivity, but found it too clunky. Jupyter feels more interactive when you are working with data because you need to explore the data and experiment with data manipulation in a way I found quite natural to do in a notebook.

Since then I've moved into software development where I rely on my IDE for any coding that involves working with more than a few modules. And as I got better working with an IDE I did gravitate toward making a script for certain kinds of tasks where I use to reach for a notebook, but there are still many data analysis tasks that I would much prefer a notebook for.

It's also quite nice to share a notebook with someone to show them how you arrived at your conclusions, and it's nice for them to be able to take your analysis and modify it or test their own ideas on top of yours. Obviously the notebooks are not great for collaboration without some fiddling around with git, but they are still very good for this kind of collaboration.

Imo there hasn't been much of a point except as a share-only format since vscode’s Python extension could natively handle comment-delimited code cells. You get all the benefits of a Jupyter notebook while still just writing a plain text file.

You can also edit the notebook, both code blocks and text. It's used for quick visual iterative exploration of datasets with descriptions. The focus is on creating a report of your analysis and process rather than a "product".

Another point not mentioned by the other comments: you run code interactively (like you would do in a REPL), but keeping what you wrote. This is very practical, for example, if you want to develop a simple code for data analysis. You fetch the data only once, then develop the rest of the code based on it, instead of writing everything without seeing the data.

As a consequence of it, it makes easier to write bad code. I care about code quality, but I must admit that sometimes I needed to stop and refactor my jupyter notebooks.

It's a nice tool, but it doesn't replace writing a .py

I'm a so called "scientific" programmer, meaning that I use programming as a tool for solving problems, not for writing software that others will use. Many of my programs run only once, or a few times with changes each time.

I've switched virtually all of my work to Jupyter, including some lab automation, but also data analysis, modeling, visualization, and so forth. I use it as an interactive lab notebook that can "do" things.

Of all the tools I've used in 40+ years, my Jupyter notebooks are the best thing I've experienced for being able to go back and understand things I've done, weeks or years later.

When I use other editing software such as word processing, I quickly reach a point where I say to myself: "I wish I could just pop a code cell in here."

As a fairly mature technology, Jupyter has a lot of known quirks and shortcomings (I'm talking about you, out-of-order execution and hidden state), but I'm putting up with them because the benefits are huge.

I think there is no single answer. Some people hear at a conference that Jupyter is "the thing to use", so they start using it for everything while they would be much better off with .py files.

Some use it because the interface was copied form Mathematica, where it makes much more sense than for Python.

These are the serious users.

There are a lot of non-serious users who have discovered that presenting a mixture of code snippets and text that looks good is enough, certainly for PyCon style talks. These users depend on the tool for their fake careers, so they promote it wherever possible, and the popularity increases even more.

Congrats! Sorry if you shared here below and I missed it, but I'd love to hear what exactly didn't work out with a pure Swift approach. I'm trying that route for a SQL client based on duckdb (as a side project) and would be very helpful to avoid similar pitfalls for example.

Awesome!

I did some explaining in this comment here: https://news.ycombinator.com/item?id=40899748

Good luck with your project. Let me know if you'd like any tips on the code editor stuff or anything else I can help with.

Great, many thanks! And yes, I hope to have something to share in some ~12 months time. The goal ie to be essentially an SQL client that (a) benefits from ducker's excellent performance and flexible SQL language, and (b) has data-science-helpful features, like the ability to filter or reorder columns with the mouse (or keyboard) afeter the data is queries.

I’m still hoping for something that is at least 80% as functional and integrated as RStudio is for R.

Have you had a look at Quarto? Any thoughts?

its called running and editing notebooks with vscode...

I just want a Python version of rstudio- I bet they probably support Python by now

You should check out Positron, which is currently beta. It's created by Posit (the company formerly known as RStudio).

https://github.com/posit-dev/positron

I'm a bit disappointed the code isn't available. I scrolled the landing page for a long time to find the Github button as I strongly expected something that was highly upvoted on hackernews was open source.

Dude I just started getting into deep learning and have been flabbergasted getting stuff working. I installed jupyter and torch via homebrew. I can use torch fine from programs, or in venvs, but when I try to use torch in a Jupyter notebook it cannot find the module. Is it a different python environment or something?

Hey, I used to run into the same issue and figured out installing conda, and utilizing its python was the easiest to keep things straight. Once you install conda and can activate your environment, then when using pip, don’t just call `pip install` because your path could be using a different pip than you expect. Instead use `python -m pip install` after activating your conda environment but make sure you’re using the right Python (`which python` & `conda env list`)

Python packaging etc can be a real pain point. I would suggest not using homebrew for these, in fact uninstall them. For jupiter/torch heavy work, I would install anaconda and then use that exclusively. Best of luck, it can be annoying but follow a good guide online you'll be OK.

It can be confusing. The key is that you probably have multiple versions of python installed on your computer (that's normal). Secondly, the default "kernel" in Jupyter was probably not the one you used to install torch.

I'd suggest 2 things to help: 1. Try `pyenv` for python version management 2. See this tutorial for how to create a virtual environment and add it as a Jupyter kernel: https://selvamsubbiah.com/run-jupyter-notebook-in-a-virtual-...

Satyrn makes it easier to add virtual environments as a kernel, but you still will need to create the virtual environment and install torch there yourself.

That's a really great point you made about how confusing it is to pip install stuff with `!pip` when working in the notebook. Right now Satyrn does not support the `!` commands, but I will add this soon and try to make it so `!pip` works with the expected virtual environment you are working with.

Jupyter and pytorch can be installed completely as python packages via pip thanks to the modern wheel distribution format. Because of that, I would generally not recommend using an external package manager for project dependencies. I prefer installing python via the Python.org downloads, then creating a dedicated virtual environment where I can pip install any packages. That way I known where all my dependencies are installed, and I can make seperate environments for different Python or library versions.

Package management is a fundamentally hard problem, and it's not all technical.

Nowadays, before I try anything new, I mentally reserve one or two days for the inevitable problems with configuring, compiling and installing. Also, it happens regularly that the cost of trying something turns out to be too high, and I just move on to the next thing.

Of course, sometimes stuff works out of the box, but that is only in a small fraction of cases.

It is sad that it has come to this, and it makes me wonder how we'll cope in a future when software has even more layers of complexity.

Great app. A good example why js apps can never be more than OK, and native apps can really rock. Would be amazing if I could use my sublime bindings here

> it's built with Electron

A bit off topic, sorry, but: Jupyter is bad for research. The ability to run code out of order, but then save the output, is confusing for the one doing the research and everybody who wants to reproduce it. I don't understand why the decision was made for Jupyter to combine the source code of a notebook and the output. Things like Quarto keep both separate, as essentially all programming languages inteded, while providing an easy-to-use implementation of literate programming.

This can be solved by just running "restart and re-run all" as a matter of habit whenever you feel like you are in a good state. If you're looking at someone else's notebook, this should also be your first step.

If you're using Python, Jupyter still offers a major advantage for sharing prototyping/research work in that it it is the only real way to provide literate programming. There are cases where code inside of a notebook should be pulled into a library, but pure code will always be inferior when most of your work is expository and exploratory.

Literate Haskell, and R Markdown are superior forms of literate programming, but Jupyter is not terrible if you just take some basic precautions before sharing.

Notebooks work great as... notebooks. Which is primarily how they're used in my experience. When the bulk of your work is prototyping and and exploring an idea, they're still an excellent choice.

Quarto is like R Markdown, but it supports the jupyter kernel, so Python support is essentially the same as jupyter notebooks. But the good practices are built in, instead of you having to remember running "restart and re-run all". So it's a valid option for literate programming in Python (and several other languages).

When I say "confusing", I don't mean I don't understand it. I mean that while using it, there is a higher than zero chance that you get confused at some point and mess up.

I love the feature that you can interactivly develop/prototype research. I just think better/less error-prone tools are available (which also track nicer on git btw, since quarto docs are flat text files).

Reply on news.ycombinator.com