What renew is

Most engines are built around an editor, and everything else reaches the engine through whatever that editor exposes. renew is built the other way around. Every capability is a library with a command-line face and machine-readable output, so a developer at a terminal, a build script and an autonomous agent all drive it the same way. That is what AI-first means here.

See it running

Every picture below was produced by the sample beneath it and is committed in the repository.

Six samples ship with the engine. The four simulation samples run headless and answer with a digest, and those are the runs CI checks on every target at once.

$ cargo run -p renew-sample-cube --bin cube
cube script=stand source=script ticks=600 digest=0xcbc2871e466a6bfc solids=5012 broken=0 placed=0 grounded=true

$ cargo run -p renew-sample-leap --bin leap
leap script=stand ticks=600 digest=0xd7058b85479adeb4 grounded=true wall=false

$ cargo run -p renew-sample-chess --bin chess
chess count depth=4 nodes=197281 result=ongoing

Determinism you can check yourself

One command runs a pinned set of simulations and writes exactly what they produced:

$ cargo run --bin renew -- determinism --emit windows.json
wrote 15 digests for windows/x86_64 to windows.json

{
  "schema_version": 1,
  "os": "windows",
  "arch": "x86_64",
  "toolchain": "rustc 1.97.1 (8bab26f4f 2026-07-14)",
  "digests": {
    "chess/play-60/digest": "0x6bf0be22d95711ee",
    "cube/build-900/digest": "0xce632722e5698fa1",
    "cube/patrol-600/digest": "0x29559b5af5e634d2"
    // 12 more, in key order
  }
}

CI produces that file on five targets every commit and holds them against each other. Any disagreement fails the build.

Making a simulation reproduce bit-for-bit across targets sets out what that property costs in practice: why the arithmetic is fixed point rather than floating, why the frame loop cannot read a clock, and why a digest compared against a committed constant proves nothing about a second machine.

Quick start

Requires stable Rust 1.97 or newer.

git clone https://github.com/renew-engine/renew
cd renew
cargo run --bin renew -- build
cargo run --bin renew -- test

# a voxel world, drawn to a window
cargo run --bin renew -- --features window run cube -- --window

One binary drives the workspace the same way for people, scripts, and CI:

cargo run --bin renew -- help

configure, build, test, bench, run, record, replay, lint, check, coverage, modules, asset-pack, asset-inspect, ui-compile, determinism, doctor. Each one takes --json and answers with a single document carrying a schema_version.

Modules

Everything outside the five core crates can be removed. CI builds and tests one configuration per optional crate on every commit, with that crate and its dependents excluded.

Twenty-seven of the twenty-nine are published on crates.io at 0.1.1. Maturity runs bootstrap, then internal, then stable. A module never claims a level it has not earned, and nothing here is stable yet.

Platforms

The table names the machine each result came from, because an emulator is not a phone and a simulator is not a device. Drawing on Android needs a runner with Vulkan 1.3; the emulator offers 1.2.

Graphics reach the GPU through Vulkan via ash, with MoltenVK on Apple platforms, and windowing through winit. No Vulkan type appears in the rendering interface's public API, which is what keeps the backend replaceable.

Quality gates

Every commit on main clears all of these. The test suite runs on all three desktop platforms; the rest run once, on Linux:

Built to be operated

Most engines are built around an editor, and everything else reaches the engine through whatever the editor happens to expose. renew is built the other way around. The machine-operable surface is the primary one: every capability is headless, scriptable, and emits schema-versioned JSON beside its human-readable output, so nothing about the engine requires a person in front of a screen.

That is what AI-first means here. A developer at a terminal, a build script, a continuous integration job, and an autonomous agent all drive the engine through exactly the same commands and read exactly the same output, because there is only one surface to drive. An editor will arrive in time, and it will be a client of these APIs like everything else, never a privileged one.