Show HN: Juvio – UV Kernel for Jupyter
31 comments
·May 20, 2025heisenzombie
I have been thinking about this for months now! Very excited to see you've implemented it, and I'm excited to try this out.
Could be fantastic for my use-case. We have a large repo of notebooks that are generally write-once, sometimes-re-run. Having a separate repo/venv/kernel per notebook would be a big overhead, so I currently just try to do a kind of semantic versioning where I make a new kernel on something like a 6-month cadence and try to keep breaking dependency changes to a minimum in that window. I can then keep around the old kernels for running old notebooks that depend on them. This is not at all an ideal state.
Thanks for sharing!
heisenzombie
Hm, I haven't had any luck making this work. Have opened an issue.
lukeyoo
I like Jupyter too! It's has been a quick easy solution for me: https://hub.docker.com/r/lukeyoo/jupyter-polyglot
banteg
there is https://marimo.io/ that does all this and more
pabs3
PEP 723 dependency management always struck me as a bit non-DRY. Wonder if there is a better way to do it, like annotating imports with versions or something similar.
stereo
Has anyone compared juv, juvio and marimo?
flakiness
The "git friendly format" is nice! How do markdown cells look like? Are they embedded as a python comment?
antman
Would it work on Jupyter lite?
okost1
Unfortunately it won't, at least due to the fact UV is not available in the in-browser/wasm ecosystem. That would be awesome though. Maybe it is possible to make something close in terms of functionality using a custom pyodide kernel + micropip, but I did not look into that.
nsonha
doesn't seem like I can just point to a pyproject.toml
I can see the point of PEP-723, in the context of jupyter, but another usecase is having your notebook to work on the same environment as some product, instead of just being a standalone thing.
chthonicdaemon
If you have an environment set up with a pyproject.toml, just select the Jupyter kernel you installed in the environment. That feels like the case that is well handled by current tooling.
I believe this is solving the common complaint that you can't just email a jupyter notebook, since it doesn't capture the dependencies.
nsonha
let's say you have a project with a pyproject.toml and some notebooks. You'll have to 1. Come up with some name for the kernel, 2. Add a script to install the kernel, polluting the collaborator's jupyter installation 3. Add a README referring to 2.
chthonicdaemon
It sounds like you expect the collaborator to have one jupyter installation that you would pollute with the kernel. In my projects that use jupyter, I always have jupyterlab as one of the dependencies. Not sure about the naming part, since I usually just put my project in a directory named for the project, and uv uses that name for the venv, so I literally have never had to "come up with some name for the kernel".
In my case, I usually cd to the project directory, activate the associated environment, then do one of the following to work on a notebook in one of my projects, `jupyter lab`, `pycharm .`, or `code .` and go from there. In all of these cases, I get the ability to open notebooks that make use of this environment, either in the actual Jupyter lab interface, or in the tool's notebook interface (pycharm or vs code). All of these options make it pretty effortless to use the kernel associated with the environment - it's either automatically selected or it's the default in the dropdown.
imcritic
> Why Use Juvio?
> No additional lock or requirements files are needed
Additional to what?
> Guaranteed reproducibility
Of what?
I probably need your project, but I don't understand what it is for.
okost1
Hi. I appreciate your feedback. Basically, juvio stores all of the project requirements (versions of the packages and of the python interpreter) directly within the notebook itself using the PEP 723 spec. Then, when you open the notebook, a new ephemeral environment is created on the fly with all of the required dependencies. Therefore, you don't have to maintain a separate e.g. requirements.txt/conda.yaml/uv.lock file.
rafram
Did you in the past? Normally Jupyter notebooks just include the package installation commands necessary to set up the environment from scratch. I've never seen a requirements.txt/lockfile distributed alongside a notebook.
mrbungie
That's common when they are distributed as single notebooks (i.e. via Google Colab). When distributed inside repos they usually contain a requirements.txt.
lyjackal
This is cool and something that I’ve wanted, but I don’t see hot listings requirements inline foregoes the need for a lock file to maintain reproducibility. What about version ranges? Versions of transitive dependencies?
null
jwilber
See also: juv
okost1
Hi. Thanks for bringing this up. To be honest, I have never tried juv, but judging from the readme the ideas of juv and juvio are slightly different. In juvio the ephemeral environment is created on kernel startup. Hence, one can have multiple notebooks within the same jupyterlab session, each with its own venv. This seems to be different with juv, but please correct me if I am wrong.
epistasis
I've been using juv on and off for for ~6 months. From what I can tell of juvio, it is a different model for using uv with jupyter notebooks.
I'm not sure which model fits best, I'll have to see how your juvio handles kernels in jupyter. Does the kernel name change, is it all the default kernel, and what changes when an install happens?
I'm not quite sure what you mean by cleaner git diffs, but hopefully that will become clear with experimentation.
For my particular method of working, I've mostly switched to having each small project (roughly a JIRA ticket) be a separate uv-managed project in a git repo, and I create a kernel for each of the uv projects. This allows me to examine multiple different tickets and kernels without having to launch multiple jupyter labs.
The whole kernel<->venv mapping is another layer of massive complexity on top of the current huge amount of complexity in Python packaging. uv makes it fast , but it does not provide the "correct" or even single route to managing venvs.
dockercompost
> In juvio the ephemeral environment is created on kernel startup. Hence, one can have multiple notebooks within the same jupyterlab session, each with its own venv.
This should be your primary selling point!
null
gogasca
[dead]
Juvio brings inline, PEP 723-style dependency management and automatic, ephemeral env setup to Jupyter notebooks.