Technical breakdown — Strata by Cornerstone Studios

Overview

Strata voxelizes every module, certifies it for compute-backend parity, and stores it with a per-module symmetry map. The bake pipeline is the engine's primary correctness boundary: nothing enters the library that hasn't been parity-checked. Below: the measured behavior, then the architecture that produces it.

The numbers

Certified library	99 modules across 3 resolution tiers
Resolution tiers	4,096 / 32,768 / 262,144 cells / module
Full-pipeline GPU bake	176× vs CPU oracle — single high-symmetry module, 16-cube
Runtime symmetry cache hit	96.8%
Symmetry-reuse speedup	5–16× / module (finer resolution)
Cylinder module bake	8+ min CPU → < 30 s with reuse
Correctness drift	0 across 99 modules × 3 res × 4 backends
Incremental certification	O(1) to add the Nth module
Backend selection	data-driven: measured GPU vs CPU wall time / module
Batch bake	99-module batch in 22.2 s wall (≈ 0.22 s/module avg)

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. The 176× full-pipeline figure was measured 2026-05-05 on a single high-symmetry module at 16-cube resolution. The 96.8% runtime symmetry cache-hit rate has no published analog at this scale during live baking.

Architecture

Every module flows geometry → bake → backend parity → symmetry map → certified library.

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 never costs a wrong solidity decision at the boundary; 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, parity vs reference, pass/fail) and is deterministic: identical input yields identical voxelization, which is what makes automated certification possible at all.

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 its GPU output compared cell-for-cell against the CPU reference across resolution tiers; only exact-parity modules are certified GPU-preferred.
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 or reflections of each other; the engine computes a canonical representative per equivalence class and bakes only the canonicals.
Equivalent cells are reconstructed by exact transform from their canonical source instead of re-voxelized — large speedups on symmetric geometry with zero change to the result.
Correctness-preserving by construction: reconstruction uses proper rotations and is verified by the same parity certification as every other path.
Cross-resolution reuse: proper cube rotations commute with grid subdivision, so canonical work at one resolution primes finer resolutions. Symmetry maps persist to a versioned snapshot store.
Preflight visibility — canonical vs equivalent is inspectable before a bake commits; geometry with no usable symmetry simply bakes every cell, so the optimization is never a correctness risk.

Diagnostic bundle export & retention

One action captures a complete snapshot of any bake run — geometry, per-phase timings, the backend that resolved it, the parity 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 parity verdicts on every inspected bake: cell-level deltas plus a pass/fail certification, so regressions surface immediately.
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

Every bake runs a GPU/CPU parity comparison; mismatches surface as a measurable patchDelta with cell-level localization.
Worker processes self-terminate via pipe heartbeat after sustained controller silence.
The multi-resolution certification matrix maintains parity across an order of magnitude in cell count.
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.

Provable correctness

Most voxel engines show screenshots and ask you to trust them. Strata maintains a per-module certification sweep with zero correctness drift across 99 modules, three resolution tiers, and four compute backends. Parity isn't a footnote here — it's the gate. See where this is headed.