#architecture
12 postsType-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.
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 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.
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.
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.
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.
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 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.