RustingEngine
A GPU-first game engine for physics-heavy scenes. Vulkan rendering, a Blender-style editor, and hybrid physics — you decide what the CPU owns and what the GPU simulates.
use rusting_engine::prelude::*;
fn update(scene: &mut GameScene<'_>, time: &FrameTime) {
scene.object("Planet").rotate_y(0.2 * time.delta_seconds());
}
rusting_game!(update);Read the docs
10,000 GPU-simulated cubes at more than 2,000 FPS on an RTX 3060. RustingEngine is built for physics-heavy scenes that can overwhelm traditional CPU-first engines long before the GPU is fully used.
StartGetting startedThis page takes you from a fresh checkout to a running game. It takes about 15 minutes, most of it the first compile.
StartCore conceptsA short tour of the ideas the tutorials rely on.
GuidesEditor guideThe editor window is split into areas, as in Blender. Each area shows one editor type, such as Scene View, Hierarchy, or Inspector, and you can split, resize, and change areas freely. Every change to the scene can be undone.
GuidesDeterministic simulationThis page records the rules behind DeterminismMode (Milestone 8). Off promises nothing. Local promises identical results on one machine and build. CrossPlatform promises identical results on every supported device. The rules in this page are what CrossPlatform enforces.
GuidesWebAssembly scriptsNative Rust plugins are the main way to write gameplay. The optional rusting-script crate adds small sandboxed scripts for modding and designer-level logic. A script is a WebAssembly module attached to one object. It runs in the Wasmi interpreter with no access to files, the network, the clock, or random numbers. It can read and write the same reflected component fields that scene files, the Inspector, and animation tracks use.
ReferenceRustingEngine ArchitectureThis document records boundaries that must remain stable as the roadmap is implemented. New features should fit these boundaries instead of reaching across layers. If a boundary must change, update this document and add a migration plan before changing public APIs.
ReferenceVerifiable development environmentMesa's lavapipe is the supported software Vulkan implementation for running GPU-touching code and tests on a machine with no display and no discrete GPU.
ReferenceRustingEngine RoadmapRustingEngine is currently a functional Vulkan renderer prototype with a native Rust ECS runtime, an egui editor, and a GPU-accelerated hybrid physics bridge. The goal of this roadmap is to turn it into a complete, general-purpose Windows/Linux game engine in the same class as Godot — covering 3D and 2D rendering, animation, audio, UI, navigation, networking, a full editor, and export — whose defining strength is physics. RustingEngine should be the engine people pick because of its physics.
ReferenceChangelogLearn by building
- 01
Tutorial 1: Hello cube
You will make the default cube spin and bob up and down, then check the motion with an automated test. You need a project made as in Getting started; this page calls it Hello Cube.
- 02
Tutorial 2: Coin Run from the command line
You will create a complete 2D platformer, play it, change it without opening the editor, catch the change breaking the level with an automated test, take a screenshot, and export a finished build. Every step uses the rusting CLI, so the same loop works in scripts, CI, and for coding agents.
- 03
Tutorial 3: Gameplay plugins
The rusting_game! API from Tutorial 1 is one function per frame. Real games want ECS systems: code that queries components, reads input, and runs at a chosen stage. This tutorial adds two systems to the Coin Run game from Tutorial 2:
- 04
Tutorial 4: GPU cube rain
You will drop 2,000 cubes simulated on the GPU, get an event back from the GPU when each one falls past a line, and show a counter on screen. This is the pattern for debris, swarms, and crowds: the GPU owns the bodies, and the CPU hears only about the moments it cares about.