Gepetto: an IDA Pro plugin that asks a language model what a function does

The gap Gepetto fills between a decompiler and a readable function

A decompiler gives you control flow and types, not intent. After a few hours in a large binary you are left with functions named sub_14002A3C and variables named v3, v7 and a5, and the only way to fix that is to read each one and type a name yourself. Gepetto attacks exactly that step. The README describes it as a Python plugin that uses large language models to give meaning to functions decompiled by IDA Pro 7.6 and newer, and it does two things with that meaning: it explains what a function does, and it automatically renames its variables.

The audience is narrow on purpose. You need a licensed IDA Pro at version 7.6 or above, you need a model provider account, and you need to be comfortable with the idea that the pseudocode of the binary you are analysing is sent to a third party over the network. Anyone doing malware triage on samples under a non-disclosure agreement should stop at that last sentence. The plugin does support local models through Ollama and LM Studio, which changes the calculus, but the default path in the README is a hosted API with a payment method attached.

How a request flows from the pseudocode window to the model and back

The README documents three entry points and three hotkeys. From the context menu of the pseudocode window you can ask for an explanation, ask for comments, or ask for better variable names; the same actions are bound to Ctrl+Alt+G, Ctrl+Alt+K, and a third hotkey for renaming that the README lists without a key combination. The plugin takes the current function's decompiled text, builds a prompt, and hands it to whichever provider is selected in the Edit > Gepetto menu. The answer is then applied to the IDA database: an explanation appears in the output window, comments are inserted into the function, and names are written onto the variables.

The provider layer is the interesting part of the architecture. Providers are loaded from three places, each overriding the previous one on a menu name collision: the modules shipped in gepetto/models/, then any .py file in $IDAUSR/cfg/gepetto/providers/, then any installed distribution advertising a gepetto.providers entry point. The README states that overrides are announced on the console, so a site can replace a built-in provider without forking the plugin. A drop-in provider subclasses an existing one, declares a menu name, a list of supported models, and an is_configured_properly check, and registers itself with gepetto.models.model_manager.register_model. That is a small contract, and it is the reason the supported-model list is as long as it is.

One consequence of the loading order deserves emphasis. The README says plainly that files in providers/ execute arbitrary Python when IDA starts. That is the same trust level as any IDA plugin, and the README says so, but it means a provider directory is not a configuration folder. It is a code directory.

Installing Gepetto with hcli and running the first explanation

The README recommends the Hex-Rays CLI tool and gives a two-command install. The first command installs the tool itself, the second asks it to install the plugin into your IDA user directory.

pip install ida-hcli
hcli plugin install gepetto

After that, start IDA and open a binary. The README states that the plugin is invoked from the context menu of the pseudocode window; select a function, right-click, and pick the Gepetto entry. The first run copies gepetto/config.ini into your IDA user directory and prints the path on the console. On Windows that path is %APPDATA%\Hex-Rays\IDA Pro\cfg\gepetto\config.ini, and on macOS and Linux it is ~/.idapro/cfg/gepetto/config.ini. The copy shipped with the plugin is a template after that first run; the README says to edit the one in the user directory. Setting GEPETTO_CONFIG_DIR overrides the location entirely.

Open that file and add an API key, either directly or by referencing an environment variable named in the file. For OpenAI the README points at the platform's API key page. Then pick a model under Edit > Gepetto and press Ctrl+Alt+G on a function. If nothing appears in the menu, the usual cause is that the provider is not configured: is_configured_properly gates whether a provider shows up at all, and Ollama and LM Studio entries are documented as absent when their local servers are not running.

If you prefer the manual route, the README gives it too. Drop gepetto.py and the gepetto/ folder into $IDAUSR/plugins ($APPDATA%\Hex-Rays\IDA Pro\plugins\ on Windows, ~/.idapro/plugins/ on macOS and Linux), find which interpreter IDA uses through the registry key Computer\HKEY_CURRENT_USER\Software\Hex-Rays\IDA, and install the requirements with that interpreter:

[/path/to/python] -m pip install -r requirements.txt

That last step is where manual installs go wrong most often. IDA ships its own Python, and installing into your system interpreter leaves the plugin unable to import openai or anthropic.

The API bill, the data boundary, and the renames you should not trust

Gepetto is not free to run. The README says API queries are usually not free, though not very expensive, and that you need a payment method with the provider. Every explanation, every comment pass and every rename is a billed request against a decompiled function, and large functions produce large prompts. There is no documented batching, caching or cost cap in the README, so the only control you have is choosing a cheaper model in the Edit > Gepetto menu. That is a real constraint for anyone planning to run this across a whole binary rather than on the handful of functions that matter.

The second limitation is the data boundary. Sending decompiled code to a hosted provider is the default behaviour, and the README does not describe a redaction step, an offline mode toggle, or a way to preview the prompt before it leaves the machine. Local models through Ollama and LM Studio are the answer the project offers, and they are listed as supported, but the README does not compare their output quality against the hosted models, so you are choosing on your own judgement.

The third limitation is trust in the output. A renamed variable is written into your database, and nothing in the plugin verifies that the name matches what the code actually does. A model that misreads an obfuscated loop will produce a confident, wrong name, and the name will persist in the IDB. The same applies to inserted comments. The README also notes one provider-level gap: mistralai/Mixtral-8x22B-Instruct-v0.1 on Together does not support renaming variables, which tells you the rename path depends on the model following a structured instruction rather than on any validation in the plugin.

Finally, the installation surface. The plugin runs inside IDA's interpreter, so a dependency conflict with another plugin is possible, and the README's upgrade story is limited to the note that configuration survives upgrades because it lives in the IDA user directory. There is no documented rollback for a bad plugin version beyond reinstalling.

Gepetto against a general chat window and against a symbolic analysis tool

The obvious alternative is copying a function out of IDA and pasting it into a chat interface. That works, and it costs nothing to set up, but the loop is manual: copy, paste, read, copy the name back, retype it into IDA. Gepetto's difference is not the model, it is the plumbing. The decompiled text goes out with the current context, and the answer comes back as an edit to the database rather than as text in another window. For renaming specifically, that difference is the whole feature.

The other alternative is a symbolic or heuristic tool that recovers names from library signatures, type information or pattern matching. Those tools do not guess from prose; they match against known code, so they either produce a defensible name or produce nothing. Gepetto does the opposite: it will always produce a name, and the confidence behind it is not exposed. The two approaches complement each other, and the honest framing is that Gepetto is faster on unfamiliar, non-library code where no signature exists, and weaker wherever a deterministic match is available.

Maintenance, licensing and what an upgrade actually costs

The repository was last pushed on 2026-08-15, and the most recent release listed is v1.5.1 from 2025-11-19, following v1.5.0 on 2025-10-03. The gap between v1.4.1 in September 2024 and v1.5.0 in October 2025 suggests a project that moves in bursts rather than continuously, which matters if you are pinning a version for a team. The declared Python requirement is >= 3.10 in pyproject.toml, and the pinned dependency floors in requirements.txt include anthropic >= 0.52.0, openai >= 1.101.0, google-genai >= 1.36.0 and pycryptodome >= 3.23.0. Those are floors, not locks, so an upgrade can pull newer provider SDKs with breaking changes.

Gepetto is licensed under GPL-3.0. If you install it as a plugin for your own analysis work, that is the ordinary case. The question worth asking before shipping anything is the provider path: the README documents that a distribution can advertise a gepetto.providers entry point, and a drop-in provider file in $IDAUSR/cfg/gepetto/providers/ is your own code. Whether a provider you distribute alongside a GPL-3.0 plugin inherits the licence is a question for a lawyer, not for this article. What can be said from the repository is the licence identifier and that the plugin is not offered under a permissive alternative.

Editorial conclusion

Adopt Gepetto if you already reverse-engineer in IDA Pro 7.6 or newer, you are willing to pay a provider per query, and you want explanations and variable names without leaving the pseudocode window. Do not adopt it as an analysis engine: it does not resolve symbols, recover types, or verify its own output, and it is the wrong tool if your binaries cannot leave the machine or if you cannot install packages into IDA's own interpreter. Before trusting a rename in a real database, check the config path it reports on first run, confirm which interpreter IDA uses, and read the provider file in $IDAUSR/cfg/gepetto/providers/ before you start IDA with it.

Frequently asked questions

Official sources

1. Issues
2. JusticeRage/Gepetto on GitHub
3. License: GPL-3.0
4. README
5. Releases