Native game engine & editor · built in Rust
KosunoOne editor. Any kind of game.
A native game engine and editor. Start with scenes, physics, scripting and UI, then add what your game needs: destructible voxel worlds, visual novels, vector UI, procedural meshes. Ship to desktop, web and Android.
Play runs the authored scene in place. Stop restores the document exactly as it was, so runtime changes never leak into what you save.
01 Packages
A project's packages.toml decides which capabilities exist. The editor, the player, the content CLI and the build tool all resolve it through one crate, so they always agree. Leave out voxels and you have a mesh game: none of the voxel code is compiled in.
Packages panel
Compiled into this build
Packages
Leave voxels out. None of that code ships.
02 The editor
The editor is the primary product, not a debug overlay. Scroll through it.
Components that derive Inspector get a field visitor automatically: ranges, sliders, enums and asset pickers. Write a custom inspector only when you want one.
#[kosuno_derive::engine_component]
pub struct Turret {
#[inspector(range = 0.0..=720.0, suffix = "°/s")]
pub turn_speed: f32,
#[inspector(range = 1.0..=500.0, log)]
pub range: f32,
pub target: NodeRef, // a handle, never a path
}A prefab is a scene referenced by a component. Instances store only their override, so editing the template updates every instance and saving writes exactly what you changed.
A free-fly Scene camera and a Game view that mirrors the scene camera at the resolution and zoom you pick. Components contribute their own gizmos, handles and tools.
The Scene view shows your HUD at the Game view's resolution. Pick, move and resize screen UI right there, and the canvas scales evenly to other screen shapes.
Change a scene, voxel object, shader, controller or Rhai script on disk and only what depends on it reloads. Every asset has a GUID, so renaming or moving files breaks nothing.
While you play, the Game State panel shows every resource and Gameplay Actions logs each command. Edit a value in place: the change is validated like a gameplay command and carries into later saves.
Pause, take a checkpoint, and return to it later in the same session. Stop always restores the authored scene exactly, with entity ids kept, and Play keeps its own undo history.
Panels, menus, inspectors, importers, documents and tools all register through one plugin API. The built-in panels use the same calls a plugin does, and View → Architecture shows a wiki generated from the code.
03 One frame
The engine owns the frame: the phase order and the gameplay work inside each phase. The editor and every player host only add platform work around it. Play in the editor and a shipped game run the same code path.
Before a scene loads or Play starts, preflight walks what the scene references and checks every capability against the project's packages. A refusal names the missing package and leaves the current scene untouched.
Preflight validates the unsaved document, not the last saved file, so what is checked is what runs. Stop puts the authored scene back exactly as it was.
One winit adapter translates window events into the engine's per-frame Input, so keys, mouse and touch behave the same in the editor and in a shipped game.
04 Renderer
Kosuno renders with wgpu through a feature-driven render graph. Features declare their passes and resources, the graph culls passes nothing consumes, and transient textures are pooled. The mesh path works on its own; voxel ray marching is a backend the voxel package adds.
Shaders
A material names a shader and its properties. Custom .rvsl shaders are tracked assets: the renderer reflects their uniforms and fills them from the material, and they hot-reload.
Settings
Rendering and environment settings load from config/ and can be tuned live. A setting that changes compiled shader branches rebuilds that one pipeline; anything else is a uniform and applies on the next frame.
Profiling
Per-pass wgpu timestamp queries feed a readback ring buffer, so you can see what each pass costs on real hardware, Android included.
05 Animation
Clips key any component field: transforms, UI, materials, even Machina graph parameters. A dope sheet edits the keys, and reusable controllers wire clips into states and transitions as a node graph, with crossfades, typed parameters and layers. Try it: fire the triggers and watch the state machine run.
Controllers
.rvctrl assetsEvery Animator that references a controller shares its states, rules and layers. Saving the controller hot-reloads every Animator using it.
Layers
Layers blend over the base with property masks, so a hover wobble can play on top of whatever state the card is in.
Scripting
animator_trigger("draw") queues a trigger; parameters feed conditional transitions; completion callbacks tell scripts when a clip ends.
06 Plugins
Each plugin comes in two halves: a runtime crate the player links, and an editor crate that registers documents, inspectors and hot reload through the editor's open registries. The editor core never names their formats.
story · kosuno_story · .story
Scenes, lines, choices, conditions and @ stage commands. Mistakes become diagnostics on their line and the rest still runs. Every stop takes a snapshot, so rollback and save slots come from the same mechanism.@run hands control to a minigame prefab. Try it: the highlighted line is the one being played.
vector · kosuno_vector · .svg · .rvv
A Rust and WGSL port of the Rive Renderer's coverage pipeline. Curves stay sharp at any scale without a texture atlas. .rvv adds bone rigs, keyframes and a state machine scripts can drive. Scroll to morph the path.
machina · kosuno_machina · .rvg
Machina is a node-graph mesh system in the style of Houdini SOPs, linked as a pinned Rust library with no FFI. Changing a parameter recooks only the nodes downstream of it.
Oakmere Crossing · 512 × 512 m
57 million voxels. One file.
07 The voxel package
Selecting the voxel package compiles in sparse brick volumes, a ray-marching renderer backend, voxel shells as a physics shape, streaming and destruction. Every surface in these worlds is voxel data: buildings, trees, water, vehicles and signs. There are no imported meshes and no billboards.
Click the bridge pillars ↓
Plans of three demo worlds built by the repository's world generators (tools/worlds/).
Format
.rvo is a bag of chunks, each a brick table, a brick pool and optional terrain sections. A rigid body is a one-chunk file with its exact voxel extent recorded beside its bricks.
Streaming
Chunks page in and out around the camera into a ring-buffer grid, and a disk cache keeps decoded chunks between runs.
Destruction
Damage carves voxels. Pieces that lose support detach as new rigid bodies. Physics dispatches per pair, per pass or per ray, never per voxel.
08 Ship anywhere
kosuno_player holds one Scene, one Renderer and the per-frame loop. Every platform shell is a thin wrapper around it, so your game behaves the same on desktop, in the browser and on mobile. Builds start from the editor's Build Settings panel and cook only the content your scenes reference.
kosuno_desktop
Windows · macOS · Linux
kosuno_web
WebAssembly on WebGPU
kosuno_android
APK builds
kosuno_ios
Simulator builds today
Each platform page lists what it needs, with sizes, and installs, repairs or removes it in the background. Nothing downloads without a click, and the same operations run from the command line.
A pinned Zig toolchain cross-compiles the Linux player with no VM, Docker or sysroot. It runs on glibc 2.28 and newer.
A scene list picks what goes in the build. The build preview lists every asset it will include, with its size and the reason it's included.
In the repository
Open any of them in the editor and press Play. The city worlds are built by the world generators in tools/worlds/.
09 Principles
The architecture page is generated from the code, and a test fails when the two drift apart. These invariants are part of it.
Entities reference each other by EntityId inside a session and by Uuid across sessions. Assets are referenced by GUID. A rename touches one field.
Runtime state lives in side-stores keyed by entity, never in component fields. Inspector edits cannot wipe a physics body handle.
Components, assets, importers, panels, inspectors and shape kinds all register into open registries. Adding a type never means editing a central match.
A node stores only what its host authored. Prefab state is composed from the cached template plus the instance override, never appended.
Gameplay talks to a solver-neutral physics API. A second provider is an adapter that passes the same conformance suite, not a rewrite.
The engine and the editor compile without warnings, with and without the voxel package, and a check builds each composition.
Get started
Clone the repository, build with stable Rust 1.95 or newer, and launch through the restart supervisor. Machina is fetched automatically at a pinned commit.
# first build also prepares offline launches
$ cargo build --locked -p kosuno_editor -p xtask
$ ./run-editor.sh # run-editor.cmd on Windows
# an optimized editor for performance work
$ ./run-editor.sh --release
# ship a player
$ cargo xtask web build
$ cargo xtask android build