Short answer
DexSQL's engine is closed source, and its strongest performance case is an analysis session that asks several questions of the same Android app. Use it if you want an MCP-connected agent to follow strings, methods and callers through an APK. Skip it if engine source access is mandatory, or if your main job is one fresh CLI search at a time. Our lab assessment stopped before execution. The recommendation here rests on the project's published comparisons and attributed issue reports, with that boundary carried through the review. Project description and licensing.
The useful distinction is how you ask questions. An agent investigating an app often finds a string, locates the method using it, follows a caller and reads the surrounding code. DexSQL keeps the loaded dataset for that sequence. A shell script starting a new process for every search pays loading costs again. The author's Douyin replay says its opening cost is recovered after two to three goals on that workload. That is a reason to consider a resident session, rather than a promise that every DexSQL command beats every alternative. Replay method and results.
What people use dexsql-release for
The documented work is Android code investigation: locating evidence across classes, strings and call relationships, then examining the relevant instructions. DexSQL exposes SQL through a CLI and an MCP server, so you can use explicit queries yourself or let an agent compose them. The README describes combining signatures, strings and calls in a single query. That makes the tool relevant when a text match alone leaves too many candidate methods. DexSQL README.
| Who used it | What they did | What the record supports |
|---|---|---|
| The project's benchmark authors | Ran class, method, string-reference, caller and compound queries against QQ 9.3.55 | Completed plotted result sets matched DexSQL reference sets. The comparison measures code-location queries and process memory. QQ report |
| The reporter of GitHub issue #3 | Searched a Douyin APK for HTTPS string references using a fresh CLI process | Reported roughly 400 to 500 ms per DexSQL search and about 100 ms with Rust ASC. Issue #3 |
| Maintainer yujincheng08 | Described repeated-query reverse engineering by agents and within LSPosed | Reports productive multi-query analysis and says Astra found an unpublished app RCE in five minutes. This is the maintainer's account. Maintainer response |
Those examples serve different decisions. The QQ authors checked selected query outputs against their reference sets. The Douyin issue reporter challenged the relevance of a headline timing to an actual command. The maintainer explained the workflow the tool was built around. For an evaluator, the second and third accounts belong together: if you intend to keep running isolated commands, a recommendation to keep the dataset open changes your workflow. Decide whether that change suits your tools before adopting DexSQL for its benchmark charts.
What happened when we ran it
We did not run DexSQL: our November 15, 2026 assessment at commit b867cfe found no supported ecosystem in the harness, which classified the repository as Python, and no Dockerfile. The sandbox configuration recorded 3 CPUs and 8 GB RAM, with no image specified. These describe the attempted assessment environment, not DexSQL's operating requirements. There are no install, build, test or query-performance results from our sandbox to turn into a product score.
| Recorded item | Result | Meaning for this review |
|---|---|---|
| Checkout assessed | b867cfe, November 15, 2026 | Identifies the assessed revision |
| Configured resources | 3 CPUs, 8 GB RAM, image n/a | Configuration only, with no executed runtime version established |
| Ecosystem route | NOT RUN: no supported ecosystem, language classified as Python; no Dockerfile | No executable assessment completed |
| Separate deployment safety step | FAILED because no supported Compose filename existed | The deployment harness stopped on its Compose requirement |
| Teardown record | ok | Cleanup status, not evidence of a working server |
The deployment safety log says none of compose.yaml, compose.yml, docker-compose.yaml or docker-compose.yml existed. Its label calls the repository unsafe, but the stated reason is the harness rule requiring Compose. That is a deployment-policy rejection. It says nothing about whether the official standalone executable works.
A separate run-summary record says the project was deployed with its own Docker Compose. That conflicts with the failed safety step and the supplied NOT RUN assessment, so it cannot support a successful deployment story. The only cleanup statement is “teardown: ok.” We treat the attempt as stopped, with no working server demonstrated.
The repository's Python classification also needs context. The official installation skill describes a prebuilt, closed-source executable and says the server needs no JVM, GUI or Python runtime. A harness that cannot select an ecosystem for this checkout has not disproved that installation route. It has failed to exercise it. Setup remains unassessed, rather than receiving a low score for an automation mismatch. Official installation guidance.
Where people get stuck: startup costs and client compatibility
Issue #3 reports a slower fresh-process string search than the benchmark number the reporter expected. The command selected distinct methods whose strings contained HTTPS, and the posted shell output includes runs around four-tenths of a second. The maintainer's response says the preferred use is repeated hot queries through MCP or the interactive CLI, and promises attention to isolated CLI queries. The thread is closed, but its reply offers a workflow explanation and an optimization promise, rather than a reproduced after-fix result. Issue #3 and response.
| Problem reported | What the sources say to do | Resolution evidence |
|---|---|---|
| Fresh CLI searches repeatedly incur loading work | Keep a dataset open for multiple questions through MCP or interactive CLI | Maintainer recommendation in closed issue #3; no before-and-after result in the thread |
| MCP resource lists omit cache fields | Issue #2 suggests updating the MCP SDK | Closed without comments; v0.1.1 release notes separately claim a cache-metadata fix |
| Linux aarch64 had no native executable in v0.1.0 | Select a release asset matching the host architecture | Issue #1 replies “Added”; v0.1.1 lists dexsql-linux-arm64 |
The reporter of issue #2 says resource-list RPCs failed in dsh because ttlMs and cacheScope were missing under protocol 2026-07-28. The issue has no explanatory closing comment. However, the v0.1.1 release notes explicitly say missing cache metadata in tool and resource lists was fixed under the newer protocol. That is a maintainer release claim, stronger than issue closure alone. Check the installed version when diagnosing this error instead of treating every build as affected.
The author of issue #1 requested a native Linux arm64 binary after finding only an amd64 Linux executable in v0.1.0. RealNullptr replied “Added.” The current v0.1.1 release asset list includes dexsql-linux-arm64, so an article still saying Linux arm64 is unavailable would send readers down the wrong path. Match the release asset to the host, then follow the executable and MCP checks in the installation skill.
Repeated sessions change the speed comparison
The author's Douyin replay reports that rasc finishes a single cold question sooner, while DexSQL wins the full repeated-query session. In the 17-goal workload, the reported whole-session results are 860 ms for DexSQL and 3,068 ms for rasc. DexSQL opens the APK once and retains the dataset. rasc uses a new process for each step. These are upstream query-workload measurements, not timings from our lab. Douyin replay.
The report's break-even explanation is more useful than its largest speedup: using that replay's mean goal time, opening the APK pays back after two to three goals. Someone following a string into a method and then tracing its callers may naturally stay in the session long enough to benefit. Someone running a single command from a build script may never reach that point. Keep startup in the total when comparing your own job, and retain the actual sequence of questions instead of choosing only the fastest lookup.
Output limits matter too. The replay excludes the full class inventory because DexSQL's MCP interface paginates results and cannot return all 567,192 classes in one response. Finding a particular method and exporting an entire inventory are different operations. If an agent needs a census, make following every page part of the acceptance task, with an explicit end condition and a saved output. A quick targeted lookup does not answer whether your export workflow is complete. Replay exclusions.
Security starts with a binary and the AI client's data policy
APK parsing runs locally, while the AI client's settings determine which query results reach its model, according to the README. A local parser can therefore still sit inside a workflow that sends extracted code or strings to a hosted model. For confidential apps, decide which model may receive that material before connecting the MCP server. The official skill describes a local stdio connection requiring no network listener or API key for the server itself. Data flow, connection guidance.
The licensing split affects trust as well as procurement. LSPosed distributes the engine under the DexSQL Binary License 1.0; the public installation skill, benchmarks and documentation use MIT licensing. The README says personal and commercial use, integration and binary redistribution are free under the binary license's terms. Read those terms for your intended redistribution. Access to the benchmark harness gives you a way to inspect the comparison method, but it does not give you the engine's implementation. License explanation.
The installation skill calls for checking a downloaded executable against an upstream SHA-256 digest when one is available. When none is available, it distinguishes a locally computed fingerprint from an upstream-checked checksum. That distinction is useful: matching an expected download establishes file identity, not good behavior. Keep the selected release and its accompanying license files together, as the skill directs, so the executable you evaluate and the terms you review belong to the same version. Download handling.
English docs exist, but stars are not deployment evidence
DexSQL provides an English README alongside a Simplified Chinese version. The captured issue #3 discussion is in Chinese, while the installation skill supplies English instructions. English readers have a documented entry point, though the most useful explanation of the cold-query disagreement may require translation. That is a support-reading consideration, not evidence that the CLI or server needs a particular interface language. README, discussion.
The public GitHub API returned 314 stars, a last push of October 25, 2026 and zero open issues and PRs on November 15, 2026. The latest release endpoint returned v0.1.1, published October 18, 2026. Read those alongside the sampled issue responses: the arm64 request got an addition response, the latency report got a workflow explanation, and the protocol report has a release-note fix claim. Those are maintenance signals. Star counts and closed threads alone cannot tell an evaluator how many teams depend on the executable. Repository facts, release.
dexsql-release vs Rust ASC, DexDec and JADX
Choose by the question sequence and the code representation you need: the supplied comparisons favor different tools for different tasks. Rust ASC is the relevant comparison for a quick isolated search, DexDec has a strong repeated-caller result in the QQ report, and JADX supplies Java output where DexSQL decodes Smali. A whole-session timing does not decide which representation helps you understand the code. QQ method, replay.
| Alternative | Reason to choose it | What the supplied comparison actually covers |
|---|---|---|
| Rust ASC / rasc | A single cold question rather than a resident analysis session | The Douyin replay says rasc finishes a single-question session sooner. Replay |
| DexDec | Repeated direct-caller lookups are central to the task | Its reference cache beats DexSQL on the repeated direct-call query in the QQ run. QQ report |
| JADX / JADX-MCP | You want Java-oriented investigation | The replay's decompilers return Java, while DexSQL decodes Smali. Java output quality is outside the QQ benchmark. Replay, QQ report |
| garlic | A prepared call graph and DuckDB fit the investigation | The QQ authors timed fresh MCP processes after the tested Windows binary exited on a second tool call. QQ report |
| droidsaw | You are evaluating its broader APK workflow through the supported interface | The QQ authors used its CLI after MCP rejected the APK under a fixed parse budget; loading is included on each invocation. QQ report |
The QQ comparison checks completed plotted result sets against DexSQL reference sets. Its timing includes result decoding, filtering and set composition, but excludes downloading, installation and compilation. That makes it useful for comparing the published query paths after preparation, while keeping those results separate from setup effort. The two workloads also use different DexSQL versions: the QQ interface description names 0.1.0, and the Douyin replay names 0.1.1. Keep the report, version and workflow together when quoting a result. QQ report, Douyin report.
What the other reviews get wrong
SkillsLLM's claim that readers can review or fork DexSQL's full source conflicts with the official closed-source engine description. GitHub Signals also presents the repository under an open-source label. The public auxiliary materials do not change the engine's license. This distinction should be settled before comparing stars or recommending the project to a team with an open-source-only policy. SkillsLLM listing, GitHub Signals, official license split.
SkillsLLM's comparisons against Hermes Agent, REA and ECC say neither project includes a SKILL.md file. DexSQL's repository contains skills/install-dexsql/SKILL.md. Its listing also presents cloning the repository into a skills directory as installation. The official skill explicitly separates installing the guidance from installing the executable and registering its MCP server. A cloned folder alone is not the completed connection those instructions require. Hermes comparison, REA comparison, ECC comparison, installation skill.
Search results also need an identity check. Microsoft's Dexsql.log documentation concerns SQL logging in Dynamics GP. LSPosed's DexSQL analyzes Android binaries. Advice for enabling a Dynamics log is irrelevant to installing this executable, despite the shared name. Search with the LSPosed owner or the full repository name when troubleshooting. Microsoft documentation record, DexSQL description.
Questions people ask
Yes: v0.1.1 lists a native Linux arm64 executable named dexsql-linux-arm64. Issue #1's original missing-build report concerned v0.1.0, and its reply says “Added.” Use the selected release's actual assets to choose a binary instead of carrying forward that older platform list. Issue #1, v0.1.1 assets.
Is there a native Linux arm64 build of DexSQL?
Yes. The v0.1.1 release includes dexsql-linux-arm64, and RealNullptr's reply to the request says it was added. The official skill tells installers to inspect the release assets for the chosen version and host architecture. A macOS arm64 binary is a different asset, so CPU architecture alone is not enough to select the download. Request and reply, release assets, selection guidance.
Why does a fresh DexSQL CLI string search take roughly 400 to 500 ms instead of the cited 0.98 ms benchmark time?
The issue #3 reporter timed fresh CLI processes; the maintainer says DexSQL's intended fast path is multiple queries after opening the dataset once. Those are different timing boundaries. The later Douyin replay makes the opening cost explicit and reports a two-to-three-goal break-even on its workload. Use that distinction to choose a test matching your job, rather than treating the cited warm-query figure as a prediction for process launch plus APK loading. Issue #3, replay method.
How does DexSQL compare with Rust ASC for a single CLI string search?
The issue #3 reporter measured about 100 ms for Rust ASC and roughly 400 to 500 ms for DexSQL on the posted Douyin string-reference searches. The author's later replay also favors rasc for a single cold question, while DexSQL wins its repeated-query session. These support choosing Rust ASC for an isolated-search evaluation, with the specific command, input and output checked together. They do not make Rust ASC faster for every query. Reported commands, author comparison.
What we have not tested yet
Our lab stopped before executing DexSQL, so installation, MCP handshakes, query correctness, memory use and runtime safety remain untested by us. The configured sandbox resources cannot establish minimum requirements. We have not tested Linux arm64 execution, the release's protocol fix in dsh, or the promised cold-CLI improvements against the issue reporter's original command. The release notes claim improvements; they supply no matching independent regression result for this review.
The Douyin replay leaves memory, other platforms and other APKs unmeasured. Its expected-token misses remain unreviewed, and the authors say Java-versus-Smali differences may explain some of them. They are repeating the unusable JADX-MCP run. A complete paginated class-inventory export is also outside the demonstrated workload. The QQ report measures code-location queries and memory, not Java decompilation quality or model reasoning. None of these comparisons independently reproduces the maintainer's unpublished RCE claim. Replay boundaries, QQ scope.
Clelp describes static checks and says its sandbox has not run this tool. Static subprocess findings in public benchmark scripts are not an executable-behavior assessment of a closed-source engine. SkillsLLM's automated scan label cannot fill that gap either. The video and social records supplied for this review contain no demonstrated DexSQL workflow: the YouTube extract is empty, the X search returned no posts, and the Bilibili results concern other subjects. Clelp's stated boundary, SkillsLLM listing.
The next useful evaluation is a supported native executable opening your APK once, answering a saved sequence of known-answer questions, and exporting any required paginated results. Compare that complete session with the isolated CLI command you would otherwise run. Keep the outputs beside the timings: locating the right evidence is the reason to use either tool.

