Posts
Build logs, postmortems, and essays from a weekend game programmer.
Every click on macOS was landing outside the window, and I put it there
Opening a menu once, on macOS only, killed every click for the rest of the session — the window kept reporting a screen position it never occupied. The engine bug is real and has its own tracker number. The thing that triggered it was a spawn I placed twice.
What gets lost between iterations
I number my Unreal prototypes and start each one fresh, with its own repo and its own initial commit. That convention lost the same kind of thing three times in a row — and a fourth loss, surfaced when an agent reasoned soundly from a stale line in a doc, turned out to be a different kind of failure entirely.
Editing ReactiveEntitySet data at scale in the RES Table View
Clicking through thousands of Inspector entries to find one stuck army doesn't work. I built a pause-time spreadsheet window for ReactiveEntitySet instead, with binary snapshot save/load.
Driving Unreal from the command line
A multiplayer host-and-join flow that needs two people at two keyboards to test let a bug through twice, in two different shapes, before I built a command-line pipeline that runs it unattended — generating, editing, packaging, and driving Unreal without opening the editor.
What Unreal gave away that Unity made me build
Roughly 3,200 lines of bandwidth machinery I hand-wrote on Unity NGO turned out to be engine features on Unreal — a token bucket, chunk reassembly, and a priority system I couldn't find any trace of in NGO.
The first travel is hard, and every one after it is seamless
Pressing Create Room gave a black screen with nothing listening. Fixing that dropped every client on the next map change. The fix is deciding hard vs seamless per ServerTravel call, and the harder lesson was almost deleting that fix entirely.
ReactiveView, querying ECS-style subsets without iterating every frame
I wanted ECS-style queries (HP < 30% AND poisoned) on ReactiveEntitySet without scanning every entity every frame. Here's the predicate-based view I ended up with, and how it stays safe once more than one view watches the same entity.
Unreal has two online stacks. I picked the one that wasn't ready.
A packaged Windows build of my Unreal EOS lobby project failed at sign-in while the same code ran fine on macOS, traced to a move assignment that drops one field. The fix was moving off the untested online stack entirely, and why nobody else hits this bug is the more interesting part.
Time travel in ReactiveEntitySet (snapshot, restore, and branching)
A seekbar in TinyHistoryDemo turned into a full snapshot/restore/branching system. Here's how a struct built for Job System capture became time travel for entity state.
Wiring ReactiveEntitySet into Burst Jobs (double buffer + change list)
TinyHistoryDemo needed 20,000 marching armies in Burst Jobs while still firing reactive events. Here's the orchestrator that bridges the two worlds.
Adding traits to ReactiveEntitySet (64-bit bitmask storage for GC-free tags)
I wanted Cursed / Poisoned / Shielded style tags on entities without allocating. A 64-bit bitmask per entity turned out to be the sweet spot.
Building an Asset Browser for Reactive SO (because the Project window wasn't enough)
Reactive SO's own documentation admits that decoupling through ScriptableObjects trades code complexity for asset complexity, and that the resulting Asset Management Hell has no real fix. Here's the Asset Browser window I built to live with that cost, not remove it.
Why I added ActionSO to Reactive SO (a Command pattern detour)
Event Channels and Variables weren't quite enough for wiring up small actions to UI buttons. Here's why I added ActionSO and how the Command pattern landed in Reactive SO.
Why I stopped Renovate from auto-merging my Unity Editor version
A Renovate PR bumped ProjectVersion.txt by a 'patch' and was about to auto-merge a new Unity Editor version into a project nobody had that Editor installed for. Here's why I disabled the unity3d manager in my shared config.
Adding an R3 bridge to Reactive SO without making R3 a dependency
Raw C# events stop being enough the moment you want Where and DistinctUntilChanged. Here's the thin R3 bridge in Reactive SO, and the asmdef setup that keeps the core library dependency-free.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.