shizuku.rikka.app

Shizuku lets apps call privileged system APIs without root, but it is not a standalone tool that works the moment you install it. Before any app can use it, you need three things in place: the Shizuku app itself, a running Shizuku service started through adb, and apps that are built to request Shizuku access. If the service is not running, Shizuku-dependent features in those apps will simply be unavailable.

Install the Shizuku App

The first step is installing Shizuku on the device. This is the app that manages the privileged connection and exposes it to other apps.

• Install Shizuku from its official distribution source.
• No root is required for the standard setup path.
• The app is the bridge: other apps talk to system APIs through it rather than through a root shell.

Start the Shizuku Service via ADB

Installing the app is not enough. The Shizuku service has to be started, and the documented path is through adb.

The site describes this as "Supports adb usage" — if an app only needs adb-level permission, Shizuku is the way to grant it without root. Practically, that means:

1. Enable developer options and USB debugging on the device.
2. Connect the device to a computer with adb available.
3. Use adb to start the Shizuku service.
4. Keep the service running for apps to use it.

The key point is that the service is a running process, not a permanent install-time switch. If it stops, apps lose access until it is started again.

Apps Must Request Access

Shizuku does not automatically grant every app elevated privileges. An app has to be written to use Shizuku and to request permission through it.

The site's example shows what this looks like from the developer side — wrapping a system service and calling a privileged method:

private static final IPackageManager PACKAGE_MANAGER =
    IPackageManager.Stub.asInterface(
        new ShizukuBinderWrapper(
            SystemServiceHelper.getSystemService("package")));

public static void grantRuntimePermission(String packageName,
                                          String permissionName,
                                          int userId) {
    try {
        PACKAGE_MANAGER.grantRuntimePermission(packageName, permissionName, userId);
    } catch (RemoteException tr) {
        throw new RuntimeException(tr.getMessage(), tr);
    }
}

For a user, the takeaway is simpler: the app you want to use must support Shizuku. If it does not, installing Shizuku will not add the feature.

Check That Shizuku Is Running

Because access depends on a live service, the running state matters. The site notes there are "a few more steps to do, like checking permission or if Shizuku is running" — that check exists precisely because the service can be inactive.

Before expecting a feature to work:

• Confirm the Shizuku service is active.
• Confirm the specific app has been granted Shizuku permission.
• If either is missing, the privileged call will fail or the feature will be hidden.

What This Means in Practice

Shizuku is faster than a shell-based approach and removes the need for root, but it trades that convenience for a setup step: you start the service through adb, and you keep it running. Once those conditions are met, supported apps can use system APIs directly.

No. Shizuku does not require root access. It lets apps call system APIs with elevated privileges by going through adb instead of a root shell, so a device only needs to have granted adb permission. This makes it a fit for apps that were previously labeled "root required" but in practice only need adb-level access.

How Shizuku works without root

Shizuku's own description frames the core idea as letting your app "use system APIs directly" and telling developers to "forget about root shell." Instead of running commands through a root shell, an app talks to system services through Shizuku, which holds the elevated permission obtained via adb.

The site summarizes this in three points:

• Use system APIs elegantly — apps can use APIs with higher privileges "directly," and Shizuku is described as significantly faster than shell.
• Supports adb usage — if a "root required app" only needs adb permission, Shizuku lets it reach a wider audience.
• Save your time — Shizuku provides detailed documentation, and the main requirement placed on users is to install Shizuku.

What the code actually shows

The example on the site is a normal app calling a system service, wrapped so the call carries Shizuku's privileges:

private static final IPackageManager PACKAGE_MANAGER =
    IPackageManager.Stub.asInterface(
        new ShizukuBinderWrapper(
            SystemServiceHelper.getSystemService("package")));

public static void grantRuntimePermission(String packageName,
                                          String permissionName,
                                          int userId) {
    try {
        PACKAGE_MANAGER.grantRuntimePermission(packageName, permissionName, userId);
    } catch (RemoteException tr) {
        throw new RuntimeException(tr.getMessage(), tr);
    }
}

The key line is new ShizukuBinderWrapper(...): the app reaches the system package service through Shizuku rather than through a root process. The site notes there are a few more steps involved, such as checking permission or whether Shizuku is running.

Shizuku vs. full root: what differs

The practical distinction is scope. Shizuku is aimed at apps whose needs stop at adb permission; the site explicitly targets the case where a "root required app" only needs adb permission. If an app genuinely depends on unrestricted root capabilities, Shizuku is not a substitute.

Deciding whether it fits your case

• Choose Shizuku if the app or task only needs adb-level system API access, and you want to avoid rooting the device.
• Choose root if the requirement goes beyond what adb permission provides.
• Check the app's actual requirement first — many apps labeled "root required" may only need adb permission, which is exactly the audience Shizuku is designed to serve.

For developers, the practical takeaway from the site is that supporting Shizuku can widen an app's audience without asking users to root, at the cost of adding the extra steps the documentation covers (permission checks and verifying Shizuku is running).

Shizuku lets an app call system APIs with elevated privileges without requiring root. For developers, integration means wrapping a system service binder with ShizukuBinderWrapper and then calling that service's API interfaces directly. The official site describes this as letting your app "use system APIs directly," with Shizuku acting as a faster alternative to shell commands. The core integration is straightforward, but the site notes there are "a few more steps to do, like checking permission or if Shizuku is running."

What Shizuku Actually Provides

Shizuku does not grant your app a new API surface. Instead, it gives your app a way to obtain a binder to an existing system service that normally requires higher privileges (root or adb-level access). Once you have that binder, you call the same AIDL interfaces the system uses internally.

The site frames two practical benefits for developers:

• No root shell needed — you can use APIs with higher privileges "directly," and Shizuku is described as "significantly faster than shell."
• Wider audience for adb-only apps — if a "root required app" only actually needs adb permission, you can "easily expand the audience by using Shizuku."

That second point matters for product decisions: if your feature only needs adb-level permission, Shizuku removes the root requirement for your users.

The Core Integration Pattern

The official example wraps the package system service and calls grantRuntimePermission through it:

private static final IPackageManager PACKAGE_MANAGER =
    IPackageManager.Stub.asInterface(
        new ShizukuBinderWrapper(
            SystemServiceHelper.getSystemService("package")
        )
    );

public static void grantRuntimePermission(
        String packageName, String permissionName, int userId) {
    try {
        PACKAGE_MANAGER.grantRuntimePermission(
            packageName, permissionName, userId);
    } catch (RemoteException tr) {
        throw new RuntimeException(tr.getMessage(), tr);
    }
}

Reading this as a sequence of inputs and actions:

1. Input: the name of a system service ("package").
2. Action: SystemServiceHelper.getSystemService("package") retrieves the service binder.
3. Action: new ShizukuBinderWrapper(...) wraps that binder so calls are routed through Shizuku.
4. Action: IPackageManager.Stub.asInterface(...) converts the wrapped binder into the typed AIDL interface.
5. Result: calling grantRuntimePermission(...) on that interface executes with the privileges Shizuku holds.

The same pattern applies to other services — swap the service name and the corresponding I...Manager interface. The site's heading for this is "As Easy as you are a system app," meaning you write code as if your app were a system app.

What the Example Leaves Out

The code sample is deliberately minimal. The site's own tip states there are "a few more steps to do, like checking permission or if Shizuku is running." So before you reach the call above, your app needs to handle at least:

• Whether Shizuku is running — if it isn't, the wrapped binder won't be usable.
• Whether your app has been granted the permission it needs — Shizuku mediates access, so your app must be authorized.
• Error handling — the sample catches RemoteException and rethrows as RuntimeException, which is a starting point, not a full strategy.

These are the practical failure points. A call that works in testing can fail in the field simply because Shizuku was stopped or permission was revoked.

Integration Checklist

When This Approach Fits

Choose Shizuku integration when your app needs system-level API access but you want to avoid requiring root from users. The site's own framing supports this: it positions Shizuku as a way to "expand the audience" for apps that only need adb permission, and as faster than shell-based approaches.

It fits less well if your feature genuinely requires root-level capabilities beyond what adb permission provides, or if you cannot ask users to install and run a separate app. The site is explicit that "only you need to do is to let the users install Shizuku" — that installation is a user-facing prerequisite, not something your app can silently satisfy.

For the exact setup steps, dependency coordinates, and permission flow, follow the detailed documentation the site references rather than the abbreviated sample above.

Shizuku is a tool that lets Android apps call system APIs directly, using higher privileges than a normal app gets, without requiring a root shell. It is most useful when an app needs adb-level permission: instead of asking every user to run adb commands or root their device, the developer can rely on Shizuku to broker that access. According to the official site, Shizuku is also significantly faster than going through a shell, and it ships with detailed documentation so the main user-side requirement is simply installing Shizuku.

The problem Shizuku solves

Normally, an Android app runs in a sandbox with limited permissions. If it needs to do something privileged — grant a runtime permission, manage packages, or call a hidden system API — the usual options are:

• Root the device, which is invasive and excludes most users.
• Run adb shell commands, which is slow and awkward to wire into an app.

Shizuku takes a different route. It runs a process with elevated privileges (started via adb or root) and exposes those privileges to apps through a binder interface. The app then calls system APIs "directly" rather than shelling out, which the site describes as significantly faster than the shell approach.

How it works in practice

The core idea is that your app talks to system services through a ShizukuBinderWrapper instead of the normal binder. The official example shows granting a runtime permission:

private static final IPackageManager PACKAGE_MANAGER =
    IPackageManager.Stub.asInterface(
        new ShizukuBinderWrapper(
            SystemServiceHelper.getSystemService("package")));

public static void grantRuntimePermission(
        String packageName, String permissionName, int userId) {
    try {
        PACKAGE_MANAGER.grantRuntimePermission(
            packageName, permissionName, userId);
    } catch (RemoteException tr) {
        throw new RuntimeException(tr.getMessage(), tr);
    }
}

The site notes there are a few more steps involved — such as checking permission and confirming Shizuku is running — so this snippet is a starting point, not a complete integration.

Who it is for

Shizuku is aimed at two groups:

Key points to remember

• Shizuku lets apps use system APIs directly with higher privileges.
• It removes the need for a root shell in cases that only require adb-level access.
• It is described as faster than shell-based approaches.
• The developer-facing requirement is mainly to have users install Shizuku; the project provides documentation to walk them through it.

For the exact setup steps and current details, refer to the official documentation at shizuku.rikka.app, since the integration involves permission checks and runtime-state handling beyond the example above.

Shizuku is most valuable for apps that need system-level API access but don't actually require full root. According to the official site, if your "root required app" only needs adb permission, you can expand your audience by using Shizuku instead. The core idea: Shizuku lets apps call system APIs directly with elevated privileges, without a root shell, and it's significantly faster than shell-based approaches.

Apps That Only Need ADB-Level Permission

This is the clearest fit. Many apps historically asked for root because that was the only practical way to reach privileged APIs — but the operations they perform (granting runtime permissions, toggling system settings, managing packages) only need adb-level access.

For these apps, switching to Shizuku means:

• Users without root can run the app
• No root shell is needed for the privileged calls
• The app reaches a larger install base

The official site states this directly: "If your 'root required app' only needs adb permission, you can easily expand the audience by using Shizuku."

Apps That Call System APIs Frequently

Shizuku is described as significantly faster than shell. If your app currently shells out commands repeatedly — for example, running pm grant or similar commands per action — each call carries shell startup overhead. Direct API calls through Shizuku avoid that.

This matters most for apps where privileged operations happen often, not just once at setup. A one-time permission grant won't feel the difference; a tool that performs privileged actions throughout a session will.

Apps That Want to Avoid Shell Parsing

Shelling out means parsing text output, handling locale differences, and dealing with inconsistent formatting across Android versions. Calling system APIs directly returns structured results. If your app's current root implementation is fragile because it depends on parsing shell output, Shizuku removes that class of bugs.

What the Integration Looks Like

The official example shows the pattern — wrapping a system service through Shizuku and calling it like a normal API:

private static final IPackageManager PACKAGE_MANAGER =
    IPackageManager.Stub.asInterface(
        new ShizukuBinderWrapper(
            SystemServiceHelper.getSystemService("package")));

public static void grantRuntimePermission(
        String packageName, String permissionName, int userId) {
    try {
        PACKAGE_MANAGER.grantRuntimePermission(
            packageName, permissionName, userId);
    } catch (RemoteException tr) {
        throw new RuntimeException(tr.getMessage(), tr);
    }
}

The site notes there are a few more steps involved, such as checking permission or whether Shizuku is running. So the snippet is the call pattern, not a complete integration.

Apps That Are a Poor Fit

• Apps that genuinely need root. If your app modifies the system partition, installs kernel modules, or requires capabilities beyond adb, Shizuku won't replace root.
• Apps with rare privileged calls. If the app touches a privileged API once during setup, the added dependency on Shizuku may not be worth it versus simply documenting the adb command.
• Apps where users won't install a companion tool. Shizuku requires the user to install and run Shizuku itself. The site frames the developer's job as: "Only you need to do is to let the users install Shizuku." If your audience won't take that step, adoption suffers.

How to Decide

The practical test: list every privileged operation your app performs, then check whether each one is achievable with adb permission. If all of them are, Shizuku is likely the better path than requiring root.