A small engine. Everything else is Lua.

Tiamat is an engine, not a game. It ships the mechanisms, and all of the content is mods. It is kept deliberately small, finer-grained than a block world, and identical on every machine.

What the engine is

An experimental multiplayer voxel engine built around subdivided voxels. The mods in game/ are reference implementations and test fixtures that prove each mechanism works through the public API. They are not a shipped game. A default game comes later, built as mods on top of a finished engine.

27 units in every block, a 3×3×3 grid
16 blocks to a chunk CHUNK_BLOCKS
90 items in a full stack ITEMS_PER_STACK
6 targets: two CPU types on three systems

How it runs

The headless server is the game. The client is a viewer onto it. That leaves exactly one simulation code path, so nothing can drift out of sync between singleplayer and multiplayer.

Server

the game · headless
Simulation and physics
Voxel data and persistence
The Lua runtime and every mod
No GPU or display needed
network
protocol

Client

the viewer
Rendering with wgpu
Windowing with winit
Audio with kira
Interface with egui
Singleplayer is the same server, started inside the client and reached over loopback. A bug in singleplayer is a bug for everyone.

Crate map

Four crates, with strict rules about what each may depend on.

Crate Role May depend on
crates/core tiamat-core
Voxel data, simulation, the Lua runtime, physics, persistence and protocol types. The whole simulation lives here.
Never wgpu, winit, kira or egui
crates/server
A thin headless binary over core. Runs with no display server.
Never wgpu, winit, kira or egui
crates/client
The viewer: rendering, windowing, audio and UI.
core, plus wgpu, winit, kira and egui
crates/bot
A scripted headless client for tests, benchmarks and load.
core
Enforced This table isn’t just intent. scripts/check-dep-firewall.sh fails CI if core or server picks up a render, window, audio or UI dependency on any platform.

Two folders sit outside the workspace: game/ holds the reference mods and test fixtures, and api/ holds the MIT-licensed stubs and docs for modders.

Finer than a block

One block is one cubic yard, split into a 3×3×3 grid of 27 units. That holds everywhere, with no special cases for partial blocks. Quantities are stored in units and shown as blocks plus nodes.

1 block + 12 nodes 39 units, stored as a whole number 39 // 27 = 1 · 39 % 27 = 12

Determinism

The same seed produces bit-identical worlds on Linux, Windows and macOS. A cross-platform hash check in CI enforces it on every push.

This isn’t done by abandoning floating point for fixed point. Instead, simulation code only uses the f32 and f64 operations that Rust guarantees match IEEE 754-2008 exactly. A clippy lint enforces the ban.

Banned in simulation

✕ Transcendental functions such as sin and atan
✕ mul_add (fused multiply-add)
✕ Float reductions with no fixed order

Free to use them

✓ Rendering
✓ Audio
✓ User interface
For modders The same rule reaches Lua. Don’t use math.sin, math.atan or ^ on values that affect the world. See the six rules.

Platforms

CPU Linux Windows macOS
x86_64 SSE2 baseline
✓
✓
✓
aarch64
✓
✓
✓
i686 (32-bit x86)
✕
✕
✕

32-bit x86 is left out on purpose. Its x87 registers compute at 80-bit precision, so results round differently than on SSE2 or NEON and the determinism check can’t pass.

Needs Client Server
Graphics
Vulkan, Metal, DX12 or OpenGL
None. No GPU or display server, checked in CI.
Audio
ALSA on Linux, WASAPI on Windows, CoreAudio on macOS
None

ALSA only plays sound. Every byte a server sends is decoded by Symphonia, in pure Rust.

Build from source

Install Rust with rustup. The exact toolchain is pinned in rust-toolchain.toml, and rustup picks it up automatically.

1

System dependencies

Windows and macOS need nothing extra. On Linux, the client needs ALSA’s headers. The server needs none on any platform.

terminal · Linux only
sudo apt install pkg-config libasound2-dev
2

Build and test

terminal
git clone https://tiamatengine.com/tiamat.git
cd tiamat
cargo build --workspace
cargo test --workspace
3

Play

With no config file, this starts a server in the same process, connects to it over loopback and opens a window.

terminal
cargo run -p client
4

Run a server or join one

Start a dedicated server with the example config. To join someone else’s server, or change view distance, field of view and controls, copy client.example.toml to client.toml. The file documents each setting.

terminal
cargo run -p server -- --config server.example.toml

Stack

Languages in the repository, as reported by GitHub in September 2026.

Rust 94.4%
Lua 3.3%
WGSL 2.0%
Shell 0.3%
Rust engine
Lua content and mods
wgpu rendering
WGSL shaders
winit windowing
kira audio
Symphonia audio decoding
egui interface

License & charter

Part License
Engine
GPLv3-only
api/
MIT
Mods
Any license you choose, through the Additional Permission in LICENSE.EXCEPTION. More on mod licensing
Contributions
Developer Certificate of Origin. Authors keep their copyright. See CONTRIBUTING.md.

The charter

CLAUDE.md is the binding architecture charter. Read it before proposing anything structural. It covers:

The dependency firewall
The unit system
Determinism rules
The identity model
Handling untrusted assets from servers

The build plan lives in voxel-prompts/.

Scroll to Top