nteract is a software suite designed to enhance interactive computing experiences, enabling seamless collaboration among teams through tools like Jupyter notebooks and REPLs. Built on open-source principles, nteract offers a versatile platform for developers, researchers, and educators to work together efficiently.
Key Features:
Cross-Platform Desktop Application: Utilizes Electron to deliver a powerful desktop experience across multiple operating systems.
Jupyter Extension Integration: Enhances Jupyter environments with additional functionality, supporting both classic Jupyter and JupyterLab setups.
Composable React Components: Provides reusable UI components for building custom interactive computing applications.
Extensible Core SDK: Offers foundational tools for developers to create tailored notebook interfaces and applications.
Real-Time Collaboration: Facilitates simultaneous editing and sharing of insights, fostering productive teamwork.
Audience & Benefit:
Ideal for data scientists, educators, researchers, and developers seeking to streamline their interactive computing workflows. By leveraging nteract's tools, users can enhance productivity, simplify the sharing of computational work, and foster a collaborative environment. The software is installable via winget, ensuring easy setup across supported platforms.
nteract empowers teams to focus on innovation by providing robust, flexible tools for interactive computing.
README
nteract
nteract is a local-first notebook environment where humans, kernels, and AI agents can work against the same live document. It ships as a native desktop app with instant startup, realtime sync across windows and programmatic clients, and managed local environments.
Linux x64 and macOS (Apple silicon or Intel) can install with one command —
the AppImage or signed .app bundle plus CLI/daemon and the per-user service
(systemd or launchd) in one step:
macOS users can equally drag the DMG from GitHub Releases. DEB/RPM/APT
installs are not currently supported because runtimed is a per-user daemon
managed by the app and CLI, not by system package-manager scripts.
For remote workstations (Outerbounds, JupyterHub) that offer compute to
hosted notebooks, use the headless one-liner — see
Remote workstations:
CLI for managing kernels, notebooks, and the daemon
runtimed (Python)
Python bindings for the daemon (ships with the app)
Runtime model
nteract stores notebook content in an Automerge-backed document and keeps live kernel state in an explicit runtime state document. The daemon owns kernel processes, execution queues, output capture, and the write path for execution results.
Execution requests name a synced cell_id; the daemon reads the cell source from the shared document, records queue and status changes in runtime state, and writes outputs through the same model. The desktop app, CLI, MCP server, and agent clients use that path, so programmatic control observes the same notebook state a human is editing.
MCP Server
The nteract MCP server connects AI assistants to Jupyter notebooks through the daemon. Agents can run code, read and write cells, manage dependencies, and collaborate with humans in real-time — watching the notebook update live in the desktop app while the agent works.
The plugin ships the right nteract-mcp binary for your platform (macOS arm64/x64, Linux x64, Windows x64) — no separate install needed. main of nteract/agent-plugins always points at the latest stable release.
For pre-release builds (updated daily):
/plugin install nightly@nteract
Install in Claude Desktop
If you use the nteract desktop app with Claude Desktop, there's a one-click install path. In the menu bar, choose nteract → Install Extension for Claude...
The desktop app builds a .mcpb bundle at runtime (manifest, icons, nteract-mcp binary) and hands it to Claude Desktop, which prompts you to confirm the install. Requires the nteract desktop app; Claude Desktop picks up the bundle from there.
Usage
# Open a notebook
runt notebook path/to/notebook.ipynb
# MCP server for notebook automation
runt mcp
# Daemon management
runt daemon status
runt daemon logs -f
List open notebooks with kernel and environment info:
Check formatting and linting across Rust, JS/TS, Python
Lint (fix)
cargo xtask lint --fix
Auto-fix formatting and linting
Dev daemon
cargo xtask dev-daemon
Run per-worktree dev daemon
Artifact status
cargo xtask artifacts status
Check generated WASM, renderer, and MCP widget artifacts
Install nightly (Linux/headless)
./scripts/install-nightly
Build + install runtimed + runt + nteract-mcp as the local nightly. Refuses on macOS and when an app bundle is installed.
Release .app
cargo xtask build-app
Testing app bundle locally
Release DMG
cargo xtask build-dmg
Distribution (usually CI)
Generate icons
cargo xtask icons [source.png]
Generate icon variants from source image
cargo xtask dev installs dependencies, ensures generated artifacts, starts the
per-worktree dev daemon, waits for it to be ready, and then launches the notebook
app with hot reload. It stops the daemon it started when the app exits. For repeat
launches, use cargo xtask dev --skip-install --skip-build.
On macOS, every worktree gets a cached app wrapper with a distinct name and bundle
identifier, such as nteract Dev f0f9d9 and
org.nteract.desktop.dev.f0f9d99b161f. This keeps unsigned source builds separate
from installed stable and Nightly apps without changing release packaging or
claiming .ipynb file associations. Use cargo xtask dev status to obtain the
live automation PID. Accessibility scripts should select the System Events process
by that PID instead of asking LaunchServices for an app named nteract:
set devPid to 12345 -- copy Automation PID from `cargo xtask dev status`
tell application "System Events"
tell first application process whose unix id is devPid
-- perform UI automation here
end tell
end tell
Frontend edits continue through Vite hot reload. After changes to Tauri bootstrap
or event-listener setup, use cargo xtask dev --fresh to terminate only this
worktree's exact app process, stop its daemon, and relaunch both cleanly. The
equivalent manual sequence is cargo xtask dev reset followed by
cargo xtask dev.
Build order
The UI must be built before Rust because crates/notebook embeds assets from apps/notebook/dist/ via Tauri.
Common commands
pnpm build # Build notebook UI
cargo test # Run Rust tests
pnpm test:run # Run JS tests
cargo xtask artifacts status # Check generated artifact readiness
cargo xtask artifacts ensure runtime # Rebuild only runtimed-wasm when needed
cargo fmt # Format Rust
vp check --fix # Lint + format JS/TS
cargo clippy --all-targets -- -D warnings # Lint Rust
Library crates
The underlying Rust libraries are published to crates.io:
