Cpp2IL turned analysis off by default and its dumps may need two runs
Work-in-progress tool to reverse unity's IL2CPP toolchain.
At a glance
- What is it?
- SamboyCoding/Cpp2IL is a work in progress tool that reverses Unity's IL2CPP build back to the original managed assemblies, and its development branch has been rewritten around a new intermediate representation after the project found itself too dependent on an assembly library. The rewrite also changed the command line: analysis is now off unless you ask for a specific output format, metadata and method dumps became separate formats so you may need two runs for both, and the page states plainly that functionality is limited compared with earlier releases.
- Who is it for?
- Use Cpp2IL when you have a build you are allowed to inspect and you need the managed form back, because it is the tool that automates the metadata parsing and the assembly reconstruction that would otherwise be manual work. Three things to check.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 10 days ago.
- What is it written in?
- Mainly C#, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- SamboyCoding/Cpp2IL3,113 ★ · +464
| Repository | 2026-10-04 | 2026-11-15 |
|---|---|---|
| SamboyCoding/Cpp2IL | 2.6k | 3.1k |
464 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The version line is named after a milestone from 2022
The three releases on record are numbered twenty one, twenty and nineteen of a pre-release whose own version begins with a year and a minor number from 2022. The release titles follow the same pattern, calling each one a milestone preview of that same 2022 version. Meanwhile the tags were published in December 2024, August 2025 and February 2026, roughly every six to eight months. So the number in the version is a milestone name rather than a date, and a reader who sees 2022 in a package or a tag next to a 2026 timestamp has to work that out. That is a defensible way to version a long running preview, and it is also a good reason to rely on the release title rather than the tag when you are checking what you installed.
Analysis is off by default now
The page lists what the rewrite removed, and the most consequential item is not an option that vanished but a behaviour that switched. A group of flags, including an analysis level and a skip analysis switch, has been removed, and analysis is now off unless you name the output format that performs it. For a tool named after converting a build back into something readable, having the conversion be the opt in rather than the default is a significant change, and it is the kind that produces an empty output directory and a confused report. The other removals follow the same pattern: a flag that suppressed injected attributes was replaced by a processing layer, which the page notes is actually implemented and which you enable with a different option and can list with another.
You may need to run it twice to get both dumps
Metadata dumps and method dumps used to be on by default, and they are now separate output formats you choose between. The page is explicit about the consequence: to get both you currently have to run the tool more than once, while adding that this may change if simultaneous output to several formats is added later. That is a small workflow regression stated plainly rather than hidden, which is the right way to write it. The rest of the command line follows the same two axis design, with one option to list the output formats and another to choose one, mirroring the processing layers, so a new user is choosing between two lists rather than reading a wall of flags. The option table on the page is where that design is clearest.
The assembly library it depended on was replaced after a rewrite
The page tells the dependency story more openly than most projects do. The application had depended heavily on one assembly library that had limitations, the maintainers investigated switching, and what they found was how reliant they were on it. So they rewrote the application, wrote it around the types of their own metadata library and a new analysis context object, and replaced the dependency with a different assembly library entirely. On top of that sits the new intermediate representation, an instruction set independent language that is translated into a control flow graph before the analysis runs, which is what enables the per method analysis actions the page then lists. It is a large amount of machinery for one tool, and the honest summary on the page is that most of it is not finished.
The core package is published under another account prefix
The command line application is described as a thin wrapper around a core module, and that module has its own readme, its own test project and its own package. Two details about the distribution are worth knowing. The package is published under an account prefix that does not match the repository owner, so searching by the project name will not find it. And builds of the development branch are not on the public package registry at all: they come from the maintainer's own feed, which is stated with a link and no apology, on the grounds that the branch is work in progress. The metadata parsing library it depends on is offered the same way, from build artefacts, under a permissive licence, for anyone who wants to do their own metadata work without the rest of the tool.
The page tells you to use a different decompiler
There is a short paragraph about output quality that is worth quoting rather than summarising. The regenerated intermediate code is described as pretty messy at the moment, the likely next step is pattern matching to turn instruction set specific constructs into more recognisable ones, and the promised next additions are named: generic instructions converted, object creation, throw and similar. Then comes the sentence that decides what you do with the result: because the code is imperfect, use one particular decompiler rather than the other, because it copes better with broken intermediate code. A project admitting its output is messy and then naming the tool that reads it best is more useful to a user than a claim of fidelity, and it tells you exactly where the boundary of automation currently sits.
Six plugins, a PowerShell release script and a new solution format
The solution contains the two main projects, the metadata library and its tests, a test data directory, a WebAssembly disassembler, a small library for name resolution, and six plugin projects. The plugin names are informative: one reports on the build, one produces the control flow graph, one handles a commercial obfuscator's output, one handles a packer format, one reads debug symbols, and one restores support for stripped code regions. The plugins are not decoration, because the page says a plugin system is being built so that third parties can add instruction sets and binary formats, and eventually obfuscated or encrypted ones. The release side is a PowerShell script rather than a workflow file, and the solution file itself uses the newer XML format, so both the tooling and the release path assume a developer working on one operating system.
Editorial conclusion
Use Cpp2IL when you have a build you are allowed to inspect and you need the managed form back, because it is the tool that automates the metadata parsing and the assembly reconstruction that would otherwise be manual work. Three things to check. Analysis is now opt in, so a default run does less than the name suggests and you should pass the output format you actually want. The rewritten branch is described as less capable than the released versions, so for a one off job the last release may serve you better than the branch. And the generated code is described as messy, with the page itself recommending a different decompiler for reading the output, so budget for a manual finishing step rather than expecting source you can compile.
Frequently asked questions
how to use cpp2il
Give the Windows executable a game folder path. It detects the Unity version, finds the files it needs and writes the output into a folder beside where you ran it. A single Android package can be passed in place of a folder, and the tool will extract what it needs from it.
what is cpp2il
A work in progress tool that reverses Unity's IL2CPP build process back to the original managed assemblies. It uses a separate library for metadata parsing and a new intermediate representation before regenerating the assemblies.
Is Cpp2IL finished?
The page says it is work in progress and subject to change, that many output formats and processing layers are not implemented yet, and that functionality is limited compared with previously released versions.
Why is Cpp2IL's development branch different?
The application was almost completely rewritten, mainly because of limitations in the assembly library it had depended on, which has been replaced. Analysis is now off by default and several former options were removed in favour of output formats and processing layers.
Where do I get Cpp2IL builds?
Command line builds are published on the repository's release page, and developer builds of the development branch come from the maintainer's own package feed. The core module is also published as a package under an account prefix that differs from the repository owner.
Why does Cpp2IL recommend a different decompiler?
Because the regenerated intermediate code is described as messy at this stage, so the page recommends one decompiler over the other for reading broken intermediate code, and names the conversions it plans to add next.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/samboycoding-cpp2il)Star history chart for your README
[](https://hysenlabs.com/projects/samboycoding-cpp2il)Was this useful?