Star

Agent-native game engine

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

Your coding agent reads and changes the game's code while it runs, through skills and MCP. You watch, edit and take over in the Studio. Everything is optional, 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

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, camera passes, lit meshes

    proof same pixels on Metal, WebGL2, CPU

  • Sprites & assets

    skill textures, sheets, glTF import

    proof CPU-rendered frame captures

  • Physics

    skill 2D bodies, sensors, raycasts

    proof headless runs, fixed ticks

  • Audio

    skill mixer, WAV, seeded synth

    proof WAV recorded headless

  • Input

    skill keyboard, pointer, recording

    proof scripted input replays

  • Game UI

    skill HUDs, menus, pixel font

    proof snapshots and frame captures

Also in the tree: cameras and sequences, particles, NPC behaviour, scenes and patches, save and rewind. 21 skills, one per area.

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 skills your agent loads. Layouts, themes and panels are plain files you can rewrite.

studio
The frame, its numbers and the entities, with selection shared with your agent.
skills
Physics, particles, NPCs, game UI, audio, cameras, assets and hosts 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 open library; 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 docs
  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. done · on main

    Runtime slice

    Input, sprites, physics, game UI, audio, the dev bridge, MCP and skills. Same simulation and pixels on every target.

  3. in the tree

    Authoring and the agent CLI

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

  4. in the tree

    Studio and presets

    A project hub, an editor onto the running game, layouts and themes as files, run and reload at the same tick.

  5. later

    Evidence and first games

    Visual conformance across renderers, replay-based regression suites 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/Hosts/Headless

  3. Run it natively on wgpu → Metal

    dotnet run --project samples/RotatingCube/Hosts/Desktop

  4. Open the Studio onto it

    bun studio/src/server.ts

  5. Drive it the way an agent does

    bun tools/mcp/src/cli.ts status