Run aimax in naklios.dev

Before you start

• aimax built and runnable (--headless mode — it's already in your tui/src/main.rs).
• Node 18+ (for the bridge).
• Nothing to download ahead of time — step 2 fetches the bridge in one command.

1. 1

   Start aimax, headless

   Runs the daemon with just the IPC server, no TUI. It listens on a unix socket.

   aimax --headless
   # → IPC listening on ~/.aimax/sock

2. 2

   Fetch & run the bridge

   One command grabs a single self-contained file and runs it. It exposes your unix socket as a WebSocket the browser can reach, over TLS with a real cert for local.naklios.dev. (Open the file first if you'd rather read it before running.)

   curl -fsSL https://bridge.naklios.dev -o nakli-bridge.mjs && node nakli-bridge.mjs
   # → nakli-local-bridge: wss://localhost:9130  ↔  ~/.aimax/sock  (TLS)

3. 3

   Open the renderer & connect

   In Chrome, open the renderer and click Connect. The endpoint is pre-filled with wss://local.naklios.dev:9130 — which resolves to your own 127.0.0.1.

   open https://naklios.dev/prototypes/aimax-renderer/aimax
   # then click Connect

4. 4

   Allow the local-network prompt

   Chrome asks permission for a public page to reach your machine. Click Allow — once.

   Expected — not a bug

   On the first connect, the status sits on “connecting…” and looks stuck. That's Chrome waiting on the “naklios.dev wants to access devices on your local network” prompt. Click Allow and it connects instantly. It's one-time, per browser.

What you get

Your live buffers as tabs, rendered natively (not a terminal in a tab). Click a tab to switch buffers. Type in the buffer and edits go to your daemon as (buffer-insert …). M-x runs your real eval — any Scheme, e.g. (buffer-names) or (buffer-switch "main.rs"). Nothing is edited in the browser; the daemon owns every buffer.

If it doesn't connect

How it works

The renderer speaks aimax's own protocol — JSON-RPC 2.0 over your IPC socket (eval / get_state / subscribe + event notifications). It subscribes, pulls get_state for the buffer list and cursor, and eval (buffer-text) for content, re-pulling on each event. No invented wire.

The only trick is reaching a local daemon from a public https page. local.naklios.dev is a public DNS record that points at 127.0.0.1 — so on your machine it's your own loopback — and it has a real Let's Encrypt cert, so your browser trusts wss://local.naklios.dev with no cert install. The bridge just shims your unix socket to that wss endpoint.

Where v0 stops

Honest limits, in case you want to close them from the daemon side:

• It renders the current buffer + a tab per buffer. get_state gives buffer metadata + cursor but not window layout or buffer text (text comes via eval). Expose windows/text in get_state and the renderer can draw your splits natively.
• Structured flavor only. There's also a raw-VT renderer (xterm) if you'd rather stream the TUI — but structured is what makes it feel native in naklios.