v0.2.0

Build Games
in pure Rust.

A modular Rust game engine. Rendering, physics, ECS — each is an independent crate. Take what you need, skip what you don't.

Get StartedView Docs
Architecture

Not a black box — it's a toolbox

Every feature is a standalone crate. Want the full engine? One line: use anvilkit::prelude::*. Just need rendering? Pull in anvilkit-render alone. Nothing you don't need comes along for the ride.

⚙

Independent Crates

Render, physics, assets — each stands alone. Compose as needed.

⚡

Zero Overhead

Rust's zero-cost abstractions + memory safety. No runtime penalty.

crate_graph
┌─────────────────────────────┐
│        anvilkit (facade)    │
└──────────────┬──────────────┘
               ▼
┌──────────────┴──────────────┐
│      anvilkit-ecs (bevy)    │
└──────┬──────────────┬───────┘
       ▼              ▼
┌──────┴──────┐ ┌─────┴──────┐
│anvilkit-    │ │anvilkit-   │
│render (wgpu)│ │physics     │
└──────┬──────┘ └─────┬──────┘
       ▼              ▼
┌──────┴──────┐ ┌─────┴──────┐
│anvilkit-    │ │anvilkit-   │
│assets (gltf)│ │input       │
└─────────────┘ └────────────┘
Code

Three lines to start

use the prelude, create an App, register your systems, run. No config files, no codegen. The Rust compiler is your type checker.

Terminal$ cargo run --release
</>src/main.rs
use anvilkit::prelude::*;

fn main() {
    App::new()
        .add_plugins(RenderPlugin::default())
        .add_systems(Startup, setup)
        .add_systems(Update, game_logic)
        .run();
}

fn setup(mut commands: Commands) {
    commands.spawn((
        CameraComponent::default(),
        Transform::from_xyz(0.0, 2.0, -5.0),
    ));
}
Built-in

8 Modules, Ready to Go

🌳

ECS

Bevy ECS at the core. Parallel schedules, archetypes, change detection.

🎨

Rendering

PBR, HDR bloom, SSAO, CSM shadows — all via wgpu.

⚛

Physics

Built-in AABB collisions + optional Rapier3D integration.

🔊

Audio

3D spatial audio powered by Rodio. WAV, Vorbis, MP3.

📦

Assets

glTF loading, hot-reload, procedural mesh generation.

🎮

Input

Keyboard, mouse, gamepad — one unified API.

🖥

UI

Flexbox layout engine with text rendering and z-order.

🔧

Dev Tools

Frame profiler, debug console, wireframe renderer.

Technical_Capabilities

REF_ID: #4492-X

Multi-Threaded
ECS Pipeline

Systems run in parallel by default. The scheduler spreads work across all CPU cores — no locks, no race conditions to worry about.

ECS
LOCK_FREE
AUTO_THREADED

wgpu Rendering

One codebase targets Vulkan, Metal, and DX12. No platform-specific code — native performance everywhere.

🎨
⚡
Zero Cost

Abstractions inline at compile time. Zero runtime overhead.

🛡
Memory Safe

No segfaults, no leaks. The compiler has your back.

Showcase

Built with AnvilKit

Craft
CRAFT

Craft — Voxel Sandbox

Procedural terrain, block building, day-night cycle, post-processing filters.

cargo run -p craft
Billiards
BILLIARDS

Billiards — Pool Sim

Full PBR rendering, custom collision physics, aiming mechanics, scoring system.

cargo run -p billiards
CLI

Anvil CLI

One command to create a project, one command to run it. Handles project structure and dependencies so you can focus on game logic.

$anvil new my-game
$cd my-game
$anvil run

✓Prerequisites

  • Rust (latest stable)
  • Git
  • C compiler (native deps)
v0.2.0

3 Steps to Launch

01

Install

One command to get the scaffolding tool.

cargo install anvil-cli
02

Create

Generate a project from template.

anvil new my_game
03

Run

Compile and launch.

cargo run
START BUILDING

Fully Open Source

Dual-licensed MIT / Apache 2.0. Standing on the shoulders of:

bevy_ecswgpuwinitglamrodiorapier