Austin Rife

Engine & Systems Programmer

When the box isn't big enough, I build a new one. Preferably in Rust.

Rust C++ HLSL Vulkan Unreal Engine

About Me

I'm a senior software engineer specializing in engine and core systems. I spent nine years at Sanzaru Games (acquired by Meta in 2020) building VR games for Quest and Rift, until the studio closed in March 2026. Our titles include Asgard's Wrath 2, winner of Immersive Reality Game of the Year at the 2024 D.I.C.E. Awards.

At Sanzaru I worked mainly in C++ and Unreal Engine. I was the go-to engineer for CPU and GPU performance on every title from 2017 on, and the de facto owner of threading and concurrency bugs. My work also covered OpenXR, save systems, and engine upgrades. I owned the cinematics tooling across three projects, reviewed code for the core tech team, and mentored other engineers.

Since 2018 I've also been building Eden, a game engine in Rust. More recently I've designed the AI developer tools I use to work on it.

Portfolio

Cancelled VR Project

A cancelled AAA VR project. Engine and systems work: spatial partitioning, audio streaming, physics performance, and a second version of the cinematics system.

Contributions

Cinematics System v2 - Rebuilt the cinematics tooling for UE5, building in what we learned from the Asgard's Wrath 2 version.
Automated Cinematics Pipeline - Built a Python pipeline that renders cinematics to 360 video and posts them to SyncSketch for review.
Spatial Partitioning - Built hierarchical spatial partitioning for world queries and streaming, as an alternative to Unreal's World Partition. It was faster for our needs, though the project stayed on World Partition.
Physics Performance - Profiled Chaos in depth to bring down the cost of heavy physics scenes. The biggest win was keeping rendering meshes out of collision.
Audio Streaming - Optimized FMOD bank loading and audio memory use.
Motion Matching Investigation - Evaluated motion matching in Unreal with the animation team, and recommended against adopting it because of bugs in the engine's implementation.
AI Workflow Integration - Led the studio's early adoption of Claude in engineering workflows, about three months before the studio closed.

Context

Development ended when Meta closed Sanzaru in March 2026. I can't share more because of the NDA.

Asgard's Wrath 2

AAA action RPG for Meta Quest 2 and 3, with 60+ hours of gameplay. I built the cinematics system, the save system, and the AI prototype. I was also the primary engineer on the engine upgrade for six months.

Contributions

Cinematics System - Designed and built a node-graph cinematics tool. Its user base grew from 3 to 30, and it shipped about 2.5 hours of cinematics.
Save System - Sole owner of save and load for the game's world state.
Rope Physics - Wrote a custom Verlet simulation for ropes, chains, reins, cables, and Abraxas's whip sword. It ran twice as fast as Unreal's cable component and stayed stable while players whipped it around hard.
HTN AI Prototype - Wrote the hierarchical task network prototype that evolved into the game's AI systems.
OpenXR - Helped move the game from OVR to OpenXR, and used OpenXR directly to hide ASW reprojection artifacts during white-fade frame stalls by briefly widening the FOV before the frame froze.
Engine Upgrade (UE 4.25 to 4.27) - Primary engineer for six months of a year-long engine upgrade, merging the studio's engine changes and keeping the game stable through the switchover.
Package Size - Wrote a custom world smart pointer that reduced package sizes.
Performance - Halved average Blueprint VM time per frame in production by reordering cold-path branches, inlining hot paths, and removing vtable dispatch in Unreal's interpreter. Go-to engineer for CPU and GPU performance on Quest: profiling, flagging problems, and gathering the data we used to prioritize fixes.
Vulkan - Fixed validation errors in Unreal's Vulkan backend.

Context

Won Immersive Reality Game of the Year at the 2024 D.I.C.E. Awards.

Asgard's Wrath

AAA action RPG for Oculus Rift. I worked on in-game cinematics (IGC), NPC and creature logic, paired animations, and gameplay mechanics.

Contributions

IGC Systems - Owned the in-game cinematics systems, building on a design inherited from another engineer.
NPC and Creature Logic - Owned most of the ambient NPC behavior in the tavern, the fairy behavior in the World Tree area, and much of the critter logic.
Paired Animations - Built paired animation support for the game's story set pieces.
Lock and Key System - Wrote the lock and key mechanism used on all doors in the game, including the gesture-based key input for locked gates.
Buoyancy - Built PID-controlled buoyancy for the opening IGC on top of the existing NVIDIA WaveWorks integration. Also fixed an uninitialized bounding volume that could make WaveWorks try to generate around a trillion voxels.
Explosives - Wrote the explosives mechanic for destructible props.
Performance - Go-to engineer for CPU and GPU performance.

Context

Named UploadVR's Best VR Game of 2019 and nominated for Best VR/AR Game at The Game Awards 2019.

Marvel Powers United VR

VR brawler for Oculus Rift with four-player online co-op as Marvel heroes. I joined late in development to help ship it.

Contributions

Ship-Blocking Deadlock - Spent one to two months tracking down a deadlock that spanned about eight systems. An enemy grenade's particle effect made a Blueprint call into a GPU physics sim from inside a physics callback, and it only reproduced in network play on min-spec machines, where the thread timing tripped it.
Ship Support - Bug fixes and data upgrades through launch.

Context

Shipped in 2018 with Oculus Studios and Marvel.

Cyberpong

VR pong for HTC Vive, released for arcades and home VR. I worked on networked AI, localization, and arcade tooling.

Contributions

Networked AI - Rewrote the single-player AI system to support networked multiplayer matches.
Localization System - Built the localization system from scratch, since Unity had no built-in support at the time.
VR Arcade Tooling - Wrote an external setup tool for VR arcades and configured the game for arcade deployment.

Context

A three-month stint at Colopl NI in 2016.

Eden

Personal game engine in Rust, 100+ crates. I wrote it by hand from 2018 to late 2025. Since November 2025, agents implement my designs and I review every change.

Highlights

EFX Shading Language - I wrote EFX1, a metalanguage on top of HLSL that every engine shader uses, modeled on Bungie's TFX (Destiny Shader Pipeline, GDC 2017). EFX2 is my design, implemented by agents: traits, generics, a direct SPIR-V backend, and a conformance suite that executes on the GPU.
GPU ECS - A GPU mirror of my hand-written ECS, with dirty-tracked uploads. I designed the GPU side and agents implemented it. Shaders can query arbitrary entity data, and a new GPU data type needs only a component definition.
Vulkan Renderer - Bindless and GPU-driven, built on a render graph compiler that lowers frame passes to bytecode for a VM executor. Agents wrote the compiler's first version; I drove its API design and the IR and bytecode simplifications. Agents also implemented the layered PBR material model, which uses a Filament-aligned BRDF.
Silk UI Framework - Vulkan UI with ECS-based widgets, animation, platform accessibility bridges, and a headless test harness. I wrote the core over nine months, including the multilingual text layout; agents added animation, accessibility, and localization (the asset layer above the text system).
Silica Design System - Eden's editor design system, built around a glass material. Windows blur, flatten, and limit their backdrop so all text stays WCAG AA on glass and opaque surfaces alike. Contrast-checked design tokens generate Silk's theme tables, with mockups for 66 editor tools. It started from my own design work in Lunacy, done before agents were part of my workflow; agents built my scene editor mockup out into the full framework.
Determinism and Headless Runs - Simulation time is deterministic and the engine runs headless, which is how I scale up automated testing. Bit-identical ECS replay isn't built yet, but the design keeps it possible.
Asset System - Persistent asset database with incremental compilation, hot reloading, and content addressing, feeding a pak packaging pipeline. Its lineage is The Machinery's The Truth, and its object model adapts V8's object internals to asset data instead of runtime fields. I wrote it by hand through its rewrite to a V8-style object model; agents have extended it since under my direction.

Scope

I wrote most of the in-house core library myself (35 crates of collections, allocators, synchronization, hashing, and a job system with async I/O), along with the ECS, windowing, EON (a custom binary object notation), and the FFI layers: my own Vulkan bindings on top of the raw C API, and a native Rust reimplementation of Android's app glue (NativeActivity and GameActivity). Android builds don't use Gradle at all: I pieced together what Gradle does from scattered, obscure sources and rebuilt those steps in Eden's own build.

Where AI Fits

I lead the project. About six developer friends have contributed over the years: the Linux port, bug fixes, early 2D demos and a lot of design feedback (before agents), and an in-progress Jolt Physics integration. The Linux port and the Jolt work are agent-assisted. The code is private, but I'm happy to walk through it on request.

Why

Nine years in Unreal showed me how much performance a general-purpose engine gives up. When I've replaced one of its systems with one built for our game, the result has been faster: my rope simulation ran twice as fast as Unreal's cable component, and my spatial partitioning beat World Partition for our needs. Eden applies that to a whole engine, with systems designed to work together. Having written most of the core layers myself also makes other engines much easier to debug.

Agentic RenderDoc

An MCP server that lets coding agents debug RenderDoc captures: inspect draw calls, read buffers and textures, query pipeline state, and compare events.

Highlights

MCP Integration - A Python MCP server talks to a Python RenderDoc extension over a local TCP socket. It works with multiple open RenderDoc instances and exposes the whole capture.
Four Tools - Eval, Search-API, Get-Texture, and Instance replace the original 70-tool design. The change followed Zhang et al., "One Tool Is Enough", where a reinforcement-learning-trained agent with a single tool beat larger models at repository-level issue localization.
Used on Real Bugs - I used the prototype to track down rendering bugs in Eden, and that experience shaped the current design.

Context

Agents wrote both versions. I did the design, planning, and testing strategy, and tuned the tool interface for LLMs. It's open source under the Eden Labs organization, and outside contributors have added Windows support. I also maintain a Wayland/Qt6 fork of RenderDoc, which couldn't be merged upstream.

Agentic Memory

Persistent memory server for coding agents, written in Rust. Agents search and record decisions, failures, and project conventions over MCP, so context carries over between sessions.

Highlights

Hybrid Search - Full-text (FTS5/BM25), vector (HNSW), and graph traversal results merged with reciprocal rank fusion.
Local Embeddings - Runs the Stella EN 400M v5 embedding model in-process through ONNX Runtime, with no external API calls.
Fixed Ontology - 11 entity types (decision, failure, convention, and others) instead of free-form notes.
Retention by Use - Entries are evicted by how recently a session used them, not by age.
Multi-User - One SQLite database per user, token or Cloudflare Access auth, and remote access over HTTP.

Context

Agents implemented it; I designed the ontology, retrieval pipeline, and retention model. I started it because long agent sessions kept forgetting decisions made hours earlier and reopening them. In an informal comparison, a friend using the same workflow without memory saw sessions degrade after about three compactions, while mine stayed coherent through 50 to 100. Some sessions, like the EFX2 work, have run for months across compactions without a fresh start. About five people have used it over eight months, and I use it daily on Eden.

Agentic Studio

Terminal app for coding agents, with persistent workspaces that can run on remote machines. Linux desktop app built with Rust and Tauri.

Highlights

Persistent Workspaces - Each workspace maps to a directory and keeps its layout and panes across restarts, and its agent sessions resume where they left off.
Remote Workspaces - A workspace can run on another machine, so its agents keep working there while I attach from the desktop app.
Sandboxed Agents - Agent CLIs launch inside bubblewrap sandboxes, with filesystem and network access set by policy.
Tiling Layout - BSP pane splits, similar to bspwm.
Attention Indicators - Panes and workspaces flag when an agent is waiting on input.
Editor and Review - A built-in code editor, plus a Review tab with commit history and side-by-side diffs.

Context

Agents implemented it to my design, and I reviewed the changes. Persistent and remote workspaces are the main reason I started it. I use it daily, along with one other person.

Hands-Free Input for Linux

Eye tracking and voice dictation for the COSMIC desktop, built to keep working through a repetitive strain injury. Together they took the RSI from a daily problem to one I rarely notice.

Gaze

A Tobii Eye Tracker 5, which Tobii doesn't support on Linux, drives pointing, clicking, and scrolling.

USB Driver - A Rust driver with no vendor SDK. It implements the wire format documented by the tobiifree reverse-engineering project, the Windows init order from nottobii's packet captures, and the calibration opcodes from Talon. On top of that, it uploads and verifies the calibration on every connect, in the same order as the Windows driver, and recovers from USB dropouts without losing it.
Calibration - Runs the tracker's own retraining from Linux, plus a quick five-point recalibration from the panel applet followed by a 4x4 accuracy check. A per-display polynomial correction is refit from that check. Median error on the current calibration is about 0.8°.
Filtering - Velocity-based fixation detection gates a One Euro filter, so fixations are smoothed and saccades pass through untouched. A quality-weighted binocular combiner covers frames where the firmware's output is invalid, and short dropouts are bridged.
Target Snapping - On-device ONNX models find widgets and text on screen, and the pointer settles on the control you're looking at, checked against the accessibility tree. Clicks go to what you were looking at 150 ms earlier, because the eyes often leave a target before the click lands.
Desktop Integration - A daemon plus a COSMIC panel applet. A click-through Wayland overlay shows the gaze target, and the system pointer is borrowed through uinput only to commit a click or scroll, then put back. A Daydream controller over Bluetooth LE serves as the click and refine pad, and looking at a window's top or bottom edge scrolls it.

Voice

Local push-to-talk dictation that types into whatever window has focus. Nothing leaves the machine.

Audio Capture - A native PipeWire client records continuously into a ring buffer, so the first syllable, spoken before the key registers, isn't lost. The trigger key is read straight from evdev, masked to that one key, with no root access.
Two Recognizers - A streaming model drives live preview text, and an offline model produces the text that's committed. Voice activity detection keeps silence and key clicks from turning into "Yeah." or "Okay."
Segmented Decoding - Long dictation is cut at pauses and decoded while you keep talking. On 60 seconds of dictation, the wait after releasing the key dropped from 3.9 seconds to 0.35 seconds.
Text Input - Types through a Wayland virtual keyboard. An optional input-method multiplexer shares the seat's single input-method slot between dictation and IBus.

Context

Agents implemented both to my design in August and September 2026, and I reviewed the changes. The gaze system is 14 crates, about 36k lines of Rust, and 320 tests; the dictation tool is about 16k lines of Rust. Both are open source.

Contact

Interested in working together? Feel free to reach out.

Email LinkedIn GitHub

Currently looking for engine, graphics, XR, and systems programming roles, and roles in simulation, developer tooling, and AI tooling.