Halo 2 Decompilation: 9,383 Functions Match Byte for Byte on Original Xbox

By Indie Kings | October 21, 2026

Updated October 21, 2026: The Halo 2 decompilation for the original Xbox now has 9,383 functions that rebuild byte for byte, and the progress log records three separate jumps in that count on October 21 alone. The project runs its own AI coding lanes through Claude and Codex, and every batch still has to pass the same byte-for-byte check.

GitHub repository card for the Halo 2 decompilation project

Image: GitHub repository card for kirklandsig/halo2-decompiled.

What the project is doing to Halo 2

Per the repository README, Halo 2 Decompilation is an independent preservation and reverse-engineering project that studies the retail executable of Halo 2 for the original Xbox and recreates its program logic in human-readable C and C++ through independent analysis. Each recreated function is checked against the retail executable: built with the period-correct compiler, it must produce exactly the same bytes, and that check is what makes the recreated code verifiable.

The README states a longer-term research goal on top of the decompilation itself, which is to study how the game's code could run on other platforms using game data that each user supplies from their own copy. The project is non-commercial and is not affiliated with or endorsed by Microsoft, Bungie or 343 Industries.

GitHub reports 103 stars, 18 forks and 42 open issues for the repository, with 10 contributors and 8,683 commits on the default branch. The source tree holds 2,257 entries, of which 2,245 are files. The source directory accounts for 1,773 entries, the headers for 349, documentation for 64, the tests for 19 and the tools for 19, with the remainder at the repository root and in the workflow, configuration and spike directories. The GitHub language breakdown puts C++ first at 15,140,273 bytes, with Python at 534,714 bytes and C at 425,143 bytes, for 16,100,130 bytes in total. The licence reported by GitHub is CC0-1.0, a public domain dedication.

The match numbers from the checker

The project publishes a checker report in the README, and the progress log records a new entry for every batch of matches. The README's status block gives the figures below.

Measure	Matched	Total	Share
Game functions	9,383	11,321	51.43% of bytes
Havok functions	867	1,041	41.37% of bytes
All functions in scope	10,284	17,654	39.23% of bytes

The gap between those two columns is the point. 82.88% of the game's functions match, but they are the smaller functions: matched code covers 1,431,971 of 2,784,283 bytes, which is 51.43%. The remaining work is in the large functions, and the byte figure is the honest measure of how much of the game is still assembly.

The rate of progress is visible in the log. October 21, 2026 carries three separate entries: 9,383 functions matching after an 11-function batch, 9,372 after a 4-function batch, and 9,368 after an 11-function batch. October 20 carries eighteen more, running from 9,357 down to 9,262. The log names the machine and batch responsible, for example Machine 3's batch 98, and the addresses that now match, such as 0x95580 and 0x26a210.

Among the matched code the README lists the script engine's built-in functions, the AI, actor behaviours and actor slot handlers, and object damage. The project tracks 1,095 units in total, of which 546 are complete.

Why Havok is in scope

The project does not only decompile the game's own code. It also decompiles Havok, the physics library linked into Halo 2, and the README explains why: Halo 2's vehicles, ragdolls and projectiles have to behave exactly as they do on the Xbox. The executable's other libraries, the Xbox SDK's along with Bink video and the rest, are not decompiled, because a port would replace them.

Havok's role in the project is larger than its function count suggests. The Havok code in the tree is recreated from the retail executable and named by what it does, with no SDK headers, documentation, samples or source involved. The first contributor matches in Havok came from Roasted-Codes, covering its collision-pair dispatch and child-agent code, and the progress log records the Havok function count moving separately from the game's own, from 851 to 864 within a single day of entries.

AI coding lanes and the byte-for-byte gate

The README is direct about how the work is done. Much of the maintainer's own decompilation runs in automated lanes driven by Claude from Anthropic and Codex from OpenAI, which are AI coding agents that write and tune the source under the same checks and provenance rules as everyone else, with each batch reviewed before it lands. Many contributors use the same tools.

What makes this workable is that the verification is not a matter of taste. A function either rebuilds to the retail bytes or it does not, and the project's tools decide that, not a reviewer. The README's guidance for newcomers is that no prior decompilation experience is needed, only patience and some C, and it points to a setup checklist, how to claim a range, and a prompt that can be pasted into an AI coding agent.

That structure is visible in the contribution model. Contributors claim a range of functions and send pull requests, maintainers review and merge, and a CI runs the Python tests on every pull request along with disc-image tests. The progress log credits each batch to the person or agent that produced it, and the techniques documented in the project's decompilation guide were worked out by people and agents alike.

What the repository deliberately excludes

The README and the project's legal notice both draw firm lines, and they are worth reading closely because this is the part of the project that is unusual. The repository does not contain and does not distribute the retail Halo 2 game, its executable, any disc image, or any game assets. It does not contain the Microsoft Xbox SDK or XDK, its compiler, libraries or headers, or any other proprietary Microsoft development tool. It does not contain original or leaked Halo 2 source code, and it does not contain leaked symbols, program databases, linker maps or confidential Microsoft, Bungie or 343 Industries material.

Two of those exclusions have a specific backstory. The README says names that came from leaked sources through a third-party dataset have been removed from the inventory, and that names in the source matching such sources have been renamed. The credits section adds that the name and object columns of the project's function inventory once came from a symbol atlas dataset whose names for this build derive from linker maps of unreleased builds, so that data has been removed.

The project's own provenance file records where its information comes from. The README also notes that byte-for-byte checking currently depends on the original compiler, and that no open-source toolchain can reproduce its output yet. Analysis, documentation and review do not need it, which is what lets newcomers contribute without a licence to the XDK.

What it takes to build and check it

To build or check anything you must supply any original game files you need from a copy of Halo 2 that you are legally entitled to use, and the project does not provide game files. The retail executable goes at a path in the project, or is pointed at through an environment variable. The README is explicit that contributors are responsible for ensuring any development tools they use are obtained and used lawfully, and that the maintainers cannot provide, link to or assist with obtaining proprietary SDK or XDK material.

That constraint shapes how the project is built. Without the period-correct compiler, a contributor can still do the documentation and review work, and that is where the README points newcomers who lack a licensed toolchain. The main project rules from the community are simple: every change has to pass the same byte-for-byte check, and the reviewer has to keep the build honest.

The people doing the work

The contributor list mixes names and machines, and the credits section spells out the split. The lead contributor accounts for 8,151 of the 8,683 commits, with the next contributors at 225, 134, 77, 47 and 23 commits.

BirchWoodGod matched ranges across the game, from units and bipeds to network voice, team balancing, map paths, animation channels and lights, and published the analysis that gave the project its leads on subsystem lifecycle, data-array layout and register conventions.
BrassMonkey71 matched functions in the unit and biped code, the AI and elsewhere.
mjshfrvstj-sys wrote the CI that runs the Python tests on every pull request, and the disc-image tests.
mrv777 analysed the capture the flag and assault objects.
andrewnakas contributed the inventory fix that took the WMADEC data tables out of the function list.
Roasted-Codes produced the first contributor matches in Havok, covering collision-pair dispatch and child-agent code.

The project also credits the Halo CE decompilation and port as the work it follows. A separate entry in the credits names a functional recovery of the same executable whose published analysis gave the project its leads on subsystem lifecycle, data-array layout and register conventions, each verified against the retail code.

FAQ

What is a matching decompilation?
It is source code that, compiled with the original toolchain, produces the same bytes as the retail binary. The README describes it as the check that makes recreated code verifiable, and it is stricter than a port because a port only has to behave the same, while a match has to be identical.

How much of Halo 2 has been decompiled?
Per the October 21, 2026 progress log, 9,383 of 11,321 game functions match, which is 82.88% of the functions but 51.43% of the bytes, since the remaining functions are the large ones. The README's checker block adds Havok at 867 of 1,041 functions and reports 10,284 of 17,654 functions in scope as matched.

Does the project include the Halo 2 game?
No. The README and the legal notice both state that the repository contains no game assets, no executable and no disc image, and that you must supply your own files from a copy you are entitled to use. It also excludes the Xbox SDK, any leaked symbols or program databases, and any confidential Microsoft or Bungie material.

Are AI coding agents used to write the code?
Yes. The README states that much of the maintainer's own decompilation runs in automated lanes driven by Claude and Codex, that agents write and tune the source under the same checks and provenance rules as human contributors, and that each batch is reviewed before it lands. The byte-for-byte check applies to agents exactly as it does to people.

Can I contribute without the original Xbox SDK?
Analysis, documentation and review do not need it, and the README says no prior decompilation experience is needed. The project points newcomers at a setup checklist, how to claim a range of functions, and a prompt to paste into an AI coding agent.

Why is Havok being decompiled as well?
Because Halo 2's vehicles, ragdolls and projectiles have to behave exactly as they do on the Xbox, and Havok is the physics library that drives them. The Havok code in the tree is recreated from the retail executable and named by what it does, with no SDK material involved.

Bottom Line

Halo 2's original Xbox executable is 82.88% decompiled by function but only 51.43% by byte, and the second number is the one that matters, because what remains is the large functions. The verification is objective rather than a reviewer's judgement, every function must rebuild to the retail bytes, which is what lets the project run AI coding lanes for Claude and Codex through the same gate as its human contributors. The provenance work is the part that distinguishes it from most decompilation projects: leaked symbols and unreleased-build linker map names have been removed and renamed out of the tree, and the project states plainly that the original compiler is still required for byte-for-byte checking because no open-source toolchain reproduces its output yet. What it delivers is a readable, checkable C and C++ reconstruction of the game and of the Havok library inside it, with no game data in the repository at all.

Sources

kirklandsig/halo2-decompiled repository README, LEGAL.md and docs/PROGRESS.md, accessed October 21, 2026
Repository metadata, language breakdown, contributor list and commit history via the GitHub API, accessed October 21, 2026
ByteMatch report for kirklandsig/halo2-decompiled, accessed October 21, 2026