Applications and Konjure Kreate

Konjure Kreate is the default workshop application. It is an independent Astro browser application under apps/kreate/, deployed at kreate.alkem.dev. It starts as a local workshop: no account, room or connected device is needed to create, edit and run a scene.

The website remains the canonical home for guides, tutorials, examples, research, devlog and Rust API documentation. Kreate is an application consumer of the Rust SDK and the extracted @konjure/workbench interface. Both deploy from this monorepo; Kreate does not create a second documentation tree.

What Kreate stores

Kreate autosaves projects in the browser’s IndexedDB. Every saved record has a revision; a stale writer caused by another browser window creates a separate copy rather than replacing the newer work. Browser storage is local to that browser. Download project is the portable path. Kreate is installable as a PWA. After its first successful cache, source editing and local runs work offline; pairing needs a reachable live host. Downloaded updates activate after all old Kreate windows close, keeping an open draft or run on its current release.

A Kreate v1 .konjure file is JSON with exactly these source-project fields:

{
  "format": "konjure.kreate",
  "version": 1,
  "title": "Spinning forms",
  "sources": { "main": "..." },
  "active_module": "main"
}

The Rust konjure-kreate core validates the envelope, title, module IDs, selected module and storage limits, then canonicalizes it. It intentionally does not compile the source. Invalid or unfinished DSL drafts therefore remain saveable and reopenable. Kreate can also open a single .kj source file as a new project, and projects support adding and removing source modules.

This format is source only. Reopening a project constructs a new runtime at tick 0. A Kreate .konjure file is not the SDK’s SceneDocument, does not persist a native scene runtime or session history, and is not yet an interchangeable runtime-save format.

Shared boundaries

Kreate’s ten starters import their source directly from checked fixtures in crates/konjure-lang/examples/; the app does not maintain copied TypeScript programs. The shared workbench excludes Kreate’s project persistence, application navigation and deployment concerns so it can remain embedded in learning pages.

Kreate’s Blender import turns an evaluated scene bundle into ordinary editable language sources: main retains the transform, material and hierarchy, while each baked triangle mesh is isolated in a generated geometry_N module. Mesh positions and normals are packed as f32; transforms remain language Number (f64) values. The bounded import rejects complex meshes or generated projects that exceed its source and module limits instead of truncating them.

For a typed scene control, Rust resolves the callback and updates accepted state. The browser projects that state into DOM controls; the RayNeo client projects it through its native stereo adapter. A renderer never reconstructs callback identity from component JSON or a button label.

Local voice and scene assistant

The optional assistant turns text or speech into editable Konjure source. It uses a Rust companion on your Mac and Gemini’s Live API. The hosted workshop does not accept a provider key or expose a shared model account.

From a checkout, install the web dependencies once with npm ci, then run:

npm run kreate:local

The launcher builds the app and starts the companion at http://127.0.0.1:8840/. It reads GEMINI_API_KEY or GOOGLE_API_KEY from the process environment, or loads your private ~/.gemini.env when neither is set. Keep that file outside the checkout. Conflicting key variables are rejected. The key stays in the companion; scene source, prompts and enabled microphone audio are sent to Gemini. Neither companion nor app saves conversation or audio. Project source continues to autosave in that browser’s IndexedDB. The local and hosted origins have separate project libraries; use Download project and Open project to move work between them.

Open Assistant, press Connect, and type a request. Talk enables the microphone after browser permission. Mute mic stops capture while the assistant can finish speaking; Stop interrupts output and disables capture. Stop starts a fresh model conversation using the current scene, retaining local undo. Undo restores the previous source, including an unfinished draft; in that case the canvas keeps its last runnable scene. Press Play to advance animations. The ordinary editor, source files and device pairing remain available alongside the conversation.

The launcher builds with the hosted workshop’s public pairing relay by default; sharing source begins only when you choose Add a device. Connection settings can select your own live host. Provider credentials never travel through pairing.

Every proposed edit carries the project identity and the source revision the model read. The companion compiles and renders it with the native Rust language runtime. The browser validates it again in WASM before replacing the source and scene, then acknowledges that exact revision. Failed compilation and stale proposals leave the draft intact. Local edits clear the assistant’s undo history; a paired scene also passes through the live host’s revision check. A lost connection preserves the project and starts a fresh conversation when reconnected, without replaying earlier prompts or scene effects.

The companion serves only the built app, binds only to loopback, checks the WebSocket origin and protocol, and admits one assistant client at a time. npm run kreate:local -- --skip-build reuses an already-built app. The model defaults to gemini-3.1-flash-live-preview; KREATE_LIVE_MODEL can select another compatible Gemini Live model. Provider connectivity and quota are required for the assistant; ordinary local scene work remains available offline.

The app owns its prompt and proposal ledger under apps/kreate/. The companion lives under apps/konjure-host/src/kreate/; shared audio capture and playback live in packages/web/. This is a separate DSL integration from the retained glasses assistant. Browser voice does not establish glasses microphone routing, physical room anchoring or device validation. Provider message behavior follows the Gemini Live protocol and audio capabilities.

Pairing and targets

Kreate can pair the current work with another browser or Konjure on RayNeo through a reachable live host. Joining a participant creates a new Kreate project, retaining the local project from before the join. Connected clients share accepted source and controls; this does not transfer a standalone runtime’s tick into a room.

Use npm run kreate:live from a source checkout to start the local application at its root path on port 4323 and Rust host on port 8830. The hosted app supplies a public HTTPS/WSS relay automatically. It persists accepted history until the room expires; local host rooms remain in memory. See Live sessions for admission limits and recovery. Pairing does not establish a shared physical coordinate system or room anchoring.

The browser and RayNeo are the initial clients. RayNeo is not a relocated Kreate Android application: it remains the native Konjure client under proto/wgpu-probe, sharing Rust semantics and the live protocol. Native protocol checks and APK builds are separate from physical-device validation; no hardware result follows from the browser build.

Build and deployment

From the repository root:

npm run kreate:build
npm run kreate:dev
npm run kreate:live
npm run kreate:local
npm run verify

kreate:build produces and verifies apps/kreate/dist. kreate:dev starts the independent app after its SDK and Kreate-core assets are prepared. npm run verify builds both the application and website as independent artifacts. Cloudflare Pages deploys apps/kreate/dist as konjure-kreate at kreate.alkem.dev; it deploys web/dist as the documentation website at konjure.alkem.dev. The relay is a separate Worker deployment, managed by npm run relay:deploy.

Another SDK application may use the portable Rust crates and its appropriate platform adapters without inheriting Kreate’s editor or project library. A paired application implements the same live-client protocol; static website hosting alone does not provide the live host.