Star

Agent-native game engine

The world is code.Agents build it.You watch every tick.

Agent
Your coding agent reads and changes the game's code while it runs, through skills and MCP.
Studio
The human window: watch every agent, edit anything, take over.
Yours
Assemble it like Arch Linux: simple, balanced or complete.
Star on GitHub Download 0.0.1
git clone https://github.com/Obed0101/ukiyo

Concept world · a GT on Chapman's Peak Drive · car CC-BY 4.0 Khronos, sky and road CC0 Poly Haven

Agents plug in. You watch.

Thirty seconds of what ukiyo is for: agents wired into a running game, reading and changing every system and proving it, while a person watches from the Studio and takes over when they want.

0:000:30

Concept film. The agent CLI, the Studio and the open library are in development; the cube frames, the three-target parity and the headless numbers in the last act are real captures from 0.0.1. Car: Car Concept (Khronos, CC-BY 4.0). Road and sky: Chapman's Drive (Poly Haven, CC0). Rendered from code, sound included.

A whole engine, taught to your agent.

Every system an engine has, as source your agent can read and change while the game runs. It connects through skills and MCP: each skill teaches it one system, and checks prove the result with code tests and visual tests on real frames.

  • Rendering

    skill lights, cameras, post

    proof golden frames per target

  • Materials & textures

    skill PBR, clearcoat, variants

    proof visual diffs on real frames

  • Physics

    skill bodies, tires, collisions

    proof headless runs, fixed ticks

  • Audio

    skill mixing, spatial, engine sound

    proof offline renders, loudness

  • Input

    skill bindings, devices, replays

    proof scripted input replays

  • Game UI

    skill HUD, menus, focus

    proof screenshots and focus tests

In progress: the core, three targets and evidence ship in 0.0.1; systems and skills land gate by gate.

Take only what you need.

Like Arch Linux: install what you need and nothing else. Start simple, balanced or complete, both for the Studio on your screen and for the engine, systems and skills your game is built from. Add the rest whenever you want.

studio
Agents, their proof, an inspector and the tick timeline.
game
Physics, audio and game UI on top of the core.

An open library, not a store.

Models, materials, sounds, templates and whole game systems, published as packages by the community. Every one of them free and open source, with its license and provenance checked, and skills and tests so your agent can use it.

  • Chapman's Drive preview

    Chapman's Drive

    CC0

    polyhaven/chapmans-driveHDRI · sky and road

  • Clean Asphalt preview

    Clean Asphalt

    CC0

    polyhaven/clean-asphaltPBR material

  • Car Concept preview

    Car Concept

    CC-BY 4.0

    khronos/car-conceptvehicle · glTF

  • public float Grip(in Contact c) =>
    Pacejka.Lateral(c.Slip, Stiffness);
// skill: tuning.md · 18 tests

    Tire Model

    MIT

    ukiyo/physics-tiresconcept

  • Speedometer.Bind(car.Speed);
Gear.Bind(car.Gearbox);
// 6 golden frames

    HUD Kit

    MIT

    ukiyo/hud-kitconcept

  • public float Aperture = 1.8f;
public bool FreezeTick = true;
// visual tests: 6

    Photo Mode

    MIT

    ukiyo/photo-modeconcept

$ ukiyo add polyhaven/chapmans-drive · the package command arrives with the agent CLI; the assets above are real and credited.

This one is not a render.

The car above is where ukiyo is going. This is where it is today: the 0.0.1 web export running on this page. C# computes every tick in WebAssembly and three.js only draws what it is told. Pause it, step it, or call ukiyo.step(60) from the console.

RotatingCubebooting…

starting .NET WebAssembly · ~5 MB, once

tick0000000.00 s
ThreeJsRenderer

Scroll is time.

The simulation is a pure function of its ticks. Scroll and you move through captures from three real targets of the same Program.cs. They agree on every captured tick.

desktopwgpu → Metal
webthree.js → WebGL2
snapshot · cube.rotation
000000…
headlessNullRenderer · no GPU
tick000000

Δ 0…

One line to run it anywhere.

This is the entire entry point, and every host compiles this exact file. The game owns its state and describes what to draw; renderers only consume that description.

Every run states what it ran: the hash of the source it was built from, the renderer, the backend and the device. Nothing an agent reports has to be taken on faith.

samples/RotatingCube/Shared/Program.cs
return await GameApplication.RunAsync(new CubeGame(), PlatformBootstrap.Create(args));
samples/RotatingCube/Shared/CubeGame.cs
public void Update(in TickInfo tick)
{
    _rotation = ExpectedRotation(tick.Tick + 1);
}
 
public void Extract(FrameBuilder frame)
{
    frame.Camera = FrameBuilder.LookAt(new Vector3(0f, 0.6f, 3.2f), …);
    frame.Draw(_mesh, _material, Pose.ToMatrix());
}
stdout · desktop run
[ukiyo] target=desktop game=RotatingCube CubeGame.cs=9846313B6743 Program.cs=138C7579F527
[ukiyo] renderer=WgpuRenderer backend=Metal device="Apple M4 Pro" profile=G0Unlit capture=True

Each step closes with evidence.

Read the first report
  1. shipped · 0.0.1

    One program, two real renderers

    Metal and WebGL2 from the same C#, a single native binary and a static web export.

  2. next

    Runtime slice

    Input and platform services, and physics validated on native, NativeAOT and WebAssembly.

  3. later

    Authoring and the agent CLI

    Scenes and prefabs as code plus data, validated patches, and the CLI agents plug into.

  4. later

    Studio and presets

    The human window onto a running game in simple, balanced or complete layouts, with safe reload.

  5. later

    Evidence and first games

    Replays, visual conformance and the first real games built with agents.

  6. later

    The open library

    Packages for assets and whole systems, published by the community, free and open source.

Order and scope can still change.

Run it yourself.

Apple Silicon Mac with the .NET 10 SDK, Xcode command line tools, cmake, ninja and bun. Or skip the build and download the 0.0.1 binaries.

  1. Get the code and pinned natives

    git clone https://github.com/Obed0101/ukiyo && cd ukiyo && scripts/fetch-native.sh

  2. Run it with no window and no GPU

    dotnet run --project samples/RotatingCube/Headless

  3. Run it natively on wgpu → Metal

    dotnet run --project samples/RotatingCube/Desktop

  4. Verify every gate, end to end

    scripts/g0.sh