# \[ANN\] KaimonSlate.jl: a reactive environment for ambitious work
**URL:** https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185
**Category:** Package Announcements
**Tags:** package, hpc, cluster, mesh, notebooks
**Created:** [September 3, 2026, 11:57am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185 "2026-09-03T11:57:36Z")
**Posts on this page:** 20
**Page:** 1
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 3, 2026, 11:57am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/1 "2026-09-03T11:57:37Z")
I’ve been building **[KaimonSlate.jl](https://github.com/kahliburke/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.
[https://dl.dropboxusercontent.com/scl/fi/aysh435ypekdgryj62xih/slate-cesium.mp4?rlkey=xdioo2f98pg75m13bv2p3zhxd&raw=1](https://dl.dropboxusercontent.com/scl/fi/aysh435ypekdgryj62xih/slate-cesium.mp4?rlkey=xdioo2f98pg75m13bv2p3zhxd&raw=1)
## 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.
[https://dl.dropboxusercontent.com/scl/fi/dfk2a4pgrky1q059criyr/slate-cluster-2-modes.mp4?rlkey=gwhtt4kwi1f2i91q6uyv9pgg5&raw=1](https://dl.dropboxusercontent.com/scl/fi/dfk2a4pgrky1q059criyr/slate-cluster-2-modes.mp4?rlkey=gwhtt4kwi1f2i91q6uyv9pgg5&raw=1)
## 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:
```julia-repl
pkg> app add KaimonSlate
```
That writes a `slate` executable into `~/.julia/bin`, which isn’t on your `PATH` by default:
```sh
export PATH="$HOME/.julia/bin:$PATH" # in ~/.zshrc, ~/.bashrc, …
```
```julia-auto
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](https://kahliburke.github.io/KaimonSlate.jl/dev/)
- **Getting started:** [Getting Started | KaimonSlate.jl](https://kahliburke.github.io/KaimonSlate.jl/dev/getting-started)
- **Architecture:** [Architecture | KaimonSlate.jl](https://kahliburke.github.io/KaimonSlate.jl/dev/architecture)
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.
---
### Author:  [@Benny](https://discourse.julialang.org/u/Benny)
#### Post date: [September 3, 2026, 1:12pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/2 "2026-09-03T13:12:19Z")
Couple knee-jerk questions:
- Does the reactive notebook have the same rules as Pluto? For an important example, how does it intend to treat soft scope?
- Does running it standalone / without Kaimon guarantee no AI model is or needs to be involved?
- Does running it standalone sacrifice the ability to run cells across different machines? I interpreted that as a Kaimon feature but I wasn’t certain.
Thanks in advance for the clarifications.
---
### Author:  [@dcelisgarza](https://discourse.julialang.org/u/dcelisgarza)
#### Post date: [September 3, 2026, 2:05pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/3 "2026-09-03T14:05:09Z")
I got a live demo a few weeks back. My jaw was on the floor. I’ll try it out soon.
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 3, 2026, 2:24pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/4 "2026-09-03T14:24:23Z")
> [@Benny](#):
>
> - Does the reactive notebook have the same rules as Pluto? For an important example, how does it intend to treat soft scope?
No, it’s not like Pluto. There is an ordering to cells, and cells are not confined to a single expression, for example. There are several reactive constructs, I’d recommend you look at some of the docs here, and try it for yourself. For example the topics [Reactive Cells | KaimonSlate.jl](https://kahliburke.github.io/KaimonSlate.jl/dev/reactivity), [The Dependency Graph | KaimonSlate.jl](https://kahliburke.github.io/KaimonSlate.jl/dev/dag), and here [Live updates | KaimonSlate.jl](https://kahliburke.github.io/KaimonSlate.jl/dev/live-updates).
> [@Benny](#):
>
> - Does running it standalone / without Kaimon guarantee no AI model is or needs to be involved?
I’d recommend using it _with_ Kaimon regardless of whether you want to use AI with it. Kaimon is doing more than connectivity with models in this case. If you never fire up an agent, it won’t be used. Also, if you had interest in running only a local model, that would be an option as well.
> [@Benny](#):
>
> - Does running it standalone sacrifice the ability to run cells across different machines? I interpreted that as a Kaimon feature but I wasn’t certain.
You know, I wasn’t sure because I’d never tried. But I thought it should probably work! I tested it and there were a couple bugs preventing it but they’re fixed now and I’ll push out 1.4.7 within the next few hours with that support. In the standalone app mode, the core Kaimon functionality which enables this is included.
The notebook in the editor, showing the remote cell and the DAG:
The standalone app running, with the same remote machine running the worker for that remote cell.
I’d be curious about what sort of use cases you might be thinking about for that? Please give it a try if you’re able and get back to me with your feedback.
---
### Author:  [@fgerick](https://discourse.julialang.org/u/fgerick)
#### Post date: [September 3, 2026, 9:25pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/5 "2026-09-03T21:25:44Z")
Thank you for introducing this to the community! It’s quite impressive 🙂 I do a lot of bad programming and trying out and testing things that need to run on machines more powerful than my laptop, so an easy interface to run things between machines is really something that could save a lot of time and trouble.
Currently I’m mostly using vs code remote evaluating code just in a normal .jl file. I think there’s room for improvement! That said, one thing I like about using vs code in that way: vim bindings! I just got too used to that, so that e.g. Pluto was also always a bit annoying as soon as the notebook got a little bit more complicated. Do you plan to add an extension or just native support for that?
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 3, 2026, 10:02pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/6 "2026-09-03T22:02:52Z")
> [@fgerick](#):
>
> vim bindings
It’s something I can take a look at, the editor is flexible and it’s likely not too much of a lift to support customization in there or custom keybindings for the general notebook UI.
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 4, 2026, 11:44am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/7 "2026-09-04T11:44:57Z")
> [@fgerick](#):
>
> vim bindings!
Yes!
Might need a little more refinement but I’ll get it into a release soon, it’s an editor preference you can set:
Update – It’s available in 1.4.8 which just dropped.
---
### Author:  [@disberd](https://discourse.julialang.org/u/disberd)
#### Post date: [September 4, 2026, 1:45pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/8 "2026-09-04T13:45:13Z")
Congratulation on the release @kahliburke!
I have been involved a bit with @kahliburke in the past 1-2 months and had some very nice exchanges on KaimonSlate so it’s nice to see this finally announced. I am actually working on a visualization package that aims to have KaimonSlate as one of it’s official backends.
I have to say that @kahliburke is doing an amazing job with this package and the amount of feedback he takes in and implement in a matter of days if not hours is impressive. I honestly think that this package could really become a big driving force for julia. I have been pretty involved in the past with Pluto also contributing to it and really think KaimonSlate can become the better Pluto for power users!
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 5, 2026, 7:25am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/9 "2026-09-05T07:25:13Z")
I didn’t want any Emacs enjoyers in the community to feel left out (you know how those Emacs people can be sometimes 😉 ) … so 1.4.9 is being packaged up by the TagBot and registry robots right now:
---
### Author:  [@scelles](https://discourse.julialang.org/u/scelles)
#### Post date: [September 5, 2026, 9:06am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/10 "2026-09-05T09:06:59Z")
I just want to say a personal thank you, @kahliburke.
Beyond the amazing developer you are, I really appreciate the person you are. You have this rare ability to listen to people, to really understand what they need and where they are coming from, and then turn that into something useful and beautiful.
I particularly enjoyed the work you did on [GiacSlate](https://github.com/kahliburke/GiacSlate.jl) to integrate Giac.jl and [Mathfield](https://mathlive.io/mathfield/) input into KaimonSlate notebooks. It was not only the quality of the technical work that impressed me, but also the way you approached it, with curiosity, care, and a genuine willingness to help.
And more generally, I’m just really happy to have met you through the Julia community. People like you are one of the reasons why this community is such a special place. And I especially appreciate the way you keep moving forward with your ideas, even when they put you in the middle of some rather passionate debates about AI. 😊
Thank you for being who you are, Kahli, and for bringing KaimonSlate.jl to the Julia community. ❤
---
### Author:  [@mahmah](https://discourse.julialang.org/u/mahmah)
#### Post date: [September 5, 2026, 9:10am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/11 "2026-09-05T09:10:26Z")
I second this!
---
### Author:  [@WuSiren](https://discourse.julialang.org/u/WuSiren)
#### Post date: [September 5, 2026, 10:24am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/12 "2026-09-05T10:24:53Z")
How far is @kahliburke from the Julia Community Prize of this year?
---
### Author:  [@fgerick](https://discourse.julialang.org/u/fgerick)
#### Post date: [September 5, 2026, 2:16pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/13 "2026-09-05T14:16:02Z")
The `vim` bindings are working well as far as I can tell for now! Amazing how quickly this became available 🙂
Playing around I saw that `InteractiveUtils` is not loaded by default into a notebook. Is there a specific reason for that? It seems quite natural to me to have access to it in a notebook.
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 5, 2026, 5:45pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/14 "2026-09-05T17:45:10Z")
Great to hear that you’re having success with the Vim bindings, please let me know if you run into any issues.
> [@fgerick](#):
>
> Playing around I saw that `InteractiveUtils` is not loaded by default into a notebook. Is there a specific reason for that?
No specific reason other than the default is simply to inherit the dependencies of the project, and nothing is automatically imported other than Slate’s base functionality. However, it’s very easy to use `InteractiveUtils`, as far as I can tell. Is there any issue you’re hitting with it?
---
### Author:  [@Maucejo](https://discourse.julialang.org/u/Maucejo)
#### Post date: [September 5, 2026, 7:39pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/15 "2026-09-05T19:39:00Z")
Hi @kahliburke. Thank you for your amazing work.
In Pluto, I am used to deactivate the package manager to use my own local environment. Is it possible with KaimonSlate? I tried to `using` a package belonging to my Base environment, but KaimonSlate asked me to install the package (I believe, after reading the doc, that it is the expected behavior).
Thank you
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 6, 2026, 9:45am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/16 "2026-09-06T09:45:14Z")
Slate’s package system for notebooks is generally centered around placing notebooks in projects where they inherit the project dependencies and then can add on top. Pointing them at an environment isn’t supported yet, but it could be added in an upcoming release.
Today, there is a method you can use which is pretty easy IMO. Create a directory for your notebooks which you want to use this environment as the base dependency set for. Create symlinks to the environment’s `Project.toml` and `Manifest.toml` files from the environment to your notebook directory. At that point, the directory looks just like a project, and you should see any deps automatically used by the notebooks.
```julia-auto
mkdir vialink && cd vialink
ln -s ~/.julia/environments/slate_env_demo/Project.toml Project.toml
ln -s ~/.julia/environments/slate_env_demo/Manifest.toml Manifest.toml
```
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 7, 2026, 12:12pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/17 "2026-09-07T12:12:44Z")
I’ve posted some updates on the in progress HPC cluster support in Slate over here:
> [@\[ANN\] Kaimon.jl — opening the gate between AI agents and Julia](https://discourse.julialang.org/t/ann-kaimon-jl-opening-the-gate-between-ai-agents-and-julia/135880/123):
>
> I’ve now pushed cluster support for SLURM and PBS to the feature branch at [GitHub - kahliburke/KaimonSlate.jl at feat/hpc-cluster · GitHub](https://github.com/kahliburke/KaimonSlate.jl/tree/feat/hpc-cluster). This needs some more testing from some brave lab ra^H^H^H^H^H^H beta testers so please get in touch if you match that description. I don’t have access to a real cluster at the moment so I’ve been running my tests against a docker environment running the real SLURM and PBS schedulers, but obviously in a much more constrained setting. I’m sure there will be a…
---
### Author:  [@VictorSeven](https://discourse.julialang.org/u/VictorSeven)
#### Post date: [September 8, 2026, 1:29pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/18 "2026-09-08T13:29:41Z")
Hi @kahliburke, thanks for the project. Didn’t know about it and downloaded it today, I’ve been playing around the full day. I’ve always wanted a Julia-specific editor combining the best of notebooks and file editing. This could be the one 🙂
I found however some problems, but apparently issue creation in GitHub is restricted… Hope you don’t mind if I mention them here (maybe also other fellow users can help me?)
- It seems like I cannot run `include`? For a lot of the code I work on I do not create full packages, I just have some functions for numerical integrations so I (ab)use `include`. I tried encapsulating everything in a module to import it via `using`. My base folder has a `Project.toml`, but the notebook always remains detached (it does not detect the project), and I cannot do anything.
- Related to that, I can do `using Pkg; Pkg.activate("globalenv", shared=true)` to get my global environments, and I correctly see the installed packages in the corresponding menu. But if I try `using CairoMakie` or whatever other thing I have installed, it complains it is not in the “notebook environment”. Is it that I did not understand that philosophy of the software?
- I am also a huge fan of those vim bindings, but they seem to clash with the notebook shortcuts. In particular, right now it is not possible to do Ctrl+V for the visual selection and doing :w does not save files.
Finally, I wonder if there are any plans to allow the file editor to have its own space, so one can work in tabs, split screen or something. As much as I love notebooks, I really like to have the core of the analysis code in normal jl files, and having a full screen for them would be great.
But in any case, I plan to continue using this as much as possible, I really like how it looks so far 😃
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 8, 2026, 1:32pm UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/19 "2026-09-08T13:32:14Z")
> [@VictorSeven](#):
>
> I found however some problems, but apparently issue creation in GitHub is restricted… Hope you don’t mind if I mention them here (maybe also other fellow users can help me?)
Thanks for taking a look, I can try to connect with you to answer some of these questions. I don’t understand your problems posting GH issues, others have done so and they should be open.
Once we figure out some answers, I can return and post a more condensed form here.
---
### Author:  [@kahliburke](https://discourse.julialang.org/u/kahliburke)
#### Post date: [September 13, 2026, 12:44am UTC](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185/20 "2026-09-13T00:44:03Z")
We were able to get things working, a bug in running Slate in standalone mode (without Kaimon installed) was a block we worked around. That’s been fixed now, and there’s more support for a streamlined Slate installation that maintains feature parity with the two piece installation path.
[Next page](https://discourse.julialang.org/t/ann-kaimonslate-jl-a-reactive-environment-for-ambitious-work/139185.md?page=2)