A Jupyter notebook frontend with built-in memory visibility.
Saturn is a lightweight desktop notebook application designed for standard .ipynb files and existing Jupyter kernels. It makes memory usage visible at the cell, variable, and output level while maintaining the notebook workflow users already know. The full application occupies roughly 17 MB on disk rather than hundreds of megabytes.
Saturn is designed for standard .ipynb workflows, but adds memory visibility that traditional notebook interfaces do not provide.
180 MB idle | ~4s startup | 5 MB installer | 17 MB on disk
Notebook workflows make it easy to execute code without understanding its resource cost. When a kernel becomes unstable or crashes, it is often difficult to determine which cell caused the spike, which variables are retaining memory, or whether notebook outputs have become unnecessarily large.
Saturn addresses this directly. Each cell displays its memory delta after execution. The variable inspector reports object sizes with deep sizing for DataFrames, arrays, and tensors. Output accounting shows which cells are responsible for notebook bloat before the file is saved.
Beyond memory visibility, Saturn is architecturally lighter than Electron-based alternatives. It uses the operating system's native WebView rather than bundling its own copy of Chromium, which is why the application is 17 MB on disk instead of 694 MB, and why it uses roughly half the RAM of JupyterLab Desktop with the same notebook open.
After each cell runs, Saturn displays the corresponding memory delta immediately. Small operations remain clearly distinguishable from large allocations, making it possible to identify the precise steps responsible for increased memory usage.
The variable inspector sorts objects by size and supports deep introspection for pandas, NumPy, and PyTorch objects. Large allocations can be identified quickly, inspected directly, and cleared when no longer needed.
Saturn includes the core workflow expected from a notebook environment: multi-tab notebooks, dark mode, an integrated terminal, a command palette, drag-and-drop cell reordering, collapsible headings, and kernel-powered autocomplete. The goal is to preserve the notebook experience while reducing unnecessary overhead and exposing information that standard notebook interfaces do not surface.
| Saturn | JupyterLab Desktop | |
|---|---|---|
| Installer | 5 MB | 500 MB |
| On disk | 17 MB | 694 MB |
 |
 |
| Saturn | JupyterLab Desktop | |
|---|---|---|
| Cold start | ~4 seconds | ~14 seconds |
Saturn
|
JupyterLab Desktop
|
Both apps were tested on Windows x64 with 16 GB RAM, using the same notebook. The Python kernel process is excluded from both measurements since it is identical regardless of frontend. Only application processes are counted.
| Step | Saturn | JupyterLab Desktop |
|---|---|---|
| Idle (no notebook) | 180 MB | 234 MB |
| Notebook open + kernel started | 226 MB | 433 MB |
| After running all cells | 238 MB | 443 MB |
The kernel process used ~166 MB in Saturn and ~169 MB in JupyterLab Desktop, confirming equivalent kernel overhead.
Measurement details
Memory was read from Windows Task Manager's Details tab. For Saturn, the total includes saturn.exe and all associated msedgewebview2.exe processes. For JupyterLab Desktop, the total includes jlab.exe and its sub-processes. The Python kernel (python.exe) is excluded from both since it runs the same ipykernel regardless of which frontend is connected.
The browser-based version of JupyterLab (jupyter lab opened in Chrome or Firefox) has a different cost profile: a Python server process (~117 MB) plus a browser tab (200-400 MB depending on the browser and notebook content). The total is comparable to JupyterLab Desktop but distributed across separate processes.
| Saturn | Jupyter | |
|---|---|---|
| Per-cell RAM tracking | Yes | No |
| Variable memory inspector | Built-in, deep sizing | Basic, no sizes |
| Output size tracking | Yes | No |
| Save without outputs | One click | Manual |
| Stale cell indicators | Yes | No |
| Execution order warnings | Yes | No |
| Interactive widgets | Yes (anywidget) | Yes |
| AI code assistance | Built-in | Extension |
Saturn reads and writes standard .ipynb files and uses standard Jupyter kernels. It is not intended to replace the broader Jupyter ecosystem. Instead, it provides an alternative frontend for users who want better visibility into notebook behavior and lower local overhead.
 |
 |
 |
 |
 |
 |
Memory tools -- per-cell RAM deltas, variable inspector with deep sizing for pandas/NumPy/PyTorch, duplicate object detection, output size accounting, save-without-outputs workflow, memory snapshots and diffs.
Notebook features -- multi-tab notebooks, dark mode, integrated terminal, anywidget support, stale cell indicators, execution order warnings, drag-and-drop cell reordering, collapsible headings, search and replace, kernel-powered autocomplete and tooltips.
AI assistance -- explain cell, fix error, with support for OpenAI, Anthropic, and local Ollama models.
Download the latest installer from Releases:
- Windows:
Saturn_0.1.0_x64-setup.exeor.msi - macOS:
.dmg(Apple Silicon and Intel) - Linux:
.AppImageor.deb
A Jupyter kernel must already be installed. For Python environments:
pip install ipykernelgit clone https://github.com/YOUR_USERNAME/saturn.git
cd saturn
npm install
npm run tauri dev # development
npm run tauri build # productionRequires Node.js 18+, Rust 1.70+, and Tauri v2 prerequisites.
Saturn is built on Tauri v2, which provides a Rust backend with the OS-native WebView rather than bundling Chromium as Electron does. This is a major reason the application remains small on disk relative to Electron-based notebook frontends.
Issues and pull requests are welcome. For larger changes, please open an issue first to discuss the approach.
npm run tauri dev # dev server
npx tsc --noEmit # type check
npx vitest run # frontend tests
cargo test --manifest-path src-tauri/Cargo.toml # rust tests- Plugin / extension API
- Real-time collaboration