Voxel truth, mesh fidelity.

What it is

Two families of engine, two compromises. Pure-voxel engines have a real simulation underneath but look like stacked blocks. Pure-mesh engines look convincing but fake their destruction along seams an artist authored in advance. Strata is an attempt to take the first one's honesty and the second one's appearance.

Every block is voxelized at micro resolution, and each voxel is meant to carry a real material. That is meant to become the ground truth for solidity, material and physics — the skeleton, not the skin. The surface you see will be a real mesh, regenerated from the current voxel state whenever that state changes, so that the mesh is a view of the simulation rather than something hand-authored alongside it.

Why it's built this way

Because the material and the forces will live in the same place — down at the voxel — breakage would not need pre-drawn crack patterns: stress would run on the lattice, the material would fail where it genuinely gives, and the surface would re-form around what remains. Concrete should crumble like concrete and steel should bend like steel, not because someone tuned a debris effect for each of them, but because they are made of different stuff and the stuff would be what gets simulated.

The bridge between the two halves is the remeshing. It is also the hard part, and it is what we are building next — not something we are claiming today. The voxel backbone underneath it exists and is written on every placement; what does not exist yet is everything that reads it back.

What it's for

The voxel world skews toward procedural terrain. Deliberate structures — assembled from a known-good kit of parts, then broken in ways that respect how they were assembled — is mostly unclaimed ground. Construction and destruction as one system rather than two: what you build should be what breaks, and it should break according to what it was built from.

Where it actually is

The foundation comes first, and the foundation is correctness. Once voxels drive material, stress, fracture and the mesh you see, a wrong voxel is a wrong crack in the wrong place — so the bake pipeline is built as a correctness boundary, not a renderer. Its job is to produce results that can be checked rather than admired. On the reference backend a per-cell coverage comparison runs during the bake, and a mismatch is measurable and locatable rather than a pass/fail mood. The faster path skips that check by design, and what the comparison measures is cell coverage rather than voxel equality — the check that would prove equality is the next piece. Full cross-implementation parity has been run on two modules so far.

That checking runs today, and it is where the honest numbers are — with one qualification we would rather state than have found: what it certifies today is cell coverage, not per-voxel equality, and closing that gap is the current gate. Where geometry is symmetric, the bake can recognize it and skip redundant GPU work. With skipping on, the GPU path measured 5.8× the CPU reference across the 99-module library at the 32-cube tier — per module that runs from no benefit at all up to 26×; in a separate run with it off, the GPU path was slower than CPU. Those are two measurements rather than one controlled comparison, so we read symmetry as what makes the GPU path pay without claiming a measured on/off delta. Elsewhere in the pipeline, symmetry is measured rather than acted on yet. The simulation and the live remeshing are still ahead of us. The figures behind what does run are on the technical page.