Skip to main content

Balaur A 2D & 3D node-based game engine, fully deterministic,
with scripts that reload in milliseconds.

Written in Rust. Fast to run, fast to iterate, easy to use — and one file to ship.

Read the docsFeaturesPrinciplesDownload

For designersScene and Interface personas

Real-time design, no build step.

  • Place, move and scale in the viewport; every property is a row in the inspector, and every change is undoable.
  • Materials, lights, shadows and particles, live in the scene you are editing.
  • Press play. The scene you designed is the game, and the HUD is laid out over the safe area right there.

Scenes and nodes →UI →Open examples/angrynerds →

For programmersScript persona

Save the script. It is already running.

  • Rune reads like Rust without the types: no build step, async/await, one language for the game and the editor.
  • Hot reload in milliseconds with state intact; breakpoints, stepping, frames and locals in the editor.
  • Plugins in Rust or C when you want the metal, and one file to ship when you are done.

Balaur for game developers →Scripting →Extensions →Open examples/hello →

For animatorsAnimate persona

2D and 3D animation for games, rigged where you play it.

  • Bend and deform images with mesh skinning: bones, painted weights, polygons.
  • Pose with inverse kinematics, two-bone IK and look-at, and key it in the timeline.
  • 3D rigs imported from glTF; clips, tweens and twelve easings drive any property.

Balaur for animators →Animation manual →Open examples/rig →

For multiplayer and simulationPhysics persona

Deterministic by default: same inputs, same bits, on every machine.

  • A fixed 60 Hz tick and a digest per tick, so the engine can prove two machines agree.
  • Record inputs only, network included, and replay the whole session; rollback-ready.
  • HTTP, websockets and QUIC delivered once per tick; rooms and server hooks through Gamend.

Balaur for multiplayer →Determinism manual →Open examples/angrynerds →

For artistsScene persona, shaders and rendering

Lights, shadows and shaders you can read.

  • 2D lights and occluders build a light map every sprite, polygon and tile is lit by.
  • Materials in WESL, WGSL with imports and variants, linked at run time rather than at build.
  • Post-processing, particles, tile maps, sprites and meshes on wgpu.

Rendering →Shaders and materials →Open examples/shaders →

Two 2D lights over a scene, the shapes casting shadows from occluders

Nodes and scenes

A game is a tree of named nodes with scripts attached. Scenes are plain TOML.

Scripting in Rune

Rust's syntax, no build step, async/await, and a debugger in the editor.

Instant hot reload

Save a script while the game runs: the new code is live in milliseconds, state intact.

Determinism, always on

Same inputs, same bits on every platform. Record a session and replay it, network replies included.

2D and 3D physics

Rapier under both, stepped on a fixed 60 Hz tick, declared in scenes or driven from scripts.

Rendering

3D and 2D on wgpu: windowed, offscreen for screenshots and CI, or fully headless.

Animation and skeletons

Clips and tweens, 2D bones with skinned polygons, 3D rigs from glTF, two-bone IK.

The editor

Itself a Balaur project: scene tree, inspector, gizmos, timeline, rig tools, play-in-editor.

Networking

HTTP and websockets with compression, delivered into the simulation once per tick.

Every platform

Windows, macOS and Linux today; iOS, Android and the web are cross-compiled in CI on every push.

One file to ship

Export fuses bytecode, scenes and assets onto the runtime: one self-contained binary per target, nothing to install.

Built on Rust

Safe Rust throughout, and the ecosystem as it is: Rapier, wgpu, egui, rodio, Rune.

Free and open source, MIT. Windows, macOS and Linux.

DownloadGetting started