Skip to content
GitHub
Rust / GPU / Creative tools

RustingStudio

Engines, intelligence, and graphics.

We explore how Rust and GPU computing can reshape game engines, machine learning, and real-time graphics.

BUILD. MEASURE. CREATE.
01 / 06Game engine
RustingEngine

A Rust game engine with Vulkan rendering, an editor, and hybrid CPU/GPU physics.

02 / 06Deep learning
RustingBrain

A deep-learning library in Rust, from small networks to transformer language models and text-to-image.

03 / 06Shader pack
RustingShader

A cinematic Iris shader pack for Minecraft, with a black hole in the End.

04 / 06LLM inference
RustingStrata

A pure-Rust inference engine for Qwen GGUF models, Qwen3 to Qwen3.8, that splits MoE experts between GPU and CPU, on CUDA or Vulkan.

05 / 06AI accelerator
RustingPU

An INT8 systolic-array accelerator in SystemVerilog, driven from Rust and checked bit for bit.

06 / 06Model runner
RustingRunner

Runs released Rusting models in Rust, on RustingBrain. One model so far: Kaze-3D-v0.1, one image in, one mesh out.

01 / 06
Game engine / Vulkan / Physics

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.

2,191FPS
10,000 GPU-simulated cubes
119FPS
50,000 colliding GPU cubes
65FPS
Black hole with a 60,000-particle disk
Measured at 1920×1080 on an RTX 3060 and a Ryzen 5 7600X.
PBR + shadowsGPU frustum cullingDeterministic scenariosrusting CLI
src/game.rsrust
use rusting_engine::prelude::*;

fn update(scene: &mut GameScene<'_>, time: &FrameTime) {
    scene.object("Planet").rotate_y(0.2 * time.delta_seconds());
}

rusting_game!(update);
02 / 06
Deep learning / CUDA / Metal

RustingBrain

Train anything from an XOR network to a 300M-parameter transformer on one desktop GPU. No Python, no C++ build step — CUDA kernels compile at startup. It also runs published FLUX, Stable Diffusion and Wan 2.2 models.

300M
Parameter LMs on a single GPU
21,787
tok/s training at 4 × 1024 (PyTorch: 20,544)
18
Tutorial chapters, zero to LMs and images
101.7M-parameter transformer, mixed precision, on an RTX 3060 12 GB; PyTorch with torch.compile.
Flash attentionMixture of ExpertsLoRA fine-tuningText to imageONNX import and export
examples/xor.rsrust
let mut model = Network::builder()
    .input_size(2)
    .dense(8, Activation::Tanh)
    .dense(1, Activation::Sigmoid)
    .loss(Loss::BinaryCrossEntropy)
    .optimizer(Optimizer::adam(0.05))
    .build();
03 / 06
Shader pack / GLSL / Iris

RustingShader

A cinematic shader pack for Minecraft Java Edition. Soft PCSS shadows, deferred water with caustics, volumetric clouds and light — and a gravitationally lensed black hole in the End.

PCSS
Soft shadows, deferred lighting
3
Dimensions, each lit its own way
GL 3
Runs through Iris on OpenGL 3.x
Developed on an RTX 3060.
Volumetric cloudsWater causticsLensed black holeBloom + auto-exposure
installbash
# 1. Install Iris for Minecraft Java Edition
# 2. Download the latest RustingShader release
$ mv RustingShader.zip ~/.minecraft/shaderpacks/
# 3. Video Settings → Shader Packs → RustingShader
04 / 06
LLM inference / CUDA / Vulkan

RustingStrata

Run Qwen3.6-35B-A3B on a 12 GB GPU and decode 1.7× faster than llama.cpp. Experts that do not fit in VRAM run on the CPU alongside the GPU, and their placement adapts to the routing it sees. No C++, no ggml — CUDA kernels compile at run time, and the same kernels run on Vulkan. DeepSeek-V4.1-Flash and GLM-5.3-Flash load too.

113
tok/s decode after 4K (llama.cpp: 66.5)
160
tok/s decode with MTP drafts, at best
2,216
tok/s prefill at 4K (llama.cpp: ~2,236)
Qwen3.6-35B-A3B Q2_K_XL (11.7 GiB) on an RTX 3060 12 GB + Ryzen 5 7600X, CUDA backend; llama.cpp tuned for the same file.
Hybrid CPU/GPU MoECUDA and Vulkan backendsMTP speculative decodingOpenAI and Anthropic compatible serverImage input
runbash
$ cargo build --release
$ rustingstrata calibrate --model $M
$ rustingstrata chat --model $M --gpu
$ rustingstrata serve --model $M --gpu --addr 127.0.0.1:8080
05 / 06
AI accelerator / SystemVerilog / Verilator

RustingPU

A complete AI accelerator, from the processing element to the DMA and the Rust driver. An N×N INT8 systolic array runs a RustingBrain network, and every result is checked bit for bit against a software reference. Simulated in Verilator today; a Tang Mega 60K FPGA is next.

97.25%
MNIST accuracy, equal to host int8
98.50%
Array utilization at 8×8
26.8cycles
Per MNIST image at 64×64
784-128-10 MLP, 10,000 test images, batch 64, in Verilator.
Output-stationary systolic arrayOn-chip requantizationGEMM sequencerBit-exact with the host
src/main.rsrust
use rusting_pu::{quant, Rpu, TILE};

let mut rpu = Rpu::new()?;
let c = rpu.run_tile_i8(&a, &b)?;
assert_eq!(c, quant::matmul_nt_i8(&a, &b, TILE, TILE, TILE));
println!("{} cycles", rpu.cycles());
06 / 06
Model runner / Image to 3D / Rust

RustingRunner

Run released Rusting models from one Rust binary: inference only, on RustingBrain, no Python. One model so far, Kaze-3D-v0.1: one image in, one mesh (GLB) out, on an NVIDIA card or the CPU. It is an early release, geometry only: it gets the rough shape and size of an object, misses detail and exact proportions, and makes no texture and no colour.

4s
Per mesh on an RTX 3060, weight loading included
2.1GiB
Card memory, about
103M
Parameter flow transformer
Kaze-3D-v0.1 on an RTX 3060; 46 s on the CPU alone (Ryzen 5 7600X). Early release, geometry only: F@0.02 of 0.215 on 64 held-out objects, against our target of 0.55.
Image to GLB meshCUDA or CPUNo PythonApache-2.0 weights112,364 CC-BY and CC0 training objects
runbash
$ cargo build --release --features cuda
$ rusting-runner 3d --weights Kaze-3D-v0.1 \
    --image my-object.png --out my-object.glb --cuda 0