POSTS
Notes, experiments, and behind-the-scenes from the arcade.
Why ReactiveEntitySet needed its own scene-persistence holder
Regular ScriptableObjects lose non-serialized fields on scene-transition unloads. ReactiveEntitySet loses NativeContainers, which is worse — once disposed, nothing brings them back. Here's the holder pattern that keeps them alive.
READ ›_The MonoBehaviour base class that ate my ReactiveEntitySet boilerplate
Every gameplay component talking to a ReactiveEntitySet carried the same OnEnable/OnDisable ritual. I lifted it into a MonoBehaviour base class, and the only hard part was the teardown order.
READ ›_A snapshot at 180 hours of game dev
A status report at the 180-hour mark of hobby Unity development. Where the hours went, where the library stands, what's in progress, and what's planned next.
READ ›_A personal standards repo, shaped as Claude Code Skills
Why I keep my Unity rules in a separate tang3cko/standards repo, and how each lesson lands as a Claude Code Skill that fires automatically the next time I touch the same domain.
READ ›_What exactly is Deferred+? Poking at URP's newest rendering path
Unity 6.1 quietly added a fourth rendering path to URP. Here's what Deferred+ actually is — deferred shading with Forward+'s clustered light culling — and the runtime-switching rig I built in my sandbox to compare all four paths.
READ ›_Dither transparency two ways in hand-written HLSL and Shader Graph
A camera-blocking wall should fade, not vanish. I built the same dither transparency effect twice in my Unity sandbox — once in HLSL, once in Shader Graph — and the circular-hole mode is where the two approaches stopped being equivalent.
READ ›_Rebuilding the Reactive SO Monitor from three windows into one
I originally said Reactive SO has three dedicated Monitor windows. It doesn't anymore. Here's why I collapsed them into a single tabbed window, and the CSV export rabbit hole I fell into on the way.
READ ›_Migrating damage resolution from client to server authority in Unity NGO
A co-op survival prototype carried over a client-trusted damage ServerRpc from a previous project. Notes from moving hit detection, projectile flight, and AoE onto the server, plus the unrelated bugs that surfaced along the way.
READ ›_How a 1200-byte ceiling on an NGO Unreliable RPC quietly capped my Wave 3
Wave 3 enemies vanished on the client while still hitting the player. The host was throwing OverflowException. Here's the failure story behind a hidden MTU ceiling in Unity Netcode for GameObjects, and what the industry actually does about it.
READ ›_A resolver chain for footstep surfaces (and why carved voxels need their own)
Footstep surface identification as a chain of small resolvers. Dig-carved voxel surfaces get a dedicated resolver because the chunk's collider can't answer the question on its own.
READ ›_A three-layer audio architecture on top of Reactive SO
Cue, Request, Service. How I separated audio data, intent, and playback in a Unity package built on Reactive SO's EventChannelSO and FloatVariableSO.
READ ›_Last-input-wins device detection across Godot and Unity
Notes on building a single 'which device did the player just use?' signal in two engines — a Godot simulation project and a Unity InputSystem project — so UI prompts and focus rules can react without per-screen plumbing.
READ ›_An in-editor voxel painter with stroke undo and generated layer gizmos
Notes on the Unity Editor window I built for painting Marching Cubes terrain: stroke-level Undo, a Y-plane mode for editing buried layers, and reference-layer Gizmos generated from the voxel grid instead of hardcoded.
READ ›_Fixing mesh holes in my Marching Cubes voxel terrain
I ported a Marching Cubes voxel digger from one Unity prototype into the next and watched it grow holes whenever the player dug at an off-grid height. Here's the algorithm swap that closed them, plus the editor workflow I built to iterate on the fix.
READ ›_Godot as a gimmick sketchpad (two weeks of prototypes, then back to Unity)
Sandbox_003 was a deliberate stretch where I forced every gimmick into Godot 4.6 + C# for two weeks. The point was speed of prototyping, and the gimmicks fed straight back into my Unity projects.
READ ›_WebPublishTools, an Editor Window for unityroom-Ready WebGL Builds in Unity
A Unity Editor window that validates WebGL Player Settings against a publish profile and applies each setting one click at a time. The unityroom profile ships out of the box, itch.io is on the roadmap.
READ ›_Syncing ScriptableObjects to Shaders in Unity
How I added automatic GPU synchronization from ScriptableObject variables to shader globals in Unity — so compute shaders and custom shaders can read gameplay state without any per-frame bridge code.
READ ›_What is Reactive SO?
An introduction to Reactive SO, a ScriptableObject-based reactive architecture for Unity. Built on Ryan Hipple's Unite Austin 2017 patterns, extended with Reactive Entity Sets, GPU Sync, and dedicated debugging windows.
READ ›_The History of "Ownership" vs "Belonging" from RDB to ECS
The 'belonging' paradigm in state management isn't new — it appears to go back to Codd's relational model in 1970. A short tour through how OOP swung back to 'ownership' and how ECS rediscovered 'belonging' for performance.
READ ›_Unified Memory and the Future of Game Architecture
Working with Metal on Apple Silicon shows what's possible when CPU and GPU share memory. A look at how today's platforms compare and why contiguous, data-oriented layouts matter even more in a Unified Memory world.
READ ›_Bringing ECS Insights to GameObject Workflows with ReactiveEntitySet
Notes from researching EnTT, Entitas, Flecs, Bevy, Svelto, and DOTS — and how ReactiveEntitySet combines Sparse Set storage with reactive change detection to give Unity GameObject projects a pragmatic data-oriented middle ground.
READ ›_Ownership vs Belonging as a New Paradigm for State Management in Unity
ReactiveEntitySet isn't a multi-instance VariableSO — it's an evolution of RuntimeSet. A look at how shifting from 'ownership' to 'belonging' changes memory layout, optimization space, and what state really means in Unity.
READ ›_Why InputActionAsset Stops Working After Scene Transitions (And How to Fix It)
In Unity 6.2+, disabling every UIDocument also disables the InputActionAsset assigned to UI — input quietly dies after a scene transition. Here's why it happens and four ways to fix it.
READ ›_Why ScriptableObject Data Disappears on Scene Transitions (And How to Fix It)
Non-serialized fields on Unity ScriptableObjects vanish when the asset is unloaded between scenes. Here's the RuntimeInitializeOnLoadMethod-based pattern I used to fix it during a Unity 1 Week Game Jam.
READ ›_