Shizuku Next

An Android app that allows other apps to use system-level APIs that require ADB/root privileges.

Shizuku Next is a fork of thedjchi's Shizuku, which is itself a fork of RikkaApps' Shizuku. Shizuku the server, the API, the shell and everything that makes this possible is RikkaW's work, and the fork this is built on is thedjchi's. Their credit is given in full below; please support them.

Note from thedjchi, whose fork this continues: "I'm pausing maintenance for the time being, I simply haven't had time to work on this and it was a side project." This fork picks up where his left off.

⚠️ This build is signed with this fork's own key, so it will not install over the official Shizuku or over thedjchi's fork Android refuses to replace an app signed with a different key. Uninstall that one first, and note that a Shizuku server it started may still be running until you stop it or reboot. Nothing else changes: the package name (moe.shizuku.privileged.api), the interfaces and the API are untouched, so apps that use Shizuku keep working.

This is a FORK of Shizuku. If you are looking for the original version, please visit the RikkaApps/Shizuku repository.

Releases of this fork are on the releases page, with the latest on top the badges above track this repository. Building it yourself is covered under Building the App.

The fork this is based on publishes its own releases on his repository. Because the two are signed with different keys, neither can replace the other: uninstall the one you have before installing the other.

Everything below is either inherited from the fork this is based on or added here. The two are kept apart on purpose, because the second list is the only part this project is responsible for.

Shizuku Next started from his fork of Shizuku, so these are his features. A couple have been extended here since the transport split inside TCP mode, for instance and where that is so, the extra behaviour also appears under this fork's own list below.

• More robust "start on boot": waits for a Wi-Fi connection before starting the Shizuku service
• TCP mode: keep the classic ADB port open (i.e. the adb tcpip command) so the USB start and the watchdog can restart Shizuku without Wi-Fi or pairing. With it off, an open port is closed whenever Shizuku starts over wireless
• Watchdog service: automatically restarts Shizuku if it stops unexpectedly, and can alert you of crashes/potential fixes
• Start/stop intents: toggle Shizuku on-demand using automation apps (e.g., Tasker, MacroDroid, Automate)
• [BETA] Stealth mode: hide Shizuku from other apps that don't work when Shizuku is installed
• [BETA] In-app updates: option to automatically check for new updates, and can automatically download/install the latest version from GitHub
• Android/Google TV and VR headset support: UI is now compatible with D-Pad remotes, all TVs are supported (including Android 14+ TVs that require pairing), and the multi-window pairing dialog is toggleable in settings for VR headsets
• MediaTek support: fixes a critical bug in the original v13.6.0 which prevented Shizuku from working on MediaTek devices
• And more!

The interface work, the start-method handling and the reliability fixes below are ours, built on top of his fork, which is built on RikkaApps' Shizuku.

• Automated setup: the separate "Pair" button has been removed pressing "Start" detects when wireless debugging still needs to be paired and launches the pairing flow automatically
• Pair without typing: Shizuku reads the pairing code and port straight out of the system's "Pair with device" dialog, pairs, and starts itself so the code never has to be typed, and can't expire while you switch apps. Manual pairing (notification + typed code) stays one tap away as a fallback the Manual button beside Automated in the same dialog and both labels are single words so they fit on one button row instead of stacking
• Wireless debugging auto-disable (optional): restore the old behaviour of turning wireless debugging off once Shizuku has started over it, instead of leaving it on so Shizuku can restart itself
• Wireless debugging stays enabled: starting Shizuku no longer turns off wireless debugging, so it can restart with USB debugging off and no Wi-Fi connection; the status card shows whether it runs over wireless or USB debugging
• Accurate status label: the home status card shows the server's real UID (e.g. uid 1000) instead of always assuming adb, plus three facts that can't be confused with each other the transport it actually runs on, the method this launch used (Current) and the method the next Start will use (Default) so wireless, USB, system and root stay apart. The four read as one row across the card label above value, a hairline rule between each pair so the whole state is legible without reading left to right. Every status notification names the method too ("USB debugging · Waiting to retry")
• Fewer cryptic failure cards: a pairing request that the device rejects is reported as a pairing failure instead of being retried until the dead socket reports "Socket closed"
• One-tap battery-optimization bypass: "fix" whitelists Shizuku directly through Shizuku/root (deviceidle whitelist, appops) instead of only opening the system dialog
• Duplicate server cleanup: the starter detects stale Shizuku server processes via multiple /proc vectors and terminates them cleanly (with a short yield) before starting a new one
• Clearer auto-start progress: the wireless/boot start notification now shows more states waiting for Wi-Fi, waiting for unlock, and connecting
• Auto wake-up: when an app requests the Shizuku binder while the server is down, the manager tries to start it in the background (if start on boot is enabled and you did not deliberately stop it)
• Reliable TCP-port rebinding: after switching adbd to the configured TCP/IP port, Shizuku waits until the new port is actually listening before connecting (custom ports avoid the 5555 conflict)
• Batch permission management: long-press an app to enter multi-select, then grant or revoke permission for many apps at once, with select-all and a confirmation, plus a Toggle all action that flips every listed app in one tap (narrow the list with the search first, it only touches what is listed)
• Device info card: the home screen describes the device the way KernelSU's manager does manager version, kernel version, device model, fingerprint, SELinux status and seccomp status (SELinux is read through the server when one is running, and otherwise inferred the way KernelSU's manager does getenforce being denied means the policy is enforcing)
• New Material 3 interface: the manager UI is rebuilt in Jetpack Compose with a KernelSU-style layout a bottom tab bar (Home · Apps · Settings), tonal status cards with dynamic color, hairline outlines on pure-black OLED themes, and one rounded card per app in the Apps tab so a long list reads as separate entries instead of a flat column
• Start as system (UID 1000): a "Start (system)" card launches Shizuku under the system UID either via a built-in device exploit or by copying a command for your own privilege escalation, selected in settings
• Start method setting: pick how Shizuku starts Wireless debugging, USB debugging, System (UID 1000) or Root and the Start button, start on boot, the watchdog and the start intents all follow it instead of guessing from the last method that happened to work. Root is only offered where the device can actually grant it, and a device that loses root (an OTA, root switched off in the manager) has a stored Root rewritten to Wireless debugging with a line in settings explaining the change rather than every start pointing at a method that can't run
• Separate USB start: home now has "Start via USB debugging" next to the wireless one, and the two never cross over in transport: a wireless start always goes over the wireless port (so it can't come back reporting USB), and never enables USB debugging or pairing; a USB start uses the classic ADB port, where the connection authenticates itself and Android asks you to allow USB debugging once
• The USB start reopens its port by itself: Android clears the classic ADB port on every reboot and it isn't persistent, so a USB start borrows the wireless connection to reopen it whenever Wi-Fi is available, then starts over the port as usual. With no Wi-Fi to borrow it says exactly what to do connect to Wi-Fi, or run adb tcpip 5555 from a computer
• Restart timing: choose whether unattended restarts wait for an unmetered Wi-Fi connection (starts you trigger yourself never wait); an unattended start that fails retries with backoff rather than giving up on the first try
• One start at a time: while Shizuku is running, every start row on the home screen wireless, USB, system, root and the "Start using computer" ADB command is dimmed and inert, so a tap can't silently do nothing; Restart is how you relaunch it
• ADB without Developer options: a startup switch that turns the Developer options flag off and puts back the two ADB settings it would otherwise take with it, so Shizuku still starts and restarts on a device that looks clean to apps which refuse to run when Developer options is on. It is re-applied after every reboot, and switching it off puts the flag back
• Asks for the minimum, and only once: WRITE_SECURE_SETTINGS is needed to switch wireless debugging on, nothing else — so a USB start, or a wireless start with that toggle already on, works on a fresh install without it, and no start is aborted by a setting the app isn't allowed to write. Only ADB can hand that permission out, so Shizuku grants it to itself as soon as a server is running (which is also what lets it enable its own accessibility service for pairing instead of asking you to). A brand-new install still needs either one adb shell pm grant … or the manual pairing fallback before the first server exists
• One-tap ADB port fix: a USB start that finds the classic ADB port closed offers to open it and start in one tap, instead of only explaining adb tcpip
• Clearer apps list: the Apps tab now says what is happening a spinner while it loads, "Shizuku is not running" with a Start button, no apps matching the search, or no app having asked for permission yet instead of a blank page
• Search and sort authorized apps: filter the apps list by name, narrow it to All, Granted, Revoked or Hidden with a count on each, and sort it alphabetically, by most recently updated or by most recently installed
• More resilient watchdog: self-heals a dead server on screen unlock (even if the manager wasn't running when it died) and never fights a deliberate Stop
• Watchdog control intents: enable/disable the watchdog via moe.shizuku.privileged.api.WATCHDOG_ON, ...WATCHDOG_OFF, or ...WATCHDOG_TOGGLE
• Status broadcasts: automation apps can react to moe.shizuku.privileged.api.SHIZUKU_CHANGED and ...WATCHDOG_CHANGED, each carrying a status extra (1 = on, 0 = off)
• Stability on some Chinese devices (Xiaomi/OPPO/Lenovo): background starts no longer force USB debugging on, so Shizuku no longer dies when the USB mode is File Transfer and the screen is off

The fork's own name and icon the fox in docs/logo.png are this project's. Everything underneath is the work credited below.

Please read the wiki for setup, info, and troubleshooting steps it belongs to the fork this one is based on, and documents the same behaviour, because the features and the server come from there.

Minimum Version: Android 7+

• Root mode: Requires a rooted device
• Wireless Debugging mode: Works on Android 11+ and all Android TVs
• PC mode: Works on all devices
• Start on boot: Available only when using Wireless Debugging or Root mode

Shizuku takes user privacy very seriously.

• No tracking or analytics
• No telemetry
• No proprietary libraries
• No Google Play Services
• Open-source codebase
• Reproducible builds
• Internet access is only used for wireless debugging connections and to fetch updates from GitHub
• Only required permissions are declared

• INTERNET: required for the wireless debugging start mode to work. Also used to fetch updates from GitHub
• ACCESS_NETWORK_STATE: used to determine when Wi-Fi is available for background start via wireless debugging
• POST_NOTIFICATIONS: required for pairing notification and other alerts
• RECEIVE_BOOT_COMPLETED: required for start on boot
• FOREGROUND_SERVICE: prevents watchdog from being killed
• REQUEST_IGNORE_BATTERY_OPTIMIZATIONS: prevents start on boot and watchdog services from being killed
• WRITE_SECURE_SETTINGS: used to toggle USB and wireless debugging in the background when starting/stopping Shizuku
• REQUEST_DELETE_PACKAGES: used to request uninstall for Shizuku/stub when using stealth mode
• REQUEST_INSTALL_PACKAGES: used to request install for app updates, as well as Shizuku stub when using stealth mode

Contribute translations through the Crowdin project.

This fork and all of its features are free, and there will never be ads. It has no donation setup of its own.

If you want to support the work it is built on, support the people who made it: thedjchi, whose fork most of these features come from, and RikkaW / RikkaApps, who wrote Shizuku itself.

The API guide and a demo project are available in the Shizuku-API repository

1. Shizuku has different permissions in root and ADB mode. You can see permissions granted to ADB here. If your app requires root permission, use ShizukuService#getUid to check if Shizuku is running as root or ADB, or use ShizukuService#checkPermission to check if the server has sufficient permissions.
2. On devices running Android 8 or lower, if you need to use Shizuku in a Service or Broadcast Receiver that might not be started by an Activity, please trigger the send binder by starting a transparent activity.
3. Please prefer using ShizukuBinderWrapper instead of directly using transactRemote when possible, as API calls can change across Android versions.

• Clone with git clone --recurse-submodules
• Run gradle task :manager:assembleDebug or :manager:assembleRelease

The :manager:assembleDebug task generates a debuggable server. You can attach a debugger to shizuku_server to debug the server. In Android Studio, ensure Run/Debug configurations > Always install with package manager is checked, so that the server will use the latest code.

1. Fork the repository
2. Create a feature branch (git checkout -b branch-name)
3. Make your changes
4. Commit your changes (git commit -m 'Commit message')
5. Push to the branch (git push origin branch-name)
6. Open a Pull Request

• RikkaW / RikkaApps the original Shizuku: the server, the API, the shell, and the foundation all of this is built on.
• thedjchi the fork this project is based on. Everything under From thedjchi's fork above is his.
• Everyone who contributed upstream, and the translators on Crowdin.

All code files in this project are licensed under Apache 2.0