bractlabs
Early access
EngineDemosEditorRequest early access
Early access · 2026

Planet-scale worlds.
Native to the web.

Bract is a GPU-driven WebGPU engine. Rendering, procedural generation, physics and streaming were designed together from the first commit, so one browser tab can hold an entire world, from orbit to the ground beneath your feet.

Request early access →Explore the engine

WebGPU · WGSL · TypeScript · WebAssembly

400K+lines of engine and editor code
64architecture decision records
3physics backends: Jolt, Havok, native
0installs. It runs in a browser tab
Why Bract

Designed together, from the start.

Most engines bolt scale on later. In Bract, the renderer, the generators and the spatial systems share one set of contracts. That is why they hold up when the world gets big.

01

Rendering

A GPU-driven WebGPU pipeline. Culling, LOD selection and indirect dispatch stay on the GPU, lit by clustered lights, virtual shadow clipmaps and a physically based sky.

02

Procedural

Terrain, erosion, biomes, foliage and oceans are generated, not authored by hand. Generators run as GPU compute and WASM, and the same seed gives the same world every time.

03

Scale

Double-precision world positions, a floating render origin, a dual spatial tree and a residency system that streams what the camera needs, from orbit down to the ground.

Inside the engine

Already running, every frame.

Each of these systems runs in the engine today. We test them in automated suites and check them visually in a live browser.

render

GPU-driven by default

Visibility, LOD binning and draw generation run in compute shaders. The CPU describes the frame and the GPU builds it.

shadows

Virtual shadow clipmaps

Page-resident shadow maps keep contact detail near the camera and stable coverage out to the horizon.

lighting

Spectral atmosphere

A physically based sky drives image-based lighting and an HDR, scene-referred post pipeline.

lighting

Clustered lighting

Lights are binned into clusters on the GPU, so dense night scenes stay within a predictable cost.

space

Planetary precision

Double-precision world space with a floating, cell-anchored render origin keeps precision intact at planetary distances.

generators

Procedural terrain

Thermal, particle and wind erosion, layered biomes and noise stacks, computed on the GPU.

nature

Foliage and scatter

Procedural trees compiled through WASM and scattered by biome, with LOD built in.

fluid

Water, from pools to oceans

FFT ocean surfaces and GPU-resident fluid state, integrated with the compute pipeline.

physics

Deterministic simulation

Tiered determinism enforced by CI canaries. You can run on Jolt, Havok or the native solver.

See every system →
Architecture

Built like infrastructure.

Backends sit behind typed adapters. Serializable state lives in an entity–component model. Every major design choice is written down as an architecture decision record before we build it.

  • Swap rendering, physics, audio and compute backends without touching game code.
  • Headless adapters run the whole engine in CI with no GPU.
  • Deterministic tiers, from bit-exact CPU math to visually stable GPU output.
Demos

See it in motion. Soon.

Playable builds open alongside early access. Each one runs in your browser, with nothing to install.

Coming soon

Bract Racer

Six cars, full physics, a live race HUD and an in-car radio, on a procedurally dressed circuit.

Coming soon

Planet Freecam

Fly from orbit to ground level over a procedural planet under a spectral sky.

Coming soon

FFT Ocean

Spectrum-driven open water simulated on the GPU.

Editor

An editor that runs on the same renderer.

The scene you edit is the scene you ship. Modeling, materials, lighting, terrain and scatter all live in one browser workspace.

Preview the editor →
Early access 2026

We are opening the doors.

Early access opens in waves for studios, technical artists and teams building large worlds on the web. Tell us what you are making.

Request early access →Read the engine overview