KaimonSlate.jl

A reactive Julia notebook for ambitious work. Cells can run across several machines, large live output stays interactive in the browser, an AI agent is available to assist in building the notebook content, and anything can be integrated through ordinary Julia packages.

Documentation · Getting started

Overview

Cells form a dependency graph. When you change a value or move a @bind control, only the cells downstream of it recompute; there is no hidden kernel state and no manual "run all".

The graph is also the execution plan. A cell can run on a different machine, and values move between machines automatically over an encrypted, content-addressed channel, so the work is not bounded by the machine in front of you. Large outputs stream back to the browser fast enough to stay interactive. Extensions are first class: widgets, output types, front-end assets and whole subsystems are ordinary Julia packages.

The rest of this page covers the parts that go beyond a standard notebook.

Run cells on another machine

Tag a cell with a region and it runs on a remote host (a GPU box, a big-memory server, a cloud VM) while the rest of the notebook stays local. Values that cross the boundary transfer automatically over an encrypted, content-addressed channel, so you don't move data by hand. The dependency graph lays out a zone per machine and shows which one ran each cell and how much data moved; warm pools keep workers ready, and a notebook's on-disk cache can move to the remote so results are restored there instead of recomputed.

 

AI agent

The agent edits the notebook by writing cells into the same .jl you edit. Ask it to add a control, draw a plot, or restructure a pipeline, and each change lands as a normal cell. It runs on Claude or a local model, and only when Kaimon is installed.

Interactive output

Output renders inline and updates as you change @bind controls (sliders, toggles, selects, color and date pickers, buttons): CairoMakie figures, interactive ECharts plots, sortable and filterable tables, and animations played back in the browser.

Dependency graph & caching

The DAG pane shows the graph directly: cells colored by state (fresh, stale, running, errored) or by compute time, manual needs= edges for dependencies no variable carries, and which machine each cell last ran on. Expensive cells are memoized to a content-addressed store on disk, so a cached result is restored after a restart instead of recomputed, and identical results are stored once.

 

Publish, present & export

A built-in manager publishes notebooks as a website, with targets for GitHub Pages, Cloudflare Pages, Netlify, S3/R2, and rsync, and can archive a citable version to Zenodo for a DOI. Any notebook is also a slide deck (a full-screen present mode), and exports to a Typst-typeset PDF, a self-contained HTML file, or a single .jl that bundles its full environment and git history for reproduction.

Reproducible environments

Each notebook is pinned to its own Julia project. Add and remove packages from the browser, and the resolved environment travels with the notebook's exports, so a shared notebook rebuilds the same versions elsewhere.

Timeline

Every run is recorded. The timeline steps back through a notebook's earlier states, outputs included.

Install

The slate app is the usual entry point. Requires Julia 1.12+.

KaimonSlate is published through its own package registry. Add that once, then install the app — from
the Pkg REPL (press ]):

pkg> registry add https://github.com/kahliburke/SlateRegistry
pkg> app add KaimonSlate

The registry is public, so no credentials are needed. Adding it is a one-time step per machine; after
that, KaimonSlate and its extension packages install like any other Julia package.

Installing the app writes a slate executable — a shell script, or slate.bat on Windows — into
Julia's app bin directory, ~/.julia/bin. That directory isn't on your PATH by default (app add
prints a reminder), so add it once:

export PATH="$HOME/.julia/bin:$PATH"     # in ~/.zshrc, ~/.bashrc, …

Now run slate at your shell prompt — it's a terminal command, not a Julia function:

slate                 # start or attach to the hub, with a status TUI
slate my_analysis.jl  # open a notebook in the browser (created if missing)

(At the julia> prompt it would just be an undefined variable; shell out with ;slate my_analysis.jl
if you're already in the REPL.)

Slate runs in two ways:

• With Kaimon — per-notebook workers, each pinned to the notebook's Julia project, plus the AI agent's slate.* tools. The first run asks once to register as a Kaimon extension.
• Standalone — slate --own my_analysis.jl runs the hub in-process, no Kaimon required. Cells, widgets, figures, and the timeline work; the AI agent needs Kaimon.

To embed the hub in your own script, add the package as a library and call the serving API:

using KaimonSlate
serve_notebook("notebook.jl"; port = 8765)   # blocks; open http://127.0.0.1:8765

See the installation guide and the architecture overview for details.