ReverserAI: Local LLM Function Naming Inside Binary Ninja
Provides automated reverse engineering assistance through the use of local large language models (LLMs) on consumer hardware.
At a glance
- What is it?
- ReverserAI is a GPL-2.0 Binary Ninja plugin that feeds decompiler output to a locally hosted GGUF model and suggests function names. It trades cloud model quality for offline operation, and the README is explicit that it is a research project rather than a finished product.
- Who is it for?
- Adopt ReverserAI if you already work in Binary Ninja, your binaries cannot leave your machine, and you accept that a 7B model will be wrong on some functions. Do not adopt it if you need IDA or Ghidra support today, since the README describes those integrations as architecture goals rather than shipped features, or if you cannot spare 16 GB of RAM and 12 CPU threads.
- Can I use it commercially?
- Yes, with conditions. GPL-2.0 is a copyleft licence: if you distribute software that includes it, you must release that software's source code under the same licence. Running it internally without distributing it does not trigger that obligation.
- Is it still maintained?
- Yes. The repository last received commits 118 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem ReverserAI targets: naming functions without sending code to a cloud
Reverse engineering produces a lot of unnamed functions. Decompiler output gives you structure, types and call relationships, but the names are usually stripped, so an analyst ends up reading each function to decide what to call it. ReverserAI automates that first pass by asking a large language model to propose a high-level, semantically meaningful name from the decompiler output. The README describes this as the initial release feature, and it is the only end-user capability documented in the supplied material. The intended audience is narrow: people who already use Binary Ninja, who have consumer-grade hardware, and who cannot or will not send binary-derived text to a hosted model. The README frames the trade-off directly. Local models do not match cloud counterparts such as ChatGPT4 and require substantial computing resources, but they balance performance against confidentiality requirements. That sentence is the whole pitch, and it is an honest one. If your threat model permits cloud inference, a hosted model will likely give better names. If it does not, this is one of the few documented options that keeps the decompiler text on your machine.
Data flow: decompiler output in, model inference, suggested names in the log
The plugin is a Binary Ninja plugin written in Python, and the README states that its architecture is designed to be extended to other platforms such as IDA and Ghidra. No IDA or Ghidra integration is described as shipped, so treat the modular architecture as an intention rather than a feature you can use today. The inference path runs through a local GGUF model. The default is mistral-7b-instruct-v0.2.Q4_K_M.gguf, a quantized 7B instruct model, and the configuration key model_identifier also accepts mixtral-8x7b-instruct. The README notes that ReverserAI explores combining static analysis with the model to improve accuracy, which suggests the prompt is not raw decompilation alone. The exact composition of that context is not spelled out in the supplied README, so I cannot describe the prompt format or which static analysis facts are included. What is documented is the interface: you pick a menu action such as Rename All Functions, and suggestions appear in the Binary Ninja Log window. Nothing is written back to the database automatically as far as the README shows. Renaming is a manual step after reading the log. That is a reasonable design for a research tool, because it keeps a wrong suggestion from silently corrupting your analysis, but it also means the plugin does not save you the mechanical work of applying names.
Installation and the 5 GB model download on first launch
Installation is either through Binary Ninja's plugin manager or from the command line in Binary Ninja's plugins folder. The README gives these commands: git clone https://github.com/mrphrazer/reverser_ai.git, then cd reverser_ai, then pip3 install -r requirements.txt, then pip3 install . On first launch the tool downloads the default model file, mistral-7b-instruct-v0.2.Q4_K_M.gguf, which the README puts at roughly 5 GB. Download time depends on your connection. If you want to trigger the download yourself or fetch a different model, the README points to scripts/model_download.py. Two practical consequences follow. First, the first launch is not offline. The plugin needs network access once to fetch the GGUF file, and in an air-gapped environment you will need to stage that file beforehand. Second, the 5 GB figure is for the default model only. The README states that mixtral-8x7b-instruct requires approximately 25 GB of RAM, which is a different hardware class entirely. The requirements.txt contents are not shown in the supplied material, so I cannot say which inference library is pinned or whether a specific llama.cpp binding is required.
Configuration keys and what the README says about hardware
Five keys carry most of the tuning: model_identifier, use_mmap, n_threads, n_gpu_layers and seed, plus verbose for logging. model_identifier selects between mistral-7b-instruct, described as needing about 5 GB of RAM and suited to limited hardware or high throughput, and mixtral-8x7b-instruct, described as needing about 25 GB and recommended for high-end hardware and more complex analysis. use_mmap enables memory mapping so the model loads data on demand, which the README says can reduce memory usage for very large models. The README also warns that mixtral may require disabling memory mapping on machines that cannot support the required RAM. n_threads sets CPU threads, with 0 disabling CPU processing. n_gpu_layers accepts values up to 99, or 0 to disable GPU. seed fixes determinism for debugging. The hardware guidance is concrete: at least 16 GB of RAM and 12 CPU threads, with queries taking about 20 to 30 seconds, and GPU optimization, especially on Apple silicon, reducing that to 2 to 5 seconds per query. Those numbers come from the README and depend on the model and the binary. Note what they imply for bulk renaming. A binary with a few thousand functions at 20 seconds each is hours of wall time, and the README itself says that depending on the total number of functions, Rename All Functions may take a while.
The wrong tool for large binaries, air-gapped first runs and non-Binary-Ninja workflows
The clearest limitation is throughput. The README's own timing puts CPU-only inference at 20 to 30 seconds per query, and function naming is per-function work. A small binary is fine. A firmware image with thousands of functions is not, unless you have the GPU path working and accept 2 to 5 seconds per function, which is still a long batch job. The second limitation is platform lock-in. The shipped product is a Binary Ninja plugin. The README says the architecture is designed for extension to IDA and Ghidra, which is not the same as support. If you are an IDA or Ghidra user, this project does not currently serve you. Third, the first run requires a network download of a roughly 5 GB file, so a fully air-gapped machine needs the model staged in advance. Fourth, quality is bounded by the model. The README states plainly that local LLMs do not match cloud-based counterparts, and the author's own disclaimer notes limited machine learning expertise and the possibility that more efficient models or methods exist. Finally, the plugin suggests names in the Log window. It does not, per the README, rewrite your database automatically, so the review burden remains with you.
How this differs from running a general local model or a cloud assistant
The obvious alternative is a general local model served through something like Ollama or llama.cpp, paired with manual copy and paste from the decompiler. The difference is not the model, it is the plumbing. ReverserAI wires the decompiler output into the prompt, applies a task-specific instruction, and returns suggestions inside the Binary Ninja UI, with the README claiming static analysis is combined with the model to improve accuracy. A general chat setup gives you no decompiler-aware prompt construction and no in-editor workflow; you build that yourself. The other alternative is a cloud assistant such as ChatGPT4, which the README names directly. That path gives better reasoning per the author's own comparison, at the cost of sending binary-derived text to a third party. A third option is simply not using an LLM and relying on Binary Ninja's existing analysis and your own reading. That is slower per function but has no hardware requirement beyond what you already run. ReverserAI sits between these: more integrated than a chat window, weaker than a cloud model, and entirely local.
Licence, maintenance and upgrade cost
The repository is GPL-2.0. If you distribute a modified version or link it into a larger distributed work, the GPL's copyleft terms apply, and the usual obligations around source disclosure and licence notices follow. I am not a lawyer and this is not legal advice; check with counsel if you plan to ship something built on this code. On maintenance, the release history shows v1.0.1 in March 2024, v1.1 in June 2024, and v1.2 in May 2026, so the project moves in occasional jumps rather than continuous releases. The repository is not archived and the last push matches the v1.2 release date. The upgrade cost is mostly model files. Switching between mistral-7b-instruct and mixtral-8x7b-instruct means a new download and a very different RAM footprint, roughly 5 GB versus 25 GB per the README, and scripts/model_download.py is the documented way to fetch them. Expect to re-tune n_threads and n_gpu_layers whenever you change model or machine. The plugin's Python dependencies are pinned only by requirements.txt, which the supplied material does not show, so dependency drift is a real possibility between releases.
Editorial conclusion
Adopt ReverserAI if you already work in Binary Ninja, your binaries cannot leave your machine, and you accept that a 7B model will be wrong on some functions. Do not adopt it if you need IDA or Ghidra support today, since the README describes those integrations as architecture goals rather than shipped features, or if you cannot spare 16 GB of RAM and 12 CPU threads. Verify first whether your Binary Ninja build loads the plugin and whether the default model download completes, because the plugin fetches a roughly 5 GB GGUF file on first launch.
Community notes