Technical breakdown — Strata by Cornerstone Studios

Overview

Strata voxelizes every module and stores it with a per-module symmetry map. On the reference backend a per-cell coverage comparison runs during the bake; the faster path skips that check by design. The bake pipeline is the engine's structural boundary: every module is voxelized, symmetry-mapped, integrity-checked on read, and the full library reproduced byte-for-byte in the runs we have measured. Compute-backend parity has been cross-checked on exactly two modules so far, and a per-bake parity gate is the next piece. Below: the measured behavior, then the architecture that produces it.

The numbers

Certified library	99 modules across 3 resolution tiers — certified for cell coverage, not voxel equality
Resolution tiers	4,096 / 32,768 / 262,144 cells / module
Symmetry-reuse speedup	Fleet aggregate 5.8× at the 32-cube tier (total CPU wall ÷ total GPU wall, 99 modules). Per module the spread is far wider and runs both ways: from 1.0× (no benefit) up to 26×, with about a third of modules under 5×. Measured separately, without symmetry skipping the GPU path was slower than the CPU reference at a coarser tier — two runs, not one controlled comparison.
Certification coverage	every module, every resolution tier — cell coverage, not voxel equality (see below)
Incremental certification	O(1) to add the Nth module
Backend selection	data-driven: measured GPU vs CPU wall time / module

Figures from the certification matrix as of 2026-05-17, at the stated resolution tiers. Comparisons are against the CPU baseline or oracle, or published voxel literature where noted; no superlatives beyond the stated baseline.

Architecture

Every module flows geometry → bake → symmetry map → certified library. *The per-cell coverage comparison runs on the REFERENCE backend only — the faster path skips it by design, so it is not a stage every bake passes through. Cross-implementation parity is a separate check, run on two modules so far.

Voxel I/O & integrity

Voxels persist in a compact binary format — a fixed header plus a tightly packed occupancy payload, sized deterministically from the grid so a reader knows the exact expected byte count up front.
Integrity is verified on read, never assumed: a file whose size doesn't match its declared cell count is rejected as incomplete instead of feeding a corrupt bake downstream.
Partial-write detection — a worker killed mid-write (crash, OOM, power loss) leaves a truncated file that is detected and re-queued, never shipped as garbage geometry.
Batch bakes are resumable: a stamp records exact executable identity and GPU adapter set; completed outputs are pre-scanned on restart, so an interrupted fleet bake continues instead of restarting from zero.
Pre-flight guards (free disk, 64-bit binary) run before a batch starts — a doomed run fails fast and loud, not halfway through. Output paths are deterministic, so re-runs and resumes are idempotent.

The voxelization pipeline

A tiered bake: coarse-to-fine detail levels resolve in sequence, so a usable preview appears fast and refines toward final fidelity.
Multiple interchangeable backends behind one entry point — a CPU reference path and GPU-accelerated paths — chosen automatically by an occupancy policy.
Correctness-first: ambiguous surface cells are confirmed against a CPU oracle, so GPU speed is not traded against a wrong solidity decision at the boundary -- with the standing caveat that the sweep measures cell coverage, so it does not detect over-production; only the unsure cells take the slow path.
Adaptive and uniform modes — spend detail where geometry is complex, stay cheap where it isn't.
Every bake emits a structured result (per-phase timings, resolved backend, pass/fail), and on the reference backend also a coverage-vs-reference delta. It is deterministic in the runs we have measured: identical input reproduced identical voxelization across a full 99-module rebuild, which is what makes automated certification practical.

Out-of-process GPU worker & certification

Heavy voxelization runs in a dedicated out-of-process GPU worker, isolating the editor from driver hangs and giving bakes the full GPU.
Multi-GPU aware: work splits across available adapters by capacity, not naive round-robin; a VRAM budget check refuses a batch that wouldn't fit instead of crashing the driver mid-run.
Versioned worker protocol — the worker refuses a bundle whose manifest version it doesn't support; a stale binary fails loudly, never produces subtly wrong output.
Certification sweep: every module is baked and checked against the reference across resolution tiers at CELL granularity, and only modules that clear that check are certified GPU-preferred. Cell granularity is not per-voxel equality, and the two-implementation parity comparison has been run exactly on two modules so far.
Fleet-scale and unattended: per-job wall-time and stall detection mean one bad module cannot wedge a full-library run. The certification matrix is the engine's standing integrity check.

Symmetry equivalence

Many voxel cells are rotations of each other. The engine computes a canonical representative per equivalence class under the 24 proper cube rotations, and where symmetry skipping is enabled it bakes the canonicals and reconstructs the rest.
Equivalent cells are reconstructed by exact transform from their canonical source instead of re-voxelized — large speedups on symmetric geometry. The reconstruction is not content re-verified today; a post-reconstruction spot-check is the guard we want before reuse is trusted more widely.
Reconstruction uses proper rotations only — reflections are deliberately excluded, which costs available reuse rather than correctness — and goes through the same cell-coverage certification as every other path.
Proper cube rotations commute with grid subdivision, which is what makes cross-resolution priming possible; that priming is on the roadmap, not built. Symmetry maps persist to a versioned snapshot store.
Preflight visibility — canonical vs equivalent is inspectable before a bake commits, and geometry with no usable symmetry simply bakes every cell.

Diagnostic bundle export & retention

One action captures a complete snapshot of any bake run — geometry, per-phase timings, the backend that resolved it, the certification verdict, certification status, logs, and a viewport screenshot — into a single portable archive.
Self-contained and human-readable: JSON + plain text + an image, openable and greppable without the engine installed.
Captures the decision trail, not just the result: why a compute path was chosen, where CPU and GPU agreed or diverged, and the exact pass/fail reasoning.
Built-in surgical retention: aged archives are pruned automatically; it only removes artifacts it created, never unrelated files, and cleanup can never block or fail an export.
Tiered and bounded: a full mode for deep instrumentation, a compact mode for fast triage; large traces are size-capped so one pathological run can't run away.

Cell-level bake inspector

An x-ray into voxelization: inspect the solidity decision for individual cells, not just the final mesh.
Side-by-side CPU-reference vs GPU comparison with automatic divergence localization — exactly which cells disagree, and by how much.
Live verdicts on an inspected bake: cell-level deltas plus a pass/fail certification, so regressions surface immediately. The deltas are cell coverage; cross-implementation parity is the separate two-module check.
Resolution sweeps catch divergence that only appears at finer voxel grids; symmetry preflight shows canonical vs symmetry-equivalent cells before a bake commits.
Fully scriptable: it drives headlessly over a command channel, so inspection and certification run automated, not just interactively.

Reflection-based introspection

Diagnostic payloads are assembled by runtime reflection over the engine's own result schema — every metric the engine records appears in exports automatically, with no hand-maintained mirror.
Structurally eliminates schema drift: “new field added but forgotten in the dump” becomes impossible by construction.
Type-aware projection emits only stable serializable fields; live object references are skipped automatically instead of crashing the export.
Backward-compatible output contract: field names and structure stay stable across engine versions, so external tooling and scripts keep working.
Self-describing and reversible: unmatched schema fields surface as explicit diagnostics, and the reflection path is validated against the prior output before the old one retires.

Engineering practices

Differences between the fast path and the reference surface as a measurable delta localized to a cell. That delta measures cell coverage, not per-voxel equality. Full GPU/CPU cross-implementation parity has been checked exactly on two modules, not on every bake.
Worker processes self-terminate via pipe heartbeat after sustained controller silence.
The multi-resolution certification matrix spans an order of magnitude in cell count; what it certifies is cell coverage rather than voxel equality, and the per-cell comparison behind it runs on the reference backend.
The certification pipeline supports per-asset incremental verification, orphan-row purge, and pre-destructive backup.
The diagnostic snapshot exporter produces a portable archive on demand for any bake run.

How correctness is checked

Most voxel engines show screenshots and ask you to trust them. Strata runs a per-module certification sweep instead: every module, every resolution tier, compared against a ground-truth oracle, with any mismatch localized to a cell rather than reported as a pass/fail mood.

Being straight about what that currently proves: today the sweep certifies cell coverage — whether the fast path found the cells the oracle found — not per-voxel equality within those cells. Those are different guarantees, and only the first one is established. Closing that gap is the current gate, and it is deliberately ahead of the features that would sit on top of it, because a voxel that is wrong underneath becomes a crack in the wrong place once physics and remeshing run on it.

Deterministic and reproducible — a full 99-module rebuild reproduces every output byte-for-byte, verified with a control that would catch a no-op. Correctness gating is still being built: the parity check that would prove voxel equality is the next piece.

The boundaries on that, because a claim without them is half a claim: the determinism run was one machine, one session, one resolution tier — it is not a cross-build or cross-machine guarantee. What else genuinely holds: a rebuilt out-of-process worker runs the whole pipeline end to end across all 99 modules with none failed, and the voxel artifacts satisfy their completeness contract and decompose exactly. Those are narrower claims than “provably correct”, and they are the ones we can actually show. See where this is headed.