mrkeyoor.comAsk

LSPosed/dexsql-release

dexsql-release review

DexSQL's engine is closed source, and our lab assessment stopped before execution.

Not run yet

Dev Toolsevaluationupdated 15 Nov 2026
+13stars / 7d

DexSQL lets you search Android APK and DEX files with SQL, either from a terminal or through an MCP-connected AI agent. It helps locate classes, methods, strings and their callers without browsing the whole app. The engine is closed source; the public installation skill, benchmarks and documentation use MIT licensing.

Verdict

DexSQL's engine is closed source, and our lab assessment stopped before execution. Use it if your Android investigation benefits from an agent asking repeated questions of one loaded APK and you accept the binary license. Skip it if engine source access is required or your main task is a single cold CLI search, where the author's replay favors rasc.

dexsql-release infographic: search Android APK and DEX files with SQL, plus what we have not run yet and who it suits
We have not run dexsql-release yet; the middle band lists what our review has not tested.

We ran it

Screenshot of dexsql-release (dexsql.lsposed.org)
dexsql.lsposed.org

Answers from our run

Did you run dexsql-release yourself?

No. Its code is Python, and it carries no manifest our lab installs from, and no Dockerfile, so there was nothing standard to install, build or test. This review is written from the repository's own documentation.

Who should not use dexsql-release?

Teams requiring access to the analysis engine source: the public repository exposes auxiliary materials, while the engine is closed source.

What are the alternatives to dexsql-release?

Rust ASC / rasc, DexDec, JADX. DexSQL's engine is closed source, and our lab assessment stopped before execution.

SetupN/ANot assessed: installation was not reproduced in a supported environment. The harness stopped before executing the native binary.
Docs4/5There is nothing to install; the README is a navigable 5,703-character document with 8 headings.Editor’s note: The README and installation skill explain binary selection, licensing, client setup and benchmark boundaries. Their instructions were not exercised by our lab.
Community4/5Last push on 2026-10-25, 314 stars and maintainers answered or closed 3 of the 3 most-discussed issues we sampled.Editor’s note: The sample contains three issue threads with differing resolution evidence. It is too narrow to rate support quality or actual adoption.
Maturity1/5Latest release v0.1.1 on 2026-10-18 (pre-1.0) and repository created 2026-10-14.Editor’s note: Author comparisons and release notes document active work, but our lab has no executable correctness, compatibility or reliability result.

How we score

Who it’s for

Android reverse engineers who expect to ask several related questions of the same APK.
Agent users who want structured queries and relevant Smali through a local MCP server.
Developers comfortable evaluating a prebuilt engine under its binary license.

Who it’s NOT for

Teams requiring access to the analysis engine source: the public repository exposes auxiliary materials, while the engine is closed source.
Users whose main job is one cold CLI search: the author replay favors rasc for a single-question session.
Buyers choosing on Java decompilation quality: DexSQL decodes Smali, and the supplied benchmarks do not judge Java output quality.

Setup reality

We did not run DexSQL at commit b867cfe on November 15, 2026: our harness found no supported ecosystem, classified the repository as Python, and found no Dockerfile. The recorded sandbox configuration was 3 CPUs and 8 GB RAM, image n/a. No install, build or test measurements resulted.

The official route is a prebuilt executable connected to an MCP client over local stdio. Its installation skill says the server needs no network listener or API key. Installing the skill alone does not install the executable or register the server.

Choose the asset for the host OS and CPU, retain its license files, check the available upstream checksum, then test the executable and MCP connection. Python is the repository classification, not a documented engine runtime requirement. The v0.1.1 assets include a native Linux arm64 executable.

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.

Alternatives

ProjectWhat it isPick it when
Rust ASC / rasc gh↗The Rust branch of ASC is the CLI comparator in the Douyin replay.Choose it for evaluating isolated cold searches: the author replay says a single-question session finishes sooner with rasc.
DexDecAn Android analysis alternative included in both supplied query comparisons.Compare it when repeated caller lookups dominate: its reference cache wins that query in the QQ report.
JADX gh↗A Java decompiler compared with DexSQL through its native API and an MCP integration.Choose it when Java output is the inspection format you need; the speed reports do not judge decompilation quality.

Sources

  1. raw.githubusercontent.com/LSPosed/dexsql-release/master/README.md
  2. raw.githubusercontent.com/LSPosed/dexsql-release/master/skills/install-dexsql/SKILL.md
  3. raw.githubusercontent.com/LSPosed/dexsql-release/master/benchmarks/agent-audit/README.md
  4. raw.githubusercontent.com/LSPosed/dexsql-release/master/benchmarks/README.md
  5. dexsql benchmark与实际情况似乎有所偏差
  6. `resources/list` and `resources/templates/list` omit required `ttlMs` and `cacheScope` on protocol 2026-07-28
  7. Request: linux-arm64 build for Linux aarch64
  8. DexSQL v0.1.1 release and assets

More dev tools reviews