There Is Only One Copy: Why SceneDB's ECS Looks Nothing Like an ECS
SceneDB isn't a gameplay-logic ECS with rendering and networking bolted on top. It's the only copy of the scene that exists. Physics, rendering, replication, and the editor all read and write the same bytes. Here's why that's the correct architecture and not just an unusual one.
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.
Quasar: A Lock-Free Spatial Audio Engine in Rust
How we built a modular spatial audio engine where arbitrary multi-channel sources route through a patch bay into positioned world emitters, spatialized per-listener through a zero-alloc DSP pipeline without a single mutex on the audio thread.
Profiling the UI Itself: A CPU+GPU Flamegraph and RenderDoc-Style Replay Viewer for GPUI
Building a feature-gated CPU+GPU profiler directly into GPUI's Inspector panel: span capture, counters, memory snapshots, a RenderDoc-style GPU deep capture and replay engine, and a flame chart rendered with a custom instanced GPU shader instead of one UI element per bar.
SceneDB 2.0: The Cross-Device Spatial Database
A deep technical walkthrough of SceneDB 2.0, a cross-device spatial database that replaces the traditional push-model ECS with GPU-native columns, delta-minimal uploads, self-healing slot mirrors, and compile-time frame phase enforcement.
Type-Agnostic Reflection: How Pulsar's Property Editors Shed JSON, Became Entities, and Stopped Knowing What They Were Editing
How Pulsar's property editor system evolved from JSON-mediated stateless function pointers to entity-based factories with type-erased value channels — and why eliminating type knowledge from the framework layer made the entire editor registry extensible without per-type boilerplate.
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.
Multi-Data-Output Nodes — One Binding, Many Pins
How Pulsar's node graph compilers handle nodes that produce multiple values — the cross-language accessor pattern, compiler internals, and the #[output] / bp_return! macros.
Pulsar's Blueprint Compiler: Graphs, Types, and Transpilation
A deep dive into Pulsar's Blueprint Graph Compiler — how graph descriptions are structured, how type checking validates connections with a coercion registry, how data flow analysis computes pure node evaluation order, how the exec_output!() marker macro is lowered via AST transformation, and how the same graph compiles to both bytecode for the editor VM and native Rust for shipping builds.
The Pulsar Blueprint System: From the Blueprint Macro to Runtime Execution
A complete walkthrough of Pulsar's Blueprint visual scripting system — how the #[blueprint] macro transforms Rust functions into graph nodes, how the reflection system and component methods feed into the node palette, and how the dual-path execution runtime runs bytecode in the editor and transpiled Rust in shipping builds.
The AI in the Machine: AI Tools and Context at Scale
How Pulsar's plugin-driven AI system lets the agent discover, traverse, and invoke tools through a macro-based pipeline — without dumping your entire codebase into a system prompt.
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.
Making GPUI Fast: A Compositor Thread, an Overscroll Buffer, and Why Browsers Don't Re-Render on Scroll
How we're planning to pull a CoreAnimation-style compositor thread and a browser-inspired overscroll buffer into GPUI to move essentially all rendering work off the main thread — and why scrolling a massive list should cost near-zero CPU time.
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.
EngineFS: Pulsar's Virtual Filesystem Layer
How Pulsar abstracts every file operation behind a swappable provider trait — making local disk, HTTP remote, and P2P collaborative sessions all look identical to every crate above them.
Pulsar's Reflection System: From Macro to Properties Panel
A deep dive into how Pulsar's runtime reflection system works — from the EngineClass derive macro and property attributes through to the Properties panel that uses that metadata to generate a live editing UI with zero handwritten widget code.
Pulsar's Subsystem Architecture: How the Engine Core Ends Up Knowing Nothing
A thorough walkthrough of how Pulsar's subsystem and component architecture achieves genuine decoupling — components only import the subsystems they touch, the central engine knows nothing about any of them, and the whole system is open to extension by plugins without modifying engine code.
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.