HoloVoxel · spatial & games

Level-of-detail isn't a mesh trick. It's how reading the world works.

Most voxel engines store a world as arrays of blocks and fake distant detail with mesh simplification, mipmaps, or LOD popping. HoloVoxel stores a chunk of the world as one holographic superposition instead: every voxel is bound (position ⊗ content) and summed into a single vector, using the Phasor VSA codec. Reading a voxel back is a correlation against that vector, and correlating with fewer components gives a cheaper, fuzzier answer — near stays crisp, far goes soft, with no discrete LOD tiers and no popping between them.

v1.3.0 net8.0+ engine only, no renderer verified headless free to use

dotnet add package EvaluatedApplications.HoloVoxel

NuGet →

Why it's different

the same read, at whatever cost you choose

LOD is free

There's no separate simplified mesh to generate, store, or stitch — the same hologram answers a near read and a far read, at whatever cost you choose to pay for that read.

Memory scales with perceived detail

A chunk only stores as many components as its LOD will ever need to read back, losslessly — the first k components of a truncated hologram are bit-identical to reading the same chunk in full.

The blur is honest, not aesthetic

Distant terrain looks soft because the engine genuinely has less information at that budget, not because a texture got downsampled — the same signal that saves compute also drives the look.

Engine only, plug into anything

No rendering or graphics dependency, verified headless. You bring the renderer, block palette, and world source (or use the built-in procedural generator).

What the same engine output can look like

a reference shading pass, not a shipped renderer

HoloVoxel hands you decoded colour fields, triangulated meshes with analytic per-vertex normals, and a confidence signal for how unambiguous each decoded point is — drawing them is up to your own renderer. As a proof of concept, the same mesh/confidence output was shaded with ordinary Lambertian lighting, heightfield ambient occlusion, and confidence-driven haze at distance, against a naive flat-block bake of the identical chunk data.

A HoloVoxel chunk rendered as flat, unlit blocks — the naive baseline. — naive flat-block bake

The same HoloVoxel chunk rendered with Lambertian lighting, ambient occlusion, and confidence-driven haze from DecodeMesh's real normals. — DecodeMesh + a reference shading pass

Same chunk, same engine data — DecodeMesh's analytic normals and FieldConfidence's ambiguity signal did the work; only the downstream shading changed. This shading recipe is a proof of concept, not something the package ships — HoloVoxel stays renderer-agnostic by design.

Key features

what you get

Holographic chunk storage

Encode a chunk once, decode it at any component budget as a colour field or a triangulated surface mesh with analytic per-vertex normals.

Continuous, meshless LOD

The same stored hologram serves a crisp near view and a soft far view; a distance-to-budget curve is provided as a starting point.

Field confidence for adaptive detail

Exposes how unambiguous each decoded point is, turning that into a signal that spends more budget only where the world is genuinely ambiguous, instead of a flat distance curve everywhere.

Spatial coarsening at distance

Far reads average over a footprint of the underlying world data, for both terrain height and material, rather than sampling a single noisy point — smooth, coherent shapes instead of speckled noise, independent of the component-budget blur.

Truncated holograms

Storage cost tracks the LOD budget you actually plan to read at, not the size of the world.

Entities too

HoloModel stores a creature or prop the same holographic way, with the same LOD and confidence machinery, independent of the terrain grid.

Built-in procedural generator

WorldGen with biomes, height fields, and optional maze layout — or supply your own world source and skip it entirely.

Ringworld warp

A pure flat-to-cylinder coordinate transform for cylindrical/ringworld spaces, on top of the same flat chunk storage.

Good to know

this is the engine, not the renderer

HoloVoxel has no graphics or engine dependency and is verified headless — it hands you decoded colour fields, meshes, and confidence values; drawing them (shaders, GPU decode, a game engine binding) is up to the consuming front end. It's built on Phasor: HoloVoxel's chunk hologram is a direct application of the Phasor VSA codec, so if you're already using Phasor elsewhere, the same binding/correlation model is reused here for space instead of arbitrary data.

No license gate: every capability in this package is free to use today; DLL-only distribution, proprietary license. Get it: dotnet add package EvaluatedApplications.HoloVoxel.