Gepetto: an IDA Pro plugin that asks a language model to explain decompiled functions

What Gepetto does that IDA's decompiler does not

IDA's Hex-Rays decompiler gives you C-like pseudocode with names like sub_401A20, v3, and a2. Reading that is mechanical work: you follow the arguments, guess what the function returns, and rename things by hand. Gepetto takes the pseudocode of the function you are looking at, sends it to a language model, and puts the answer back in front of you as an explanation, as comments inserted into the code, or as suggested names for the function's variables.

The intended user is a reverse engineer who is already working inside IDA Pro 7.6 or later and who is willing to send decompiled code to a model provider. That last part is the whole decision. Gepetto is not an analysis engine; it does not disassemble anything, does not build a call graph, and does not verify its own output. It is a prompt builder and a response parser bolted onto IDA's UI, and the quality of what you get back is the quality of the model you pointed it at.

How the plugin reaches a model: providers, config, and the menu

Gepetto ships a set of provider modules under gepetto/models/. Each one wraps a vendor SDK and exposes the same small contract: a menu name, a list of supported models, a check for whether the provider is configured, and a call that turns a prompt into text. The built-in list covers Anthropic, OpenAI, Google Gemini, Azure OpenAI, Groq, Together, Novita AI, Kluster.ai, plus local models through Ollama and LM Studio. The two local entries only appear in the menu when the corresponding server is running, which is why a missing Ollama entry usually means the daemon is not up.

Configuration lives in an INI file in your IDA user directory rather than next to the plugin, so it survives plugin upgrades. The README gives the paths: %APPDATA%\Hex-Rays\IDA Pro\cfg\gepetto\config.ini on Windows, and ~/.idapro/cfg/gepetto/config.ini on macOS and Linux. On first run the plugin copies its bundled template there and prints the path on the console. After that, the bundled copy is only a template, and the GEPETTO_CONFIG_DIR environment variable overrides the location entirely.

The extension path is the part worth reading twice. Providers load 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. Overrides are announced on the console, so you can replace a built-in provider without forking the repository. The README is explicit that files in providers/ execute arbitrary Python when IDA starts, and says to install only providers you trust. That is the same trust level as any IDA plugin, but it is worth stating plainly because a provider file is code, not configuration.

Installing Gepetto with hcli or by hand

The recommended route is Hex-Rays' own CLI tool, which places the plugin in your IDA user directory for you. The README gives these two commands:

pip install ida-hcli
hcli plugin install gepetto

After that, Gepetto should appear in IDA's menus without further copying. If you prefer to control the layout, the manual route is to drop gepetto.py and the gepetto/ folder into $IDAUSR/plugins. The README lists the per-platform locations: %APPDATA%\Hex-Rays\IDA Pro\plugins\ on Windows, and ~/.idapro/plugins/ on macOS and Linux.

Manual installation needs one more step, because IDA runs its own Python interpreter and does not see packages installed into a different one. The README points at the registry key Computer\HKEY_CURRENT_USER\Software\Hex-Rays\IDA to find which interpreter IDA uses, notes that the default on Windows is %LOCALAPPDATA%\Programs\Python\Python39, and then asks you to install the dependencies with that interpreter:

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

The requirements file pins minimums rather than exact versions, including openai >= 1.101.0, anthropic >= 0.52.0, groq >= 0.8.0, together >= 1.2.0, ollama >= 0.4.5, azure-identity >= 1.21.0, google-genai >= 1.36.0, pytest >= 9.0.1 and pycryptodome >= 3.23.0. The pyproject.toml declares requires-python >= 3.10, so IDA builds running an older embedded interpreter are out of scope regardless of what the plugin folder contains.

First real use: open a binary, put the cursor in the pseudocode window, and use the context menu entry that the README shows in its usage screenshot. The hotkeys are the faster path. Ctrl + Alt + G asks the model to explain the function, Ctrl + Alt + K asks it to add comments to the code, and the third action requests better names for the function's variables. Model selection happens under Edit > Gepetto. There is also a CLI inside IDA: select Gepetto in the input bar and type a question directly.

Writing a provider for an endpoint Gepetto does not ship

If your model is served from an OpenAI-compatible endpoint, you do not need to modify the repository. Drop a file into $IDAUSR/cfg/gepetto/providers/ that subclasses the built-in GPT provider, declares a menu name and a model list, and registers itself. The README's example is short enough to reproduce in full:

import openai
import gepetto.config
import gepetto.models.model_manager
from gepetto.models.openai import GPT


class MyProvider(GPT):
    @staticmethod
    def get_menu_name() -> str:
        return "MyProvider"

    @staticmethod
    def supported_models():
        return ["my-model-v1"]

    @staticmethod
    def is_configured_properly() -> bool:
        return bool(gepetto.config.get_config("MyProvider", "API_KEY", "MYPROVIDER_API_KEY"))

    def __init__(self, model):
        try:
            super().__init__(model)
        except ValueError:
            pass  # No OpenAI key needed for this provider.
        self.model = model
        self.client = openai.OpenAI(
            api_key=gepetto.config.get_config("MyProvider", "API_KEY", "MYPROVIDER_API_KEY"),
            base_url="https://api.example.com/v1",
        )


gepetto.models.model_manager.register_model(MyProvider)

You then add a matching [MyProvider] section to config.ini and restart IDA, because providers are registered at load time. A new key or a new file will not show up in the menu until the process restarts. To distribute a provider as a package instead, expose the class or a register(register_model) callable through an entry point:

[project.entry-points."gepetto.providers"]
myprovider = "myprovider:MyProvider"

Note the get_config signature in the example: a section, a key, and an environment variable name as fallback. That is how the plugin lets you keep keys out of the INI file.

Where Gepetto gets in the way

The obvious limitation is the one the README states without softening it: API queries are usually not free, though not very expensive, and you need a payment method with the provider. Every explanation, comment pass, or rename request is a billed call. On a large binary where you want help with hundreds of functions, that adds up, and there is no batching or caching layer described in the repository.

Confidentiality is the harder constraint. Sending a decompiled function to OpenAI, Anthropic, Google, Azure, Groq, Together, Novita or Kluster means that function leaves your machine. For malware analysis, firmware from a client, or anything under an NDA, that is often a non-starter. Gepetto does offer a way out through Ollama and LM Studio, which run models locally, but the README does not claim those models match the hosted ones on rename quality, and the supported-model list for local entries is simply whatever your server exposes.

Capability is uneven across providers. The README flags one entry explicitly: mistralai/Mixtral-8x22B-Instruct-v0.1 through Together does not support renaming variables. If you pick a model on price or availability and then wonder why renames do nothing, that is the reason. Nothing in the plugin validates that the model you selected can perform the action you asked for.

Finally, the output is a suggestion, not a result. Gepetto does not check whether a proposed variable name matches the type or the usage, and it does not roll back a rename you accepted. The README does not document an undo path for accepted renames, so the practical recovery is IDA's own undo. Treat every accepted name as an edit you made.

Gepetto against a plain chat window

The realistic alternative is not another IDA plugin; it is copying the pseudocode into a chat interface or a script that calls the same APIs. That approach costs nothing to set up and works with any model you like. The difference is friction and context. Gepetto reads the function directly from the decompiler, so you never paste code, never lose the association between the model's answer and the function it describes, and can apply a rename in place instead of retyping it. The hotkeys make the round trip a couple of seconds.

The trade-off runs the other way too. A chat window lets you paste surrounding functions, a string table, or your own notes, and lets you argue with the model across several turns. Gepetto's actions are one-shot: explain, comment, rename. If your question is "what does this function do in the context of these four callers", the plugin is the wrong tool and a chat session is the right one. Gepetto is best understood as the fast path for the routine question, not as a replacement for reasoning about the binary yourself.

Maintenance, licensing and upgrade cost

The repository is not archived, and the last push was on 2026-08-15, about a month before this writing. Releases are infrequent: v1.4.1 in September 2024, then v1.5.0 in October 2025 and v1.5.1 in November 2025. The pyproject.toml still declares version 1.5.0, which is a small inconsistency worth knowing if you check versions programmatically. The dependency set is broad, spanning seven vendor SDKs plus pytest and pycryptodome, and each SDK moves on its own schedule, so an upgrade of Gepetto can pull in major-version changes from a provider library you were not thinking about. The configuration file living in the IDA user directory rather than in the plugin folder is a deliberate choice that keeps your keys and model selection across upgrades, and GEPETTO_CONFIG_DIR gives you a way to pin it elsewhere.

The licence is GPL-3.0. If you distribute a modified Gepetto, or bundle it inside something you ship, the GPL's terms apply to that distribution. Writing a provider file for your own endpoint is not the same thing as redistributing the plugin, but the boundary depends on how you package it, and this is a question for your own legal review rather than something the README answers.

Editorial conclusion

Adopt Gepetto if you already live in IDA Pro 7.6 or newer and want a second opinion on pseudocode without leaving the window. Skip it if your samples cannot leave the machine and you are not running a local model through Ollama or LM Studio, because every other provider sends the decompiled function to a third party. Before trusting a rename, check that the provider you selected actually supports renaming, since the README notes that at least one listed model does not.

Frequently asked questions

Official sources

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