Live sessions

Run one Konjure program on your desktop, another browser, and RayNeo. Each client executes the accepted commands in Rust and renders its own view.

Konjure Kreate works on its own. Add a device extends your work to other browsers or glasses; pairing is optional. The hosted workshop includes a public HTTPS/WSS relay; no server setup is needed.

Start a local workshop

From the repository root:

npm run dev:live

The command builds the Rust/WASM artifacts, starts the Rust live host on loopback port 8830, and serves Kreate at its root path on port 4323. Open the printed LAN address on each device. Use -- --advertise-host 192.168.1.20 if your Mac has multiple network interfaces and the automatically selected address is unreachable. Stop an existing website server before starting this command.

Pair a scene

1. Open Kreate and select Add a device → Show pairing code.
2. On the glasses, open Menu → Connect live and point the camera at the code. Select Make QR larger in Kreate if needed.
3. The glasses outline the detected QR in their camera preview. For local HTTP, confirm Join local room with a temple tap. Manual entry is available with the Kreate address and code as a fallback.
4. The joining device receives the source and current run. On the host, select Play, Step, or edit the source and select Run.

For another browser, select Copy link and open that link on the other device. It opens directly to Join session, showing the live host before you join. You can also open Add a device → Join a session and paste a full invitation link or enter its ten-character code. A full link includes its host; a code alone uses Kreate or the Live host in Connection settings.

The toolbar shows This device during standalone work and a device count once another device joins. Devices opens the list; runtime and renderer details remain in Debug. An expired invitation cannot admit another device, but devices already connected can keep working.

The relay owns the accepted source and event order. Paired browsers can edit code; both browsers and RayNeo can use scene buttons and sliders. The owner controls playback. Concurrent source edits are checked against the revision they started from; a conflict keeps your draft and the accepted run. Use live code replaces your draft with the accepted room source when you want to reconcile it. Selecting geometry and moving the camera remain local to each viewer. Show pairing code begins a fresh run of the currently compiled source; unsent editor changes stay local until Run succeeds.

Leave session keeps the last accepted scene locally. End for everyone closes the room for everyone. When the host disconnects, playback pauses. A temporary connection loss retries with the same room credential and restores the accepted history; inputs whose outcome is uncertain are never automatically repeated. Reloading the page requires joining again. The public relay retains accepted history across restarts until the room expires. The local Rust host keeps rooms in memory, so they disappear when its process stops.

Join on RayNeo

Build and install the current Android application using the device guide. Connect live is the first menu item. Menu navigation wraps at either end. The scanner and local-HTTP confirmation render separately in each eye; swipe to select, tap to confirm, or press Back to cancel. The preview uses the existing upright camera stream. Its QR outline marks image coordinates, not a calibrated location in the room.

The glasses show a compact connected-peer indicator. The desktop shows a device count beside Devices; expand it for device names or open Debug for runtime and renderer progress.

If scanning is unavailable, select Manual entry, enter the Kreate address and pairing code with a connected keyboard, then select Join. The form uses the same stereo semantic UI adapter as scene controls; it does not open an Android dialog. For a local HTTP Kreate instance, confirm Join local room in the stereo form. That mode is intended for a trusted development network; it does not encrypt source or room credentials.

For a USB development connection, forward the local Kreate port:

adb -s "$KONJURE_DEVICE_SERIAL" reverse tcp:4323 tcp:4323

Then use http://127.0.0.1:4323 in the glasses’ manual connection form. The native app uses the same Rust language runtime; it does not require a WebXR browser. Joining opens the scene view with a fixed viewer position facing the scene origin. Stereo rendering remains untracked until a validated tracking adapter supplies the room transform.

The View tab shows the program’s buttons and sliders. Swipe to select a control; tap a slider to adjust it, then tap again or press Back to finish adjusting. Back from scene controls returns to Menu. Code shows the accepted live source and supplied modules. Code editing currently happens in connected browsers; the glasses’ Code tab is a viewer.

What travels between devices

Paired editors ─ source revisions ──┐
                                  ▼
Scene controls ── typed input ── Rust live host
                                  │
                       accepted ordered commands
                          ┌───────┴────────┐
                          ▼                ▼
                     Browser WASM     RayNeo Rust
                     local view       stereo view

The host validates each command before broadcasting its sequence number. Clients reject missing or repeated sequences. A rejected program keeps the accepted run. Meshes, physics, lifecycle callbacks, source metadata and inspector values come from the Rust SDK. Replay uses the standard runtime without external host effects; this protocol does not replay camera capture, model calls or tool actions.

The WebSocket connection carries traffic in both directions. It mirrors accepted program execution; each device renders locally. Pairing grants scene interaction and source-edit access to that room. See Architecture for the authority, UI and hardware boundaries.

Peer acknowledgments report progress. Browser scene views acknowledge after a render submission; console examples acknowledge execution. RayNeo acknowledges after both eye views have been submitted. The toolbar shows the connected-device count, and the workbench Debug tab lists each device’s latest acknowledged sequence, runtime tick, render rate, and runtime status. A device that has not sent telemetry is shown as No runtime/render report. These are bounded, client-reported runtime and render observations; they do not expose a remote debugger, change commands, or prove optical alignment or room anchoring.

Limits and hosting

Pairing codes accept up to eight joins and expire after ten minutes. Credentials are scoped to one room and expire after two hours. Reused request IDs are rejected without executing them again. Room credentials stay in the client’s memory; reloading requires a new join.

The public relay uses Rust/WASM to validate commands and SQLite Durable Objects to persist accepted events and credentials. It supports four simultaneous rooms, 16 connections per room and 100 room creations per day. Each room has a 4 MiB retained event budget and 16,384 explicit requests. Source revisions retain the SDK’s 1 MiB source and 216,000 simulation-tick limits. Run the source again to begin a fresh history; start a new room if its request budget is exhausted. Ending or expiring a room removes its credentials and retained events.

The local Rust host supports 16 rooms and a 16 MiB journal per room. It is available through npm run kreate:live; npm run dev:live -- --app site serves the documentation website with the same development proxy. An independent HTTPS/WSS host can be supplied under Connection settings. Configure its exact browser origins with --allow-origin when using the Rust service.

Kreate and the relay deploy separately. The managed Kreate build supplies PUBLIC_KONJURE_LIVE_URL; the relay’s source lives in apps/live-relay. The current hosted service runs within an existing free account with admission limits. If capacity or provider quota is exhausted, it reports an error; standalone editing and saved projects remain available.

WebXR entry is available when the viewing browser reports a supported mode. HTTP on a LAN supports ordinary 3D pairing, but immersive WebXR generally needs a secure origin. Pairing does not synchronize physical coordinate systems or create a shared room map. See Browser and WebXR.