Former Valve developer Tom Forsyth revealed one of gaming’s most bizarre bugs in a November 21, 2025 thread on Mastodon, explaining how a single metro cop’s toe completely broke a Half-Life 2 VR prototype back in 2013. The story showcases how the tiniest changes in floating-point calculations can shatter carefully calibrated physics systems, creating what Forsyth called a time-traveling bug that appeared to retroactively break code that had worked perfectly for years. The issue prevented Valve from shipping their Oculus Rift port despite Half-Life 2 being one of the easiest games in their catalog to translate to virtual reality.
The Bug That Stopped Everything
Forsyth and Valve programmer Joe Ludwig were working on porting Half-Life 2 to the Oculus Rift VR headset in 2013 when they encountered a showstopper bug mere minutes into the game. In the opening sequence, a metro cop is supposed to open a door and usher the player through. In the VR build, the door simply refused to open, softlocking the entire game and preventing any further progress. Players were left staring at a closed door waiting for a scripted event that would never trigger.
The problem was especially baffling because the code hadn’t been touched. Forsyth recalled getting other developers involved, including some who worked on Half-Life 2 originally, and confirming the bug existed even when not in VR mode. The relevant code was identical to what shipped in the original game years earlier. Nobody could explain why a door that opened perfectly fine in 2004 suddenly refused to budge in 2013 without any code changes.
Good Old Floating Point
The answer lay in floating-point arithmetic, specifically the difference between x87 and SSE instruction sets for handling decimal calculations. The original Half-Life 2 compiled using x87, the standard CPU floating-point system of the early 2000s era which Forsyth described as having a wacky grab-bag of precisions. The 2013 VR build used a newer compiler that defaulted to SSE instructions, a more modern and efficient system for handling floating-point math.
Even though the code itself was unchanged, the new compiler meant the game calculated physics differently. These weren’t massive differences, just tiny variations in how numbers rounded at the decimal level. In most situations those microscopic changes were completely invisible. But in this specific scenario involving a door, a guard, and precise positioning, the subtle precision differences created a cascade failure that broke the entire scripted sequence.
The Toe That Blocked the Door
After extensive investigation, the team discovered the physical cause. A metro cop guard stands behind the door that’s supposed to open. He was positioned just a few pixels too close. When the door tried to swing open, the corner of its bounding box clipped the guard’s toe. The physics engine detected the collision and did exactly what it was programmed to do, the door hit an obstacle, bounced back, and remained closed. The guard had effectively door-stopped the entire campaign with his foot.
Here’s where the floating-point precision differences became critical. In the x87 version running on the original compiler, the door hit the guard with enough momentum to slightly rotate him. The guard’s friction calculation said he should slide just enough to clear the path. His toe moved out of the way by the tiniest margin, and the door opened as intended. The sequence worked perfectly because the math rounded in a specific way that produced just enough rotation to move the toe.
In the SSE version with the newer compiler, those numerous tiny precision differences meant the guard rotated slightly less. The friction calculation produced a result where he didn’t slide quite as far. In the next frame of simulation, his toe remained in the door’s path by literally a couple of pixels. Unable to pass through the obstruction, the door bounced back and stayed closed. The scripted sequence never completed, and players were permanently stuck.
Why It’s Called a Time-Traveling Bug
Forsyth described this as a time-traveling bug because it appeared to have reached back through time to break old code. The original Half-Life 2 shipped in 2004 and worked perfectly. The code for this sequence remained completely unchanged for nine years. Then in 2013, simply recompiling that identical code with a newer compiler using different floating-point instructions caused a bug that retroactively broke what had always worked.
This phenomenon isn’t unique to Half-Life 2, it’s a lurking danger in any game with complex physics systems built on precise floating-point calculations. The physics in the original game was calibrated so carefully that it relied on specific rounding behavior from x87 instructions. When SSE provided slightly different rounding, suddenly edge cases that previously worked by the thinnest margins started failing. The bug always existed as a potential failure state, but the original compiler’s math happened to avoid triggering it.
Why Half-Life 2 for VR
Valve chose Half-Life 2 as one of their VR experiments in 2013 because it was one of the easiest translations to virtual reality in their back catalog. The game was relatively recent compared to the original Half-Life, featuring a first-person perspective with physics interactions that mapped naturally to VR controllers. Portal seemed like another obvious candidate, but as Forsyth noted, the tricks with perspective in that puzzle game were a nauseating disaster in VR.
This 2013 VR work represents an early stage of what eventually became Half-Life Alyx, Valve’s full VR entry released in 2020. The company spent years experimenting with VR using Half-Life 2 assets, learning what worked and what didn’t about VR game design. They discovered that Half-Life’s core systems were a natural fit for VR, but that almost every aspect of design needed rethinking, including level design, combat, movement, and pacing.
The Modern Half-Life 2 VR Mod
While Valve’s official 2013 VR port never shipped, the community eventually created their own solution. Half-Life 2 VR is a comprehensive mod available on Steam that adds full VR support with motion controls, roomscale tracking, and modern VR features. Players can physically pump shotguns, reload weapons with gestures, and manually rotate valves with their hands. The mod is frequently cited as one of the best VR experiences available, second only to Half-Life Alyx itself.
The community mod likely encountered and solved similar floating-point issues during development, though they had the advantage of working with modern compilers and tools that Valve’s 2013 team didn’t have access to. The existence of a high-quality community VR mod raises questions about how many other Valve projects were abandoned before public announcement, leaving the community to eventually fill those gaps years later.
Lessons About Game Development
Forsyth’s story illustrates how fragile these digital worlds really are. A tiny change in how a processor rounds decimal numbers can turn a masterpiece into a broken mess. Modern game engines abstract away many of these low-level concerns, but any game with complex physics systems remains vulnerable to these kinds of precision issues when moving between compilers, platforms, or instruction sets.
The bug also demonstrates why QA testing matters even for seemingly simple ports. On paper, recompiling Half-Life 2 with a newer compiler shouldn’t cause any issues since the code is identical. In practice, the subtle interaction between compiler optimizations, instruction sets, and physics calculations can create unexpected failures in edge cases that were previously working by the thinnest margins. Without thorough testing, these issues only surface after shipping.
Valve’s Complicated VR History
This 2013 VR experiment was just one of many projects Valve explored before committing to Half-Life Alyx. The company developed several VR prototypes with three projects under development by 2017. They eventually settled on a Half-Life prequel as the perfect showcase for VR technology, avoiding the terrifyingly daunting prospect of Half-Life 3 while still returning to the beloved franchise.
However, Valve recently confirmed they have no first-party VR games currently in development for their new Steam Frame headset or any other platform. This puts an end to rumors about an asymmetric PC versus VR game in the Half-Life universe that had circulated since 2020. Whether those rumors were correct and the project was cancelled, or no such game existed in the first place, remains unclear. What’s certain is Valve’s approach to VR development continues prioritizing hardware and software platforms over creating new VR content.
FAQs
What was the Half-Life 2 VR bug?
A metro cop’s toe blocked a door from opening in a 2013 VR prototype, softlocking the game within minutes. The bug was caused by floating-point precision differences between x87 and SSE instruction sets, which changed how the physics engine calculated the guard’s rotation by microscopic amounts.
Who discovered this bug?
Former Valve developer Tom Forsyth discovered and documented the bug while working with programmer Joe Ludwig on porting Half-Life 2 to Oculus Rift in 2013. Forsyth shared the story on Mastodon in November 2025.
What is a time-traveling bug?
Forsyth called it a time-traveling bug because it appeared to reach back through time to break code that worked perfectly in 2004. The bug existed as a potential failure state in the original game, but the x87 compiler’s rounding behavior happened to avoid triggering it until a newer SSE compiler changed the math.
Did Valve ever release Half-Life 2 VR officially?
Valve added basic Oculus Rift support to Half-Life 2 on Steam in 2013, but never finished the full VR port they were working on. A community-created mod called Half-Life 2 VR later provided comprehensive VR support with motion controls and modern features.
What’s the difference between x87 and SSE?
X87 is an older CPU floating-point instruction set with varied precision handling. SSE is a newer, more efficient instruction set for floating-point math. The subtle differences in how they round decimal numbers can cause physics calculations to produce slightly different results.
Why was Half-Life 2 chosen for VR experiments?
Forsyth explained Half-Life 2 was one of the easiest Valve games to translate to VR because it was relatively recent and its first-person physics interactions mapped naturally to VR. Portal was considered but proved nauseating in VR due to perspective tricks.
What happened to Valve’s VR development?
These 2013 experiments eventually led to Half-Life Alyx in 2020. However, Valve recently confirmed no first-party VR games are currently in development for Steam Frame or any other platform, focusing instead on hardware and software platforms.
Can I play Half-Life 2 in VR now?
Yes. A community mod called Half-Life 2 VR is available on Steam with full motion controls, roomscale tracking, and modern VR features. It’s frequently cited as one of the best VR experiences available aside from Half-Life Alyx.
Conclusion
Tom Forsyth’s story about the metro cop’s toe demonstrates how seemingly insignificant technical details can have massive consequences in game development. A difference of a couple pixels in rotation, caused by microscopic floating-point precision changes, was enough to permanently break a scripted sequence that had worked flawlessly for years. It’s a sobering reminder that even battle-tested code isn’t immune to subtle environmental changes like compiler updates or instruction set differences. The tale also offers a glimpse into Valve’s lengthy VR journey, showing how early experiments with Half-Life 2 eventually evolved into the groundbreaking Half-Life Alyx after years of iteration and learning what works in virtual reality.