B2R2 is a binary analysis framework written in F# for .NET

Why the language choice is the first thing to understand

B2R2 is written in F#, and the README makes the case for that as the first of its overview points, calling the project analysis-friendly because F# suits building program analyzers thanks to pattern matching, algebraic data types and expressive functional abstractions. The second point follows from the first, calling it fast because the core binary analysis engine is designed for efficiency and written in a functional-first style, which the documentation says makes it a natural fit for pure parallelism across common analysis tasks such as instruction lifting and CFG recovery. The third point is about adoption rather than design, that it is easy to use because as a fully managed library it avoids complicated native dependency setup, and the instruction is to install the.NET SDK and you are ready to go, with native IntelliSense support making the APIs easier to explore. The fourth point is portability, since B2R2 is OS-independent and works on Linux, macOS and Windows as well as any other platform supported by.NET, and it is interoperable, not tied to a single programming language, with the APIs in principle usable from any CLI-supported language.

The name, and what it tells you about the audience

The naming story is short and tells you who the project is for. The name takes inspiration from R2-D2, the iconic robot from Star Wars, and the project was originally called B2-R2 before adopting the dash-free form B2R2, because .NET identifiers and namespaces do not allow hyphens. The documentation then explains what the letters mean, with B and 2 suggesting binary and two-state computation while R stands for reversing, and the summary is that B2R2 is built for binary reversing. That is worth knowing because B2R2 is aimed at people who write analyzers, not only at people who run a disassembler. The samples directory reinforces this, since it holds a CSharp sample, an FSharp sample, a VB sample, an IActionExample and a README, which is a portfolio of how to consume the library from several languages rather than a set of end-user tools.

What the framework actually provides

The feature list is the core of the analysis chain. B2R2 supports instruction parsing, binary disassembly, assembly, control-flow recovery and other building blocks for binary analysis, and it includes several user-facing command-line tools comparable to readelf and objdump while remaining platform-agnostic. Four binary file formats are supported: ELF, PE, Mach-O and WebAssembly. The distinction between a library and a set of tools is the one to keep in mind, because the tools are described as user-facing while the library is the substance. The .NET side of the project appears in the repository as a solution, `B2R2.slnx`, alongside `Directory.Build.props` and `Directory.Build.targets`, a `CHANGELOG.md`, an `AUTHORS.md` and a `CONTRIBUTING.md`, and the NuGet badge in the README points at a package named `B2R2.RearEnd.Launcher`, which is the launcher for the front end rather than the analysis core. The primary language is F# and the licence is MIT.

The ISA table is where the real limits are

The support table is the most useful thing in the README, and it needs reading carefully because the markers distinguish a complete column from a partial one. For general-purpose CPUs, the columns are instruction parsing, disassembly, lifting, CFG recovery and assembly. x86 and x86-64 are complete across all of them. For ARMv7, ARMv8 with AArch64, MIPS32, MIPS64, M68K, Alpha, PA-RISC, PPC32, PPC64, SPARC and SH4, the pattern is consistent: instruction parsing, disassembly, lifting and assembly are complete, while CFG recovery is marked as partial. That single column is where the gaps are, and CFG recovery is exactly what you need for most higher level analysis, since a control-flow graph is the precondition for reachability, call graph work and decompilation. The table also covers the areas the documentation says are still in progress, and the repository topics list more architectures than the visible portion of the table covers, including AVR, EVM and RISC-V, alongside aarch64, mips and risc-v, so the set of targets is broader than one table page suggests.

Building it and the two CI pipelines

There is no install command in the documentation, and that is because there is nothing to build in the traditional sense. The instruction is to install the .NET SDK, and the package is consumed from NuGet, with the launcher package already published there. The repository carries two workflow badges, one for a build and test pipeline and one for a jumptable test pipeline, and the presence of a dedicated jumptable test suggests the project verifies its instruction decoders against jump table data, which is a reasonable way to catch decoder mistakes. The project also ships a `.b2r2-ci.json` configuration file, a GitLab CI configuration alongside the GitHub workflows, an `AGENTS.md`, a `scripts/` directory, a `docs/` directory and a `.config/` directory. The documentation asks that the contribution guideline be read before opening a pull request, and states that contributions are welcome. The last push to the repository was on 2026-10-19, with releases v0.10.1 in June 2026, v0.10.0 in May 2026 and v0.9.1 in September 2025.

Where B2R2 is the wrong tool

The case against it is narrow but real. If your work is control-flow analysis on ARM, MIPS, PowerPC or SPARC binaries, the table tells you that column is only partly filled in, and you will be filling the gap yourself or using a different tool for that step. The second limit is the language. F# is a first-class .NET language with excellent tooling, but if your team does not already ship .NET, adopting a framework written in F# means adopting the F# toolchain as well, and the interoperability claim, that the APIs can in principle be used from any CLI-supported language, is about the surface rather than about the developer experience of writing a large analyzer in it. The third is scope. B2R2 is a library and a set of command line tools, not a platform with a plugin ecosystem, a scripting environment or a corpus of ready-made analyses, so if what you need is an out-of-the-box binary analysis suite, this is a component to build on rather than a product to install.

Editorial conclusion

Adopt B2R2 if you are building analysis tooling on .NET and want a managed library with a wide instruction set coverage rather than a native toolchain you have to build and ship. Skip it if you need completed control-flow recovery on a specific architecture, because the support table marks that capability as partial outside x86 and x86-64, and skip it if your pipeline is built around an existing binary analysis tool with a command line interface you already know. Before you commit, check the table row for your target architecture, and read the contribution guideline before opening a pull request.

Frequently asked questions

Official sources

1. B2R2-org/B2R2 on GitHub
2. License: MIT
3. Project website
4. README
5. Releases