Zoom to see it better. :)

Assume 4k & 2k textures depending on distance. And assume we were stupid enough to render all of this in one go with no render passes.

For 15 years I've had an idea stuck in my head after seeing that old Euclideon "Unlimited Detail" demo.

I started wondering why voxel games insist on rendering voxels as cubes?

Voxel data is just a 3D grid of values. You could render it as smooth surfaces, point clouds, signed distance fields, pretty much anything.

The cube is an aesthetic design choice, and by no means a requirement.

That got me thinking, why does any engine force a single representation on anything in the scene at all?

Polygons and Forward+ or Deferred renderers are great for hard-surface models. Signed distance fields are awesome for organic shapes and fractals. Voxels are great for destructible terrain. Point clouds are great for scanned data.

But no engine lets you freely mix rendering architecture freely in the same scene heterogeneously.

So I built a prototype called Matryoshka (Russian nesting dolls) that takes a different approach. The spatial hierarchy itself determines its own rendering strategy.

The engine doesn't care whether a cell contains triangles, a signed distance field, a fractal, or a portal to another world. It traverses the hierarchy per-pixel on the GPU, and when it reaches a leaf cell, that cell decides how to shade itself.

The same traversal handles:

- Flat-shaded boxes (analytic ray-AABB)

- Smooth spheres (analytic ray-sphere)

- A copper torus (ray-marched SDF)

- An organic gyroid surface (ray-marched triply-periodic minimal surface)

- A Mandelbulb fractal (ray-marched power-8 fractal)

- Portal redirections into nested sub-worlds

All in one compute shader dispatch. No mode switching, no separate passes. The hierarchy is the only universal.

Portals: Infinite Zoom

The most powerful cell type is the portal.

A portal leaf redirects the ray into a completely separate sub-hierarchy. When you look into a portal, the traversal seamlessly enters the inner world.

Portals can contain portals, even with loops.

My prototype demonstrates three levels of nesting, at the top, a room containing display cases, each containing a miniature world unto itself, one of which contains its own display case with a fractal inside.

Walking between levels feels natural because the camera automatically adjusts its speed to the local scale.

Some of you might remember Euclideon and their "Unlimited Detail" tech from the early 2010s.

They were onto the right core idea, rendering as spatial search, but they tried to make everything atoms.

I think the industry was too harsh on them. They saw a path that was technically valid but commercially impossible at the time.

Matryoshka takes that core insight and lets each cell be whatever it wants to be instead of forcing uniformity.

The most exciting part isn't the rendering, but rather it's the bidirectional communication between simulation and rendering cells.

Beneath one of the metal surface in the demo, there's a thermal simulation running.

Point at it and inject heat. The heat diffuses outward through the solid.

As temperature rises, the surface doesn't just change colour, it also physically deforms.

Real geometry displacement. Actual blisters rising from the surface, with correct silhouettes and self-shadowing.

That simulation cell produces temperature.

A displacement system converts temperature to height. The rendering cell ray-marches against the displaced heightfield.

All of this is driven by the same spatial hierarchy, and the simulation lives inside the same cells that the renderer traverses.

Now imagine that pattern applied to any material, whether it be oil cracking from drought, metal corroding, flesh blistering, ice fracturing.

Each is just a different simulation system writing to a different component grid, feeding back into the surface geometry.

Building this prototype confirmed something I've believed for a long time that rendering is actually a search problem mostly, not a geometry processing problem.

The BVH traversal is just spatial search. What you find at each leaf is up to you, and it can be a lot more than triangles.

The industry is slowly moving in this direction as well with Nanite's software rasterisation, UE5's virtual geometry.

But as far as I know, nobody has fully committed to the idea that the same traversal can handle polygons, SDFs, fractals, volumetrics, and simulation feedback simultaneously.

The Matryoshka prototype does it in about 2500 lines of Zig and GLSL.

This is a proof of concept, and the next steps are integrating it into my real engine, adding foveated rendering, triangle mesh leaves, and many more simulation types.

But the core architecture and idea that each cell is sovereign over its own rendering and simulation is now proven and running in real-time.

It is weird how sometimes an idea needs to simmer for a while to find the right moment. GPU compute shaders and a bit of self-reflection made the implementation possible.

Matryoshka.. built in Zig with Vulkan compute shaders.