[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-80499":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":9,"language":10,"languages":9,"totalLinesOfCode":9,"stars":11,"forks":12,"watchers":13,"openIssues":14,"contributorsCount":15,"subscribersCount":15,"size":15,"stars1d":16,"stars7d":17,"stars30d":18,"stars90d":15,"forks30d":15,"starsTrendScore":19,"compositeScore":20,"rankGlobal":9,"rankLanguage":9,"license":21,"archived":22,"fork":22,"defaultBranch":23,"hasWiki":24,"hasPages":22,"topics":25,"createdAt":9,"pushedAt":9,"updatedAt":26,"readmeContent":27,"aiSummary":28,"trendingCount":15,"starSnapshotCount":15,"syncStatus":29,"lastSyncTime":30,"discoverSource":31},80499,"Glass","azw413\u002FGlass","azw413","Glass - a fast and free IDA Pro alternative",null,"Rust",165,10,99,1,0,3,58,66,42,3.12,"GNU General Public License v3.0",false,"main",true,[],"2026-06-12 02:04:03","# Glass\n*as in transparent and smooth*\n\nA fast, native, **mobile-app first** interactive disassembler. Spiritual successor to IDA Pro for the Android \u002F iOS reverse engineering workflow, built around:\n\n- `smali` for APK \u002F DEX \u002F smali handling\n- `armv8-encode` for AArch64 and ARMv7 (A32 \u002F Thumb) — native `.so`, iOS Mach-O\n- `gpui` (Zed) for GPU-accelerated native UI\n- `redb` for content-addressed persistence\n- An in-built MCP server so any MCP-aware host (Claude Desktop, Cursor, Zed) can drive Glass directly\n- `rquickjs` for scriptable plugins (planned)\n\nLicense: GPL-3.0-only (inherited from `smali`).\n\n## Why?\n\nWe’ve all used IDA Pro — it’s the industry standard for reversing and has years of plugins behind it, but it’s slow, expensive, and dated. Glass is 100% Rust native with a GPU-accelerated UI for fluid interaction. It’s also 100% free and open source — please contribute.\n\n## Features\n* Buttery smooth 120fps GPU accelerated rendering\n* Lightning fast analysis: 1-2 seconds for most larger binaries compared with minutes on IDA Pro\n* AArch64 **and** ARMv7 (ARM mode + Thumb) disassembly — covers iOS arm64 \u002F arm64e and both common Android ABIs.\n* Fully linked and annotated disassemblies with control flow lines, data literals in comments, clickable links to other functions. All coloured for easy visibility.\n* Control flow graphs showing basic blocks and clickable links to other functions\n* Full project search for symbols or string literals across DEX, code and data sections\n* Native binary layout overview with section data\n* Xref search of callers, references to data\n* Binary and instruction search across **every** native artifact in the bundle (so both `arm64-v8a` and `armeabi-v7a` copies of a library are searched in one query). Byte-pattern grammar with masking + gaps; typed-assembly grammar for AArch64 and ARMv7, with an ISA-aware autocomplete dropdown.\n* Annotate any line (code or data) with a colour and\u002For comment so you can easily find it again later.\n* In-place editing of instructions and data (double-click an item). Smali class editor + AArch64 \u002F ARMv7 instruction editor; right-click any listing row to open a byte-level hex view at the same address as an escape hatch.\n* MCP server exposes every analysis verb as a tool for any MCP-aware host — Claude Desktop, Cursor, Zed.\n* Themes for Glass and also selectable background colours for each workspace.\n\n\n## Screenshots\n\nA walk through the main views — click any thumbnail to see it full size.\n\n\u003Ctable>\n  \u003Ctr>\n    \u003Ctd align=\"center\">\n      \u003Ca href=\"screenshots\u002Fdisassembly.png\">\n        \u003Cimg src=\"screenshots\u002Fdisassembly.png\" width=\"420\" alt=\"AArch64 disassembly listing with arrow gutter, resolved string literals, clickable symbol references\"\u002F>\n      \u003C\u002Fa>\n      \u003Cbr\u002F>\n      \u003Csub>\u003Cb>Disassembly listing\u003C\u002Fb>\u003Cbr\u002F>colour-coded operands, control-flow arrows, resolved string literals inline\u003C\u002Fsub>\n    \u003C\u002Ftd>\n    \u003Ctd align=\"center\">\n      \u003Ca href=\"screenshots\u002Fcfg.png\">\n        \u003Cimg src=\"screenshots\u002Fcfg.png\" width=\"420\" alt=\"Control flow graph for a native function showing basic blocks, conditional and unconditional edges\"\u002F>\n      \u003C\u002Fa>\n      \u003Cbr\u002F>\n      \u003Csub>\u003Cb>Control flow graph\u003C\u002Fb>\u003Cbr\u002F>per-function CFG with dotted conditional edges and routed multi-rank lanes\u003C\u002Fsub>\n    \u003C\u002Ftd>\n  \u003C\u002Ftr>\n  \u003Ctr>\n    \u003Ctd align=\"center\">\n      \u003Ca href=\"screenshots\u002Fdex.png\">\n        \u003Cimg src=\"screenshots\u002Fdex.png\" width=\"420\" alt=\"DEX method call graph rooted at a smali method; hover-expandable callee nodes\"\u002F>\n      \u003C\u002Fa>\n      \u003Cbr\u002F>\n      \u003Csub>\u003Cb>DEX call graph\u003C\u002Fb>\u003Cbr\u002F>hover-to-expand callees, click to jump to the method's smali\u003C\u002Fsub>\n    \u003C\u002Ftd>\n    \u003Ctd align=\"center\">\n      \u003Ca href=\"screenshots\u002Foverview.png\">\n        \u003Cimg src=\"screenshots\u002Foverview.png\" width=\"420\" alt=\"Section-map overview of a native binary with coloured proportional bar and per-section detail\"\u002F>\n      \u003C\u002Fa>\n      \u003Cbr\u002F>\n      \u003Csub>\u003Cb>Section-map overview\u003C\u002Fb>\u003Cbr\u002F>proportional bar by section size, click to jump to listing \u002F hex view\u003C\u002Fsub>\n    \u003C\u002Ftd>\n  \u003C\u002Ftr>\n\u003C\u002Ftable>\n\n## Scripting\n\nEvery analysis Glass does in the GUI is also exposed as a CLI verb that emits structured JSON. The same `glass` binary is the automation entry point — pick a subcommand and you get a one-shot, scriptable result, perfect for `jq` pipelines and CI.\n\n```sh\n# What classes ship in this APK?\nglass classes .\u002Fapp.apk --package com.example. --text\n\n# Who calls glass::main, by address?\nglass callers .\u002Flibfoo.so --artifact libfoo.so --symbol \"glass::main\"\n\n# Every `onCreate` across DEX, machine-readable:\nglass search .\u002Fapp.apk onCreate | jq '.data.hits[] | select(.kind==\"method\")'\n```\n\nPass `--text` for a human-readable rendering, omit it for JSON.\n\nFull reference: **[docs\u002Fcli-api.md](docs\u002Fcli-api.md)**.\n\nThis means you can script and automate common operations. \n\n\n## Skills and MCP\n\nEvery CLI verb is also exposed as a tool through an inbuilt MCP (Model Context Protocol) server, so any MCP-aware host — Claude Desktop, Cursor, Zed, your own client — can drive Glass directly to help with reversing tasks.\n\n```sh\n# Print the machine-readable skill catalog (one JSON object listing\n# every verb with its schema and an example invocation).\nglass skills\n\n# Run as an MCP stdio server. Plug into any MCP host's tool list.\nglass mcp\n```\n\nTo register with **Claude Desktop**, add Glass to `~\u002FLibrary\u002FApplication Support\u002FClaude\u002Fclaude_desktop_config.json`:\n\n```json\n{\n  \"mcpServers\": {\n    \"glass\": { \"command\": \"\u002Fusr\u002Flocal\u002Fbin\u002Fglass\", \"args\": [\"mcp\"] }\n  }\n}\n```\n\nThe model can then call `inspect`, `symbols`, `disasm`, `cfg-of`, `dex-callers`, `search` and every other verb on any bundle you point it at. Tool results come back as the same JSON envelope you'd get from the CLI.\n\n\n## Searching\n\nThree complementary engines, all available from the same ⌘F palette in the GUI and as CLI \u002F MCP verbs.\n\n### Full text search\n\nBundle-wide fuzzy match across native symbols, DEX classes \u002F methods \u002F fields, and string literals in code and data sections. Live-filtered as you type; results dispatch to the right view (listing for native addresses, smali viewer for DEX targets, hex view for data hits). Indices build on a background thread after load — a progress chip shows while in flight.\n\n```sh\nglass search .\u002Fapp.apk onCreate                 # all things named like \"onCreate\"\nglass search .\u002Flibfoo.so init --limit 20\n```\n\nCLI reference: [`search` verb in `docs\u002Fcli-api.md`](docs\u002Fcli-api.md#search--path-p---query-q---limit-n).\n\n### Binary search\n\nByte-level pattern engine. Each atom is a 2-character hex mask (`c0`, `e?`, `?f`, `??`) or a gap (`*` = 0..=32 bytes, `*(min..max)` for explicit bounds). Matches don't span sections. In the GUI palette, ⌘2 switches to Binary mode; the **Code only** checkbox (default on) restricts the scan to text sections so you aren't drowning in data hits when looking for an instruction shape.\n\n```sh\n# returning-true stub finder — `mov w0, #1 ; ret`\nglass bin-search .\u002Flibfoo.so --artifact libfoo.so --pattern '20 00 80 52 c0 03 5f d6'\n\n# any ADRP+ADD pair with no intervening bytes\nglass bin-search .\u002Flibfoo.so --artifact libfoo.so --pattern '?? ?? ?? 9? ?? ?? 4? 91'\n\n# raw data: find embedded magic\nglass bin-search .\u002Flibfoo.so --artifact libfoo.so --pattern 'de ad be ef'\n```\n\nFull grammar + worked examples: [`docs\u002FBinSearch.md`](docs\u002FBinSearch.md).\n\n### Instruction search\n\nWrite the assembly, Glass compiles it to bytes. A `;`-separated sequence is encoded via [armv8-encode](https:\u002F\u002Fgithub.com\u002Fazw413\u002Farmv8-encode) — **AArch64** (`mov w0, #1`, `adrp x1, *`) and **ARMv7** in both modes (Thumb `mov r1, r7` \u002F `bxeq lr` \u002F `push {r4-r7, lr}` and A32). Any wildcards are translated to operand-bit masks before the byte engine takes over. The scan is global — every native artifact in the bundle gets the right ISA's atoms (Android apps with both `arm64-v8a` and `armeabi-v7a` libraries are searched in a single query).\n\nInside Binary mode in the GUI, ⌘B toggles between **Bytes** and **Asm** grammars; an ISA-aware autocomplete dropdown shows variants that still match what you've typed — `r1` filters out AArch64 candidates, `w0` filters out ARMv7 ones.\n\nWildcards:\n\n| Token | Meaning |\n|---|---|\n| `*` | any operand (kind inferred from the chosen opcode) |\n| `#*` | any immediate (hints the opcode picker) |\n| `x`, `w` | any AArch64 X- or W-class register |\n| `r` | any ARMv7 GPR (`r0..r15`, `sp`, `lr`, `pc`) |\n| `\u003C*>`, `\u003CX>`, `\u003CW>`, `\u003CR>`, `\u003Cimm>` | bracketed equivalents, useful nested in other syntax (`[x, #*]`, `[r, #*]`) |\n\n```sh\n# AArch64 — every `mov w0, #N` (any N)\nglass insn-search .\u002Flibfoo.so --artifact libfoo.so --pattern 'mov w0, #*'\n\n# AArch64 — any ADRP into x1 followed immediately by ADD into the same reg\nglass insn-search .\u002Flibfoo.so --artifact libfoo.so --pattern 'adrp x1, * ; add x1, x1, #*'\n\n# ARMv7 (Thumb) — `mov r1, r*` followed by a return\nglass insn-search .\u002Flibfoo.so --artifact libfoo.so --pattern 'mov r1, r* ; bx lr'\n\n# ARMv7 (any cond) — conditional bx in literal-pool callers\nglass insn-search .\u002Flibfoo.so --artifact libfoo.so --pattern 'bxeq lr'\n\n# every `ret x30` — concrete, no wildcards\nglass insn-search .\u002Flibfoo.so --artifact libfoo.so --pattern 'ret'\n```\n\nThe response carries `bytes_hex` showing the compiled mask (e.g. `01\u002F1f ?? ?? 90\u002F9f` for `adrp x1, *`) so you can see exactly which bits are pinned vs wildcarded. Captures (`\u003Cname:kind>` cross-referencing the same operand later in the pattern) are designed but not yet implemented.\n\nFull design + phasing: [`docs\u002FInsnPattern.md`](docs\u002FInsnPattern.md). CLI\u002FMCP reference: [`insn-search` in `docs\u002Fcli-api.md`](docs\u002Fcli-api.md#insn-search--path-p---artifact-a---pattern----section-s---limit-n).\n\n\n## Current Status\n\nGlass is usable today for reversing Android (APK \u002F DEX \u002F native `.so`) and iOS (IPA \u002F Mach-O) apps targeting AArch64 **and** 32-bit ARMv7 (`armeabi-v7a` libraries, A32 + Thumb).\n\n### What works\n\n**File loading**\n- Open Android bundles (`.apk`, `.aab`), iOS bundles (`.ipa`), or any standalone ELF \u002F Mach-O binary (`.so`, `.dylib`, raw executables) directly — Glass auto-detects the format.\n- Fat \u002F universal Mach-O is handled transparently: `arm64e` is preferred, plain `arm64` is the fallback. Works on bundles and on standalone files alike (e.g. `glass gui \u002Fusr\u002Flib\u002Fdyld`).\n- Loader pipeline reports progress (Reading archive → Parsing DEX \u002F Disassembling native → Building symbols).\n- Per-artifact content-addressed IDs (blake3, rayon-parallel for large libs). Annotations follow the artifact, not the container — the same `libfoo.so` shipped in two APKs (or the same `libswiftCore.dylib` across two IPAs) shares analysis state.\n- AndroidManifest viewer (binary XML decoded via `smali`).\n- Info.plist viewer for iOS bundles — bundle id, executable name, version, min OS, and the rest of the plist rendered as colour-coded XML.\n\n**iOS — IPA \u002F Mach-O**\n- Unzip the IPA, locate `Payload\u002F*.app\u002F`, parse `Info.plist`, and pick the arm64 \u002F arm64e slice from any fat binary inside.\n- Main executable and every `Frameworks\u002F*.framework` + `*.dylib` is loaded as its own native artifact, with the same Overview + per-section disassembly views used for Android `.so` files.\n\n**Android — APK \u002F DEX \u002F native**\n- Class tree across all DEX files in the APK.\n- Smali listing per class with syntax-aware tokenization (directives, types, method names, string literals, etc.).\n- Method cross-references resolve to the right class + line.\n- Native `.so` files under `lib\u002F\u003Cabi>\u002F` loaded per ABI; AArch64 (`arm64-v8a`) and ARMv7 (`armeabi-v7a`) both get full disassembly views. Other ABIs (x86 \u002F x86_64) route to the hex view until a decoder lands.\n\n**Editing**\n- Smali class editor (double-click a class header \u002F field \u002F method to open inline editors).\n- AArch64 in-place instruction editing: type new assembly, Glass encodes it back to bytes; staged changes show as a green tint in the listing until you Export to a new APK \u002F IPA.\n- ARMv7 in-place editing: handles same-width swaps, 4-byte → 2-byte shrinks (auto-pads with a Thumb-1 NOP), and 2-byte → 4-byte grows that consume a following NOP. Refuses unsafe grows that would shift downstream code.\n- ISA-aware autocomplete in the inline editor — typing `r1` shows ARMv7 variants only; `w0` shows AArch64 only.\n- Right-click any listing row → **Open hex view here** to drop into a byte-level hex editor at the same address when the typed-assembly editor can't express what you need.\n\n**AArch64 native (ELF + thin Mach-O)**\n- Linear-sweep disassembly with virtualized rendering — large libraries open in seconds, not minutes.\n- Symbol map merged from ELF symtab, dynsym, DWARF, `.eh_frame` FDEs, and synthesized `\u003Cname>@plt` entries. C++\u002FRust\u002FSwift demangling via `symbolic-demangle`.\n- Branch operands rendered as clickable symbol references; `adrp` + `add`\u002F`ldr` pairs resolved to data targets, including string literals shown inline as comments.\n- Per-section views (code sections get disassembly; data sections get a hex view).\n\n**ARMv7 native (ELF)**\n- Recursive-descent disassembly from symbol entry points so literal pools, jump tables and inline data don't get mis-decoded as instructions. Per-symbol mode (ARM vs Thumb) honoured via the low-bit marker.\n- Variable-width Thumb rendering: 16-bit Thumb-1 rows show 2 bytes (no phantom `00 00` padding), 32-bit Thumb-2 and A32 show 4.\n- Symbol map: ELF symtab, DWARF, `.eh_frame`, and synthesized `\u003Cname>@plt` entries (12-byte stubs).\n- `movw + movt` fusion: `movw R, #lo16 ; movt R, #hi16` is detected across instruction pairs and the resolved 32-bit constant gets a `; \"...\"` rodata-string comment on the `movt` row.\n- Thumb `ldr Rt, [pc, #imm]` literal-pool loads dereference one level into rodata for the same kind of inline string comment AArch64's ADRP+ADD path produces.\n- Control-flow arrow gutter on conditional and unconditional branches (same lane assignment as AArch64).\n\n**UI**\n- Tabbed right pane with overflow-safe dropdown, close buttons, click-to-activate.\n- Horizontal + vertical scrollbars on listing, hex, and manifest views.\n- Cmd-F symbol palette with fuzzy filter. Multi-token queries are AND-matched in order (`change me` finds `changeMessage` and `change_me_count` but not `dispatchMenuVisibilityChanged`).\n- Binary \u002F instruction palette (⌘2 to switch into it) scans every native artifact globally — Android apps with `arm64-v8a` + `armeabi-v7a` get unified results with the artifact + section labelled per match.\n- Right-click cross-references in every view: **References to address** \u002F **Callers of function** \u002F **Open hex view here** in the listing, hex and CFG; **Callers of method** \u002F **References to field** in smali. Results show in the palette with a scope chip; Esc clears the scope back to bundle-wide search. Indices build on a background thread after load — a progress chip shows while in flight.\n- Themes (View → Theme) with selectable per-window background tints.\n- Cmd-O open, Cmd-N new window, Cmd-W close window, Cmd-⇧W close file (return window to launched-empty state). macOS app menu with **File → Open Recent** (last 10 bundles, deduplicated by path).\n- Window bounds + open tabs + tree expansion state persisted per-bundle in `redb`; relaunching reopens where you left off.\n\n### What's missing\n\n- x86 \u002F x86_64 disassembly (those code sections currently route to the hex view).\n- ARMv7 in-place edits that need to *grow without an adjacent NOP* — refused with a clear error today; would need section-level relayout + branch-target rebinding to support.\n- iOS entitlements and `embedded.mobileprovision` parsing.\n- Swift metadata pass — Swift Mach-O symbol stubs are sparse without it.\n- ObjC `__objc_classlist` extraction.\n- Cross-references DEX ↔ native via JNI signatures.\n- QuickJS scripting host.\n- Drag-to-scroll on scrollbars (currently visual-only — use trackpad \u002F wheel).\n- Resource ID decoding in the manifest (would need `resources.arsc` parsing).\n- ARMv7 typed-assembly editor: works for the common forms; shifted operands (`r0, lsl #2`) and pre\u002Fpost-index memory (`[rN, #imm]!`, `[rN], #imm`) parse but only concretely — no wildcards inside brackets.\n\n## Building\n\nGlass runs on **macOS 13+** (the primary target, GPU-accelerated via Metal — no extra SDK needed, the Metal framework ships with the OS) and **Linux** (X11 or Wayland via `gpui_linux`, Vulkan-backed). A Windows port is on the roadmap.\n\nThere is a release prebuilt binary for macOS under Releases but if you need to build from source: the good news: it's two commands.\n\n1. **Install Rust** (if you don't already have it):\n\n   ```sh\n   curl --proto '=https' --tlsv1.2 -sSf https:\u002F\u002Fsh.rustup.rs | sh\n   ```\n\n2. **Linux only — install gpui's native dependencies.** The easiest way is to run Zed's setup script, which knows about apt \u002F dnf \u002F pacman \u002F etc:\n\n   ```sh\n   curl -sSL https:\u002F\u002Fraw.githubusercontent.com\u002Fzed-industries\u002Fzed\u002Fmain\u002Fscript\u002Flinux | bash\n   ```\n\n   This pulls in `libxkbcommon-dev`, the Wayland and XCB headers, Vulkan, ALSA, and the rest of the toolchain `gpui_linux` needs to link. Without these the build fails at link time with missing `xkbcommon` \u002F `wayland-client` symbols.\n\n3. **Clone and build**:\n\n   ```sh\n   git clone https:\u002F\u002Fgithub.com\u002Fazw413\u002FGlass.git\n   cd glass\n   cargo build --release -p glass-cli\n   cp target\u002Frelease\u002Fglass \u003Cto somewhere on your PATH>\n   ```\n   \n   The first build will compile `gpui` and friends and will take several minutes. Subsequent builds are fast.\n   \n4. **Run it**:\n\n   ```sh\n   # Open the GUI on an Android APK or iOS IPA — no subcommand needed.\n   glass ~\u002Fpath\u002Fto\u002Fapp.apk\n   glass ~\u002Fpath\u002Fto\u002Fapp.ipa\n   \n   # Or on a standalone binary — ELF .so, Mach-O .dylib, or raw\n   # executable. Fat \u002F universal Mach-O is sliced automatically.\n   glass ~\u002Fpath\u002Fto\u002Flibfoo.so\n   glass ~\u002Fpath\u002Fto\u002FlibBar.dylib\n   glass \u002Fusr\u002Flib\u002Fdyld\n   \n   # No args → opens an empty Glass window; use File → Open.\n   glass\n   \n   # Headless bundle inspect\n   glass bundle ~\u002Fpath\u002Fto\u002Fapp.apk\n   \n   # Inspect persisted state for a bundle\n   glass db-dump ~\u002Fpath\u002Fto\u002Fapp.apk\n   ```\n\nAlways use the release build — debug builds disassemble orders of magnitude slower.\n\n### Packaging a `.app` bundle\n\nTo wrap the release binary in a Glass.app bundle for double-click launch from Finder:\n\n```sh\ncargo build --release -p glass-cli\n.\u002Fpackaging\u002Fmake-app.sh\nopen dist\u002FGlass.app\n```\n\nThe bundle is ad-hoc signed (not Developer-ID signed \u002F notarized), so on first launch macOS will refuse to open it; right-click → **Open** to bypass Gatekeeper once.\n\nTwo ways to grab a prebuilt zip without building locally:\n\n- **Latest `main`** — every push uploads a `Glass-app-\u003Csha>.zip` as a 14-day workflow artifact. Pull it from the [Actions tab](https:\u002F\u002Fgithub.com\u002Fazw413\u002FGlass\u002Factions).\n- **Tagged release** — pushing a `v*` tag (e.g. `v0.1.0`) triggers the same workflow and additionally publishes a `Glass-\u003Ctag>-macOS.zip` to the [Releases page](https:\u002F\u002Fgithub.com\u002Fazw413\u002FGlass\u002Freleases) with auto-generated release notes.\n\n## Workspace\n\n| Crate            | Purpose                                                          |\n|------------------|------------------------------------------------------------------|\n| `glass-core`     | Shared types (`CodeKind`, IDs)                                   |\n| `glass-arch-arm` | AArch64 + ARMv7 disassembly, symbol map, PLT synthesis, demangling |\n| `glass-arch-dex` | DEX \u002F smali facade over `smali`                                  |\n| `glass-mobile`   | APK + IPA bundle loading, native-lib extraction, manifest        |\n| `glass-db`       | Content-addressed persistence (redb): bundles, tabs, settings    |\n| `glass-device`   | Android (adb) + iOS (usbmux) device discovery                    |\n| `glass-api`      | Analysis verbs (search, xrefs, CFG, edits) shared by CLI + MCP + GUI |\n| `glass-ui`       | `gpui` front-end: tree, listing, hex, manifest, palette          |\n| `glass-cli`      | Headless inspector + GUI launcher                                |\n| `glass-mcp`      | MCP server exposing every CLI verb as a tool                     |\n| `glass-script`   | QuickJS plugin runtime (placeholder)                             |\n\n## Roadmap\n\n- **iOS deeper** — Entitlements, `embedded.mobileprovision`, ObjC `__objc_classlist`, Swift metadata pass.\n- **x86 \u002F x86_64** — Disassembly for emulator-builds of Android `.so` files.\n- **ARMv7 xref + CFG parity** — wire callers \u002F refs \u002F register-tracking through the unified `DecodedInsn` facade so the existing AArch64 cross-reference engine works for armeabi-v7a libraries too.\n- **Internal Scripting** — QuickJS plugin host with a stable API for analysis passes.\n- **Advanced** — Signed APK rebuilding, downstream-shift on ARMv7 in-place edits (so 2→4-byte grows can splice past adjacent code instead of refusing).\n","Glass 是一个快速且免费的 IDA Pro 替代品，专为移动应用逆向工程设计。项目采用 Rust 语言编写，具备 GPU 加速的用户界面，支持流畅的 120fps 渲染和秒级的大二进制文件分析速度。它能够处理 AArch64 和 ARMv7 架构下的 Android APK\u002FDEX 文件以及 iOS Mach-O 文件，并提供完全链接注释的反汇编、控制流图等功能。此外，Glass 还内置了 MCP 服务器，允许任何 MCP 兼容主机直接驱动 Glass。适合需要对 Android 或 iOS 应用进行深入逆向分析的场景使用，特别是对于寻找开源且高性能工具的研究人员或开发者来说，Glass 是一个理想的选择。",2,"2026-06-11 04:00:59","CREATED_QUERY"]