diff --git a/composeApp/src/androidMain/AndroidManifest.xml b/composeApp/src/androidMain/AndroidManifest.xml
index c7297029e..8d9d16a03 100644
--- a/composeApp/src/androidMain/AndroidManifest.xml
+++ b/composeApp/src/androidMain/AndroidManifest.xml
@@ -18,6 +18,8 @@
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
 
+    <uses-permission android:name="com.rosan.dhizuku.permission.API" />
+
     <!--
         Fallback visibility for installer-source classification when
         QUERY_ALL_PACKAGES is denied on Android 11+. We need to recognise
@@ -31,6 +33,8 @@
         <package android:name="org.fdroid.fdroid" />
         <package android:name="com.android.vending" />
         <package android:name="com.aurora.store" />
+        <package android:name="com.rosan.dhizuku" />
+        <provider android:authorities="com.rosan.dhizuku.server.provider" />
     </queries>
 
     <application
diff --git a/core/data/build.gradle.kts b/core/data/build.gradle.kts
index 099b5862f..761a60c32 100644
--- a/core/data/build.gradle.kts
+++ b/core/data/build.gradle.kts
@@ -36,6 +36,7 @@ kotlin {
                 implementation(libs.androidx.work.runtime)
                 implementation(libs.shizuku.api)
                 implementation(libs.shizuku.provider)
+                implementation(libs.dhizuku.api)
                 compileOnly(libs.hidden.api.stub)
             }
         }
diff --git a/core/data/src/androidMain/aidl/zed/rainxch/core/data/services/dhizuku/IDhizukuInstallerService.aidl b/core/data/src/androidMain/aidl/zed/rainxch/core/data/services/dhizuku/IDhizukuInstallerService.aidl
new file mode 100644
index 000000000..76f587085
--- /dev/null
+++ b/core/data/src/androidMain/aidl/zed/rainxch/core/data/services/dhizuku/IDhizukuInstallerService.aidl
@@ -0,0 +1,7 @@
+package zed.rainxch.core.data.services.dhizuku;
+
+interface IDhizukuInstallerService {
+    int installPackage(in ParcelFileDescriptor pfd, long fileSize, String expectedPackageName, long expectedVersionCode);
+    int uninstallPackage(String packageName);
+    void destroy();
+}
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/di/PlatformModule.android.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/di/PlatformModule.android.kt
index 2c9a8efe2..f07bc14d9 100644
--- a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/di/PlatformModule.android.kt
+++ b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/di/PlatformModule.android.kt
@@ -25,8 +25,9 @@ import zed.rainxch.core.data.services.LocalizationManager
 import zed.rainxch.core.data.services.external.AndroidExternalAppScanner
 import zed.rainxch.core.data.services.external.InstallerSourceClassifier
 import zed.rainxch.core.data.services.external.ManifestHintExtractor
-import zed.rainxch.core.data.services.shizuku.AndroidInstallerStatusProvider
-import zed.rainxch.core.data.services.shizuku.ShizukuInstallerWrapper
+import zed.rainxch.core.data.services.dhizuku.DhizukuServiceManager
+import zed.rainxch.core.data.services.installer.AndroidInstallerStatusProvider
+import zed.rainxch.core.data.services.installer.SilentInstallerDispatcher
 import zed.rainxch.core.data.services.shizuku.ShizukuServiceManager
 import zed.rainxch.core.data.utils.AndroidAppLauncher
 import zed.rainxch.core.data.utils.AndroidBrowserHelper
@@ -74,22 +75,33 @@ actual val corePlatformModule =
             ).also { it.initialize() }
         }
 
-        // Installer — the ShizukuInstallerWrapper is the public Installer singleton.
-        // It delegates to AndroidInstaller by default, intercepting with Shizuku when enabled.
+        // DhizukuServiceManager — manages Dhizuku lifecycle, permissions, service binding
+        single {
+            DhizukuServiceManager(
+                context = androidContext(),
+            ).also { it.initialize() }
+        }
+
+        // Installer — SilentInstallerDispatcher routes through the user's selected
+        // silent backend (Shizuku, Dhizuku) or falls back to the standard installer.
         single<Installer> {
-            ShizukuInstallerWrapper(
+            SilentInstallerDispatcher(
+                androidContext = androidContext(),
                 androidInstaller = get<AndroidInstaller>(),
                 shizukuServiceManager = get(),
+                dhizukuServiceManager = get(),
                 tweaksRepository = get(),
-            ).also { wrapper ->
-                wrapper.observeInstallerPreference(get<CoroutineScope>())
+                scope = get<CoroutineScope>(),
+            ).also { dispatcher ->
+                dispatcher.observeInstallerPreference()
             }
         }
 
-        // InstallerStatusProvider — exposes Shizuku availability to the UI layer
+        // InstallerStatusProvider — exposes both Shizuku and Dhizuku availability to UI
         single<InstallerStatusProvider> {
             AndroidInstallerStatusProvider(
                 shizukuServiceManager = get(),
+                dhizukuServiceManager = get(),
                 scope = get(),
             )
         }
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AutoUpdateWorker.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AutoUpdateWorker.kt
index 6489fa7d4..40ee02a9c 100644
--- a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AutoUpdateWorker.kt
+++ b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AutoUpdateWorker.kt
@@ -18,6 +18,8 @@ import co.touchlab.kermit.Logger
 import kotlinx.coroutines.flow.first
 import org.koin.core.component.KoinComponent
 import org.koin.core.component.inject
+import zed.rainxch.core.data.services.dhizuku.DhizukuServiceManager
+import zed.rainxch.core.data.services.dhizuku.model.DhizukuStatus
 import zed.rainxch.core.data.services.shizuku.ShizukuServiceManager
 import zed.rainxch.core.data.services.shizuku.model.ShizukuStatus
 import zed.rainxch.core.domain.model.InstalledApp
@@ -45,6 +47,7 @@ class AutoUpdateWorker(
     private val downloader: Downloader by inject()
     private val tweaksRepository: TweaksRepository by inject()
     private val shizukuServiceManager: ShizukuServiceManager by inject()
+    private val dhizukuServiceManager: DhizukuServiceManager by inject()
 
     override suspend fun doWork(): Result {
         return try {
@@ -53,12 +56,21 @@ class AutoUpdateWorker(
             val autoUpdateEnabled = tweaksRepository.getAutoUpdateEnabled().first()
             val installerType = tweaksRepository.getInstallerType().first()
 
-            shizukuServiceManager.refreshStatus()
-            val shizukuReady = shizukuServiceManager.status.value == ShizukuStatus.READY
+            val silentReady = when (installerType) {
+                InstallerType.SHIZUKU -> {
+                    shizukuServiceManager.refreshStatus()
+                    shizukuServiceManager.status.value == ShizukuStatus.READY
+                }
+                InstallerType.DHIZUKU -> {
+                    dhizukuServiceManager.refreshStatus()
+                    dhizukuServiceManager.status.value == DhizukuStatus.READY
+                }
+                InstallerType.DEFAULT -> false
+            }
 
-            if (!autoUpdateEnabled || installerType != InstallerType.SHIZUKU || !shizukuReady) {
+            if (!autoUpdateEnabled || !silentReady) {
                 Logger.i {
-                    "AutoUpdateWorker: Conditions not met (autoUpdate=$autoUpdateEnabled, installer=$installerType, shizuku=$shizukuReady), skipping"
+                    "AutoUpdateWorker: Conditions not met (autoUpdate=$autoUpdateEnabled, installer=$installerType, silentReady=$silentReady), skipping"
                 }
                 return Result.success()
             }
@@ -199,7 +211,8 @@ class AutoUpdateWorker(
             )
         }
 
-        Logger.d { "AutoUpdateWorker: Installing ${app.appName} via Shizuku" }
+        val installerLabel = tweaksRepository.getInstallerType().first().name
+        Logger.d { "AutoUpdateWorker: Installing ${app.appName} via $installerLabel" }
         try {
             installer.install(filePath, ext)
         } catch (e: Exception) {
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/UpdateCheckWorker.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/UpdateCheckWorker.kt
index 9b4f05fdc..c687a2569 100644
--- a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/UpdateCheckWorker.kt
+++ b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/UpdateCheckWorker.kt
@@ -70,9 +70,10 @@ class UpdateCheckWorker(
                 val autoUpdateEnabled = tweaksRepository.getAutoUpdateEnabled().first()
                 val installerType = tweaksRepository.getInstallerType().first()
 
-                if (autoUpdateEnabled && installerType == InstallerType.SHIZUKU) {
+                val isSilentBackend = installerType == InstallerType.SHIZUKU || installerType == InstallerType.DHIZUKU
+                if (autoUpdateEnabled && isSilentBackend) {
                     Logger.i {
-                        "UpdateCheckWorker: Auto-update enabled with Shizuku, scheduling AutoUpdateWorker for ${appsWithUpdates.size} apps"
+                        "UpdateCheckWorker: Auto-update enabled with $installerType, scheduling AutoUpdateWorker for ${appsWithUpdates.size} apps"
                     }
                     UpdateScheduler.scheduleAutoUpdate(applicationContext)
                 } else {
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/DhizukuInstallerServiceImpl.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/DhizukuInstallerServiceImpl.kt
new file mode 100644
index 000000000..83f79f066
--- /dev/null
+++ b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/DhizukuInstallerServiceImpl.kt
@@ -0,0 +1,270 @@
+package zed.rainxch.core.data.services.dhizuku
+
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.PackageInstaller
+import android.os.Build
+import android.os.ParcelFileDescriptor
+import java.util.UUID
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+
+class DhizukuInstallerServiceImpl() : IDhizukuInstallerService.Stub() {
+
+    companion object {
+        private const val TAG = "DhizukuService"
+
+        private const val STATUS_SUCCESS = 0
+        private const val STATUS_FAILURE = -1
+        private const val INSTALL_TIMEOUT_SECONDS = 120L
+        private const val UNINSTALL_TIMEOUT_SECONDS = 30L
+
+        private const val ACTION_INSTALL_RESULT = "zed.rainxch.dhizuku.INSTALL_RESULT"
+        private const val ACTION_UNINSTALL_RESULT = "zed.rainxch.dhizuku.UNINSTALL_RESULT"
+
+        private fun log(msg: String) = android.util.Log.d(TAG, msg)
+        private fun logW(msg: String) = android.util.Log.w(TAG, msg)
+        private fun logE(msg: String, e: Throwable? = null) = android.util.Log.e(TAG, msg, e)
+    }
+
+    override fun installPackage(
+        pfd: ParcelFileDescriptor,
+        fileSize: Long,
+        expectedPackageName: String?,
+        expectedVersionCode: Long,
+    ): Int {
+        log("installPackage() called — fileSize=$fileSize, expected=$expectedPackageName@$expectedVersionCode")
+        log("Process UID: ${android.os.Process.myUid()}, PID: ${android.os.Process.myPid()}")
+
+        val ctx: Context = currentApplicationOrNull() ?: run {
+            logE("currentApplication() returned null — no context available")
+            return STATUS_FAILURE
+        }
+
+        val installer = ctx.packageManager.packageInstaller
+        val params = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            params.setRequireUserAction(PackageInstaller.SessionParams.USER_ACTION_NOT_REQUIRED)
+        }
+        if (fileSize > 0) params.setSize(fileSize)
+
+        var sessionId = -1
+        var session: PackageInstaller.Session? = null
+        var receiver: BroadcastReceiver? = null
+        var committed = false
+        return try {
+            sessionId = installer.createSession(params)
+            log("createSession() — sessionId=$sessionId")
+            session = installer.openSession(sessionId)
+
+            session.openWrite("apk", 0, fileSize).use { out ->
+                ParcelFileDescriptor.AutoCloseInputStream(pfd).use { input ->
+                    val copied = input.copyTo(out)
+                    out.flush()
+                    session.fsync(out)
+                    log("APK piped to session: $copied bytes (expected: $fileSize)")
+                }
+            }
+
+            val latch = CountDownLatch(1)
+            val resultRef = AtomicInteger(STATUS_FAILURE)
+            val token = UUID.randomUUID().toString()
+            val action = "$ACTION_INSTALL_RESULT.$token"
+
+            receiver = object : BroadcastReceiver() {
+                override fun onReceive(context: Context, intent: Intent) {
+                    val status = intent.getIntExtra(
+                        PackageInstaller.EXTRA_STATUS,
+                        PackageInstaller.STATUS_FAILURE,
+                    )
+                    val message = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE)
+                    log("install result — status=$status, message='$message'")
+                    resultRef.set(if (status == PackageInstaller.STATUS_SUCCESS) STATUS_SUCCESS else STATUS_FAILURE)
+                    latch.countDown()
+                }
+            }
+            registerInternalReceiver(ctx, receiver, action)
+
+            val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+            } else {
+                PendingIntent.FLAG_UPDATE_CURRENT
+            }
+            val pendingIntent = PendingIntent.getBroadcast(
+                ctx,
+                token.hashCode(),
+                Intent(action).setPackage(ctx.packageName),
+                pendingFlags,
+            )
+
+            session.commit(pendingIntent.intentSender)
+            committed = true
+            log("session.commit() called, awaiting result...")
+
+            val finished = latch.await(INSTALL_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            if (!finished) {
+                logE("install timed out after ${INSTALL_TIMEOUT_SECONDS}s — verifying package state")
+                if (verifyInstallSucceeded(ctx, installer, sessionId, expectedPackageName, expectedVersionCode)) {
+                    log("post-timeout verification confirmed install succeeded")
+                    STATUS_SUCCESS
+                } else {
+                    logE("post-timeout verification could not confirm install")
+                    STATUS_FAILURE
+                }
+            } else {
+                resultRef.get()
+            }
+        } catch (e: Exception) {
+            logE("installPackage() exception", e)
+            STATUS_FAILURE
+        } finally {
+            if (!committed && sessionId >= 0) {
+                try { installer.abandonSession(sessionId) } catch (_: Exception) {}
+            }
+            try { session?.close() } catch (_: Exception) {}
+            if (receiver != null) {
+                try { ctx.unregisterReceiver(receiver) } catch (_: Exception) {}
+            }
+        }
+    }
+
+    override fun uninstallPackage(packageName: String): Int {
+        log("uninstallPackage() called for: $packageName")
+
+        val ctx: Context = currentApplicationOrNull() ?: run {
+            logE("currentApplication() returned null — no context available")
+            return STATUS_FAILURE
+        }
+
+        val installer = ctx.packageManager.packageInstaller
+        val latch = CountDownLatch(1)
+        val resultRef = AtomicInteger(STATUS_FAILURE)
+        val token = UUID.randomUUID().toString()
+        val action = "$ACTION_UNINSTALL_RESULT.$token"
+        var receiver: BroadcastReceiver? = null
+
+        return try {
+            receiver = object : BroadcastReceiver() {
+                override fun onReceive(context: Context, intent: Intent) {
+                    val status = intent.getIntExtra(
+                        PackageInstaller.EXTRA_STATUS,
+                        PackageInstaller.STATUS_FAILURE,
+                    )
+                    val message = intent.getStringExtra(PackageInstaller.EXTRA_STATUS_MESSAGE)
+                    log("uninstall result — status=$status, message='$message'")
+                    resultRef.set(if (status == PackageInstaller.STATUS_SUCCESS) STATUS_SUCCESS else STATUS_FAILURE)
+                    latch.countDown()
+                }
+            }
+            registerInternalReceiver(ctx, receiver, action)
+
+            val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+            } else {
+                PendingIntent.FLAG_UPDATE_CURRENT
+            }
+            val pendingIntent = PendingIntent.getBroadcast(
+                ctx,
+                token.hashCode(),
+                Intent(action).setPackage(ctx.packageName),
+                pendingFlags,
+            )
+
+            installer.uninstall(packageName, pendingIntent.intentSender)
+
+            val finished = latch.await(UNINSTALL_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+            if (!finished) {
+                logE("uninstall timed out after ${UNINSTALL_TIMEOUT_SECONDS}s — verifying package state")
+                if (!isPackageInstalled(ctx, packageName)) {
+                    log("post-timeout verification confirmed uninstall succeeded")
+                    STATUS_SUCCESS
+                } else {
+                    logE("post-timeout verification: package still installed")
+                    STATUS_FAILURE
+                }
+            } else {
+                resultRef.get()
+            }
+        } catch (e: Exception) {
+            logE("uninstallPackage() exception", e)
+            STATUS_FAILURE
+        } finally {
+            if (receiver != null) {
+                try { ctx.unregisterReceiver(receiver) } catch (_: Exception) {}
+            }
+        }
+    }
+
+    override fun destroy() {
+        log("destroy() — service being unbound")
+    }
+
+    private fun verifyInstallSucceeded(
+        ctx: Context,
+        installer: PackageInstaller,
+        sessionId: Int,
+        expectedPackageName: String?,
+        expectedVersionCode: Long,
+    ): Boolean {
+        val targetPackage = expectedPackageName?.takeIf { it.isNotBlank() }
+            ?: runCatching { installer.getSessionInfo(sessionId)?.appPackageName }
+                .onFailure { logE("getSessionInfo() failed during verification", it) }
+                .getOrNull()
+            ?: return false
+        val info = packageInfoOrNull(ctx, targetPackage) ?: return false
+        if (expectedVersionCode <= 0L) return true
+        val installedVersion = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            info.longVersionCode
+        } else {
+            @Suppress("DEPRECATION")
+            info.versionCode.toLong()
+        }
+        val matches = installedVersion >= expectedVersionCode
+        if (!matches) {
+            logW("installed $targetPackage@$installedVersion does not match expected@$expectedVersionCode")
+        }
+        return matches
+    }
+
+    private fun isPackageInstalled(ctx: Context, packageName: String): Boolean =
+        packageInfoOrNull(ctx, packageName) != null
+
+    private fun packageInfoOrNull(ctx: Context, packageName: String): android.content.pm.PackageInfo? = try {
+        ctx.packageManager.getPackageInfo(packageName, 0)
+    } catch (_: android.content.pm.PackageManager.NameNotFoundException) {
+        null
+    } catch (e: Exception) {
+        logE("getPackageInfo($packageName) failed", e)
+        null
+    }
+
+    private fun currentApplicationOrNull(): Context? {
+        return try {
+            val cls = Class.forName("android.app.ActivityThread")
+            val app = cls.getMethod("currentApplication").invoke(null)
+            app as? Context
+        } catch (e: Exception) {
+            try {
+                val cls = Class.forName("android.app.AppGlobals")
+                val app = cls.getMethod("getInitialApplication").invoke(null)
+                app as? Context
+            } catch (_: Exception) {
+                logE("Failed to obtain Application context", e)
+                null
+            }
+        }
+    }
+
+    private fun registerInternalReceiver(ctx: Context, receiver: BroadcastReceiver, action: String) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            ctx.registerReceiver(receiver, IntentFilter(action), Context.RECEIVER_NOT_EXPORTED)
+        } else {
+            @Suppress("UnspecifiedRegisterReceiverFlag")
+            ctx.registerReceiver(receiver, IntentFilter(action))
+        }
+    }
+}
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/DhizukuServiceManager.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/DhizukuServiceManager.kt
new file mode 100644
index 000000000..0f33e4517
--- /dev/null
+++ b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/DhizukuServiceManager.kt
@@ -0,0 +1,207 @@
+package zed.rainxch.core.data.services.dhizuku
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.ServiceConnection
+import android.content.pm.PackageManager
+import android.os.IBinder
+import android.os.RemoteException
+import co.touchlab.kermit.Logger
+import com.rosan.dhizuku.api.Dhizuku
+import com.rosan.dhizuku.api.DhizukuRequestPermissionListener
+import com.rosan.dhizuku.api.DhizukuUserServiceArgs
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withTimeoutOrNull
+import zed.rainxch.core.data.services.dhizuku.model.DhizukuStatus
+import kotlin.coroutines.resume
+
+class DhizukuServiceManager(
+    private val context: Context,
+) {
+    private val _status = MutableStateFlow(DhizukuStatus.NOT_INSTALLED)
+    val status: StateFlow<DhizukuStatus> = _status.asStateFlow()
+
+    private val bindMutex = Mutex()
+    private var serviceConnection: ServiceConnection? = null
+
+    @Volatile
+    var installerService: IDhizukuInstallerService? = null
+        private set
+
+    fun initialize() {
+        refreshStatus()
+    }
+
+    fun refreshStatus() {
+        _status.value = computeStatus()
+    }
+
+    private fun computeStatus(): DhizukuStatus =
+        try {
+            if (!isPackageInstalled(DHIZUKU_PACKAGE)) {
+                Logger.d(TAG) { "computeStatus() — Dhizuku package not installed" }
+                DhizukuStatus.NOT_INSTALLED
+            } else {
+                val initialized = try {
+                    Dhizuku.init(context)
+                } catch (e: Exception) {
+                    Logger.w(TAG) { "Dhizuku.init() threw: ${e.message}" }
+                    false
+                }
+                Logger.d(TAG) { "computeStatus() — Dhizuku.init=$initialized" }
+                if (!initialized) {
+                    DhizukuStatus.NOT_RUNNING
+                } else {
+                    val granted = try {
+                        Dhizuku.isPermissionGranted()
+                    } catch (e: Exception) {
+                        Logger.w(TAG) { "Dhizuku.isPermissionGranted() threw: ${e.message}" }
+                        false
+                    }
+                    if (granted) {
+                        Logger.d(TAG) { "computeStatus() — READY" }
+                        DhizukuStatus.READY
+                    } else {
+                        DhizukuStatus.PERMISSION_NEEDED
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Logger.w(TAG) { "Error checking Dhizuku status: ${e.javaClass.simpleName}: ${e.message}" }
+            DhizukuStatus.NOT_RUNNING
+        }
+
+    private fun isPackageInstalled(packageName: String): Boolean =
+        try {
+            context.packageManager.getPackageInfo(packageName, 0)
+            true
+        } catch (_: PackageManager.NameNotFoundException) {
+            false
+        } catch (_: Exception) {
+            false
+        }
+
+    fun requestPermission() {
+        try {
+            if (!Dhizuku.init(context)) {
+                Logger.w(TAG) { "requestPermission() — Dhizuku.init() failed, cannot request" }
+                refreshStatus()
+                return
+            }
+            if (Dhizuku.isPermissionGranted()) {
+                refreshStatus()
+                return
+            }
+            Dhizuku.requestPermission(object : DhizukuRequestPermissionListener() {
+                @Throws(RemoteException::class)
+                override fun onRequestPermission(grantResult: Int) {
+                    Logger.d(TAG) {
+                        "Dhizuku permission result: granted=${grantResult == PackageManager.PERMISSION_GRANTED}"
+                    }
+                    refreshStatus()
+                }
+            })
+        } catch (e: Exception) {
+            Logger.w(TAG) { "Failed to request Dhizuku permission: ${e.message}" }
+        }
+    }
+
+    suspend fun getService(): IDhizukuInstallerService? {
+        Logger.d(TAG) { "getService() — current status=${_status.value}" }
+        if (_status.value != DhizukuStatus.READY) {
+            Logger.w(TAG) { "getService() — Dhizuku not READY (status=${_status.value}), returning null" }
+            return null
+        }
+
+        return bindMutex.withLock {
+            installerService?.let { service ->
+                try {
+                    val alive = service.asBinder().pingBinder()
+                    Logger.d(TAG) { "getService() — cached service ping=$alive" }
+                    if (alive) return@withLock service
+                    Logger.w(TAG) { "getService() — cached service binder dead, rebinding..." }
+                    installerService = null
+                } catch (e: Exception) {
+                    Logger.w(TAG) { "getService() — cached service error: ${e.message}, rebinding..." }
+                    installerService = null
+                }
+            } ?: run {
+                Logger.d(TAG) { "getService() — no cached service, binding..." }
+            }
+
+            bindService()
+        }
+    }
+
+    private suspend fun bindService(): IDhizukuInstallerService? {
+        Logger.d(TAG) { "bindService() — attempting to bind Dhizuku UserService..." }
+        return try {
+            withTimeoutOrNull(BIND_TIMEOUT_MS) {
+                suspendCancellableCoroutine { continuation ->
+                    val componentName = ComponentName(
+                        context.packageName,
+                        DhizukuInstallerServiceImpl::class.java.name,
+                    )
+                    Logger.d(TAG) { "bindService() — component: $componentName" }
+
+                    val args = DhizukuUserServiceArgs(componentName)
+
+                    val connection = object : ServiceConnection {
+                        override fun onServiceConnected(name: ComponentName?, binder: IBinder?) {
+                            Logger.d(TAG) {
+                                "onServiceConnected() — name=$name, binderAlive=${binder?.pingBinder()}"
+                            }
+                            val service = IDhizukuInstallerService.Stub.asInterface(binder)
+                            installerService = service
+                            Logger.d(TAG) { "Dhizuku installer service connected and cached" }
+                            if (continuation.isActive) {
+                                continuation.resume(service)
+                            }
+                        }
+
+                        override fun onServiceDisconnected(name: ComponentName?) {
+                            installerService = null
+                            Logger.d(TAG) { "Dhizuku installer service disconnected: $name" }
+                        }
+                    }
+
+                    serviceConnection = connection
+
+                    Logger.d(TAG) { "Calling Dhizuku.bindUserService()..." }
+                    val bound = Dhizuku.bindUserService(args, connection)
+                    Logger.d(TAG) { "Dhizuku.bindUserService() returned: $bound" }
+                    if (!bound && continuation.isActive) {
+                        continuation.resume(null)
+                    }
+
+                    continuation.invokeOnCancellation {
+                        Logger.d(TAG) { "bindService() coroutine cancelled, unbinding..." }
+                        try {
+                            Dhizuku.unbindUserService(connection)
+                        } catch (_: Exception) {
+                        }
+                    }
+                }
+            }.also { service ->
+                if (service == null) {
+                    Logger.w(TAG) { "bindService() timed out or failed after ${BIND_TIMEOUT_MS}ms" }
+                }
+            }
+        } catch (e: Exception) {
+            Logger.e(TAG) { "Failed to bind Dhizuku service: ${e.javaClass.simpleName}: ${e.message}" }
+            Logger.e(TAG) { e.stackTraceToString() }
+            null
+        }
+    }
+
+    companion object {
+        private const val TAG = "DhizukuServiceManager"
+        private const val DHIZUKU_PACKAGE = "com.rosan.dhizuku"
+        private const val BIND_TIMEOUT_MS = 15_000L
+    }
+}
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/model/DhizukuStatus.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/model/DhizukuStatus.kt
new file mode 100644
index 000000000..57afbf40f
--- /dev/null
+++ b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/dhizuku/model/DhizukuStatus.kt
@@ -0,0 +1,8 @@
+package zed.rainxch.core.data.services.dhizuku.model
+
+enum class DhizukuStatus {
+    NOT_INSTALLED,
+    NOT_RUNNING,
+    PERMISSION_NEEDED,
+    READY,
+}
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/shizuku/AndroidInstallerStatusProvider.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/installer/AndroidInstallerStatusProvider.kt
similarity index 53%
rename from core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/shizuku/AndroidInstallerStatusProvider.kt
rename to core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/installer/AndroidInstallerStatusProvider.kt
index 6409ccb71..6eb2e36af 100644
--- a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/shizuku/AndroidInstallerStatusProvider.kt
+++ b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/installer/AndroidInstallerStatusProvider.kt
@@ -1,20 +1,21 @@
-package zed.rainxch.core.data.services.shizuku
+package zed.rainxch.core.data.services.installer
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
+import zed.rainxch.core.data.services.dhizuku.DhizukuServiceManager
+import zed.rainxch.core.data.services.dhizuku.model.DhizukuStatus
+import zed.rainxch.core.data.services.shizuku.ShizukuServiceManager
 import zed.rainxch.core.data.services.shizuku.model.ShizukuStatus
+import zed.rainxch.core.domain.model.DhizukuAvailability
 import zed.rainxch.core.domain.model.ShizukuAvailability
 import zed.rainxch.core.domain.system.InstallerStatusProvider
 
-/**
- * Android implementation of [InstallerStatusProvider].
- * Maps [ShizukuServiceManager.status] to the platform-agnostic [ShizukuAvailability] enum.
- */
 class AndroidInstallerStatusProvider(
     private val shizukuServiceManager: ShizukuServiceManager,
+    private val dhizukuServiceManager: DhizukuServiceManager,
     scope: CoroutineScope,
 ) : InstallerStatusProvider {
     override val shizukuAvailability: StateFlow<ShizukuAvailability> =
@@ -32,7 +33,26 @@ class AndroidInstallerStatusProvider(
                 initialValue = ShizukuAvailability.UNAVAILABLE,
             )
 
+    override val dhizukuAvailability: StateFlow<DhizukuAvailability> =
+        dhizukuServiceManager.status
+            .map { status ->
+                when (status) {
+                    DhizukuStatus.NOT_INSTALLED -> DhizukuAvailability.UNAVAILABLE
+                    DhizukuStatus.NOT_RUNNING -> DhizukuAvailability.NOT_RUNNING
+                    DhizukuStatus.PERMISSION_NEEDED -> DhizukuAvailability.PERMISSION_NEEDED
+                    DhizukuStatus.READY -> DhizukuAvailability.READY
+                }
+            }.stateIn(
+                scope = scope,
+                started = SharingStarted.Eagerly,
+                initialValue = DhizukuAvailability.UNAVAILABLE,
+            )
+
     override fun requestShizukuPermission() {
         shizukuServiceManager.requestPermission()
     }
+
+    override fun requestDhizukuPermission() {
+        dhizukuServiceManager.requestPermission()
+    }
 }
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/installer/SilentInstallerDispatcher.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/installer/SilentInstallerDispatcher.kt
new file mode 100644
index 000000000..0c7fe67b3
--- /dev/null
+++ b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/installer/SilentInstallerDispatcher.kt
@@ -0,0 +1,208 @@
+package zed.rainxch.core.data.services.installer
+
+import android.content.Context
+import android.os.ParcelFileDescriptor
+import co.touchlab.kermit.Logger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import zed.rainxch.core.data.services.dhizuku.DhizukuServiceManager
+import zed.rainxch.core.data.services.dhizuku.model.DhizukuStatus
+import zed.rainxch.core.data.services.shizuku.ShizukuServiceManager
+import zed.rainxch.core.data.services.shizuku.model.ShizukuStatus
+import zed.rainxch.core.domain.model.GithubAsset
+import zed.rainxch.core.domain.model.InstallerType
+import zed.rainxch.core.domain.model.SystemArchitecture
+import zed.rainxch.core.domain.repository.TweaksRepository
+import zed.rainxch.core.domain.system.InstallOutcome
+import zed.rainxch.core.domain.system.Installer
+import zed.rainxch.core.domain.system.InstallerInfoExtractor
+import java.io.File
+
+class SilentInstallerDispatcher(
+    private val androidContext: Context,
+    private val androidInstaller: Installer,
+    private val shizukuServiceManager: ShizukuServiceManager,
+    private val dhizukuServiceManager: DhizukuServiceManager,
+    private val tweaksRepository: TweaksRepository,
+    private val scope: CoroutineScope,
+) : Installer {
+    companion object {
+        private const val TAG = "SilentInstaller"
+    }
+
+    @Volatile
+    private var cachedInstallerType: InstallerType = InstallerType.DEFAULT
+
+    fun observeInstallerPreference() {
+        scope.launch {
+            tweaksRepository.getInstallerType().collect { type ->
+                cachedInstallerType = type
+                Logger.d(TAG) { "Installer type changed to: $type" }
+            }
+        }
+    }
+
+    override suspend fun isSupported(extOrMime: String): Boolean = androidInstaller.isSupported(extOrMime)
+
+    override fun isAssetInstallable(assetName: String): Boolean = androidInstaller.isAssetInstallable(assetName)
+
+    override fun choosePrimaryAsset(assets: List<GithubAsset>): GithubAsset? = androidInstaller.choosePrimaryAsset(assets)
+
+    override fun detectSystemArchitecture(): SystemArchitecture = androidInstaller.detectSystemArchitecture()
+
+    override fun isObtainiumInstalled(): Boolean = androidInstaller.isObtainiumInstalled()
+
+    override fun openInObtainium(
+        repoOwner: String,
+        repoName: String,
+        onOpenInstaller: () -> Unit,
+    ) = androidInstaller.openInObtainium(repoOwner, repoName, onOpenInstaller)
+
+    override fun isAppManagerInstalled(): Boolean = androidInstaller.isAppManagerInstalled()
+
+    override fun openInAppManager(
+        filePath: String,
+        onOpenInstaller: () -> Unit,
+    ) = androidInstaller.openInAppManager(filePath, onOpenInstaller)
+
+    override fun getApkInfoExtractor(): InstallerInfoExtractor = androidInstaller.getApkInfoExtractor()
+
+    override fun openApp(packageName: String): Boolean = androidInstaller.openApp(packageName)
+
+    override fun openWithExternalInstaller(filePath: String) = androidInstaller.openWithExternalInstaller(filePath)
+
+    override suspend fun ensurePermissionsOrThrow(extOrMime: String) {
+        Logger.d(TAG) {
+            "ensurePermissionsOrThrow() — extOrMime=$extOrMime, cachedType=$cachedInstallerType"
+        }
+        if (resolveActiveBackend() != Backend.DEFAULT) {
+            Logger.d(TAG) { "Silent backend active — skipping unknown sources permission check" }
+            return
+        }
+        androidInstaller.ensurePermissionsOrThrow(extOrMime)
+    }
+
+    override suspend fun install(
+        filePath: String,
+        extOrMime: String,
+    ): InstallOutcome {
+        Logger.d(TAG) { "install() called — filePath=$filePath, extOrMime=$extOrMime, cached=$cachedInstallerType" }
+
+        val backend = resolveActiveBackend()
+        if (backend != Backend.DEFAULT) {
+            val outcome = trySilentInstall(filePath, backend)
+            if (outcome != null) return outcome
+        }
+
+        Logger.d(TAG) { "Falling back to standard AndroidInstaller for: $filePath" }
+        androidInstaller.ensurePermissionsOrThrow(extOrMime)
+        return androidInstaller.install(filePath, extOrMime)
+    }
+
+    override fun uninstall(packageName: String) {
+        Logger.d(TAG) { "uninstall() called — packageName=$packageName, cached=$cachedInstallerType" }
+
+        when (val backend = resolveActiveBackend()) {
+            Backend.SHIZUKU, Backend.DHIZUKU -> {
+                scope.launch(Dispatchers.IO) {
+                    silentUninstall(packageName, backend)
+                }
+            }
+            Backend.DEFAULT -> {
+                androidInstaller.uninstall(packageName)
+            }
+        }
+    }
+
+    private suspend fun trySilentInstall(filePath: String, backend: Backend): InstallOutcome? {
+        Logger.d(TAG) { "Routing install through $backend" }
+        return try {
+            val result = withContext(Dispatchers.IO) {
+                val file = File(filePath)
+                val (expectedPkg, expectedVc) = readApkIdentity(filePath)
+                ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY).use { pfd ->
+                    when (backend) {
+                        Backend.SHIZUKU -> {
+                            val service = shizukuServiceManager.getService() ?: return@use null
+                            service.installPackage(pfd, file.length())
+                        }
+                        Backend.DHIZUKU -> {
+                            val service = dhizukuServiceManager.getService() ?: return@use null
+                            service.installPackage(pfd, file.length(), expectedPkg, expectedVc)
+                        }
+                        Backend.DEFAULT -> null
+                    }
+                }
+            }
+            when {
+                result == null -> {
+                    Logger.w(TAG) { "$backend service is null, will fall back" }
+                    null
+                }
+                result == 0 -> InstallOutcome.COMPLETED
+                else -> {
+                    Logger.w(TAG) { "$backend install returned $result, will fall back" }
+                    null
+                }
+            }
+        } catch (e: Exception) {
+            Logger.e(TAG) { "$backend install exception, falling back: ${e.javaClass.simpleName}: ${e.message}" }
+            null
+        }
+    }
+
+    private fun readApkIdentity(filePath: String): Pair<String?, Long> {
+        val info = try {
+            androidContext.packageManager.getPackageArchiveInfo(filePath, 0)
+        } catch (e: Exception) {
+            Logger.w(TAG) { "getPackageArchiveInfo($filePath) failed: ${e.message}" }
+            null
+        } ?: return null to -1L
+        val versionCode = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.P) {
+            info.longVersionCode
+        } else {
+            @Suppress("DEPRECATION")
+            info.versionCode.toLong()
+        }
+        return info.packageName to versionCode
+    }
+
+    private suspend fun silentUninstall(packageName: String, backend: Backend) {
+        try {
+            val result = when (backend) {
+                Backend.SHIZUKU -> {
+                    val service = shizukuServiceManager.getService()
+                    service?.uninstallPackage(packageName)
+                }
+                Backend.DHIZUKU -> {
+                    val service = dhizukuServiceManager.getService()
+                    service?.uninstallPackage(packageName)
+                }
+                Backend.DEFAULT -> null
+            }
+            if (result == null || result != 0) {
+                Logger.w(TAG) { "$backend uninstall failed (result=$result), falling back" }
+                androidInstaller.uninstall(packageName)
+            }
+        } catch (e: Exception) {
+            Logger.e(TAG) { "$backend uninstall exception, falling back: ${e.message}" }
+            androidInstaller.uninstall(packageName)
+        }
+    }
+
+    private fun resolveActiveBackend(): Backend = when (cachedInstallerType) {
+        InstallerType.SHIZUKU -> {
+            shizukuServiceManager.refreshStatus()
+            if (shizukuServiceManager.status.value == ShizukuStatus.READY) Backend.SHIZUKU else Backend.DEFAULT
+        }
+        InstallerType.DHIZUKU -> {
+            dhizukuServiceManager.refreshStatus()
+            if (dhizukuServiceManager.status.value == DhizukuStatus.READY) Backend.DHIZUKU else Backend.DEFAULT
+        }
+        InstallerType.DEFAULT -> Backend.DEFAULT
+    }
+
+    private enum class Backend { DEFAULT, SHIZUKU, DHIZUKU }
+}
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/shizuku/ShizukuInstallerWrapper.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/shizuku/ShizukuInstallerWrapper.kt
deleted file mode 100644
index b85075227..000000000
--- a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/shizuku/ShizukuInstallerWrapper.kt
+++ /dev/null
@@ -1,206 +0,0 @@
-package zed.rainxch.core.data.services.shizuku
-
-import co.touchlab.kermit.Logger
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.withContext
-import zed.rainxch.core.data.services.shizuku.model.ShizukuStatus
-import zed.rainxch.core.domain.model.GithubAsset
-import zed.rainxch.core.domain.model.InstallerType
-import zed.rainxch.core.domain.model.SystemArchitecture
-import zed.rainxch.core.domain.repository.TweaksRepository
-import zed.rainxch.core.domain.system.InstallOutcome
-import zed.rainxch.core.domain.system.Installer
-import zed.rainxch.core.domain.system.InstallerInfoExtractor
-
-/**
- * Wrapper around [Installer] that transparently intercepts `install()` and `uninstall()`
- * calls to use Shizuku when available and enabled by the user.
- *
- * All other methods (asset selection, architecture detection, Obtainium/AppManager support)
- * delegate directly to the underlying [androidInstaller] unchanged.
- *
- * Fallback behavior: if Shizuku install/uninstall fails for any reason, falls back
- * to the standard [androidInstaller] implementation silently.
- */
-class ShizukuInstallerWrapper(
-    private val androidInstaller: Installer,
-    private val shizukuServiceManager: ShizukuServiceManager,
-    private val tweaksRepository: TweaksRepository,
-) : Installer {
-    companion object {
-        private const val TAG = "ShizukuInstaller"
-    }
-
-    /**
-     * Cached installer type preference, updated by flow collection.
-     * Defaults to DEFAULT so Shizuku is never used unless explicitly opted in.
-     */
-    @Volatile
-    private var cachedInstallerType: InstallerType = InstallerType.DEFAULT
-
-    /**
-     * Start observing the installer type preference from DataStore.
-     * Call once after construction (from DI setup).
-     */
-    fun observeInstallerPreference(scope: CoroutineScope) {
-        scope.launch {
-            tweaksRepository.getInstallerType().collect { type ->
-                cachedInstallerType = type
-                Logger.d(TAG) { "Installer type changed to: $type" }
-            }
-        }
-    }
-
-    override suspend fun isSupported(extOrMime: String): Boolean = androidInstaller.isSupported(extOrMime)
-
-    override fun isAssetInstallable(assetName: String): Boolean = androidInstaller.isAssetInstallable(assetName)
-
-    override fun choosePrimaryAsset(assets: List<GithubAsset>): GithubAsset? = androidInstaller.choosePrimaryAsset(assets)
-
-    override fun detectSystemArchitecture(): SystemArchitecture = androidInstaller.detectSystemArchitecture()
-
-    override fun isObtainiumInstalled(): Boolean = androidInstaller.isObtainiumInstalled()
-
-    override fun openInObtainium(
-        repoOwner: String,
-        repoName: String,
-        onOpenInstaller: () -> Unit,
-    ) = androidInstaller.openInObtainium(repoOwner, repoName, onOpenInstaller)
-
-    override fun isAppManagerInstalled(): Boolean = androidInstaller.isAppManagerInstalled()
-
-    override fun openInAppManager(
-        filePath: String,
-        onOpenInstaller: () -> Unit,
-    ) = androidInstaller.openInAppManager(filePath, onOpenInstaller)
-
-    override fun getApkInfoExtractor(): InstallerInfoExtractor = androidInstaller.getApkInfoExtractor()
-
-    override fun openApp(packageName: String): Boolean = androidInstaller.openApp(packageName)
-
-    override fun openWithExternalInstaller(filePath: String) = androidInstaller.openWithExternalInstaller(filePath)
-
-    override suspend fun ensurePermissionsOrThrow(extOrMime: String) {
-        Logger.d(TAG) {
-            "ensurePermissionsOrThrow() — extOrMime=$extOrMime, cachedType=$cachedInstallerType, status=${shizukuServiceManager.status.value}"
-        }
-        if (shouldUseShizuku()) {
-            Logger.d(TAG) { "Shizuku active — skipping unknown sources permission check" }
-            return
-        }
-        Logger.d(TAG) { "Delegating ensurePermissionsOrThrow to AndroidInstaller" }
-        androidInstaller.ensurePermissionsOrThrow(extOrMime)
-    }
-
-    override suspend fun install(
-        filePath: String,
-        extOrMime: String,
-    ): InstallOutcome {
-        Logger.d(TAG) { "install() called — filePath=$filePath, extOrMime=$extOrMime" }
-        Logger.d(TAG) { "cachedInstallerType=$cachedInstallerType, shizukuStatus=${shizukuServiceManager.status.value}" }
-
-        if (shouldUseShizuku()) {
-            Logger.d(TAG) { "Shizuku is enabled and READY — attempting Shizuku install" }
-            try {
-                val service = shizukuServiceManager.getService()
-                if (service != null) {
-                    val result =
-                        withContext(Dispatchers.IO) {
-                            val file = java.io.File(filePath)
-                            val pfd =
-                                android.os.ParcelFileDescriptor.open(
-                                    file,
-                                    android.os.ParcelFileDescriptor.MODE_READ_ONLY,
-                                )
-                            pfd.use {
-                                Logger.d(TAG) { "Got Shizuku service, calling installPackage($filePath, size=${file.length()})..." }
-                                service.installPackage(it, file.length())
-                            }
-                        }
-                    Logger.d(TAG) { "Shizuku installPackage() returned: $result" }
-                    if (result == 0) {
-                        Logger.d(TAG) { "Shizuku install SUCCEEDED for: $filePath" }
-                        return InstallOutcome.COMPLETED
-                    }
-                    Logger.w(TAG) { "Shizuku install FAILED with code: $result, falling back to standard installer" }
-                } else {
-                    Logger.w(TAG) { "Shizuku service is NULL, falling back to standard installer" }
-                }
-            } catch (e: Exception) {
-                Logger.e(TAG) { "Shizuku install exception, falling back: ${e.javaClass.simpleName}: ${e.message}" }
-            }
-        } else {
-            Logger.d(TAG) { "Not using Shizuku (enabled=${isShizukuEnabled()}, status=${shizukuServiceManager.status.value})" }
-        }
-
-        Logger.d(TAG) { "Using standard AndroidInstaller for: $filePath" }
-        androidInstaller.ensurePermissionsOrThrow(extOrMime)
-        return androidInstaller.install(filePath, extOrMime)
-    }
-
-    override fun uninstall(packageName: String) {
-        Logger.d(TAG) { "uninstall() called — packageName=$packageName" }
-        Logger.d(TAG) { "cachedInstallerType=$cachedInstallerType, shizukuStatus=${shizukuServiceManager.status.value}" }
-
-        if (isShizukuEnabled() && shizukuServiceManager.status.value == ShizukuStatus.READY) {
-            Logger.d(TAG) { "Attempting Shizuku uninstall..." }
-            Thread {
-                try {
-                    val service = runBlocking { shizukuServiceManager.getService() }
-                    if (service != null) {
-                        Logger.d(TAG) { "Got service, calling uninstallPackage($packageName)..." }
-                        val result = service.uninstallPackage(packageName)
-                        Logger.d(TAG) { "Shizuku uninstallPackage() returned: $result" }
-                        if (result == 0) {
-                            Logger.d(TAG) { "Shizuku uninstall SUCCEEDED for: $packageName" }
-                        } else {
-                            Logger.w(TAG) { "Shizuku uninstall FAILED with code: $result, falling back" }
-                            androidInstaller.uninstall(packageName)
-                        }
-                    } else {
-                        Logger.w(TAG) { "Shizuku service is NULL, falling back" }
-                        androidInstaller.uninstall(packageName)
-                    }
-                } catch (e: Exception) {
-                    Logger.e(TAG) { "Shizuku uninstall exception, falling back: ${e.message}" }
-                    androidInstaller.uninstall(packageName)
-                }
-            }.start()
-            return
-        }
-
-        Logger.d(TAG) { "Using standard AndroidInstaller uninstall for: $packageName" }
-        androidInstaller.uninstall(packageName)
-    }
-
-    /**
-     * Whether this install attempt should be routed through Shizuku.
-     *
-     * Refreshes status first so we don't act on a stale cache. The
-     * status flow is only updated reactively by Shizuku's
-     * binder-received / binder-dead / permission-result listeners,
-     * plus a one-shot `initialize()` at DI time. If the app has been
-     * backgrounded long enough for the binder to die and revive
-     * without our listener catching the transition (e.g. days between
-     * the user opening the app), the cached value lags reality and
-     * we'd wrongly fall through to the unknown-sources prompt — the
-     * concrete symptom in issue #419. [AutoUpdateWorker] already does
-     * this before its own gate; this mirrors that pattern for every
-     * install path.
-     *
-     * Both gates are required: the user's explicit
-     * [InstallerType.SHIZUKU] preference AND a live/granted Shizuku.
-     * We deliberately don't override the preference — DEFAULT means
-     * "use the system installer," even when Shizuku happens to be
-     * granted for another purpose.
-     */
-    private fun shouldUseShizuku(): Boolean {
-        shizukuServiceManager.refreshStatus()
-        return isShizukuEnabled() && shizukuServiceManager.status.value == ShizukuStatus.READY
-    }
-
-    private fun isShizukuEnabled(): Boolean = cachedInstallerType == InstallerType.SHIZUKU
-}
diff --git a/core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services/DesktopInstallerStatusProvider.kt b/core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services/DesktopInstallerStatusProvider.kt
index f86fce940..b2dfb43fd 100644
--- a/core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services/DesktopInstallerStatusProvider.kt
+++ b/core/data/src/jvmMain/kotlin/zed/rainxch/core/data/services/DesktopInstallerStatusProvider.kt
@@ -3,18 +3,17 @@ package zed.rainxch.core.data.services
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
+import zed.rainxch.core.domain.model.DhizukuAvailability
 import zed.rainxch.core.domain.model.ShizukuAvailability
 import zed.rainxch.core.domain.system.InstallerStatusProvider
 
-/**
- * Desktop (JVM) no-op implementation of [InstallerStatusProvider].
- * Shizuku is Android-only, so this always reports UNAVAILABLE.
- */
 class DesktopInstallerStatusProvider : InstallerStatusProvider {
     override val shizukuAvailability: StateFlow<ShizukuAvailability> =
         MutableStateFlow(ShizukuAvailability.UNAVAILABLE).asStateFlow()
 
-    override fun requestShizukuPermission() {
-        // No-op on desktop
-    }
+    override val dhizukuAvailability: StateFlow<DhizukuAvailability> =
+        MutableStateFlow(DhizukuAvailability.UNAVAILABLE).asStateFlow()
+
+    override fun requestShizukuPermission() = Unit
+    override fun requestDhizukuPermission() = Unit
 }
diff --git a/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/DhizukuAvailability.kt b/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/DhizukuAvailability.kt
new file mode 100644
index 000000000..dbaa9bcc9
--- /dev/null
+++ b/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/DhizukuAvailability.kt
@@ -0,0 +1,8 @@
+package zed.rainxch.core.domain.model
+
+enum class DhizukuAvailability {
+    UNAVAILABLE,
+    NOT_RUNNING,
+    PERMISSION_NEEDED,
+    READY
+}
diff --git a/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/InstallerType.kt b/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/InstallerType.kt
index b37b3e20f..3b3be4bd3 100644
--- a/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/InstallerType.kt
+++ b/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/model/InstallerType.kt
@@ -2,7 +2,8 @@ package zed.rainxch.core.domain.model
 
 enum class InstallerType {
     DEFAULT,
-    SHIZUKU;
+    SHIZUKU,
+    DHIZUKU;
 
     companion object {
         fun fromName(name: String?): InstallerType =
diff --git a/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/system/InstallerStatusProvider.kt b/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/system/InstallerStatusProvider.kt
index c078b52d3..08c76f542 100644
--- a/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/system/InstallerStatusProvider.kt
+++ b/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/system/InstallerStatusProvider.kt
@@ -1,9 +1,13 @@
 package zed.rainxch.core.domain.system
 
 import kotlinx.coroutines.flow.StateFlow
+import zed.rainxch.core.domain.model.DhizukuAvailability
 import zed.rainxch.core.domain.model.ShizukuAvailability
 
 interface InstallerStatusProvider {
     val shizukuAvailability: StateFlow<ShizukuAvailability>
+    val dhizukuAvailability: StateFlow<DhizukuAvailability>
+
     fun requestShizukuPermission()
+    fun requestDhizukuPermission()
 }
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/16.json
index f6d86a389..6cab2c968 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/16.json
@@ -10,7 +10,8 @@
         "APK Inspect — peek inside any release before installing.",
         "Apps screen now groups updates, pending installs, and installed apps.",
         "What's new sheet — see what changed after every update.",
-        "Announcements feed — privacy notices, surveys, and security advisories in Profile."
+        "Announcements feed — privacy notices, surveys, and security advisories in Profile.",
+        "Dhizuku silent install — bypass OEM install prompts on Xiaomi, OPPO, vivo, Huawei devices via Device Owner."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/ar/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/ar/16.json
index 0ad02b13e..c70dccd2c 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/ar/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/ar/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: ألقِ نظرة داخل أي إصدار قبل تثبيته.",
         "شاشة التطبيقات تُجمّع الآن التحديثات والتثبيتات المعلّقة والتطبيقات المثبّتة في أقسام منفصلة.",
         "نافذة «الجديد»: شاهد ما الذي تغيّر بعد كل تحديث.",
-        "بثّ الإعلانات: إشعارات الخصوصية والاستبيانات والتنبيهات الأمنية داخل «الملف الشخصي»."
+        "بثّ الإعلانات: إشعارات الخصوصية والاستبيانات والتنبيهات الأمنية داخل «الملف الشخصي».",
+        "تثبيت صامت عبر Dhizuku: تجاوز نوافذ التثبيت في أجهزة Xiaomi و OPPO و vivo و Huawei عبر صلاحية «مالك الجهاز»."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/bn/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/bn/16.json
index 0e73e6882..9b3b2318f 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/bn/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/bn/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: ইনস্টল করার আগেই যেকোনো রিলিজের ভেতরে চোখ বুলিয়ে নিন।",
         "Apps স্ক্রিন এখন আপডেট, পেন্ডিং ইনস্টল আর ইনস্টল হওয়া অ্যাপগুলো আলাদা সেকশনে দেখায়।",
         "'নতুন কী' শিট: প্রতিটি আপডেটের পরে কী বদলেছে এক নজরে দেখুন।",
-        "ঘোষণা ফিড: গোপনীয়তা নোটিশ, জরিপ আর নিরাপত্তা সতর্কতা প্রোফাইলে এক জায়গায়।"
+        "ঘোষণা ফিড: গোপনীয়তা নোটিশ, জরিপ আর নিরাপত্তা সতর্কতা প্রোফাইলে এক জায়গায়।",
+        "Dhizuku সাইলেন্ট ইনস্টল — Device Owner-এর মাধ্যমে Xiaomi, OPPO, vivo, Huawei ডিভাইসে OEM ইনস্টল প্রম্পট এড়িয়ে যান।"
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/es/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/es/16.json
index 3c2a16ed2..50cc99470 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/es/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/es/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: examina el contenido de cualquier release antes de instalarlo.",
         "La pantalla de Apps ahora agrupa actualizaciones, instalaciones pendientes y apps instaladas.",
         "Hoja de novedades: descubre qué cambió tras cada actualización.",
-        "Canal de anuncios: avisos de privacidad, encuestas y alertas de seguridad en Perfil."
+        "Canal de anuncios: avisos de privacidad, encuestas y alertas de seguridad en Perfil.",
+        "Instalación silenciosa con Dhizuku: omite los diálogos de instalación de OEM en Xiaomi, OPPO, vivo y Huawei mediante el propietario del dispositivo."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/fr/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/fr/16.json
index 3d034a9bc..998fd9344 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/fr/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/fr/16.json
@@ -10,7 +10,8 @@
         "APK Inspect : examinez le contenu d’une release avant de l’installer.",
         "L’écran Apps regroupe désormais les mises à jour, installations en attente et apps installées.",
         "Fiche des nouveautés : voyez ce qui a changé après chaque mise à jour.",
-        "Fil d’annonces : avis de confidentialité, sondages et alertes de sécurité dans Profil."
+        "Fil d’annonces : avis de confidentialité, sondages et alertes de sécurité dans Profil.",
+        "Installation silencieuse via Dhizuku : contournez les fenêtres d’installation des OEM (Xiaomi, OPPO, vivo, Huawei) grâce au statut Propriétaire de l’appareil."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/hi/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/hi/16.json
index a6f20d5b9..019c657c7 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/hi/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/hi/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: इंस्टॉल करने से पहले किसी भी रिलीज़ के अंदर झाँकें।",
         "Apps स्क्रीन अब अपडेट, पेंडिंग इंस्टॉल और इंस्टॉल हो चुके ऐप्स को अलग-अलग सेक्शन में दिखाती है।",
         "'क्या नया है' शीट: हर अपडेट के बाद देखें कि क्या बदला।",
-        "घोषणा फ़ीड: गोपनीयता सूचनाएँ, सर्वे और सुरक्षा अलर्ट प्रोफ़ाइल में मिलेंगे।"
+        "घोषणा फ़ीड: गोपनीयता सूचनाएँ, सर्वे और सुरक्षा अलर्ट प्रोफ़ाइल में मिलेंगे।",
+        "Dhizuku साइलेंट इंस्टॉल — Device Owner के ज़रिए Xiaomi, OPPO, vivo, Huawei डिवाइसों पर OEM इंस्टॉल प्रॉम्प्ट बायपास करें।"
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/it/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/it/16.json
index 2c9bf694d..f8ed1b528 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/it/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/it/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: esamina il contenuto di una release prima di installarla.",
         "La schermata App ora raggruppa aggiornamenti, installazioni in attesa e app installate.",
         "Pannello Novità: scopri cosa è cambiato dopo ogni aggiornamento.",
-        "Feed annunci: avvisi sulla privacy, sondaggi e segnalazioni di sicurezza nel Profilo."
+        "Feed annunci: avvisi sulla privacy, sondaggi e segnalazioni di sicurezza nel Profilo.",
+        "Installazione silenziosa con Dhizuku: bypassa i prompt di installazione OEM su Xiaomi, OPPO, vivo e Huawei tramite il proprietario del dispositivo."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/ja/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/ja/16.json
index 4a95f1c84..f926b50ee 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/ja/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/ja/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: インストール前にリリースの中身を確認できます。",
         "アプリ画面で更新・保留中のインストール・インストール済みをセクション分け表示。",
         "「新着情報」シート: アップデート後に何が変わったかをすぐ確認できます。",
-        "お知らせフィード: プライバシー通知・アンケート・セキュリティ告知をプロフィール内で配信します。"
+        "お知らせフィード: プライバシー通知・アンケート・セキュリティ告知をプロフィール内で配信します。",
+        "Dhizuku によるサイレントインストール — Device Owner 経由で Xiaomi、OPPO、vivo、Huawei 端末の OEM インストール確認をスキップ。"
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/ko/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/ko/16.json
index ac0898c57..c409d1211 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/ko/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/ko/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: 설치 전에 릴리스 내부를 미리 확인할 수 있습니다.",
         "앱 화면이 업데이트, 대기 중인 설치, 설치된 앱을 섹션별로 그룹화합니다.",
         "‘새로운 소식’ 시트: 업데이트 후 무엇이 바뀌었는지 바로 확인할 수 있습니다.",
-        "공지 피드: 개인정보 안내, 설문, 보안 권고를 프로필에서 받아볼 수 있습니다."
+        "공지 피드: 개인정보 안내, 설문, 보안 권고를 프로필에서 받아볼 수 있습니다.",
+        "Dhizuku 무음 설치 — 기기 소유자(Device Owner) 권한으로 Xiaomi, OPPO, vivo, Huawei 기기에서 OEM 설치 확인 창을 건너뜁니다."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/pl/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/pl/16.json
index 3be35aece..bae7e1e64 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/pl/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/pl/16.json
@@ -10,7 +10,8 @@
         "APK Inspect — zajrzyj do środka dowolnego wydania przed instalacją.",
         "Ekran aplikacji grupuje teraz aktualizacje, instalacje oczekujące i aplikacje zainstalowane.",
         "Panel „Co nowego” — od razu wiadomo, co się zmieniło po każdej aktualizacji.",
-        "Kanał ogłoszeń — informacje o prywatności, ankiety i alerty bezpieczeństwa w Profilu."
+        "Kanał ogłoszeń — informacje o prywatności, ankiety i alerty bezpieczeństwa w Profilu.",
+        "Cicha instalacja przez Dhizuku — pomijaj okna instalacji OEM na urządzeniach Xiaomi, OPPO, vivo i Huawei dzięki uprawnieniom właściciela urządzenia."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/ru/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/ru/16.json
index 80b8b50d5..a0ec839bb 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/ru/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/ru/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: загляните внутрь любого релиза до установки.",
         "Экран приложений теперь группирует обновления, ожидающие установки и установленные приложения.",
         "Окно «Что нового»: после каждого обновления видно, что именно изменилось.",
-        "Лента объявлений: уведомления о приватности, опросы и предупреждения безопасности в Профиле."
+        "Лента объявлений: уведомления о приватности, опросы и предупреждения безопасности в Профиле.",
+        "Тихая установка через Dhizuku — обход системных диалогов установки на устройствах Xiaomi, OPPO, vivo и Huawei через статус владельца устройства."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/tr/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/tr/16.json
index e0032ee93..8da1f775d 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/tr/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/tr/16.json
@@ -10,7 +10,8 @@
         "APK Inspect: kurmadan önce herhangi bir sürümün içine göz at.",
         "Uygulamalar ekranı artık güncellemeleri, bekleyen kurulumları ve kurulu uygulamaları gruplandırıyor.",
         "“Yenilikler” paneli: her güncellemenin ardından nelerin değiştiğini hemen görün.",
-        "Duyurular akışı: gizlilik bildirimleri, anketler ve güvenlik uyarıları Profil’de tek yerde."
+        "Duyurular akışı: gizlilik bildirimleri, anketler ve güvenlik uyarıları Profil’de tek yerde.",
+        "Dhizuku ile sessiz kurulum — Xiaomi, OPPO, vivo, Huawei cihazlarında OEM kurulum istemlerini Cihaz Sahibi yetkisiyle atlayın."
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/files/whatsnew/zh-CN/16.json b/core/presentation/src/commonMain/composeResources/files/whatsnew/zh-CN/16.json
index 95693cbd2..971db6f40 100644
--- a/core/presentation/src/commonMain/composeResources/files/whatsnew/zh-CN/16.json
+++ b/core/presentation/src/commonMain/composeResources/files/whatsnew/zh-CN/16.json
@@ -10,7 +10,8 @@
         "APK Inspect:安装前先看清 APK 内部信息。",
         "应用页面将更新、待安装和已安装的应用分组展示。",
         "「新功能」面板:每次更新后,一眼看到改了什么。",
-        "公告中心:隐私通告、问卷调研和安全提示统一在「我的」中查看。"
+        "公告中心:隐私通告、问卷调研和安全提示统一在「我的」中查看。",
+        "Dhizuku 静默安装:通过设备所有者权限绕过小米、OPPO、vivo、华为等机型的安装确认弹窗。"
       ]
     },
     {
diff --git a/core/presentation/src/commonMain/composeResources/values/strings.xml b/core/presentation/src/commonMain/composeResources/values/strings.xml
index a190c8c6b..db6371ade 100644
--- a/core/presentation/src/commonMain/composeResources/values/strings.xml
+++ b/core/presentation/src/commonMain/composeResources/values/strings.xml
@@ -619,8 +619,17 @@
     <string name="shizuku_install_hint">Install Shizuku to enable silent installs</string>
     <string name="shizuku_start_hint">Start Shizuku to enable silent installs</string>
     <string name="shizuku_install_failed_fallback">Shizuku install failed, using standard installer</string>
+    <string name="installer_type_dhizuku">Dhizuku</string>
+    <string name="installer_type_dhizuku_description">Silent install via Device Owner — bypasses OEM install prompts</string>
+    <string name="dhizuku_status_not_installed">Dhizuku is not installed</string>
+    <string name="dhizuku_status_not_running">Dhizuku is not active</string>
+    <string name="dhizuku_status_permission_needed">Permission required</string>
+    <string name="dhizuku_status_ready">Ready</string>
+    <string name="dhizuku_grant_permission">Grant Permission</string>
+    <string name="dhizuku_install_hint">Install Dhizuku and activate it as Device Owner to enable silent installs</string>
+    <string name="dhizuku_start_hint">Activate Dhizuku as Device Owner to enable silent installs</string>
     <string name="auto_update_title">Auto-update apps</string>
-    <string name="auto_update_description">Automatically download and install updates in background via Shizuku</string>
+    <string name="auto_update_description">Automatically download and install updates in background via the selected silent installer</string>
 
     <string name="section_updates">Updates</string>
     <string name="update_check_interval_title">Update check interval</string>
diff --git a/feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsViewModel.kt b/feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsViewModel.kt
index 9cec26e67..53def48fd 100644
--- a/feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsViewModel.kt
+++ b/feature/apps/presentation/src/commonMain/kotlin/zed/rainxch/apps/presentation/AppsViewModel.kt
@@ -1030,6 +1030,7 @@ class AppsViewModel(
                     val policy =
                         when (installerType) {
                             InstallerType.SHIZUKU -> InstallPolicy.AlwaysInstall
+                            InstallerType.DHIZUKU -> InstallPolicy.AlwaysInstall
                             InstallerType.DEFAULT -> InstallPolicy.InstallWhileForeground
                         }
 
diff --git a/feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/DetailsViewModel.kt b/feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/DetailsViewModel.kt
index 478234454..6567f906c 100644
--- a/feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/DetailsViewModel.kt
+++ b/feature/details/presentation/src/commonMain/kotlin/zed/rainxch/details/presentation/DetailsViewModel.kt
@@ -1625,6 +1625,7 @@ class DetailsViewModel(
                         when {
                             platform != Platform.ANDROID -> InstallPolicy.AlwaysInstall
                             installerType == InstallerType.SHIZUKU -> InstallPolicy.AlwaysInstall
+                            installerType == InstallerType.DHIZUKU -> InstallPolicy.AlwaysInstall
                             else -> InstallPolicy.InstallWhileForeground
                         }
 
diff --git a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksAction.kt b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksAction.kt
index 33d1366e5..dacc23abc 100644
--- a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksAction.kt
+++ b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksAction.kt
@@ -77,6 +77,8 @@ sealed interface TweaksAction {
 
     data object OnRequestShizukuPermission : TweaksAction
 
+    data object OnRequestDhizukuPermission : TweaksAction
+
     data class OnAutoUpdateToggled(
         val enabled: Boolean,
     ) : TweaksAction
diff --git a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksState.kt b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksState.kt
index 58171906f..a77d16f5a 100644
--- a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksState.kt
+++ b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksState.kt
@@ -1,6 +1,7 @@
 package zed.rainxch.tweaks.presentation
 
 import zed.rainxch.core.domain.model.AppTheme
+import zed.rainxch.core.domain.model.DhizukuAvailability
 import zed.rainxch.core.domain.model.FontTheme
 import zed.rainxch.core.domain.model.InstallerType
 import zed.rainxch.core.domain.model.ProxyScope
@@ -21,6 +22,7 @@ data class TweaksState(
     val isClearDownloadsDialogVisible: Boolean = false,
     val installerType: InstallerType = InstallerType.DEFAULT,
     val shizukuAvailability: ShizukuAvailability = ShizukuAvailability.UNAVAILABLE,
+    val dhizukuAvailability: DhizukuAvailability = DhizukuAvailability.UNAVAILABLE,
     val autoUpdateEnabled: Boolean = false,
     val updateCheckIntervalHours: Long = 6L,
     val includePreReleases: Boolean = false,
diff --git a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksViewModel.kt b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksViewModel.kt
index 5b9b9a62c..abf3f054d 100644
--- a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksViewModel.kt
+++ b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/TweaksViewModel.kt
@@ -77,6 +77,7 @@ class TweaksViewModel(
                     loadAppLanguage()
 
                     observeShizukuStatus()
+                    observeDhizukuStatus()
 
                     hasLoadedInitialData = true
                 }
@@ -288,6 +289,16 @@ class TweaksViewModel(
         }
     }
 
+    private fun observeDhizukuStatus() {
+        viewModelScope.launch {
+            installerStatusProvider.dhizukuAvailability.collect { availability ->
+                _state.update {
+                    it.copy(dhizukuAvailability = availability)
+                }
+            }
+        }
+    }
+
     private fun loadAutoUpdatePreference() {
         viewModelScope.launch {
             tweaksRepository.getAutoUpdateEnabled().collect { enabled ->
@@ -575,6 +586,10 @@ class TweaksViewModel(
                 installerStatusProvider.requestShizukuPermission()
             }
 
+            TweaksAction.OnRequestDhizukuPermission -> {
+                installerStatusProvider.requestDhizukuPermission()
+            }
+
             is TweaksAction.OnAutoUpdateToggled -> {
                 viewModelScope.launch {
                     tweaksRepository.setAutoUpdateEnabled(action.enabled)
diff --git a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/components/sections/Installation.kt b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/components/sections/Installation.kt
index 66337281c..b1156b15c 100644
--- a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/components/sections/Installation.kt
+++ b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/components/sections/Installation.kt
@@ -22,6 +22,7 @@ import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.InstallMobile
 import androidx.compose.material.icons.outlined.Schedule
+import androidx.compose.material.icons.outlined.Security
 import androidx.compose.material.icons.outlined.Speed
 import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
 import androidx.compose.material3.FilledTonalButton
@@ -44,6 +45,7 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
 import org.jetbrains.compose.resources.stringResource
 import zed.rainxch.core.domain.getPlatform
+import zed.rainxch.core.domain.model.DhizukuAvailability
 import zed.rainxch.core.domain.model.InstallerType
 import zed.rainxch.core.domain.model.Platform
 import zed.rainxch.core.domain.model.ShizukuAvailability
@@ -72,18 +74,27 @@ fun LazyListScope.installationSection(
         InstallerTypeCard(
             selectedType = state.installerType,
             shizukuAvailability = state.shizukuAvailability,
+            dhizukuAvailability = state.dhizukuAvailability,
             onTypeSelected = { type ->
                 onAction(TweaksAction.OnInstallerTypeSelected(type))
             },
-            onRequestPermission = {
+            onRequestShizukuPermission = {
                 onAction(TweaksAction.OnRequestShizukuPermission)
+            },
+            onRequestDhizukuPermission = {
+                onAction(TweaksAction.OnRequestDhizukuPermission)
             }
         )
 
-        // Auto-update toggle — only shown when Shizuku is selected and ready
-        if (state.installerType == InstallerType.SHIZUKU &&
-            state.shizukuAvailability == ShizukuAvailability.READY
-        ) {
+        // Auto-update toggle — shown when a silent installer is selected and ready
+        val silentReady = (
+            state.installerType == InstallerType.SHIZUKU &&
+                state.shizukuAvailability == ShizukuAvailability.READY
+            ) || (
+            state.installerType == InstallerType.DHIZUKU &&
+                state.dhizukuAvailability == DhizukuAvailability.READY
+            )
+        if (silentReady) {
             Spacer(Modifier.height(12.dp))
 
             AutoUpdateCard(
@@ -140,8 +151,10 @@ fun LazyListScope.updatesSection(
 private fun InstallerTypeCard(
     selectedType: InstallerType,
     shizukuAvailability: ShizukuAvailability,
+    dhizukuAvailability: DhizukuAvailability,
     onTypeSelected: (InstallerType) -> Unit,
-    onRequestPermission: () -> Unit
+    onRequestShizukuPermission: () -> Unit,
+    onRequestDhizukuPermission: () -> Unit
 ) {
     ExpressiveCard {
         Column(
@@ -171,34 +184,93 @@ private fun InstallerTypeCard(
                 }
             )
 
-            when (shizukuAvailability) {
-                ShizukuAvailability.PERMISSION_NEEDED -> {
-                    FilledTonalButton(
-                        onClick = onRequestPermission,
-                        modifier = Modifier.fillMaxWidth(),
-                        shape = RoundedCornerShape(12.dp)
-                    ) {
-                        Text(
-                            text = stringResource(Res.string.shizuku_grant_permission),
-                            style = MaterialTheme.typography.titleSmall,
-                            fontWeight = FontWeight.Bold
-                        )
-                    }
-                }
+            if (selectedType == InstallerType.SHIZUKU) {
+                ShizukuStatusActions(
+                    availability = shizukuAvailability,
+                    onRequestPermission = onRequestShizukuPermission
+                )
+            }
 
-                ShizukuAvailability.UNAVAILABLE -> {
-                    HintText(text = stringResource(Res.string.shizuku_install_hint))
+            InstallerOption(
+                icon = Icons.Outlined.Security,
+                title = stringResource(Res.string.installer_type_dhizuku),
+                description = stringResource(Res.string.installer_type_dhizuku_description),
+                isSelected = selectedType == InstallerType.DHIZUKU,
+                onClick = { onTypeSelected(InstallerType.DHIZUKU) },
+                statusBadge = {
+                    DhizukuStatusBadge(
+                        availability = dhizukuAvailability
+                    )
                 }
+            )
 
-                ShizukuAvailability.NOT_RUNNING -> {
-                    HintText(text = stringResource(Res.string.shizuku_start_hint))
-                }
+            if (selectedType == InstallerType.DHIZUKU) {
+                DhizukuStatusActions(
+                    availability = dhizukuAvailability,
+                    onRequestPermission = onRequestDhizukuPermission
+                )
+            }
+        }
+    }
+}
 
-                ShizukuAvailability.READY -> {
-                    // No hint needed
-                }
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun ShizukuStatusActions(
+    availability: ShizukuAvailability,
+    onRequestPermission: () -> Unit
+) {
+    when (availability) {
+        ShizukuAvailability.PERMISSION_NEEDED -> {
+            FilledTonalButton(
+                onClick = onRequestPermission,
+                modifier = Modifier.fillMaxWidth(),
+                shape = RoundedCornerShape(12.dp)
+            ) {
+                Text(
+                    text = stringResource(Res.string.shizuku_grant_permission),
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Bold
+                )
             }
         }
+        ShizukuAvailability.UNAVAILABLE -> {
+            HintText(text = stringResource(Res.string.shizuku_install_hint))
+        }
+        ShizukuAvailability.NOT_RUNNING -> {
+            HintText(text = stringResource(Res.string.shizuku_start_hint))
+        }
+        ShizukuAvailability.READY -> Unit
+    }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun DhizukuStatusActions(
+    availability: DhizukuAvailability,
+    onRequestPermission: () -> Unit
+) {
+    when (availability) {
+        DhizukuAvailability.PERMISSION_NEEDED -> {
+            FilledTonalButton(
+                onClick = onRequestPermission,
+                modifier = Modifier.fillMaxWidth(),
+                shape = RoundedCornerShape(12.dp)
+            ) {
+                Text(
+                    text = stringResource(Res.string.dhizuku_grant_permission),
+                    style = MaterialTheme.typography.titleSmall,
+                    fontWeight = FontWeight.Bold
+                )
+            }
+        }
+        DhizukuAvailability.UNAVAILABLE -> {
+            HintText(text = stringResource(Res.string.dhizuku_install_hint))
+        }
+        DhizukuAvailability.NOT_RUNNING -> {
+            HintText(text = stringResource(Res.string.dhizuku_start_hint))
+        }
+        DhizukuAvailability.READY -> Unit
     }
 }
 
@@ -321,6 +393,41 @@ private fun ShizukuStatusBadge(
         )
     }
 
+    StatusDot(color = color, label = label)
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun DhizukuStatusBadge(
+    availability: DhizukuAvailability
+) {
+    val (color, label) = when (availability) {
+        DhizukuAvailability.READY -> Pair(
+            Color(0xFF4CAF50),
+            stringResource(Res.string.dhizuku_status_ready)
+        )
+
+        DhizukuAvailability.PERMISSION_NEEDED -> Pair(
+            Color(0xFFFF9800),
+            stringResource(Res.string.dhizuku_status_permission_needed)
+        )
+
+        DhizukuAvailability.NOT_RUNNING -> Pair(
+            Color(0xFFFF5722),
+            stringResource(Res.string.dhizuku_status_not_running)
+        )
+
+        DhizukuAvailability.UNAVAILABLE -> Pair(
+            MaterialTheme.colorScheme.outline,
+            stringResource(Res.string.dhizuku_status_not_installed)
+        )
+    }
+
+    StatusDot(color = color, label = label)
+}
+
+@Composable
+private fun StatusDot(color: Color, label: String) {
     Row(
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(4.dp)
diff --git a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/feedback/FeedbackViewModel.kt b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/feedback/FeedbackViewModel.kt
index fb50d9995..82535e95b 100644
--- a/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/feedback/FeedbackViewModel.kt
+++ b/feature/tweaks/presentation/src/commonMain/kotlin/zed/rainxch/tweaks/presentation/feedback/FeedbackViewModel.kt
@@ -111,6 +111,7 @@ class FeedbackViewModel(
                 when (installerType) {
                     InstallerType.DEFAULT -> "Default"
                     InstallerType.SHIZUKU -> "Shizuku"
+                    InstallerType.DHIZUKU -> "Dhizuku"
                 }
             } else {
                 null
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 655ba496d..218751393 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -42,6 +42,7 @@ markdownRenderer = "0.39.2"
 liquid = "1.1.1"
 landscapist = "2.9.5"
 shizuku = "13.1.5"
+dhizuku = "2.5.4"
 hidden-api = "4.4.0"
 jsystemthemedetector = "3.9.1"
 work = "2.11.1"
@@ -158,6 +159,9 @@ shizuku-api = { module = "dev.rikka.shizuku:api", version.ref = "shizuku" }
 shizuku-provider = { module = "dev.rikka.shizuku:provider", version.ref = "shizuku" }
 hidden-api-stub = { module = "dev.rikka.hidden:stub", version.ref = "hidden-api" }
 
+# Dhizuku
+dhizuku-api = { module = "io.github.iamr0s:Dhizuku-API", version.ref = "dhizuku" }
+
 # Liquid effect
 liquid = { module = "io.github.fletchmckee.liquid:liquid", version.ref = "liquid" }