Implementation status

Evaluate Kosuno with its boundaries in view

A dated view of implemented systems, validation evidence and remaining delivery work. Use it to scope a technical evaluation.

Implementation review · October 21, 2026

Start with a representative project.

Evaluate the architecture against your own gameplay rules, content scale, tooling requirements and target hardware. The pages here describe implementation reviewed on October 21, 2026; they are not a platform certification or a support commitment.

Build and author

Open a scene, edit a prefab, extend a component and exercise the native or scripting workflow you expect to use.

Measure and reproduce

Profile your workload on target devices. Record a scenario, reproduce a failure and inspect the state involved.

Export and recover

Build your actual composition. Exercise persistence, lifecycle events and any content or authority recovery your game requires.

Platform status

Current target scope
Target	Present scope	Evaluation boundary
Desktop	Native player and editor compositions	Windows, macOS and Linux targets exist. Export support depends on the host; Linux cross-builds use a pinned Zig toolchain. macOS export is currently an unsigned executable folder.
Web	WebAssembly / WebGPU player	Composed web players exist. Browser and adapter limits matter, particularly for the optional voxel backend. A public browser demo is not currently linked.
Android	APK builds and device checks	The shared player runs on Android, with documented Vulkan device profiling and automation checks. These measurements do not certify every device or export workflow.
iOS	Simulator workflow; delivery incomplete	The iOS host and package builds exist. Device export, signing and real-device acceptance remain required work.

Tool availability in Build Settings checks prerequisites. A green status does not establish that a complete export or device run passes. Shared runtime code still requires platform-specific acceptance.

Implemented foundations and remaining work

SDK iteration: Rust game-package reload and rust-analyzer integration exist. Hot reload requires the dynamic SDK editor and a matching pinned compiler.
Recording & testing: Player/session and editor Play recordings, identity checks, replay, observations, scenarios and failure bundles exist. Exact replay has same-build/platform and state-coverage limits.
Execution checkpoints: Restore-and-continue tests include physics, scripts, animation, navigation and vector transitions. Coverage also includes streamed-out entities, runtime render textures and material parameters. Mid-recording replay from a supplied checkpoint exists; broad state coverage and rolling checkpoint windows remain incomplete. Unsupported state is refused by name.
MCP & agent workflows: Structured observations, semantic actions, undoable editor edits, package-defined methods and multi-target hub selection exist. Tool availability depends on host and mode. Logic-only sessions cannot produce rendered captures.
Browser session sharing: Native offscreen games stream over WebRTC, with separate view/control links and up to four viewers. Recorded sessions support pause, forward skip, restart and taking control to continue live. Current scope is local/LAN development; audio, internet infrastructure, arbitrary backward seeking and automatic fork recording remain unfinished.
Content releases: Checked cooked formats and local native content releases exist. Content-only changes are restricted. Remote delivery, publication and universal consumer migration remain planned.
World streaming & storage: Scene-owned entity streaming follows explicit sources on player and headless hosts. Voxel reads/decode use the content executor; native caches support edited-chunk spill. The voxel window retains one view center. Web persistent backends and remote delivery remain planned.
UI & localization: Vector inputs bind to state, shared atlas pages batch widgets, and scroll views support drag, flick, wheel and snapping. Keyed text, ICU plurals and locale preferences exist. RTL, translator exchange, per-locale content loading and complete vector-text checkpoint identity remain unfinished.
Authority: Headless authority, prediction/reconciliation, PostgreSQL storage and WebSocket adapters exist. Production accounts, scene integration, multi-server routing and realtime replication remain incomplete.

Licensing, source access and support

Commercial licensing, source-access arrangements, support terms and long-term maintenance policies are not currently published on this site. These terms need to be established directly with the project owner for a production evaluation.

The SDK design distributes prebuilt engine libraries and API stubs without engine implementation sources. The technical documentation describes that distribution model; it does not define commercial terms.

Build from a checkout

Follow the repository setup guide for prerequisites. The checkout workflow currently specifies stable Rust 1.95 or newer. Build from the repository root; use run-editor.cmd on Windows.

cargo build --locked -p kosuno_editor -p xtask
./run-editor.sh

Native SDK package reload is a separate workflow from this statically linked checkout launch. Use the SDK instructions when evaluating native iteration.