LSPatch rootless: patch APKs for Xposed without root
LSPatch runs Xposed modules without root by rewriting one target APK at a time instead of hooking the whole system. This surgical approach means you trade system-wide coverage for the ability to function on completely stock devices — useful for sideloading module-ladened apps to friends or testing module behavior in isolation. The LSPlant engine is solid, both module generations work, and the manager UI makes the workflow approachable. Skip it if you need to hook system processes or apps you cannot repackage; that's Vector's job.
What LSPatch is and how it works
LSPatch is a rootless Xposed framework that injects the Xposed runtime directly into a target APK rather than the system. It works by repackaging the app to include Vector's loader and the LSPlant hook engine, then signing the result so Android accepts it as a normal update. The patched app loads Xposed modules on its own, inside its own process. This differs from rootful Xposed because no system-level hooks are involved — LSPatch never touches /system or needs Zygisk.
Key features: Manager mode, Integrated mode, and CLI
- ✓Manager mode keeps the patched app tethered to the LSPatch manager, so adding or removing modules does not require re-patching — useful during active development
- ✓Integrated mode bakes modules into the APK permanently, producing a self-contained app that installs and runs without any manager present
- ✓Command-line patcher (lspatch.jar) runs from any shell and accepts APK paths directly, enabling scripted or CI-based workflows
- ✓Both modern libxposed modules and legacy de.robv.android.xposed modules run on the same LSPlant hook engine, no API translation needed
- ✓Shizuku integration, when available, performs silent installation instead of requiring manual APK install confirmation
- ✓Live framework log inside the manager lets you inspect hook behavior in real time without leaving the patched app context
- ✓Requires Android 9 (API 28) minimum; upper compatibility bounds follow Vector's published device and ROM compatibility notes
What LSPatch is built for
- •Running ad-blocking or privacy modules on banking or streaming apps that refuse to install on rooted devices — patch the specific app, leave the rest of the system alone
- •Sharing module-loaded apps with non-technical friends who cannot or will not root their phones — hand them a single APK instead of a root tutorial
- •Testing Xposed module behavior in a sandboxed context where a module crash only kills one app rather than soft-bricking the device
- •CI pipelines that patch an app, run instrumented tests against the modified APK, then discard the patched build — the CLI handles this cleanly
- •Distributing a privacy-hardened version of a messaging app to a small team without MDM overhead — patch once, ship the integrated APK
Getting started with LSPatch
Download the latest manager.apk from the GitHub Releases page and install it on your Android 9+ device. Enable "Install unknown apps" for the LSPatch manager in system settings. If you have Shizuku running (via ADB or wireless), the manager can install patched APKs silently; otherwise, each patched app prompts once for manual installation. The command-line patcher (lspatch.jar) can be downloaded separately and run with `java -jar lspatch.jar` from any shell with Java 11+.
Patching your first app
Open the LSPatch manager, tap "Select app," and choose the target APK from your installed apps or load one from storage. Choose Manager mode to keep module changes reversible, or Integrated mode if you want a standalone patched APK. Tap Patch, wait for the repackaging to finish, then install the result. In the manager, navigate to the patched app's card to add modules from the store or load modules from disk. The live log button shows framework-level hook events as they happen inside that app's process.
Strengths
- ✓No root required — patches a single APK to embed the Xposed loader instead of hooking the entire system, so you can run modules on any unrooted Android 9+ device.
- ✓Works with both generations of Xposed modules: modern libxposed modules get a real IXposedService, and legacy de.robv.android.xposed modules keep working as-is.
- ✓Two patching modes let you trade off flexibility vs. portability — manager mode lets you add or remove modules without re-patching, while integrated mode produces a standalone APK with everything baked in.
- ✓Shares LSPlant's hook engine and the manager UI with its sibling project Vector, so modules run unchanged across the rootful and rootless paths.
- ✓Shizuku integration enables silent installation of patched APKs; without it, you just grant 'install unknown apps' once and install manually — no middle ground of painful manual steps.
What LSPatch cannot do
- △LSPatch can only hook the one app you patched — it cannot reach system processes, other apps, or anything running outside the modified APK's process boundary
- △Apps that verify their integrity via Play Protect, root detection SDKs, or in-app cheat detection may refuse to run once patched, depending on how aggressively those checks are implemented
- △Each patched app occupies a separate installation slot, so running five patched apps means five app entries in your launcher and five entries in your app manager
- △The patched APK must be resigned; if the original app uses package signature verification for API access or content providers, those connections break after patching
- △APK repackaging is not instantaneous — large apps take noticeably longer to patch than small ones, and the process consumes temporary storage during processing
- △Whether a given Xposed module works inside LSPatch depends on what the module hooks; modules that inject into system services or expect to see other apps' data will fail silently in a per-app context
How LSPatch compares to Vector and LSPosed
Frequently asked questions
LSPatch requires Android 9 (API level 28) or higher. The upper bound depends on Vector's compatibility notes, which track tested ROMs and Android versions.
Only the app you patched. System processes and other apps are completely out of reach because LSPatch operates inside a single repackaged APK, not at the system level.
Manager mode keeps the patched app connected to the LSPatch manager so you can add, remove, or update modules without re-patching the APK. Integrated mode bakes the modules into the APK permanently, producing a standalone file that needs no manager to run.
No. Shizuku is optional. Without it, you grant the "install unknown apps" permission once and manually confirm each patched APK installation. Shizuku removes that friction by performing silent installation.
Yes. Both the legacy de.robv.android.xposed API and the modern libxposed API with IXposedService run on the same LSPlant hook engine inside LSPatch.
Yes. LSPatch is published under the GPL-3.0 license, and the source code is available on GitHub.
The problem it solves
Root-based Xposed frameworks require Magisk or KernelSU — a significant barrier for users who cannot or do not want to disable the bootloader lock. Existing rootless alternatives either modify the system partition in ways that break SafetyNet, or they force a one-size-fits-all overlay that affects every app whether you need it or not.
Who should try it — and who should skip
Try LSPatch if you want to run Xposed modules on a stock device, distribute module-loaded APKs to non-rooted users, or test modules in isolation without risking system stability. It is also worth considering if you are an Android developer who needs to instrument a third-party app for debugging without modifying the system. Skip it if you need to hook system apps, if your target app actively blocks patched APKs, or if you have root and want true system-wide coverage — Vector handles all of those cases better.
Related repositories
Curious whether LSPatch is right for you?
Let ChatGPT, Claude, or Perplexity look into it — click below and see what AI actually says about LSPatch.
