KaimonSlate.jlReactive Julia notebooks, without a ceiling

A reactive notebook built for ambitious work — distributed compute across a mesh of machines, agentic AI from day one, high-throughput low-latency output in the browser, an extension system that integrates anything, and beautiful rendering, publishing, and standalone exports.

Get Started

The AI Agent

GitHub

Reactive by construction

Cells form a dependency DAG. Change a value and every downstream cell restales and recomputes automatically — no manual "run all", no stale state hiding in the kernel.

Compute across machines

Tag a cell with a region and it runs on a GPU box, a big-memory server, or a cloud VM while the rest of the notebook stays local. Values cross the boundary automatically over an encrypted, content-addressed channel, and the DAG shows which machine ran what.

Real @bind widgets

Widgets are ordinary Julia constructors — Slider(1:hi), Toggle, Select, ColorPicker, … — so their arguments can be dynamic. Bind a control in one cell, read it in others, and watch them re-render live.

An AI agent that builds cells

A chat pane drives the notebook through the same tools you do — adding, editing, and running cells one at a time. Scope a turn to a single cell with ✨, reference cells by @id, and pick Sonnet, Opus, Haiku, or a local Ollama model.

Interactive figures

ECharts for interactive, in-browser charts that animate on reactive updates; CairoMakie for static scientific figures. Both flow through one image interface — so the agent can see your plots, and exports embed them.

A built-in timeline

Every edit is captured to a durable, content-addressed history. Scrub the rail, diff any checkpoint, restore non-destructively, or ▶ replay the whole buildup of the notebook.

Extend anything

Widgets, output types, front-end assets, and whole subsystems arrive as ordinary Julia packages built on a lean SDK. Integrate a plotting stack, a solver, a device, or your own UI without forking the notebook.

Publish to the web

Turn notebooks into a site or blog — each lands at its own URL behind a generated front page. One build deploys to GitHub Pages, Cloudflare, Netlify, S3, or your own server, or export a self-contained HTML document to hand to a collaborator. Archive a citable DOI to Zenodo at milestones.

KaimonSlate.jl

KaimonSlate is a reactive notebook for Julia, built for ambitious work. Every cell's output always reflects its current inputs: cells declare what they read and write, KaimonSlate builds a dependency graph, and exactly the cells affected by a change recompute, so nothing silently goes stale.

The graph is also the execution plan. A cell can run on a different machine, and values move between machines over an encrypted, content-addressed channel. Expensive results are memoized to disk. Large outputs stream back to the browser fast enough to stay interactive. An AI agent is available to assist in building the notebook content. Extensions are first class: widgets, output types, front-end assets and whole subsystems are ordinary Julia packages.

It is built as a Kaimon extension: cells evaluate in a per-notebook gate worker, and the browser stays in sync over a live channel.

Quick start

Install Kaimon — the recommended runtime, which gives each notebook its own worker and powers the AI agent — then install the slate app from the Pkg REPL:

julia

pkg> app add KaimonSlate      # installs the `slate` launcher

See Installation for the full steps.

That installs a slate executable in Julia's app bin (~/.julia/bin, or slate.bat on Windows); add that directory to your PATH and run it from your shell, not from the Julia REPL:

export PATH="$HOME/.julia/bin:$PATH"     # once, in your shell profile

slate my_analysis.jl          # start the hub, open the notebook, show a status TUI

On first run slate offers to register as a Kaimon extension (so the agent gets the slate.* tools). No Kaimon? slate --own runs standalone. See Installation and Getting Started.