nteract/hydrogen: Running Jupyter Kernels Inside the Atom Editor

The problem Hydrogen solves for Atom users

The usual way to run Python interactively is to keep a terminal REPL or a browser notebook open next to your editor, then copy code back and forth. Hydrogen removes that copy step. It is an Atom package that connects the editor to a running Jupyter kernel, so a line, a selection, or a marked cell executes where you are already typing and the result appears inline.

The README frames the motivation as Bret Victor's ideas about instantaneous feedback and the design of Light Table: running code inline and in real time. That is the audience. If you write exploratory Python, R, or JavaScript and you already live in Atom, Hydrogen is aimed at you. If your work is a large application with a test suite, the interactive loop it provides is not the loop you need.

One design decision shapes daily use: the README states there is one kernel per language, so snippets from several files share a namespace. That is convenient for exploratory work across files and a hazard if you expected file-level isolation.

How the Jupyter messaging protocol reaches your editor

Hydrogen implements the Jupyter messaging protocol. Jupyter uses ZeroMQ to connect a client to a running kernel, and Hydrogen is that client. The client sends code to be executed, the kernel runs it, and the kernel sends results back. Everything the package does, from running a selection to asking the kernel for completions, goes through that channel.

That architecture explains the feature list. Completions come from the running kernel rather than from a static index, so they reflect what is actually imported. Code inspection returns whatever information the kernel provides. Rich media support for plots, images, and video exists because the protocol carries results as structured messages rather than plain text, which is also why the examples directory contains files like examples/plotly.py, examples/images.py, and examples/vega_datasets-altair.py.

The same architecture is why a kernel must be running before anything works. The package exposes hydrogen:start-local-kernel and hydrogen:connect-to-remote-kernel as activation commands, and the README notes that a custom kernel connection can be used to run code inside Docker. The connection is the product; without it there is nothing to execute against.

Installing Hydrogen and running your first cell

Hydrogen is distributed as an Atom package, and the README points to the installation page in its GitBook documentation for the steps. The package.json declares the package name as Hydrogen and its main entry as ./dist/main, which is what Atom loads.

Because Atom's package servers are down, the normal install path through the editor's package manager may not resolve. The README's Atom Sunset Notice says it is not possible to publish new packages anymore, and that if you have Atom working offline locally it should continue to work. For a source build, the repository ships a pnpm lockfile and a set of npm scripts, so the build runs from a checkout:

pnpm install
npm run build

The build script cleans dist, runs the TypeScript compiler against lib/tsconfig.json, then strips declaration files and the tsbuildinfo artifact. After that, linking the checkout into Atom's package directory is the way to load it.

Once the package is active, open a Python file and start a kernel from the command palette. The activation commands registered for atom-text-editor include hydrogen:start-local-kernel, hydrogen:run, hydrogen:run-cell, hydrogen:run-all, and hydrogen:export-notebook; atom-workspace registers hydrogen:import-notebook. Run a selection and the output appears inline below the code. The examples directory is the fastest way to see what that looks like: examples/dataframes.py, examples/pandas.py, and examples/matplot-pyqt.py each exercise a different result type.

Where Hydrogen is the wrong tool

The largest limitation is not in the code. Atom is sunsetted, and the README states plainly that new packages cannot be published and the servers are down. A package that depends on a discontinued editor inherits that editor's end of life. The repository's last push was on 2026-07-19, so work continues, but the host application does not.

The second limitation is the shared namespace. One kernel per language means state leaks between files. Reproducing a result in a clean session requires interrupting or restarting the kernel, which the README lists as a feature but which is really a workaround for the shared-state model. If your work depends on reproducible, isolated execution per file, a notebook format that serializes cell order and outputs is a better fit.

The third is environment coupling. The package needs a Jupyter kernel reachable over ZeroMQ, plus a working Atom install. Teams that standardize on editor-agnostic tooling will find that requirement awkward, and anyone who cannot run Atom offline cannot use Hydrogen at all. The README also does not document rollback or downgrade steps for a broken kernel connection beyond interrupt and restart.

Nteract and VS Code as alternatives

The README's own migration guidance names two alternatives, and they differ from Hydrogen in approach rather than only in polish.

Nteract is described as directly inspired by Hydrogen, but it is a desktop application that wraps the Jupyter notebook format rather than an editor plugin. The unit of work is the notebook document, with cells and saved outputs, not an arbitrary source file. You gain a durable artifact you can commit and re-run; you give up running code inside the editor where the rest of your project lives.

VS Code with its Jupyter integration takes a third path: the Jupyter experience is built into a general-purpose editor that is still maintained. The interactive model is closer to Hydrogen's, but the extension ecosystem and the editor itself are not frozen. For someone choosing today, that difference matters more than any feature comparison, because Hydrogen's constraint is external to the project.

Hydrogen also supports plugins through a documented plugin API, and the README lists Hydrogen Launcher, hydrogen-python, and Data Explorer as examples. That extensibility is real, but it does not change the host editor's status.

Maintenance, licensing and upgrade cost

The repository is not archived and the last push was on 2026-07-19, so commits are still landing. The published release history tells a different story about distribution: v2.16.5 dates from 2023-01-10, v2.16.4 from 2022-11-21, and v2.16.3 from 2021-06-02. The package.json version field reads 2.16.4, behind the most recent release tag. Anyone tracking versions should check the GitHub Releases page, which the README names as the changelog, rather than assuming the manifest and the release tags agree.

Upgrade cost is dominated by the toolchain. The build uses TypeScript, ESLint, Prettier, and a pnpm lockfile, and the scripts include format, lint, tsc, build, and a test target that runs atom --test spec. That test command requires a working Atom binary, so a contributor without a local Atom install cannot run the suite. The dist directory is generated by the build and cleaned on each run.

Hydrogen is MIT licensed, which permits commercial and private use, modification, and redistribution provided the copyright notice and permission notice are preserved. That is a permissive licence, but it grants nothing about Atom itself, and the README's note that publishing is closed is a distribution constraint rather than a licensing one. This is a description of the licence text, not legal advice.

Editorial conclusion

Hydrogen is worth adopting only by people who already run Atom offline and want kernel-backed execution inside it, and who accept that no new packages can be published. Anyone starting fresh should look at the alternatives the README itself points to, since the recommended migration path is exporting to ipynb. Before committing, verify that a local Jupyter kernel starts from your Atom install with hydrogen:start-local-kernel, because the whole package depends on that ZeroMQ connection working.

Frequently asked questions

Official sources

1. License: MIT
2. nteract/hydrogen on GitHub
3. Project website
4. README
5. Releases