I’ve been building KaimonSlate.jl, a reactive computing environment for Julia, for a while now. It’s fully available in General, and I’d like to take a quick tour of it here.
Julia got rid of the two-language problem. Slate is aimed at what’s left: the two-tool problem, where you explore in a notebook, rewrite it as a package, rewrite it again for the cluster, and rewrite it once more for whoever has to read it.
In Slate that’s one continuous piece of work. Explore, tinker, measure, see everything as it happens, iterate with advanced AI models as fast as you can think. Then refine, expand, test, test bigger, scale up, and share what you’ve made.
You can enter anywhere. Learn an unfamiliar package by taking it apart in a live document. Teach from one. Rebuild a result from a paper whose authors are long gone and let a room full of people turn the knobs. Build an instrument you can play in the browser. Make something beautiful for no reason at all.
Slate is a large surface to cover in an announcement thread, but here are some highlights.
Reactivity, without the hidden state
A Slate notebook stays in sync with the source describes. This avoids the errors Jupyter notebooks often exhibit, where you make changes, reorder cells, and downstream cells don’t work, but you don’t realize it.
Output renders inline and updates live: CairoMakie figures, interactive ECharts plots, sortable and filterable tables, animations played back in the browser. Sliders, toggles, selects, color and date pickers, buttons, range sliders, file upload.
An AI agent to partner with your research and development
Slate was designed with an agent in the room. It works alongside you, can access the notebook state, add/edit/delete/view/introspect/diagnose. This philosophy carries throughout all Slate features, equal accessibility for humans and agents.
AI integration is a very powerful feature, but it’s not mandatory. If your workflow is all about hand crafted code, Slate works just as well and includes a very functional editing system using CodeMirror, an integrated help system with lexical and semantic search that outperforms other systems, and smart autocompletion. You can open and edit other files in your project as well.
The agent pane currently runs Claude Code, or a local model through Ollama or vMLX on Apple Silicon. More options coming soon.
Past the pane, Slate’s full tool surface is exposed over MCP. Any compliant agent can drive a
notebook with everything the built-in one has, with the conversation living wherever that agent
lives.
Semantic search over your packages’ documentation runs on local embeddings, so the index never leaves the machine either. Point OLLAMA_HOST or VMLX_HOST at your own hardware and none of it has to leave your network.
Your package and your notebook, the same project
The notebook may be created in isolation, or placed within a Julia project, and that project can be the package you’re writing. Edit src/model.jl in the built-in editor, save, and the cells that depend on what you changed recompute. Using Slate to exercise new code as you create it, and to build examples for others to see, is simple.
Build the library and the document that exercises it in the same place, with nothing in between.
Slate’s built in documentation system indexes your project automatically, providing lexical and semantic search, autocomplete, and a docs browser that’s really usable.
Turn a pile of machines into a mesh
Tag a cell with a region and it runs somewhere else. A GPU box, a big-memory server, a cloud VM you spun up an hour ago.
The only requirement is that you can SSH to it with key auth. Julia doesn’t even need to be installed. Slate will fully provision all the requirements: Julia, packages, and manage the worker process on the remote.
Data crossing a machine boundary moves itself, encrypted, smartly. If simply recomputing values is cheaper than sending it, Slate will discover this and choose that option. Slate automatically determines whether mesh resources can communicate with one another directly, or to use your system as a hub to facilitate transfer.
Workers report health back to the hub, locally and across the mesh, and you can view realtime system metrics and telemetry for them.
See everything, remember everything
The DAG pane colors cells by state or by compute time. Expensive results are cached to disk and restored after a restart instead of recomputed.
Every run is recorded. The timeline steps back through earlier states with their outputs. The store is append-only, and undo and restore are entries in it.
Undo lives with the notebook, not the browser page. Close the tab, come back tomorrow, hit ⌘Z, all the way back to the first edit you made.
Real-time, to the browser
Over 1 GB/s sustained into the front end. Sub-millisecond p95 latency at upwards of 2000 frames per second, low jitter.
I’ve built a fully playable modular synthesizer running on this, with all the audio generated in Julia. (That deserves its own thread)
Markdown, media and web cells
Drop an image, video or audio file into a markdown cell and it embeds. It can be exported in many ways, and even inlined into standalone documents.
Web cells are a first-class cell kind alongside code and markdown: HTML, CSS and JS panes, live {{ }} interpolation of notebook values, a two-way bridge back into Julia. Whatever you build there survives export.
Slides, PDF, and exporting your project
Every notebook is already a slide deck. You can present in full screen mode, with an optional speaker track and timer window. Automatic slide boundaries from Markdown, or customize. Multi column modes are supported in slides, HTML, and PDF.
Or export to a Typst-typeset PDF with real citations and a bibliography, a self-contained HTML file, or a single .jl that carries the environment, the module code and the git repository with it. Someone downloads that one file, gets your whole project, and can collaborate using version control.
Publishing and app mode
Define targets, group notebooks into sites, sync with one click. GitHub Pages, Cloudflare Pages, Netlify, S3/R2, rsync to your own box. Archive a version to Zenodo for a DOI.
App mode exports a notebook as a read-only dashboard or demo, in the spirit of Streamlit, except it’s the notebook you already wrote. You get a standalone package you can deploy, with interactivity.
Integrate with anything
Widgets, output types, editor extensions, front-end assets, language support, whole subsystems. All can be brought into Slate through extension packages written in Julia, building on SlateExtensionsBase, a lightweight interface package with no dependencies. Once built, Slate supports a built-in catalog/registry and you may browse and install them from inside the notebook.
Coming very soon – HPC cluster support
Building on the foundation of Slate’s mesh computing system, full support for integration with clusters for both interactive and non-interactive batch submission supporting SLURM, PBS, and Kubernetes is currently underway.
This will allow creation of local notebooks which run cells on compute nodes, handle the details of SSH and 2FA for you, allow scheduling of batch jobs which run on the cluster with your defined parameters for partition, wall time, etc.. Cells may be designated as running on cluster worker regions, which will start a new interactive cluster session for you and execute the code locally. Any local cells which need the results can access them transparently.
The notebook can be disconnected from a batch job and reconnected any time, the current progress will be shown, partial results may be used in the notebook. I’m building this to be robust for jobs which take days of compute and write TBs of data. Slate supports an efficient data transfer system which allows looking at slices of the data without attempting to transfer the entire structure.
Currently this supports Arrays, NamedTuples, Vector{NamedTuple}, Arrow, and DataFrames. Support for other formats like HDF5, NCDatasets, and more will be arriving soon. Here is a sneak peak of submitting a non-interactive batch to a SLURM cluster. The computation is completed quickly for demonstration purposes, but these units could be long running jobs, which you can monitor as they complete.
Here is an example against a cluster requiring 2FA through a login node in order to access compute nodes, with batch jobs as well as cells running on remote compute nodes. The outputs from both of those processes are combined transparently on the local notebook worker.
A note on security
Slate runs your code, and the agent’s, with your privileges. The editing hub binds 127.0.0.1 by default, and there is no authentication at any bind address, so who can reach the port is the whole access-control story. App mode is the deliberate exception: it binds 0.0.0.0, because serving it to other people is what app mode is for. Narrow it with --host when that isn’t what you want.
Notebooks from untrusted sources are not sandboxed. Treat Slate the way you treat a REPL: your own machines, your own networks, code you’re willing to run. Authentication and authorization are coming, most likely on an OAuth model.
Getting started
Requires Julia 1.12+. Kaimon, KaimonSlate, and the extension package SlateExtensionsBase are all in the General registry.
It’s recommended (though not required) that you first install Kaimon.jl and then install Slate:
pkg> app add KaimonSlate
That writes a slate executable into ~/.julia/bin, which isn’t on your PATH by default:
export PATH="$HOME/.julia/bin:$PATH" # in ~/.zshrc, ~/.bashrc, …
slate # start or attach to the hub, with a status TUI
The first time you run, if you are using Kaimon, you’ll be asked whether to install Slate as a Kaimon extension. This is the recommended path, but it is optional and you can run Slate standalone if desired.
- Docs: KaimonSlate.jl
- Getting started: Getting Started | KaimonSlate.jl
- Architecture: Architecture | KaimonSlate.jl
Questions, bug reports and ideas all welcome. Slate is still a new platform, and given the scope it covers, there are still edge cases to run into, and bugs. Report them to GH or reach me directly and I’ll work on resolving them and making sure Slate works for you. If there is a use case that Slate doesn’t quite handle the way you’d want, let me know and it’s quite likely that it’s something I’ll want to add, I’m releasing new versions frequently.
