Glaurung: A pre-1.0 Rust/Python reverse-engineering framework with agentic AI hooks

What Glaurung actually is

Glaurung is a reverse-engineering framework written from scratch, not a Ghidra plugin. The README is explicit: it is a pre-1.0 project with a Rust analysis core, Python bindings, a CLI, and persistent SQLite project files. It is designed for automated binary triage and analysis, not for interactive reverse engineering. The project is useful today for that narrow purpose, but the documentation warns it is not yet a drop-in replacement for mature tools like Ghidra or IDA Pro. The decompiler output is experimental and should be checked against disassembly and runtime behavior. That is a refreshingly honest positioning. If you need a stable, interactive decompiler, this is not the tool yet. If you need to script the first pass over a batch of binaries, it may be.

The Rust core and Python bindings

The architecture is a Rust analysis core with Python bindings, exposed through both a CLI and a Python API. The README shows a Python example that imports `from glaurung import triage` and calls `triage.analyze_path(sample)`. The returned artifact has verdicts, entropy, and other fields. For repeated decompiler queries, the README recommends retaining one immutable `g.ir.DecompilerSession` so that exact discovery and rendered artifacts can be reused. The cache key includes the function address, discovery budgets, type/style options, and normalized architecture address. Diagnostic runs and PDB overlays bypass rendered-output reuse, which means you cannot accidentally hide new evidence behind a stale cache hit. That design choice shows attention to correctness in a tool that is still experimental.

Getting it running from source

Glaurung is not published on PyPI, so you build from source. The prerequisites are Git, CPython 3.11 or newer, Rust 1.88 or newer, and a native C compiler and linker. The README directs you to install `uv`, then run: `git clone https://github.com/mjbommar/glaurung.git`, `cd glaurung`, `uv sync --locked --dev`, and `uv run glaurung --version`. The `uv sync` command creates a `.venv`, resolves the checked-in lockfile, builds the Rust extension, and installs the Python package. After that, every command is invoked with `uv run glaurung ...` from the repository root. The repository includes real sample binaries, so you can run the smoke test without an API key. For example, `uv run glaurung triage "$SAMPLE"` performs a fast first pass, and `uv run glaurung kickoff "$SAMPLE"` runs the deeper deterministic pipeline. The README also lists `strings`, `symbols`, `graph`, and `detect-packer` as other entry points.

What the analysis pipeline covers

The triage and kickoff commands cover ELF, PE/COFF, and Mach-O formats. The analysis includes symbols, strings, IOCs, entropy, packer signals, and hardening metadata. Disassembly is bounded for x86/x86-64, ARM/ARM64, and RISC-V, but the decompiler only lifts x86/x86-64 and ARM/ARM64. RISC-V is disassembly-only. Function discovery, control-flow graphs, call graphs, cross-references, stack-frame analysis, type propagation, DWARF ingestion, and PE/PDB support are listed as working. The decompiler produces C-like pseudocode through an LLIR/SSA/AST pipeline. The persistent `.glaurung` project database stores names, comments, labels, types, prototypes, xrefs, stack variables, bookmarks, and journal entries. That is a substantial feature set for a pre-1.0 tool, but the decompiler caveat is the key limitation.

LLM-assisted workflows and configuration

Glaurung includes optional LLM-assisted workflows through PydanticAI agents for question answering, naming, vulnerability review, and source recovery. The default model is `openai:gpt-5.4-mini` with OpenAI's `flex` service tier. You set `OPENAI_API_KEY` in the environment or in a `.env` file. Override the model with `--model provider:model` or globally with `GLAURUNG_LLM_MODEL`. Anthropic and Google credentials are also supported for explicitly selected models. The README shows an `ask` command: `uv run glaurung ask "$SAMPLE" --route -a "What does this binary do?"`. Deterministic analysis needs no credentials, so the LLM features are clearly additive. The README warns never to commit `.env` or API keys. The complete environment-variable reference, configuration precedence, and cache behavior are in the setup guide.

Limitations and wrong-tool cases

The most obvious limitation is the decompiler. The README states that decompiler output is experimental and should be checked against disassembly and runtime behavior. That means you cannot trust the pseudocode for security-critical analysis without manual verification. RISC-V is disassembly-only, so if your target is RISC-V, you lose the decompiler entirely. The project is also not a drop-in replacement for Ghidra or IDA Pro, which are interactive tools with mature GUIs. Glaurung is designed for automated triage, so if your workflow requires interactive exploration and manual annotation, you will fight the CLI. Resource limits are set via command-line flags like `--max-file-size`, `--max-read-bytes`, `--max-functions`, and `--timeout-ms`, but not every command exposes every limit. You have to check each command's `--help` to know what is available. That is a real usability friction point.

Alternatives and how Glaurung differs

The obvious alternative is Ghidra, which the README itself names. Ghidra is a mature, interactive reverse-engineering suite with a decompiler that has been refined over years. It is written in Java with a Python scripting interface (Jython). Glaurung is a ground-up project written in Rust with Python bindings, not a Ghidra plugin or extension. The architectural difference is significant: Glaurung is designed for automation and scriptability from the start, with a persistent SQLite project format, while Ghidra is built around a GUI and a proprietary project format. For batch triage of many binaries, Glaurung's CLI and Python API may be more convenient. For interactive analysis of a single binary, Ghidra is far more mature. Another alternative is radare2/rizin, which is also scriptable and has a decompiler, but the README does not mention it, so I will not speculate further.

Maintenance, licensing, and upgrade path

The project is licensed under Apache-2.0, which is permissive and allows commercial use, modification, and redistribution, with the caveat that you should consult a lawyer for legal advice. The repository is not archived, and the last push is dated 2026-08-13, so it is actively maintained. The release tags are named `decbench-*`, which suggests the maintainers are using a decoder benchmark to track decompiler quality. The README includes a development section with commands for rebuilding the Rust extension (`uv run maturin develop`) and running the standard checks (`cargo test`, `uv run pytest python/tests/`, `uvx ruff format --check python/`, `uvx ruff check python/`, `uvx ty check python/`). The upgrade cost is tied to the source build: since there is no PyPI package, you must pull the latest source and rerun `uv sync --locked --dev` to get updates. The lockfile should keep dependencies reproducible, but you are on the hook for Rust toolchain upgrades, as the minimum Rust version is 1.88.

Editorial conclusion

Adopt Glaurung if you need scriptable, deterministic triage of ELF, PE, or Mach-O binaries and want to experiment with LLM-assisted analysis without committing to a mature interactive tool. Do not adopt it if you need production-grade decompilation or a drop-in Ghidra replacement; the README explicitly warns that decompiler output is experimental. Before adopting, verify that the architectures you target are covered (RISC-V is disassembly-only), confirm the resource-limit flags you need exist on your chosen commands, and check the development setup guide for platform-specific build requirements. Then run `uv run glaurung kickoff "$SAMPLE" --db trial.glaurung` on a representative sample to see if the pipeline meets your needs.

Frequently asked questions

Official sources

1. Official README
2. Project repository
3. Release notes