Clouds wrapped around a sphere, generated by particles moving according to simulated wind bands that we then stamp a heightmap onto as they drift across the planet. The raymarch shader samples the heightmap to determine density along each ray.

Naive raymarching of a planetary atmosphere is brutal. One trick is temporal amortization: render a fraction of the pixels every frame, write them into a history buffer, and reproject the history forward as the camera moves. Another trick is extensive use of precomputed LUTs to reduce the cost of raymarching itself.

A Mk19 automatic grenade launcher kicks up an absurd amount of dust, which can be a genuine targeting concern. The training app needed that to feel right: long-lasting plumes that settle slowly and accumulate with repeated impacts.

The approach I went with was a 2D heightfield projection. Each explosion writes a circular density-and-height stamp into a world-spanning RenderTexture. A compute shader handles diffusion and natural settling. The raymarching shader uses 3D worley noise to erode the dust for a more organic appearance. The player position is static and the experience is overcast, so I was able to get away with some low-iteration, subtle lightmarching to enhance the dimensionality of the dust. And since the dust is visually low-frequency (and accompanied by separate, higher-frequency particle effects), quarter res rendering with temporal amortization met both our visual and performance goals.

Province borders on a planet sphere, the way Paradox grand strategy games render them on flat maps. The obvious approach (bake borders into an equirectangular texture) breaks at the poles where the projection compresses one axis into a singularity. It doesn't work for spheres (at least if you want them to look good).

The fix is to do the whole thing in screen space. Render an intermediate province ID buffer, then run jump flooding across the buffer to compute, for each pixel, the distance to the nearest pixel of a different province ID. Boom, beautiful undistorted borders on a spherical planet.

Whole-planet terrain that builds itself as you fly around it. New mesh chunks are generated asynchronously on a DOTS job system as the camera moves, so the main thread never stalls waiting on geometry. Chunks stream in across frames and hand their finished meshes back when ready.

Each chunk's surface is procedurally generated from a planetary heightmap index map, and then further modified by a coarse global height texture. Every pixel points at a specific heightmap to sample, letting different regions pull from purpose-built high-fidelity terrain instead of one stretched global texture. Parallel jobs do the per-vertex sampling and mesh construction.

At Earth scale, float precision falls apart thousands of kilometers from the origin and geometry starts to jitter. A floating origin system continuously recenters the world on the camera, keeping everything close to zero so positions stay precise no matter how far you've travelled.

Battlespace-scale F-16 engagement telemetry rendered as procedural flight-path geometry. A compute shader builds the ribbon mesh directly from the telemetry buffer each frame and issues a DrawIndirect call, so the CPU never touches vertex data.

Rendering a massive amount of on-screen text without the per-character draw call overhead that normally makes that impossible. Characters are drawn as SDF quads via a single instanced indirect draw call, so all text in the view costs only one call regardless of how much is on screen.

The performance additionally comes from CPU-side data locality: character instance data is cached and laid out for sequential access so the CPU can rip on it with minimal cache misses (this is where the fade behavior lives). Per-instance fade is computed from the view, letting every label fade in and out smoothly against the camera for next to nothing. It's basically TextMeshPro after it decided to start lifting and glow up. (I accidentally typed TexMexPro just now and now I'm hungry.)

The interaction layer behind every Procedures module. Custom fresnel emission shader marks interactive parts, a proximity term drives error highlighting that responds to hand position, and a dithered fade lives entirely in the opaque pipeline to dodge alpha-blending cost on tile-based mobile GPUs.

Continuous level of detail with the entire quadtree living and updating on the GPU. The CPU never sees a node or a triangle. The quadtree subdivides toward the camera. Every leaf node carries a compact bit-packed key: three bits for the cube face, then two bits per level encoding which of the four children it descends into, with the highest set bit marking the node's depth. The full path (the patch's position and size) is recovered straight from the key with bit ops.

Each frame the tree is refined by ping-ponging two append/consume buffers: a compute pass consumes the current set of leaves and writes the next generation. Leaves close to the camera split into four children; leaves that have fallen far back collapse into their parent; the rest pass through untouched.

The surviving leaves emit their triangles into an append buffer that's drawn directly with DrawProceduralIndirect. A tiny helper pass turns the appended triangle count into the vertex count for the indirect draw args via CopyCount and an indirect dispatch, so the GPU drives its own draw with zero readback. The CPU's whole job each frame is handing over the camera matrices and kicking off the dispatches.

A personal project: a space station whose hull you can breach. The interior is a grid where every cell carries pressure, velocity, temperature, and a gas mix, tagged as open, wall, or vacuum. It's built from the ship's actual tile layout, so walls seal rooms, an open door connects two of them, and the edge of the world is open space sitting at zero pressure.

Every fixed step a compute shader runs a diffusion relaxation pass over the whole grid: each cell pulls its pressure toward the average of its eight neighbors, the same kind of iterative solve behind stable-fluids diffusion, converging over successive frames. Walls are masked out with branchless comparisons rather than if branches, so air only moves between connected cells and a sealed room holds its room pressure indefinitely. Velocity falls straight out of the pressure gradient (gas accelerates from high pressure toward low) and any cell exposed to space is pinned at zero, turning a breach into a sink the entire compartment drains toward.

Blow a hole in the hull and those cells flip to open vacuum; the solver does the rest, evacuating the room in a rush of decompression that settles once it's resealed or fully empty. The velocity field is pulled back to the CPU with an async GPU readback (no pipeline stall) and fed into the particle systems, so dust and debris get dragged toward the gap along the real airflow. It runs in real time on grids up to 1024×1024 at about a million cells a step using ping-pong buffers.

Planetary rendering at solar system scale spans absurd depth ranges far outside of a single camera's typical view frustrum. This approach "squashes" far away vertices back into the camera's view frustrum, modifying the depth buffer and calculating scale and foreshortening to make objects look correctly distant.

You can see in the example that the camera's far plane only has a depth of 10 meters, but it still correctly renders objects out an arbitrary distance.

A blur used across a mobile app with 100k+ daily active users, so it had to be cheap. The standard separable trick of two 1D passes instead of one 2D kernel plus downsampled render to hit the frame budget on low-end hardware. This was years ago and they're still using it. 😎