Show HN: A modern Jupyter client for macOS (satyrn.app)

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.

> 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?

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?

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

That contribution to Zed from rgbkrk looks awesome.

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

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.

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

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

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.

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.

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?

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.

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.

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

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

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

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

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.

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?

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

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.

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

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.

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.

Looks like a native app vs an Electron app.

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

Have you had a look at Quarto? Any thoughts?

its called running and editing notebooks with vscode...

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.

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

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