Half-Life 2 Speedrunning Guide: The Bug That Beats the Game in 36 Minutes

Half-Life 2 is 69 maps long. The world record is 36 minutes and 30 seconds.

That gap is not mostly route knowledge. It exists because Valve wrote a speed limiter that checks which direction you are looking rather than which direction you are moving, so if you run backwards the code that is supposed to slow you down speeds you up instead. Twenty years of Source engine speedrunning is essentially one long argument with that single mistake.

If you have watched a Half-Life 2 run and wondered why Gordon spends the entire game moonwalking through City 17 at the speed of a car, this is the explanation, along with the rest of the toolkit and the rules that govern which parts of it you are allowed to use.

Two leaderboards, because Half-Life 2 has two engines

Half-Life 2 shipped on Source 2004, alongside Lost Coast. Episode One brought Source 2006. Episode Two and Portal brought Source 2007, usually called the OrangeBox engine. In 2010 Valve moved Half-Life 2, the episodes, and Portal onto Source 2009, and later moved the 2009 games onto Source 2013, better known as SteamPipe — which is functionally close enough to 2009 that most glitches still work on the copy in your Steam library right now.

Runners bundle those into Old Engine (2004 and 2006) and New Engine (2007, 2009 and 2013), and speedrun.com gives each its own full-game leaderboard. Different engines, different bugs, genuinely different games to run.

Here is where the records actually sit:

Two things jump out of that table. The first is the gap between the two timing methods: the New Engine record is 36:30 without loads and 46:22 with them, so roughly ten minutes of a world-record Half-Life 2 run is a loading screen. The leaderboard's default sort is real time without loads, but both are recorded on every submission, and runs need video and are manually verified.

The second is that Old Engine and New Engine land within forty seconds of each other at the top while using almost completely different movement. Old Engine also carries a With Scripts and a Scriptless split, and the difference between them is enormous — 37:07 against 58:49.

Accelerated back hopping, the bug the whole run is built on

Accelerated Back Hopping — ABH — is credited on the SourceRuns wiki to Spider-Waffle and Hlook, and it is the main movement method for every OrangeBox-based game. It replaced bunnyhopping, which OrangeBox patched out.

The mechanism: when you jump while moving faster than a threshold, the game trims your speed back toward a cap. To trim it, the game applies a correction opposite your view direction — not opposite your velocity. Turn around, and that correction points the same way you are travelling. The brake becomes the throttle.

Better still, the size of the correction scales with how fast you already were, so each hop compounds. The equation the wiki gives for a perfect jump with no angle change is:

new speed = (current speed × 2) − flMaxSpeed

where flMaxSpeed is the cap for whichever movement state you jumped in. Those caps, and the speed you land on after your first ABH out of a sprint jump and a clean 180, look like this (all values in units per second, with the HEV suit):

Without the suit the numbers change: crouching caps at 165 and gets you to 285, and walking still caps at 225. You cannot sprint without the suit at all.

The counterintuitive part is that the lowest cap is the best one. A smaller flMaxSpeed means a bigger gap between your speed and the cap, which means a bigger correction, which the bug hands straight back to you as acceleration. Crouching's 209 is the lowest of the four, which is why runners duck. Walking is the other common choice, because it gives better air control between jumps.

Feed 495 back through that equation twice and you are at 781, then 1,353. A sprint is 320. Three accelerated hops out of a sprint jump therefore leave you moving more than four times sprint speed, and you have not touched a weapon or a vehicle.

In practice: bind +jump to your mouse wheel so timing the landing is a scroll rather than a tap, do not hold forward or back while ABHing, and duck.

Accelerated forward hopping, so you can see where you are going

Running an entire campaign facing backwards is exactly as awkward as it sounds, so there is a variant. Once you have speed, turn around and tap S on each jump. Holding S makes the game read your movement as backwards, which flips the sign on the correction again, and you keep accelerating while facing the direction you are travelling.

The catch is air acceleration. Half-Life 2's is relatively high, so every extra frame you hold S actively decelerates you mid-air, and the taps have to be sharp. (Portal has lower air acceleration, which is why Portal runners can just hold S and get away with it.)

The modern approach uses +strafe, a modifier that converts mouse movement into player movement while held. A downward flick in that state does the same job as pressing S, but movement in that state is considerably slower than normal WASD input — so a mistimed input costs you much less. That makes forward hops both faster and easier to start from a standstill.

Bunnyhopping is the Old Engine answer

Bunnyhopping predates all of this. It was found in Quake around 1997 to 1998 as an evolution of zig-zagging, once players noticed that being airborne cost no speed and extra jumps added it. The first run to use it was Quake done Quick Lite in September 1998, and because Half-Life is built on the Quake 1 engine, the behaviour came along for the ride into GoldSrc.

The version limits matter. In WON Half-Life up to 1.1.0.8 you could keep gaining speed all the way to maxvelocity, 2,000 units per second. Later builds, including the Steam release, cap bunnyhop speed at 544 — exceed that and the game slows you on your next jump instead.

OrangeBox fixed bunnyhopping outright, which is precisely why ABH became the New Engine standard. Old Engine runs still bunnyhop. That is the real reason the two boards look and feel like different games rather than a version quibble.

Saveload clipping and the glitch the main board bans

The second pillar is geometry, not speed. Source runs an unstuck routine when it loads you out of the entity list: if it decides you are stuck, it shoves you — up in Old Engine, up and then down in New Engine — and then simply leaves you wherever it put you rather than restoring your position. Save, load, repeat, and you ratchet through the map.

The distances are small and very specific. Crouched, each saveload moves you about 20 units. Standing, about 2. Which is why the whole technique is done crouched.

Getting stuck in the first place is the skill. In New Engine the usual method is propclipping: push a physics object flat against yourself and against a wall until it ends up inside you. The wiki lists item boxes, barrels and metal folding chairs among the props that behave, and is blunt that the results are finicky and high-precision. Old Engine uses J-Clip instead. The vast majority of runners bind the loop to a single key:

bind KEY "save slsave;load slsave"

Once you are out of bounds you can move freely through the void. But on Source 2009 and later Half-Life 2-based games, entering the void zeroes your velocity, and so does hitting a level transition on every version. The workaround is a tick-perfect saveload executed in the 0-tick window, which never gives the engine the chance to reset you. Doing that while out of bounds is what the community calls void clipping.

And that is what the category split is about. The leaderboard speedrun.com shows by default is Any% No Voidclip, and it carries 182 runs. The board where voidclip is allowed carries 34, and its best no-loads time is 40:42.705, set by maltemller in April 2021. The main event is the one with voidclip taken off the table.

One detail I enjoy far too much: you can redirect a void clip mid-flight by damage boosting yourself, and if you do it with a frag grenade you get a hard limit on how many saveloads you have left — the grenade's sprite duplicates on every single one until the game crashes.

Save deletion, the free health and ammo button

Save deletion restores health, ammo, and any vehicle or item the map requires you to have. It behaves roughly like a map or restart command, and it is the reason runners can afford to take damage they would otherwise have to route around.

There are three methods, and which one works depends on your build:

• Original method. Entering a map, make two saves, go to the menu, delete the most recent one, resume, then reload or die.
• Pre-SteamPipe. Make a save with a name longer than about 200 characters, then run reload. Stop somewhere around 210 characters so the bind still fits inside the console's command length limit.
• Post-SteamPipe. Make a save named with a single colon, then run reload.

All three can be bound to one key as save <name>;reload. Availability is uneven: save deletion works on most OrangeBox versions, but on Source 2006 it exists only in build 4044.

If you want the effect without the glitch, there is a legitimate equivalent — on the first map of any chapter, restarting that chapter from the New Game menu restores your health and ammo the same way.

Four smaller tricks worth knowing

• Sharking. Hold jump as you hit water and you bounce along the surface instead of sinking into it, keeping your velocity. Note the wiki's warning: pause any autojump script first, or it will not work.
• Ladderspeeding. On Source, repeatedly jumping and crouching while mounted on a ladder sends you flying up it far faster than climbing.
• Stuckjumping. Old Engine only. Trap a physics object inside an animated one — a closing door, a rising ramp — and the deformed physics store an enormous amount of energy, which transfers to you on contact. Duckjump into the object's diagonal for the best height. OrangeBox patched this: attempting it now kills you outright.
• Quickclip. Achieve yesclip, then touch a barnacle. You lose the noclip property but keep a broken physics bounding box, which lets you clip through walls, props and displacements more or less at will. Entering and leaving a vehicle removes the state, as does save deleting. It is much more consistent on Old Engine, though still possible on New.

What the rules actually allow

The two boards run different rulesets, and the details are more specific than a glance at the leaderboard suggests.

New Engine requires an officially released version of the game. Ghosting and Source Unpack 2.5 or older are explicitly banned because they do not qualify as official releases. Scripts and macros are not allowed, and that ban includes aliases.

Old Engine allows official releases or a Source 2006 custom build that the moderation team has verified. 2707 is the common legitimate version; 2733 and 4044 are the common mod builds. This is the board where the With Scripts and Scriptless split lives.

Binding is generous. You can bind any command reachable from the pause menu, bind one command to several keys (+jump on both mouse wheel directions is standard), and bind several commands to one key — bind x "save glitch;load glitch" is given as an example in the rules themselves. Console-exclusive commands are banned by default, with named examples including ent_remove, unpause, minus-commands like -speed, exec, toggle and BindToggle.

A community whitelist grandfathers in the exceptions, and a few are worth memorising:

• mat_dxlevel must be 90 or 95. Below 90 modifies game physics and force-enables fullbright on some maps.
• fps_max accepts 1 to 999. Uncapping with 0 is banned, and going above 999 pushes the game into a timescaled state.
• viewmodel_fov is allowed between 54 and 90. Outside that the viewmodel starts disappearing, and hiding it entirely is not allowed.
• cl_showpos, use weapon_x, reload, cl_showfps, net_graph, r_portalsopenall 1 and save_screenshot are all permitted.

Console runs sit on the same leaderboards under the same rules, with one exception: they are timed in real time.

Picking a build and getting set up

The current New Engine record was set on build 4231-4260 and second place on 5288, and the board also tracks 20th Anniversary, Steam Legacy, 5135 Unpack 2.6, 4044, 2733, 2707, the Xbox 2533 build and PS3. There is no single "correct" answer, which is why the leaderboard tags runs with the build they were set on.

Two tools do most of the heavy lifting:

Source Unpack is build 5135 with Half-Life 2 and Portal unpacked. You need to own both on Steam to run it. It bundles RInput, which strips mouse acceleration out of the game, and it ships with the Source Pause Tool already included.

Source Pause Tool is a plugin for OrangeBox games that automatically pauses on loads and level transitions, so you can take control and start or stop a demo recording at the right instant. Load it with plugin_load spt, then y_spt_autojump 1 for autojump and y_spt_pause 1 for autopause — both of which matter most for segmented runs.

The community itself is SourceRuns, which the Half-Life wiki records as having grown out of the HL2DQ team in 2009 and expanded into marathons and competitions since. Their Discord is the one linked directly from the leaderboard.

If you want a realistic first target, ignore the full game. Both engine boards carry individual-level leaderboards alongside the full-game ones, and chapter runs start either from the menu or by loading the first map with the map command. Learning ABH properly on one chapter will teach you more than grinding out failed full runs.

Quick Action Checklist

• Decide New Engine or Old Engine first — they use different movement, and the boards are separate.
• Bind +jump to your mouse wheel before anything else.
• Learn ABH crouched. The 209 cap is the lowest, so it yields the most speed.
• Do not hold forward or back while ABHing; tap S only once you switch to forward hops.
• Bind save slsave;load slsave to one key for saveload clipping.
• Learn the save deletion method that matches your build — colon-named save for post-SteamPipe, 200-plus characters for pre-SteamPipe.
• Keep mat_dxlevel at 90 or 95 and fps_max at 999 or below, or your run is invalid.
• Start on individual chapters, not the full game.