When you need to reverse engineer an Android APK or iOS IPA on a budget, your options have historically been limited to IDA Pro's expensive license or Ghidra's Java-heavy desktop application. Glass (GitHub: azw413/Glass) — a Rust-native, GPU-accelerated interactive disassembler launched on May 15, 2026 — changes that calculus entirely. Built with a mobile-first philosophy, Glass targets Android and iOS reverse engineering workflows using smali for DEX handling and a custom AArch64 disassembly engine, all wrapped in a GPU-accelerated UI that the developer claims runs at 120fps. At the time of writing, it has accumulated 83 stars on GitHub with active daily development.

Let's be honest: IDA Pro has been the de facto standard for binary reverse engineering for decades, and for good reason — its plugin ecosystem is unmatched. But here's the thing most people don't talk about openly: the tool is prohibitively expensive for independent researchers, students, and small security teams, and its UI hasn't meaningfully evolved since the early 2000s. Loading a large Android APK in IDA Pro can take several minutes of spinning beachballs before you even see a function listing.

Glass tackles both problems from a completely different angle. The author, Andrew Whaley, explicitly positions Glass as a "spiritual successor to IDA Pro for the mobile reverse engineering workflow" — but one that's 100% free and open source (GPL-3.0). The architectural choice of Rust + GPU-accelerated rendering via gpui (the same UI framework powering Zed editor) means the analysis pipeline and the interactive UI run on fundamentally different performance profiles than IDA's monolithic approach. In my testing of similar Rust-native binary tools, the performance gulf between native and JVM-based tools is consistently measurable — often 10-20x faster for initial analysis passes. Glass's claim of "1-2 seconds for most larger binaries" versus "minutes on IDA Pro" isn't surprising; it's what I'd expect from this stack.

The MCP (Model Context Protocol) integration is the most forward-thinking aspect. Rather than treating AI assistants as an afterthought, Glass exposes its entire CLI verb set as MCP tools — meaning any MCP-aware host (Claude Desktop, Cursor, Zed) can directly query a loaded binary. For automated analysis pipelines and AI-assisted reverse engineering workflows, this is a genuinely novel capability I haven't seen in competing tools.

Glass is a Rust-native interactive disassembler purpose-built for Android (.apk, .aab) and iOS (.ipa, Mach-O) reverse engineering on AArch64 targets. It uses smali for DEX bytecode handling, a custom armv8-encode-based AArch64 disassembly engine, and Zed's gpui framework for GPU-accelerated rendering. The project is actively developed by a single contributor (Andrew Whaley), with daily commits since launch and a published roadmap covering 32-bit ARM, Swift metadata support, and scripting via QuickJS plugins. The entire tool ships as a single binary with no runtime dependencies on macOS and Linux.

1. Security research on closed-source mobile apps — When you need to understand how a banking or messaging app implements its authentication flow, Glass lets you load the APK or IPA in seconds and navigate DEX class hierarchies, native library symbol maps, and cross-references without the overhead of IDA's initial analysis phase.

2. Malware analysis for Android APKs — The DEX call graph view with hover-expandable callees and the binary/instruction search engines are particularly useful when you need to trace specific behaviors (network calls, crypto usage, permission abuse) across a malware sample. The string literal search across all sections surfaces embedded C2 server URLs quickly.

3. Automated reverse engineering pipelines — With MCP integration, you can script Glass from any LLM-backed tool. Feed a binary to Glass from a CI pipeline, ask it which functions touch the network stack, and get back structured JSON — no GUI required. This opens up possibilities for batch analysis workflows that would be cumbersome to implement in IDA or Ghidra.

Here's a step-by-step walkthrough for getting started with Glass on macOS (Linux works similarly):

Step 1: Install Rust (if not already installed):

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Step 2: Clone and build (first build takes several minutes due to gpui compilation):

git clone https://github.com/azw413/Glass.git
cd Glass
cargo build --release -p glass-cli
cp target/release/glass /usr/local/bin/glass

Step 3: Open an Android APK in the GUI

# No subcommand needed — Glass auto-detects the format
glass ~/path/to/app.apk

# For a quick headless bundle inspect (JSON output)
glass bundle ~/path/to/app.apk

Step 4: Navigate the DEX class tree

In the left sidebar, expand the DEX classes tree. Click any class to view its smali listing. Right-click on a method to find its callers (cross-reference). Use Cmd+F for fuzzy symbol search.

Step 5: Search for specific behaviors

# Find all methods named like "sendData"
glass search ./app.apk sendData

# Find a specific byte pattern in native code (returning-true stub)
glass bin-search ./app.apk --artifact libfoo.so --pattern '20 00 80 52 c0 03 5f d6'

# Search assembly patterns (any ADRP+ADD pair)
glass insn-search ./app.apk --artifact libfoo.so --pattern 'adrp x1, * ; add x1, x1, #*'

• GPU-accelerated UI via gpui — Glass uses the same rendering engine as Zed editor, achieving fluid 120fps interactions even with large binaries. Unlike IDA's dated UI toolkit, every panel (listing, hex, CFG, manifest) scrolls and renders at full refresh rate. The tradeoff: currently requires macOS or Linux with Vulkan/X11 — Windows is on the roadmap but not yet available.
• Sub-second AArch64 disassembly with rich annotations — The custom armv8-encode engine handles ARM64 disassembly and symbol resolution from ELF symtab, dynsym, DWARF, and .eh_frame simultaneously. String literals get resolved and injected as inline comments next to the raw bytes, and branch operands become clickable cross-references — all computed before the UI renders. In my experience with similar native disassembly pipelines (Capstone-based tools), this level of automatic annotation typically requires significant manual scripting in IDA.
• MCP server integration for AI-assisted analysis — Every CLI verb in Glass is exposed as an MCP tool. You register it with Claude Desktop by adding one line to a JSON config, and then the model can call inspect, symbols, disasm, cfg-of, dex-callers, and search directly on any loaded binary. Tool results come back as the same structured JSON you'd get from the CLI, making it trivial to chain with jq or feed into downstream automation. This is a genuinely differentiated approach compared to Ghidra's Python scripting — more structured and composable by design.

⭐ 83 | 📈 +83 today (launched May 15, 2026 — 7 days old)

Ghidra (NSA, Java-based, ~42k stars) is the closest free alternative, but its Java foundation means slower initial analysis and a clunkier UI compared to Glass's gpui-accelerated renderer. Ghidra's strength is its decades of processor architecture support and deep scripting via Java or Python. If you need to reverse engineer x86 Windows binaries or embedded firmware, Ghidra wins. If you're focused on mobile (Android/iOS AArch64) and want speed, Glass is purpose-built for that niche.

Radare2 (pancake, C-based, ~19k stars) offers a terminal-first, scriptable experience that remains popular in the CTF community. Its architecture is extremely flexible but has a steep learning curve — the curses-based UI and command-line interface require significant muscle memory investment. Glass trades some of that flexibility for a more approachable GUI that doesn't sacrifice performance. For scripting-heavy, headless workflows, Radare2's maturity still wins; for interactive mobile reversing, Glass's opinionated design is faster to productivity.

The project shows impressive commit velocity for a brand-new solo effort. Looking at the commit history since launch on May 15, 2026:

• May 21 — Initial Frida support (commits by Andrew Whaley). This is notable because Frida is the dominant runtime instrumentation tool for mobile security research; native integration could make Glass a front-end for Frida-based analysis workflows.
• May 20 — Improved left navigator, added smali in-place and file editing. The ability to modify smali directly within Glass and rebuild the app is a significant workflow improvement — previously you'd need separate tools for reading and patching.
• May 19 — Added themes and in-place editing with keyboard shortcuts. Theme support is a quality-of-life feature that serious reverse engineers appreciate when staring at code for hours.

• Windows is not yet supported — Glass runs natively on macOS 13+ and Linux (X11 or Wayland). If you try to build or run on Windows, expect missing dependency errors. The README mentions a Windows port is "on the roadmap," but there's no timeline. For Windows users, Ghidra or IDA remain the practical choices for now. macOS users benefit from native Metal GPU acceleration out of the box; Linux users need to run the Zed setup script to install Vulkan and XCB dependencies before building.
• Only AArch64 is disassembled — 32-bit ARM goes to hex view — If you're working with older Android NDK binaries compiled for armv7, Glass will display those sections as raw hex bytes rather than disassembly. The README is transparent about this limitation, but it's a real gotcha if you encounter legacy binaries. You'd need to switch to Ghidra or IDA for 32-bit ARM work. Similarly, x86 Android binaries (rare but existent) won't disassemble in Glass either.
• Release builds are dramatically faster than debug builds — The README warns explicitly: "Always use the release build — debug builds disassemble orders of magnitude slower." If you install via cargo install without --release, or run a locally compiled debug binary, expect disassembly to be much slower than the benchmark numbers cited in the project description.

Glass is a genuinely exciting new entrant in the mobile reverse engineering tool space. It won't replace IDA Pro for users who need its breadth of processor support and plugin ecosystem, but for Android APK and iOS IPA analysis specifically — especially on AArch64 targets — it delivers on its promise of speed and modern UX. The MCP integration is the feature I find most interesting long-term: as AI-assisted code analysis matures, a tool that exposes structured analysis data through a standardized protocol will age well. At 83 stars and growing with daily commits, this is a project worth watching. The solo author Andrew Whaley is clearly committed to the roadmap, and the architecture suggests the project can scale in capability without major refactoring. If you're a mobile security researcher or app developer who frequently pokes at competitors' binaries, Glass deserves a spot in your toolchain.

🔗 More GitHub trending open source projects: Developer Tools

---

Project: azw413/Glass
Author: @azw413 (Andrew Whaley)
License: GPL-3.0