ReverserAI: Local LLM Function Naming Inside Binary Ninja

The naming problem ReverserAI addresses in Binary Ninja

Stripped binaries hand you a list of functions called sub_401230 and nothing else. Naming them is the part of reverse engineering that scales worst with human attention: a firmware image or a large Windows driver can contain thousands of functions, and most of them are only worth a glance. ReverserAI targets exactly that step. The README describes the release as offering "the automatic suggestion of high-level, semantically meaningful function names derived from decompiler output", delivered as a Binary Ninja plugin. The intended user is a reverse engineer who already works inside Binary Ninja and cannot or will not send decompiled code to a cloud service. The README is explicit about the trade-off: local LLMs "do not match the performance and capabilities of their cloud-based counterparts like ChatGPT4 and require substantial computing resources". That sentence is the honest summary of the project. You are buying confidentiality and offline operation with output quality and wall-clock time.

How the plugin turns decompiler output into suggested names

The pipeline is a plugin action, not a background service. Inside Binary Ninja you open Plugins -> ReverserAI and pick an action such as "Rename All Functions". The plugin walks the functions in the current binary, feeds decompiler output to the local model, and writes the suggested names into the Log window rather than silently renaming anything. That last detail matters: the README shows the suggestions appearing in the log, so review is part of the workflow. The model runs through llama-cpp-python, which is listed in requirements.txt alongside huggingface-hub, networkx, toml and typer. The networkx dependency is consistent with the README's claim that the project combines static analysis with LLM input, since call-graph relationships are a natural thing to feed the model as context. The README states this combination is meant to "improve the accuracy of AI-assisted reverse engineering" but does not document the prompt construction or how much graph context reaches the model, so treat the static-analysis contribution as a design intent you should evaluate on your own binaries. Two models are selectable via model_identifier: mistral-7b-instruct, about 5 GB of RAM, and mixtral-8x7b-instruct, about 25 GB. The README notes the larger model "may necessitate disabling memory mapping on machines that cannot support the required RAM level", which is a concrete failure mode: leave use_mmap on with insufficient RAM and you are relying on swap.

Installing ReverserAI and naming functions for the first time

The README offers two install paths. The first is Binary Ninja's plugin manager, which is the path of least resistance. The second is a command-line install executed inside Binary Ninja's plugins folder. The README gives these commands:

git clone https://github.com/mrphrazer/reverser_ai.git
cd reverser_ai

# install requirements
pip3 install -r requirements.txt

# install ReverserAI
pip3 install .

setup.py requires Python 3.10 or newer and declares the package name ReverserAI at version 1.2, so the interpreter you point pip3 at must satisfy that. On first launch the tool downloads the default mistral-7b-instruct-v0.2.Q4_K_M.gguf model file, roughly 5 GB. If that download is interrupted or you want a different model, the README points to scripts/model_download.py, which can also be run manually to start the download yourself.

Configuration lives in a TOML file, and the repository ships example_config.toml at the top level as a starting point. The keys the README documents are model_identifier, use_mmap, n_threads, n_gpu_layers, seed and verbose. A configuration for a machine without a usable GPU would set n_gpu_layers to 0 and raise n_threads toward the number of available CPU threads; the README says to set n_threads to 0 to disable CPU threading. The README describes the default configuration as balancing performance and resource usage "with a preference for GPU acceleration where feasible", so on a CPU-only box you should expect to change it rather than accept it.

After installation, open a binary in Binary Ninja, go to Plugins -> ReverserAI, and run "Rename All Functions". The README warns that depending on the total number of functions this may take a while, and that results land in the Log window. Expect 20 to 30 seconds per query on a 16 GB, 12-thread CPU system, or 2 to 5 seconds with Apple silicon GPU acceleration, according to the hardware section of the README. Multiply that by your function count before running it on a large binary.

Where ReverserAI is the wrong tool

Three limits are worth stating plainly. First, quality. The README's own comparison to ChatGPT4 concedes that local models do not match cloud counterparts, and the author's disclaimer says his machine learning expertise is limited and that more efficient models or methods may exist. If your goal is the best possible name suggestions and confidentiality is not a constraint, a local 7B model is the wrong end of that trade. Second, platform lock-in. ReverserAI ships as a Binary Ninja plugin. The README says the architecture is designed to be extended to IDA and Ghidra, but those are stated as intentions, not supported targets; if you live in Ghidra, this release does not serve you. Third, throughput. At 20 to 30 seconds per query on CPU, "Rename All Functions" on a binary with several thousand functions is an overnight-scale operation, and the README does not document a way to queue, resume or checkpoint that run. The README also does not document how suggestions are scored, whether low-confidence names are filtered, or how to roll back a bulk rename; if you care about those properties, the documentation is silent. Finally, this is a research project by its own description, so pinning a version and reading the diff between releases is more prudent here than with a mature plugin.

How ReverserAI differs from cloud decompiler assistants

The obvious comparison is a cloud-backed assistant that sends decompiled pseudocode to a hosted model and returns names or summaries. The difference is not the task, it is where the computation happens and what that costs. A cloud assistant gives you a larger, better-tuned model and near-instant responses; it also means the binary's contents leave your machine, which is a non-starter for malware analysis under an NDA, for firmware you do not own, or for anything under export control. ReverserAI inverts both sides of that: nothing leaves the host, and you pay in latency and in model capability. The second difference is integration depth. A cloud assistant is typically a chat window you paste into; ReverserAI is a plugin action that enumerates functions in the open Binary Ninja database and returns names into the log, and the README states the architecture is meant to be extended to other platforms. If your workflow is already Binary Ninja-centric, that integration is the reason to pick this over a general-purpose chat interface pointed at the same code.

Maintenance, licensing and upgrade cost

The last push to the repository was on 2026-05-20, which is also the date of the v1.2 release. The release history shows v1.0.1 in March 2024, v1.1 in June 2024, and then a gap of roughly two years before v1.2. That cadence suggests a research project that moves in bursts rather than one with a steady release train, and the README's framing of ReverserAI as an "initial exploration" and a "playground for future developments" supports reading it that way. Plan for upgrades as discrete events: read the release notes, re-run pip3 install . after pulling, and re-check your TOML against example_config.toml in case keys changed. The model files are the larger ongoing cost, since switching from mistral-7b-instruct to mixtral-8x7b-instruct means another download and a jump from roughly 5 GB to roughly 25 GB of RAM.

On licensing: setup.py declares the package under "GNU General Public License v2 or later (GPLv2+)" and the repository carries a LICENSE file. GPL-2.0 is a copyleft licence, which matters if you intend to redistribute ReverserAI, bundle it into a commercial product, or modify and ship it; the obligations attach to distribution, not to using the plugin internally. The README does not discuss the licence terms of the downloaded model weights, and those are separate from the plugin's licence, so check each model's own terms before deploying it. This is a description of what the repository states, not legal advice.

Editorial conclusion

Adopt ReverserAI if you already use Binary Ninja, your binaries cannot leave your machine, and you can give the plugin 16 GB of RAM and 12 CPU threads; the README itself puts queries at 20 to 30 seconds on CPU and 2 to 5 seconds with Apple silicon GPU acceleration. Do not adopt it if you need cloud-grade naming quality, use IDA or Ghidra as your primary disassembler (the README calls support for those platforms a design goal, not a feature), or expect a stable plugin API, since the author describes the project as an initial exploration and a playground. Before installing, check the model download size against your disk and network, confirm your Binary Ninja version loads a plugin installed with pip3 install ., and read example_config.toml against your hardware so that n_threads and n_gpu_layers are not left at defaults that assume a GPU you do not have.

Frequently asked questions

Official sources

1. Issues
2. License: GPL-2.0
3. mrphrazer/reverser_ai on GitHub
4. README
5. Releases