Tests, not eyes.
A game engine an AI can build in, and prove.
Press Start is built on Bevy. Your agent writes the game as documents, runs it on a fixed tick, and proves every frame against a reference. Same seed, same inputs, same game. Every time.
| rank | tick | run A | run B | result |
|---|---|---|---|---|
| 01 | 000 | 6a059ae83a9ff47b | 6a059ae83a9ff47b | PASS |
| 02 | 040 | 4edc74743e7f1c7f | 4edc74743e7f1c7f | PASS |
| 03 | 080 | 945a5f7bde1f6fa8 | 945a5f7bde1f6fa8 | PASS |
| 04 | 120 | 184c7e529ed26059 | 184c7e529ed26059 | PASS |
| 05 | 160 | b308ffa24fc8bc09 | b308ffa24fc8bc09 | PASS |
| 06 | 200 | d5c13fefb4253fd4 | d5c13fefb4253fd4 | PASS |
| 07 | 240 | c33a5e745a750293 | c33a5e745a750293 | PASS |
| -- | 080 | run C · another seed | ffbc2b56c260432e | FAIL |
Agents can type code. They cannot see whether the game is right.
Ask an agent for a game in an engine built for human hands. It writes a script, presses play, takes a screenshot and guesses. The frame rate changes the outcome, the random seed is unseeded, and nothing says what "right" means. Two runs are two different games.
- 01scriptok
- 02playok
- 03screenshotok
- 04guess?
An engine whose first user is an agent. You direct it.
- 01Everything is a document.
- Scenes, laws and assets are files an agent can read and write. 89 engine crates cover what Bevy leaves out: terrain, shaders, physics, animation, UI, navigation, networking and more.
- 02The game answers back.
- A running game answers four verbs: query, command, capture, control. Your agent asks, edits, looks and steps through the same door a player uses.
- 03Every feature can fail a test.
- Pixel goldens, geometry checks and a reference tool to match. Nothing is taken on faith.
How an agent builds a game here.
procedure
- 01
Write the scene as data.
A scene is a base plus patches. A field is set by name, never by a click.
- 02
Validate before it runs.
Every document is checked before the app exists. A refusal names the value and the fix.
- 03
Run it on a fixed tick.
Tick 128 is the same tick on every run, driven by a recorded input tape.
- 04
Look with numbers, then pixels.
Query the positions and the state checksum, capture the frame, compare it with its golden.
use bevy::app::FixedUpdate;
use bevy::ecs::resource::Resource;
use bevy::ecs::system::ResMut;
use press_start_test_app::{advance, fixed_step_app};
#[derive(Resource, Default)]
struct TickCount(u64);
fn count_ticks(mut count: ResMut<TickCount>) {
count.0 += 1;
}
#[test]
fn three_fixed_steps_a_frame_are_thirty_after_ten_frames() {
let mut app = fixed_step_app(3);
app.init_resource::<TickCount>();
app.add_systems(FixedUpdate, count_ticks);
app.update(); // priming: Startup runs, zero fixed steps
assert_eq!(app.world().resource::<TickCount>().0, 0);
advance(&mut app, 10);
assert_eq!(app.world().resource::<TickCount>().0, 30);
}
Same seed, same inputs, same frame.
Every random stream comes from one seed you can write down. Game logic may not read the clock or sleep. The simulation steps on a fixed tick. So a replay is exact, a test is a fact, and "the bug at tick 340" is something one agent can hand to another. Today: the same build on the same platform.
every core
All your cores. The same answer.
Bevy runs your game's systems across every core of the machine, and Press Start keeps it that way: nothing is slowed to a single thread to make it reproducible. Our gate refuses two systems that touch the same data in no declared order, and names both. A parallel sum must be ordered or order-independent, never "whatever the scheduler did". So the replay does not depend on how many cores ran it.
Proven on integrated graphics.
Every picture the engine proves is shot on an Intel UHD 770, the integrated graphics of an office desktop, and no other card is allowed. If it holds there, it holds on the machines players actually own.
Measured against the tools you already trust.
We do not grade our own homework. Physics is held against Jolt and PhysX, navigation against Recast, UI against Chromium and Yoga, text against HarfBuzz, lighting against Mitsuba, meshes against Blender and Manifold. Where we differ, the difference is written down with both numbers.
- JOLT
- PHYSX
- RECAST
- CHROMIUM
- YOGA
- HARFBUZZ
- MITSUBA
- BLENDER
- MANIFOLD
Parity is the bar. Not every feature meets it yet, and the misses are recorded.
Pictures are tests too.
Every picture the engine draws in a test is compared with a golden: a frame a human accepted in a reviewed commit. A tool can propose a golden. It can never accept one.
- 01shot on one reference cardok
- 02compared pixel by pixelok
- 03a human accepted it in a reviewed commitok
more accepted goldens
the engine's 189 accepted goldens are test evidence, not screenshots: small, plain, shot with the noisy features off · engine c998685
What the engine covers, and how much of it is built.
- stage 01
Beyond the usual
things no engine ships, written down anyway
17 / 24 · 71% built - stage 02
World building
scenes, terrain, procgen, 2D, navigation
16 / 54 · 30% built - stage 03
Game services
audio, UI, save, localisation, VFX
24 / 85 · 28% built - stage 04
Simulation
physics, input, cameras, performance
17 / 67 · 25% built - stage 05
Asset creation
modeling, rigging, animation, pipeline
18 / 75 · 24% built - stage 06
Rendering
lighting, pipelines, shaders, textures
7 / 57 · 12% built - stage 07
Reach
networking, export, platforms
4 / 42 · 10% built
how to play
We keep a checklist of everything a game engine needs: 404 things, from terrain to crash reports, in seven areas. A thing counts as built only when a test holds it. Here is where each area stands today.
- engine crates
- 89
- things built
- 103 of 404
- reference tools
- 71
The first game, Team Fights, a small team shooter made of primitives, is built on these crates.
synced 2026-11-01 · engine c998685
Where we are, honestly.
Press Start is not public yet. This is the road to version 1, in order:
- 01now
Version 1:
a launcher, a new project from a template, save, build, Windows export. No account required, and it works fully offline.
- 02
Then:
the big performance pain points, one full release gate, and the public repository under our own source-available licence.
- 03
After:
a version every two weeks, the remaining gaps, more platforms.
What "beta" means.
You get an invitation when version 1 opens, and earlier builds if we open a private preview. We email you about access and major releases only.
Join the beta.
We will email you when your invite is ready. Nothing else, unless you ask.
Questions.
manual- 01Is it open source?
- It will be source-available. The repository goes public at version 1, under our own licence: free to make and ship games, with a royalty only above a revenue threshold.
- 02Do I need an account?
- No. An account will be optional, and nothing in the engine, editor or launcher will require one.
- 03Which AI does it work with?
- Your own. The engine exposes data and verbs, not a model.
- 04Is it a Bevy fork?
- No. It is built around Bevy 0.19: each system is a Bevy plugin plus our own document formats, and a game is a normal Rust codebase you own.
- 05Which platforms?
- Windows first at version 1. More platforms follow.
- 06How much will it cost?
- Using and shipping is free below a revenue threshold. The threshold and the rate are set with the licence text.
- 07When?
- When version 1 passes its release gate. We do not publish dates we have not earned.