Status: MVP

The game engine for moving a box across the screen.

Designed with minimal brainpower and maximum enthusiasm. Under the hood it's a 3D engine and editor in Rust on Vulkan, with game code as plain Rust in a hot-reloadable DLL.

Download latest release View on GitHub

Features

Some of them are even true.

01

Zero-Brain Architecture

No complex setups. If a 5-year-old with a keyboard can't figure it out, we haven't dumbed it down enough.

02

Blazing Fast (Probably)

So light on features that your CPU won't even notice it's running.

03

Advanced Physics

Objects fall down. Sometimes they bounce. Don't push your luck.

04

Photorealistic-ish Graphics

Supports pixels, colored rectangles, and severe artistic compromises.

And the parts that are actually serious:

vulkan 1.3

Rust + Vulkan renderer

PBR, skinning, sky lighting and reflections. Shaders are WGSL, compiled by naga at build time, so no Vulkan SDK needed.

hot reload

Scripts are plain Rust

One file per script in a DLL that reloads while the game runs. Components keep their values across rebuilds.

blender

Author in Blender

Imports .blend, .fbx, .obj, .gltf and more automatically, with collision proxies, LODs and animations.

rapier

Physics

Rigid bodies, colliders and a character controller, simulated at a fixed rate during Play.

ecs

Big worlds

A sparse-set ECS built for very large worlds, procedural generation and simulation. The demo runs 90,000 entities.

mcp

AI agents can drive it

A built-in MCP server with about 75 tools lets agents build levels, write scripts and play the game. Edits are undoable.

Quick start

You need a Vulkan 1.3 GPU and a Rust toolchain. Blender is optional.

  1. Clone the repository and open a terminal in it.
  2. Run the editor. It opens the sample project and its startup scene.
  3. Press Build scripts once on first run, then hit Play.
  4. Or skip the editor and run the standalone player.
# 1
git clone https://github.com/Matheuswells/dumb_engine.git
cd dumb_engine
# 2
cargo run -p dumb_editor -- project
# 4
cargo run -p dumb_runtime --bin dumb-player -- project

Scripting

Each .rs file in Scripts/src/ is one script. Nothing to register by hand.

  1. Pick a template: Behaviour, Component, System or Empty.
  2. Derive Editor and the inspector shows your fields, with ranges and tooltips.
  3. Rebuild while playing. The DLL reloads and every component keeps its values, even if you reorder fields.
use dumb_script::prelude::*;

#[derive(Component, Editor, Clone, Default)]
pub struct Player {
    #[editor(range = 0.0..=20.0, tooltip = "Meters per second")]
    pub speed: f32,
}

fn movement(ctx: &mut ScriptContext) {
    let dir = Vec3::new(ctx.input.axis(Key::A, Key::D), 0.0,
                        ctx.input.axis(Key::W, Key::S));
    for (t, p) in ctx.world.query::<(&mut Transform, &Player)>() {
        t.translation += dir * p.speed * ctx.time.delta;
    }
}

pub fn register(reg: &mut Registry) {
    reg.component::<Player>();
    reg.system("player::movement", movement);
}

The editor

Everything you need to place a box, and a few things you don't.

Scene
3D viewport, move/rotate/scale gizmos with snapping, picking, scene tabs, undo/redo, Play/Pause/Step/Stop that restores the exact pre-play scene.
Hierarchy
Virtualized tree that's fine with 100k entities, drag-and-drop reparenting, prefabs.
Inspector
Generated from reflection for engine and script components: asset pickers, entity references, enums, lists, colors.
Assets
Folder tree with real 3D thumbnails, search, import by drag-and-drop, dependencies, hot reload.
Viewers
Model viewer (meshes, bones, LODs, collision proxies), animation viewer with scrubbing and events, live material editor.
Scripts panel
Toggle systems while playing, per-system cost in ms, compiler problems that jump to the line in VS Code.

Read more in the architecture notes, the MCP guide and the roadmap.

MCP

Let an AI agent drive the editor

The editor runs a Model Context Protocol server, so Claude Code, Claude Desktop or any MCP client can build levels, tune materials, write and hot-reload scripts, play the game and look at screenshots. You watch every change happen live, and Ctrl+Z undoes it.

  1. Open the editor. The server starts with it, on this computer only.
  2. Open the MCP menu and choose Copy Claude Code command, or Add .mcp.json to this project.
  3. Start a new Claude session and ask for something. The status bar shows 🔌 Agent active while it works.
# Claude Code
claude mcp add --transport http dumb-engine http://127.0.0.1:47100/mcp
# or .mcp.json in your project
{ "mcpServers": { "dumb-engine": {
    "type": "http", "url": "http://127.0.0.1:47100/mcp" } } }

Things you can ask for:

scenes

"Build a small arena with a ramp and four lights."

Creates entities, sets transforms and components, spawns assets and saves the scene.

materials

"Make the floor look like wet asphalt."

Creates and edits materials, assigns them and checks the result with a screenshot.

scripts

"Add a double jump to the player."

Writes the script, builds it, reads compiler errors, and hot-reloads the DLL.

play mode

"Play and tell me why the box falls through the floor."

Plays, sends input, steps frames, reads the console and captures the game view.

About 75 tools cover scenes, entities, prefabs, materials, assets, scripts, play mode, the console and exports. The full list is in the MCP guide.