The engine
REACT
A proprietary engine written from scratch, entirely in-house. It grows planets from plate tectonics, simulates their oceans and skies from physics, and lights story scenes with real-time global illumination.
- C++ core
- OpenGL + Vulkan
- Custom physics
- In-engine editor
- Not for sale
Systems
Six systemsone codebase
Rendered in REACT
Planetary terrain
Worlds start as a set of tectonic plates drifting over a sphere. Where plates collide, crust folds into mountain belts. Where they pull apart, rifts and ocean ridges open. Rivers then erode the uplift into drainage basins, and climate assigns biomes from latitude, altitude and rainfall. Nothing is painted by hand, and nothing is random noise pretending to be a landscape.
How it works
Rendered in REACT
Oceans
The ocean surface is synthesized from an empirical wave spectrum and animated with an inverse FFT every frame, the same technique used in film water. Shallow water turns clear and green over sand, deep water swallows red light first, and whitecaps appear exactly where the simulation says a wave is folding over itself.
How it works
Rendered in REACT
Atmosphere & weather
The sky is not a gradient. REACT precomputes how sunlight scatters off air molecules and aerosols, so dawn, noon, sunset and the view from orbit all fall out of one physical model. Volumetric clouds drift over the terrain, shadow it, and carry weather around the planet.
How it works
Rendered in REACT
Global illumination
Light in REACT bounces. Sunlight through a window lights the whole room, a red wall tints everything near it, and a neon sign is a real light source, not a sticker with bloom. The renderer voxelizes the scene and traces cones through it every frame, so the lighting reacts the instant anything moves.
How it works
Rendered in REACT
Materials & reflections
Shading is physically based end to end: energy-conserving BRDFs, proper Fresnel, roughness that behaves the same under sun and neon. Mirrors and polished metals get live reflections, and emissive materials feed directly into the GI system.
How it works
Rendered in REACT
Editor & tools
Everything is authored inside the engine itself: scene editing, material tweaking, terrain inspection, profiling. The editor hot-reloads shaders and scripts, and every chart in the documentation was exported straight from its profiler.
Architecture
Five layers, no black boxes
Each layer only talks to the one below it. That discipline is what keeps roughly ninety thousand lines of C++ manageable: when something breaks, there is exactly one place it can be.
Editor
Built on the engine it edits
Scene editingMaterial editorTerrain inspectorProfilerHot reload
Renderer
OpenGL today, Vulkan backend in progress
Clustered forward shadingVoxel GIAtmosphere LUTsFFT oceanVolumetric cloudsPost stack
Simulation
The part that grows the worlds
Plate tectonicsFluvial erosionClimate and biomesRigid body physicsBuoyancyOrbital mechanics
Core
Shared by everything above
Math libraryECS scene modelAsset pipelineJob systemLua scripting
Platform
The only layer that touches the OS
WindowingInputFile I/OAudio backendMemory allocators
Performance
11.2 ms, measured honestly
This is a full frame of the coastline scene at 1440p on a desktop RTX 4070: planet terrain, simulated ocean, physical sky and voxel GI all running at once, with room to spare under the 16.6 ms budget of 60 fps.
The numbers come from REACT's own GPU profiler, averaged over 1,000 frames. The same profiler exported every performance chart in the documentation, so what you read there is what the engine actually does.
GPU time per system
total 11.2 ms / 89 fps
Global illuminationvoxelize, inject, trace0.0 ms
Shadingclustered forward + shadows0.0 ms
Terrainquadtree update + draw0.0 ms
OceanFFT + surface shading0.0 ms
Post processingTAA, bloom, tonemap0.0 ms
AtmosphereLUT lookup + clouds0.0 ms
Everything elsephysics, scripts, UI0.0 ms
Specifications
The full spec sheet
Everything below is implemented and running, not planned. Where a number appears in the documentation, it matches this table.
Core
- Language
- C++20, with C at the platform edges
- Codebase
- roughly 92,000 lines, zero engine middleware
- Scene model
- custom ECS, archetype storage
- Scripting
- Lua, hot-reloaded at runtime
- Threading
- job system, frame graph schedules GPU work
- Determinism
- one seed reproduces a whole world, bit for bit
Renderer
- APIs
- OpenGL 4.6 today, Vulkan backend in progress
- Lighting path
- clustered forward, HDR throughout
- Global illumination
- voxel cone tracing, 256³ clipmap, 3 cascades
- Materials
- physically based GGX, energy conserving, emissive feeds GI
- Shadows
- cascaded maps for the sun, cached locals
- Anti-aliasing
- temporal, with filmic tonemap and bloom
World simulation
- Terrain
- plate tectonics plus 200 steps of stream power erosion
- Scale
- planet radius 6,371 km, finest detail 0.3 m
- LOD
- cube-sphere quadtrees, 20 levels, geomorphed
- Precision
- double precision camera-relative positions
- Streaming
- fully asynchronous, zero loading screens
- Climate
- latitude, altitude and rain shadow drive biomes
Ocean and atmosphere
- Waves
- Phillips spectrum, inverse FFT, 3 cascades of 256²
- Foam
- from the displacement Jacobian, not painted
- Underwater
- Beer-Lambert absorption per color channel
- Sky
- precomputed Rayleigh and Mie LUTs, 4 scattering orders
- Clouds
- raymarched volumetrics, weather-driven coverage
- Aerial perspective
- same LUTs applied to distant terrain
Physics
- Rigid bodies
- custom solver, sequential impulses
- Buoyancy
- sampled from the displaced ocean heightfield
- Ropes and joints
- position based, stable under load
- Orbits
- Keplerian elements for planets and moons
- Queries
- raycasts and sweeps against terrain at any LOD
Tooling
- Editor
- in-engine, edits the running scene live
- Hot reload
- shaders, Lua scripts and materials
- Profiler
- per-pass GPU timings, CSV export (source of every chart in the docs)
- World inspector
- view uplift, drainage and biome fields directly
- Platforms
- Windows now, Linux planned
Lineage
Not the first engine, just the one that survived
Years of throwaway engines and renderers came before it. They were never wasted: every dead end taught something that REACT now does right the first time.
2024
First engines
A voxel engine, software rasterizers and a stack of renderer prototypes. Each one built to answer a question, then retired once it had.
2025
Renderer experiments
Deferred versus forward, shadow techniques, early GI attempts. The lessons from this year decided most of REACT’s architecture.
2026
REACT is born
Real-time global illumination, physics, and an in-engine editor that can rebuild the engine around itself.
2026
Planetary scale
Earth-sized worlds grown from tectonic plates, with erosion, climate, biomes and forests. Then oceans, atmospheres and whole solar systems with real orbits.
Next
The first game
A story-driven title in hand-built scenes, not a planet sim. The planetary tech proved the headroom; the game gets to spend it. It releases here, on this site.
Go deeper
Every system has a write-up
The documentation explains how each system works, from the physics to the data structures, with graphs measured in engine.
Read the documentation