Not Enough Triangles: Helio's Virtual Geometry in Action
What virtual geometry is, where it helps and where it does not, how Helio selects geometry per cluster on the GPU and rasterizes it in three tiers, and what the first measurements on a 777 million triangle scene looked like.
Through the Glass: Physically Based Lens Simulation in Helio
How Pulsar's rendering engine reconstructs real optical behavior using physical lens prescriptions, spectral ray mapping, pupil functions, and GPU compute shaders.
One Allocator for Space: Parent-Relative Worlds, Level Instances, and Portals That Light Themselves
A folder in the hierarchy panel that would not move its children turned into a rewrite of how Pulsar represents space. Parent-relative transforms resolved on the GPU, dirty-subtree propagation, camera-relative precision, rigid frames, one allocator behind portals and sublevels, level instances you can drop into a scene, and portals that now take their lighting and their materials from the world they show. This is how each piece works, what we measured, and the places where our own tests lied to us.
Portals Aren’t Cameras: How Helio Folds Space in WGSL
How Helio renders portals as transition maps across a discrete fourth spatial axis, transforming geometry directly into the shared G-buffer through GPU-driven culling, nested spatial clipping, indirect draws, and temporally stable motion vectors.
Sublevels: One Coordinate Space Behind Moving Chunks, Streamed Worlds, and Portals
Helio's Sublevels system is one shared GPU table of rigid transforms. Moving a group of a thousand objects, streaming a world chunk in and out, and rendering a portal all reduce to the same operation: claim a slot, tag the members, write one matrix.
Helio 2D: GPU-Driven Sprites at 10 Million Instances
Helio's GPU-driven 2D sprite pipeline — persistent handle-addressed pools, GPU compute culling and radix sort, vertex-pulling batch rendering, GPU bounce physics for 10M sprites, and real-time 2D radiance cascades global illumination.
Helio VR: OpenXR Integration Through wgpu's Vulkan Escape Hatch
How Helio drives an HMD through OpenXR: Vulkan instance and device created through the runtime, dual-pass stereo rendering through existing forward pipelines, asymmetric-FOV camera math with a documented clip-space bug, controller input across four interaction profiles, and a PC mirror blit that shows both eyes side by side.
Rendering a Million Blades of Grass: Helio's GPU-Driven Foliage System
Helio's GPU-driven foliage system with tile ring residency, three-band wind, correct motion vectors, and 1M blades under 3ms.
Helio Radiant: Zero-Cost Custom Materials Through Template Fusion
How Helio's Radiant material system combines hand-authored shader templates with graph-generated WGSL snippets to deliver custom surface shaders with zero per-permutation PSO cost — through warp-uniform feature branches, lazy shader compilation, and draw-call grouping by material class.
Helio Fusor: How the Executor Took Ownership of the Render Pass and Why Nobody Noticed
How Helio's Fusor system fuses adjacent render passes into a single GPU render pass — why the executor, not the passes, owns the render pass lifecycle, how passes write to a pointer they don't own, and what this saves on Vulkan, Metal, DX12, and WebGPU.
Post Processing and Custom Shader Injection in Helio
How Helio handles post processing — the uber-pass design, multi-point shader injection, GPU volume blending, auto-exposure, bloom, color grading, and the post-process volume system with GPU-side spatial blending.
Cascaded Shadow Maps: From Matrix Compute to PCSS Filtering
A complete walkthrough of Helio's shadow pipeline — GPU matrix generation for point/directional/spot lights, the 256-layer shadow atlas with GPU-driven dirty tracking, per-face frustum culling, and PCSS soft shadows with Vogel disk sampling.
Why Compute Shaders Beat CPU Loops: Helio's O(1) Frame Cost Philosophy
A deep technical walkthrough of Helio's GPU-driven architecture — why the CPU never iterates over objects, how every frame costs the same regardless of scene complexity, and what it took to make that work in practice.
Cross-Platform GPU Programming Without Losing Your Mind
A practical field guide to the platform differences that actually matter when building a GPU renderer on wgpu — bindless limits, indirect draw capabilities, texture format support, and the WGSL footguns that look the same everywhere but behave differently nowhere you expect.
Culling Done Right: Fixing What Everyone Gets Wrong About GPU Culling
A deep technical postmortem of Helio's culling system — the critical bugs that caused objects to vanish when they shouldn't and appear when they shouldn't, the fixes that brought everything inline with AAA standards, and what a 110% occlusion-culled stat taught us about atomic counter races.
Editor Gizmos: 3D Transform Manipulation in Rust
A technical walkthrough of Helio's editor gizmo system — how translate/rotate/scale handles work, the ray intersection picking for handle selection, the axis-aligned rendering, and how everything integrates with the debug draw pipeline for zero-cost editor visualization.
Building an In-Engine GPU Profiler for Fun and Frame Time
A thorough technical walkthrough of how Helio's built-in profiler works — zero-instrumentation pass timing, GPU timestamp queries, resolve buffer mechanics, staging readback without stalling, and the live telemetry viewer that ties it all together.
Radiance Cascades: Probe-Based Global Illumination
A technical walkthrough of Helio's probe-based global illumination system — how a sparse grid of radiance probes captures indirect light, the cascade atlas format, multi-bounce accumulation, ambient fallback outside the grid, and why we're waiting on hardware ray tracing for the next step.
Designing a Render Graph That Doesn't Get in the Way
A detailed walkthrough of Helio's render graph — how passes declare resource dependencies, the lazy bind-group rebuild pattern, subpass chaining for framebuffer compression, and why we chose typed passes over a JSON graph.
Tiled Light Culling: From Linear Scan to Forward+
A technical walkthrough of Helio's tile-based light culling system — how we replaced a linear per-pixel light scan with a compute shader that assigns lights to 16x16 tiles, the tile frustum construction, the cache key that makes it free on static scenes, and what 1000+ dynamic lights look like in practice.
Corona: Building a GPU-Native Particle System
A full technical walkthrough of Corona — Helio's GPU-native particle system. How we went from invisible particles and flickering garbage to a million stable, depth-sorted, atlas-rendered particles using prefix sums, bitonic sort, and a lot of debugging.
Introducing Helio: A GPU-Driven Renderer Built in Rust
A deep technical walkthrough of Helio — the custom GPU-driven deferred renderer we built for Pulsar. Why we built it, how its pipeline is structured, and what we learned along the way.