chore: Release v1.26.0-dev.32 [skip ci]

# app [1.26.0-dev.32](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.31...v1.26.0-dev.32) (2026-03-08) ### Features * migrate to API v5 ([2270f32](2270f329de))
feat: migrate to API v5
2026-03-13 08:41:57 +08:00 · 2026-03-08 20:23:49 +00:00 · 2026-03-08 21:16:49 +01:00 · 2026-03-04 03:54:17 +00:00 · 2026-03-04 06:46:40 +03:00 · 2026-03-02 17:24:20 +00:00
59 changed files with 2272 additions and 361 deletions
--- a/.github/workflows/build_pull_request.yml
+++ b/.github/workflows/build_pull_request.yml
@@ -29,3 +29,4 @@ jobs:
          path: |
            app/build/outputs/apk/release/revanced-manager*.apk
            app/build/outputs/apk/release/revanced-manager*.apk.asc
+          archive: false
--- a/api/CHANGELOG.md
+++ b/api/CHANGELOG.md
@@ -1,3 +1,10 @@
+# api [1.0.0-dev.2](https://github.com/ReVanced/revanced-manager/compare/api@1.0.0-dev.1...api@1.0.0-dev.2) (2026-02-27)
+
+
+### Features
+
+* Update to Patcher v22 ([#2939](https://github.com/ReVanced/revanced-manager/issues/2939)) ([8667051](https://github.com/ReVanced/revanced-manager/commit/8667051283f934a32ac7b7cc76178397dc45a0e6))
+
 # api 1.0.0-dev.1 (2026-02-19)


--- a/api/build.gradle.kts
+++ b/api/build.gradle.kts
@@ -23,6 +23,10 @@ kotlin {
    jvmToolchain(17)
    compilerOptions {
        jvmTarget = JvmTarget.JVM_17
+        freeCompilerArgs.addAll(
+            "-Xexplicit-backing-fields",
+            "-Xcontext-parameters",
+        )
    }
 }

--- a/api/gradle.properties
+++ b/api/gradle.properties
@@ -1 +1 @@
-version = 1.0.0-dev.1
+version = 1.0.0-dev.2
--- a/app/CHANGELOG.md
+++ b/app/CHANGELOG.md
@@ -1,3 +1,91 @@
+# app [1.26.0-dev.32](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.31...v1.26.0-dev.32) (2026-03-08)
+
+
+### Features
+
+* migrate to API v5 ([2270f32](https://github.com/ReVanced/revanced-manager/commit/2270f329de25376eb9f0ce196994cc841977ff2a))
+
+# app [1.26.0-dev.31](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.30...v1.26.0-dev.31) (2026-03-04)
+
+
+### Features
+
+* Don't mark all announcements as read on first launch, and set the correct default tags ([398ca00](https://github.com/ReVanced/revanced-manager/commit/398ca006b637048e6280edaf9685800f7638e6ba))
+
+# app [1.26.0-dev.30](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.29...v1.26.0-dev.30) (2026-03-02)
+
+
+### Features
+
+* Update AAPT2 to built-tools v35. ([1ba11b3](https://github.com/ReVanced/revanced-manager/commit/1ba11b30218be263a56f6512b968f5e3dded9daf))
+
+# app [1.26.0-dev.29](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.28...v1.26.0-dev.29) (2026-02-28)
+
+
+### Bug Fixes
+
+* Exclude desktop AAPT and disable R8 optimizations ([6ce5b67](https://github.com/ReVanced/revanced-manager/commit/6ce5b672feb677eccafffb6a04bdf5513f6d62fa))
+* unexclude other destabilizers ([2c3d436](https://github.com/ReVanced/revanced-manager/commit/2c3d436b258f100feea0b9864b7131ae2c5bda79))
+
+# app [1.26.0-dev.28](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.27...v1.26.0-dev.28) (2026-02-28)
+
+
+### Features
+
+* Add patch selection filters ([#2956](https://github.com/ReVanced/revanced-manager/issues/2956)) ([0be493d](https://github.com/ReVanced/revanced-manager/commit/0be493da662ed2b46d4b8616942357eb6a111d17))
+
+# app [1.26.0-dev.27](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.26...v1.26.0-dev.27) (2026-02-28)
+
+
+### Features
+
+* Show patch bundle version used to patch an app ([#2966](https://github.com/ReVanced/revanced-manager/issues/2966)) ([11bd46c](https://github.com/ReVanced/revanced-manager/commit/11bd46ce26d4fbc7f126bee5e254d4f6b5e0cc43))
+
+# app [1.26.0-dev.26](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.25...v1.26.0-dev.26) (2026-02-27)
+
+
+### Features
+
+* improve InstalledAppsScreen caching/perf ([#2963](https://github.com/ReVanced/revanced-manager/issues/2963)) ([323d217](https://github.com/ReVanced/revanced-manager/commit/323d2170efa0e3f2c8d2245ff08a2e92c52cb9d7))
+
+# app [1.26.0-dev.25](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.24...v1.26.0-dev.25) (2026-02-27)
+
+
+### Features
+
+* improve AppSelectorScreen caching/perf ([#2961](https://github.com/ReVanced/revanced-manager/issues/2961)) ([81e5a93](https://github.com/ReVanced/revanced-manager/commit/81e5a9315db4c858fa29163d15457af97163967a))
+
+# app [1.26.0-dev.24](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.23...v1.26.0-dev.24) (2026-02-27)
+
+
+### Bug Fixes
+
+* Incorrect patcher string value ([f19080a](https://github.com/ReVanced/revanced-manager/commit/f19080a9862be4600860b67cd981b9a3a56b21e7))
+* Never show again toggle doing nothing for Update dialog ([6f4219c](https://github.com/ReVanced/revanced-manager/commit/6f4219c01ba43b70e130f210c8d48978a6056f68))
+* Release builds not working ([00b3c59](https://github.com/ReVanced/revanced-manager/commit/00b3c59572760993f69f2663456237faafff0283))
+* Remove quotes from strings ([fc30ba5](https://github.com/ReVanced/revanced-manager/commit/fc30ba5e83f27329b05dc81f484bb8f7471b6a99))
+* we actually don't want to exclude reflection symbols ([3222840](https://github.com/ReVanced/revanced-manager/commit/32228404c4ef38bb8931d5cfdf6a7aefde23a89c))
+
+
+### Features
+
+* Add announcements ([#2948](https://github.com/ReVanced/revanced-manager/issues/2948)) ([813df46](https://github.com/ReVanced/revanced-manager/commit/813df46847620bd854dccc52ff244388b3385e17))
+* Update to Patcher v22 ([#2939](https://github.com/ReVanced/revanced-manager/issues/2939)) ([8667051](https://github.com/ReVanced/revanced-manager/commit/8667051283f934a32ac7b7cc76178397dc45a0e6))
+
+# app [1.26.0-dev.23](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.22...v1.26.0-dev.23) (2026-02-19)
+
+
+### Bug Fixes
+
+* Flutter migration ([#2946](https://github.com/ReVanced/revanced-manager/issues/2946)) ([31a0f75](https://github.com/ReVanced/revanced-manager/commit/31a0f751aaff3233f50821963f28454d239318b2))
+
+# app [1.26.0-dev.22](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.21...v1.26.0-dev.22) (2026-02-19)
+
+
+### Bug Fixes
+
+* Create modules path in root installer ([4fc2ba3](https://github.com/ReVanced/revanced-manager/commit/4fc2ba339b6d275fb9da8b65ff86b74a6594436d))
+
 # app [1.26.0-dev.21](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.20...v1.26.0-dev.21) (2026-02-19)


--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -135,15 +135,15 @@ android {
    buildToolsVersion = "35.0.1"

    defaultConfig {
-        applicationId = "app.revanced.manager"
+        applicationId = "app.revanced.manager.flutter"
        minSdk = 26
        targetSdk = 35

        val versionStr = if (version == "unspecified") "1.0.0" else version.toString()
        versionName = versionStr
        versionCode = with(versionStr.toVersion()) {
-            major * 10_000_000 +
-                    minor * 10_000 +
+            major * 100_000_000 +
+                    minor * 100_000 +
                    patch * 100 +
                    (preRelease?.substringAfterLast('.')?.toInt() ?: 99)
        }
@@ -165,7 +165,6 @@ android {

    buildTypes {
        debug {
-            applicationIdSuffix = ".debug"
            resValue("string", "app_name", "ReVanced Manager (Debug)")

            buildConfigField("long", "BUILD_ID", "${Random.nextLong()}L")
@@ -175,13 +174,12 @@ android {
            if (!project.hasProperty("noProguard")) {
                isMinifyEnabled = true
                isShrinkResources = true
-                proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+                proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")
            }

            val keystoreFile = file("keystore.jks")

            if (project.hasProperty("signAsDebug") || !keystoreFile.exists()) {
-                applicationIdSuffix = ".debug_signed"
                resValue("string", "app_name", "ReVanced Manager (Debug signed)")
                signingConfig = signingConfigs.getByName("debug")

@@ -217,23 +215,6 @@ android {
        includeInBundle = false
    }

-    packaging {
-        resources.excludes.addAll(
-            listOf(
-                "/prebuilt/**",
-                "META-INF/DEPENDENCIES",
-                "META-INF/**.version",
-                "DebugProbesKt.bin",
-                "kotlin-tooling-metadata.json",
-                "org/bouncycastle/pqc/**.properties",
-                "org/bouncycastle/x509/**.properties",
-            )
-        )
-        jniLibs {
-            useLegacyPackaging = true
-        }
-    }
-
    ksp {
        arg("room.schemaLocation", "$projectDir/schemas")
    }
@@ -254,12 +235,67 @@ android {
            version = "3.22.1"
        }
    }
+
+    packaging {
+        resources {
+            // Useless files
+            excludes += "/XPP3_*_VERSION"
+            excludes += "/font-awesome-license.txt"
+            excludes += "/smali.properties"
+            excludes += "/baksmali.properties"
+            excludes += "/properties/apktool.properties"
+            excludes += "/org/antlr/**"
+            excludes += "/org/mockito/**"
+            excludes += "/org/bouncycastle/pqc/**.properties"
+            excludes += "/org/bouncycastle/x509/**.properties"
+            excludes += "/META-INF/INDEX.LIST"
+            excludes += "/META-INF/**/*.txt"
+            excludes += "/META-INF/**/*.properties"
+            excludes += "/META-INF/DEPENDENCIES"
+
+            // AAPT
+            excludes += "/prebuilt/**/*"
+        }
+        jniLibs {
+            // 32-bit x86 is dead
+            excludes += "/lib/x86/*.so"
+
+            // Equivalent of AndroidManifest's extractNativeLibs=true to ensure libs are compressed
+            useLegacyPackaging = true
+        }
+    }
+}
+
+
+androidComponents {
+    onVariants(selector().withBuildType("release")) {
+        it.packaging.resources.excludes.apply {
+            // Debug metadata
+            add("/META-INF/*.version")
+            add("/META-INF/*.kotlin_module")
+            add("/kotlin-tooling-metadata.json")
+
+            // Kotlin debugging (https://github.com/Kotlin/kotlinx.coroutines/issues/2274)
+            add("/DebugProbesKt.bin")
+        }
+    }
 }

 kotlin {
    jvmToolchain(17)
    compilerOptions {
        jvmTarget = JvmTarget.JVM_17
+        freeCompilerArgs.addAll(
+            "-Xexplicit-backing-fields",
+            "-Xcontext-parameters",
+        )
+    }
+}
+
+configurations {
+    all {
+        // ReVanced Library has a dependency which conflicts with whatever this is. We don't use protobuf, so it should be fine.
+        exclude(group = "com.google.api.grpc", module = "proto-google-common-protos")
    }
 }

--- a/app/gradle.properties
+++ b/app/gradle.properties
@@ -1 +1 @@
-version = 1.26.0-dev.21
+version = 1.26.0-dev.32
--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@@ -1,4 +1,5 @@
 -dontobfuscate
+-keepattributes *

 -keep class app.revanced.manager.patcher.runtime.process.* { *; }
 -keep class app.revanced.manager.downloader.** { *; }
@@ -11,4 +12,7 @@
 -dontwarn com.google.j2objc.annotations.*
 -dontwarn java.awt.**
 -dontwarn javax.**
-dontwarn org.slf4j.**
+-dontwarn org.slf4j.**
+
+-dontwarn org.immutables.value.Generated
+-dontwarn reactor.blockhound.integration.BlockHoundIntegration
--- a/app/schemas/app.revanced.manager.data.room.AppDatabase/2.json
+++ b/app/schemas/app.revanced.manager.data.room.AppDatabase/2.json
@@ -0,0 +1,466 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 2,
+    "identityHash": "d9350f0e779a1bde46227a29884a7865",
+    "entities": [
+      {
+        "tableName": "patch_bundles",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER NOT NULL, `name` TEXT NOT NULL, `version` TEXT, `source` TEXT NOT NULL, `auto_update` INTEGER NOT NULL, PRIMARY KEY(`uid`))",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "versionHash",
+            "columnName": "version",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "source",
+            "columnName": "source",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "autoUpdate",
+            "columnName": "auto_update",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "uid"
+          ]
+        }
+      },
+      {
+        "tableName": "patch_selections",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER NOT NULL, `patch_bundle` INTEGER NOT NULL, `package_name` TEXT NOT NULL, PRIMARY KEY(`uid`), FOREIGN KEY(`patch_bundle`) REFERENCES `patch_bundles`(`uid`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "patchBundle",
+            "columnName": "patch_bundle",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "packageName",
+            "columnName": "package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "uid"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_patch_selections_patch_bundle_package_name",
+            "unique": true,
+            "columnNames": [
+              "patch_bundle",
+              "package_name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_patch_selections_patch_bundle_package_name` ON `${TABLE_NAME}` (`patch_bundle`, `package_name`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "patch_bundles",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "patch_bundle"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "selected_patches",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`selection` INTEGER NOT NULL, `patch_name` TEXT NOT NULL, PRIMARY KEY(`selection`, `patch_name`), FOREIGN KEY(`selection`) REFERENCES `patch_selections`(`uid`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "selection",
+            "columnName": "selection",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "patchName",
+            "columnName": "patch_name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "selection",
+            "patch_name"
+          ]
+        },
+        "foreignKeys": [
+          {
+            "table": "patch_selections",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "selection"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "downloaded_app",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `version` TEXT NOT NULL, `directory` TEXT NOT NULL, `last_used` INTEGER NOT NULL, PRIMARY KEY(`package_name`, `version`))",
+        "fields": [
+          {
+            "fieldPath": "packageName",
+            "columnName": "package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "directory",
+            "columnName": "directory",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastUsed",
+            "columnName": "last_used",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "package_name",
+            "version"
+          ]
+        }
+      },
+      {
+        "tableName": "installed_app",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`current_package_name` TEXT NOT NULL, `original_package_name` TEXT NOT NULL, `version` TEXT NOT NULL, `install_type` TEXT NOT NULL, PRIMARY KEY(`current_package_name`))",
+        "fields": [
+          {
+            "fieldPath": "currentPackageName",
+            "columnName": "current_package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "originalPackageName",
+            "columnName": "original_package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "version",
+            "columnName": "version",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "installType",
+            "columnName": "install_type",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "current_package_name"
+          ]
+        }
+      },
+      {
+        "tableName": "applied_patch",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `bundle` INTEGER NOT NULL, `patch_name` TEXT NOT NULL, PRIMARY KEY(`package_name`, `bundle`, `patch_name`), FOREIGN KEY(`package_name`) REFERENCES `installed_app`(`current_package_name`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`bundle`) REFERENCES `patch_bundles`(`uid`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "packageName",
+            "columnName": "package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bundle",
+            "columnName": "bundle",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "patchName",
+            "columnName": "patch_name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "package_name",
+            "bundle",
+            "patch_name"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_applied_patch_bundle",
+            "unique": false,
+            "columnNames": [
+              "bundle"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_applied_patch_bundle` ON `${TABLE_NAME}` (`bundle`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "installed_app",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "package_name"
+            ],
+            "referencedColumns": [
+              "current_package_name"
+            ]
+          },
+          {
+            "table": "patch_bundles",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "bundle"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "installed_patch_bundle",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `bundle_uid` INTEGER NOT NULL, `bundle_name` TEXT NOT NULL, `bundle_version` TEXT, PRIMARY KEY(`package_name`, `bundle_uid`), FOREIGN KEY(`package_name`) REFERENCES `installed_app`(`current_package_name`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "packageName",
+            "columnName": "package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bundleUid",
+            "columnName": "bundle_uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bundleName",
+            "columnName": "bundle_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bundleVersion",
+            "columnName": "bundle_version",
+            "affinity": "TEXT"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "package_name",
+            "bundle_uid"
+          ]
+        },
+        "foreignKeys": [
+          {
+            "table": "installed_app",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "package_name"
+            ],
+            "referencedColumns": [
+              "current_package_name"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "option_groups",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`uid` INTEGER NOT NULL, `patch_bundle` INTEGER NOT NULL, `package_name` TEXT NOT NULL, PRIMARY KEY(`uid`), FOREIGN KEY(`patch_bundle`) REFERENCES `patch_bundles`(`uid`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "uid",
+            "columnName": "uid",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "patchBundle",
+            "columnName": "patch_bundle",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "packageName",
+            "columnName": "package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "uid"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_option_groups_patch_bundle_package_name",
+            "unique": true,
+            "columnNames": [
+              "patch_bundle",
+              "package_name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_option_groups_patch_bundle_package_name` ON `${TABLE_NAME}` (`patch_bundle`, `package_name`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "patch_bundles",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "patch_bundle"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "options",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`group` INTEGER NOT NULL, `patch_name` TEXT NOT NULL, `key` TEXT NOT NULL, `value` TEXT NOT NULL, PRIMARY KEY(`group`, `patch_name`, `key`), FOREIGN KEY(`group`) REFERENCES `option_groups`(`uid`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "group",
+            "columnName": "group",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "patchName",
+            "columnName": "patch_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "key",
+            "columnName": "key",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "value",
+            "columnName": "value",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "group",
+            "patch_name",
+            "key"
+          ]
+        },
+        "foreignKeys": [
+          {
+            "table": "option_groups",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "group"
+            ],
+            "referencedColumns": [
+              "uid"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "trusted_downloaders",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`package_name` TEXT NOT NULL, `signature` BLOB NOT NULL, PRIMARY KEY(`package_name`))",
+        "fields": [
+          {
+            "fieldPath": "packageName",
+            "columnName": "package_name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "signature",
+            "columnName": "signature",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "package_name"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'd9350f0e779a1bde46227a29884a7865')"
+    ]
+  }
+}
--- a/app/src/main/java/app/revanced/manager/MainActivity.kt
+++ b/app/src/main/java/app/revanced/manager/MainActivity.kt
@@ -1,12 +1,9 @@
 package app.revanced.manager

-import android.content.ActivityNotFoundException
 import android.os.Bundle
 import android.os.Parcelable
-import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
-import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.animation.ExperimentalAnimationApi
 import androidx.compose.animation.slideInHorizontally
@@ -25,6 +22,8 @@ import androidx.navigation.compose.composable
 import androidx.navigation.compose.navigation
 import androidx.navigation.compose.rememberNavController
 import androidx.navigation.toRoute
+import app.revanced.manager.ui.model.navigation.Announcement
+import app.revanced.manager.ui.model.navigation.Announcements
 import app.revanced.manager.ui.model.navigation.AppSelector
 import app.revanced.manager.ui.model.navigation.ComplexParameter
 import app.revanced.manager.ui.model.navigation.Dashboard
@@ -33,6 +32,8 @@ import app.revanced.manager.ui.model.navigation.Patcher
 import app.revanced.manager.ui.model.navigation.SelectedApplicationInfo
 import app.revanced.manager.ui.model.navigation.Settings
 import app.revanced.manager.ui.model.navigation.Update
+import app.revanced.manager.ui.screen.AnnouncementScreen
+import app.revanced.manager.ui.screen.AnnouncementsScreen
 import app.revanced.manager.ui.screen.AppSelectorScreen
 import app.revanced.manager.ui.screen.DashboardScreen
 import app.revanced.manager.ui.screen.InstalledAppInfoScreen
@@ -62,6 +63,7 @@ import org.koin.androidx.compose.koinViewModel
 import org.koin.core.parameter.parametersOf
 import org.koin.androidx.viewmodel.ext.android.getViewModel as getActivityViewModel

+
 class MainActivity : AppCompatActivity() {
    @ExperimentalAnimationApi
    override fun onCreate(savedInstanceState: Bundle?) {
@@ -74,21 +76,10 @@ class MainActivity : AppCompatActivity() {
        val vm: MainViewModel = getActivityViewModel()

        setContent {
-            val launcher = rememberLauncherForActivityResult(
-                ActivityResultContracts.StartActivityForResult(),
-                onResult = vm::applyLegacySettings
-            )
            val theme by vm.prefs.theme.getAsState()
            val dynamicColor by vm.prefs.dynamicColor.getAsState()
            val pureBlackTheme by vm.prefs.pureBlackTheme.getAsState()

-            EventEffect(vm.legacyImportActivityFlow) {
-                try {
-                    launcher.launch(it)
-                } catch (_: ActivityNotFoundException) {
-                }
-            }
-
            ReVancedManagerTheme(
                darkTheme = theme == Theme.SYSTEM && isSystemInDarkTheme() || theme == Theme.DARK,
                dynamicColor = dynamicColor,
@@ -117,7 +108,7 @@ private fun ReVancedManager(vm: MainViewModel) {
        enterTransition = { slideInHorizontally(initialOffsetX = { it }) },
        exitTransition = { slideOutHorizontally(targetOffsetX = { -it / 3 }) },
        popEnterTransition = { slideInHorizontally(initialOffsetX = { -it / 3 }) },
-        popExitTransition = { slideOutHorizontally(targetOffsetX = { it }) },
+        popExitTransition = { slideOutHorizontally(targetOffsetX = { it }) }
    ) {
        composable<Dashboard> {
            DashboardScreen(
@@ -133,6 +124,12 @@ private fun ReVancedManager(vm: MainViewModel) {
                },
                onAppClick = { packageName ->
                    navController.navigate(InstalledApplicationInfo(packageName))
+                },
+                onAnnouncementsClick = {
+                    navController.navigate(Announcements)
+                },
+                onAnnouncementClick = { announcement ->
+                    navController.navigateComplex(Announcement, announcement)
                }
            )
        }
@@ -178,6 +175,22 @@ private fun ReVancedManager(vm: MainViewModel) {
            )
        }

+        composable<Announcements> {
+            AnnouncementsScreen(
+                onBackClick = navController::popBackStack,
+                onAnnouncementClick = { announcement ->
+                    navController.navigateComplex(Announcement, announcement)
+                }
+            )
+        }
+
+        composable<Announcement> {
+            AnnouncementScreen(
+                onBackClick = navController::popBackStack,
+                announcement = it.getComplexArg()
+            )
+        }
+
        navigation<SelectedApplicationInfo>(startDestination = SelectedApplicationInfo.Main) {
            composable<SelectedApplicationInfo.Main> {
                val parentBackStackEntry = navController.navGraphEntry(it)
--- a/app/src/main/java/app/revanced/manager/data/room/AppDatabase.kt
+++ b/app/src/main/java/app/revanced/manager/data/room/AppDatabase.kt
@@ -1,13 +1,15 @@
 package app.revanced.manager.data.room

+import androidx.room.AutoMigration
 import androidx.room.Database
 import androidx.room.RoomDatabase
 import androidx.room.TypeConverters
-import app.revanced.manager.data.room.apps.downloaded.DownloadedAppDao
 import app.revanced.manager.data.room.apps.downloaded.DownloadedApp
+import app.revanced.manager.data.room.apps.downloaded.DownloadedAppDao
 import app.revanced.manager.data.room.apps.installed.AppliedPatch
 import app.revanced.manager.data.room.apps.installed.InstalledApp
 import app.revanced.manager.data.room.apps.installed.InstalledAppDao
+import app.revanced.manager.data.room.apps.installed.InstalledPatchBundle
 import app.revanced.manager.data.room.selection.PatchSelection
 import app.revanced.manager.data.room.selection.SelectedPatch
 import app.revanced.manager.data.room.selection.SelectionDao
@@ -21,8 +23,9 @@ import app.revanced.manager.data.room.downloader.TrustedDownloaderDao
 import kotlin.random.Random

@Database(
-    entities = [PatchBundleEntity::class, PatchSelection::class, SelectedPatch::class, DownloadedApp::class, InstalledApp::class, AppliedPatch::class, OptionGroup::class, Option::class, TrustedDownloader::class],
-    version = 1
+    entities = [PatchBundleEntity::class, PatchSelection::class, SelectedPatch::class, DownloadedApp::class, InstalledApp::class, AppliedPatch::class, InstalledPatchBundle::class, OptionGroup::class, Option::class, TrustedDownloader::class],
+    version = 2,
+    autoMigrations = [AutoMigration(from = 1, to = 2)]
 )
@TypeConverters(Converters::class)
 abstract class AppDatabase : RoomDatabase() {
--- a/app/src/main/java/app/revanced/manager/data/room/apps/installed/InstalledAppDao.kt
+++ b/app/src/main/java/app/revanced/manager/data/room/apps/installed/InstalledAppDao.kt
@@ -25,11 +25,20 @@ interface InstalledAppDao {
        "patch_name"
    ) String>>

+    @Query("SELECT * FROM installed_patch_bundle WHERE package_name = :packageName")
+    suspend fun getInstalledPatchBundles(packageName: String): List<InstalledPatchBundle>
+
    @Transaction
-    suspend fun upsertApp(installedApp: InstalledApp, appliedPatches: List<AppliedPatch>) {
+    suspend fun upsertApp(
+        installedApp: InstalledApp,
+        appliedPatches: List<AppliedPatch>,
+        patchBundles: List<InstalledPatchBundle>
+    ) {
        upsertApp(installedApp)
        deleteAppliedPatches(installedApp.currentPackageName)
+        deleteInstalledPatchBundles(installedApp.currentPackageName)
        insertAppliedPatches(appliedPatches)
+        insertInstalledPatchBundles(patchBundles)
    }

    @Upsert
@@ -38,9 +47,15 @@ interface InstalledAppDao {
    @Insert
    suspend fun insertAppliedPatches(appliedPatches: List<AppliedPatch>)

+    @Insert
+    suspend fun insertInstalledPatchBundles(patchBundles: List<InstalledPatchBundle>)
+
    @Query("DELETE FROM applied_patch WHERE package_name = :packageName")
    suspend fun deleteAppliedPatches(packageName: String)

+    @Query("DELETE FROM installed_patch_bundle WHERE package_name = :packageName")
+    suspend fun deleteInstalledPatchBundles(packageName: String)
+
    @Delete
    suspend fun delete(installedApp: InstalledApp)
 }
--- a/app/src/main/java/app/revanced/manager/data/room/apps/installed/InstalledPatchBundle.kt
+++ b/app/src/main/java/app/revanced/manager/data/room/apps/installed/InstalledPatchBundle.kt
@@ -0,0 +1,24 @@
+package app.revanced.manager.data.room.apps.installed
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.ForeignKey
+
+@Entity(
+    tableName = "installed_patch_bundle",
+    primaryKeys = ["package_name", "bundle_uid"],
+    foreignKeys = [
+        ForeignKey(
+            InstalledApp::class,
+            parentColumns = ["current_package_name"],
+            childColumns = ["package_name"],
+            onDelete = ForeignKey.CASCADE
+        )
+    ]
+)
+data class InstalledPatchBundle(
+    @ColumnInfo(name = "package_name") val packageName: String,
+    @ColumnInfo(name = "bundle_uid") val bundleUid: Int,
+    @ColumnInfo(name = "bundle_name") val bundleName: String,
+    @ColumnInfo(name = "bundle_version") val bundleVersion: String?
+)
--- a/app/src/main/java/app/revanced/manager/data/room/options/Option.kt
+++ b/app/src/main/java/app/revanced/manager/data/room/options/Option.kt
@@ -5,8 +5,6 @@ import androidx.room.Entity
 import androidx.room.ForeignKey
 import app.revanced.manager.patcher.patch.Option
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.SerializationException
-import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonNull
@@ -36,7 +34,7 @@ import kotlin.reflect.typeOf
 data class Option(
    @ColumnInfo(name = "group") val group: Int,
    @ColumnInfo(name = "patch_name") val patchName: String,
-    @ColumnInfo(name = "key") val key: String,
+    @ColumnInfo(name = "key") val name: String,
    // Encoded as Json.
    @ColumnInfo(name = "value") val value: SerializedValue,
 ) {
--- a/app/src/main/java/app/revanced/manager/di/RepositoryModule.kt
+++ b/app/src/main/java/app/revanced/manager/di/RepositoryModule.kt
@@ -11,6 +11,7 @@ import org.koin.dsl.module

 val repositoryModule = module {
    singleOf(::ReVancedAPI)
+    singleOf(::AnnouncementRepository)
    singleOf(::Filesystem) {
        createdAtStart()
    }
--- a/app/src/main/java/app/revanced/manager/di/ViewModelModule.kt
+++ b/app/src/main/java/app/revanced/manager/di/ViewModelModule.kt
@@ -14,6 +14,7 @@ val viewModelModule = module {
    viewModelOf(::AppSelectorViewModel)
    viewModelOf(::PatcherViewModel)
    viewModelOf(::UpdateViewModel)
+    viewModelOf(::AnnouncementsViewModel)
    viewModelOf(::ChangelogsViewModel)
    viewModelOf(::ImportExportViewModel)
    viewModelOf(::AboutViewModel)
--- a/app/src/main/java/app/revanced/manager/domain/installer/RootInstaller.kt
+++ b/app/src/main/java/app/revanced/manager/domain/installer/RootInstaller.kt
@@ -121,7 +121,7 @@ class RootInstaller(
            execute("pm install \"${stockApp.absolutePath}\"").assertSuccess("Failed to install stock app")
        }

-        remoteFS.getFile(modulePath).mkdir()
+        remoteFS.getFile(modulePath).mkdirs()

        listOf(
            "service.sh",
--- a/app/src/main/java/app/revanced/manager/domain/manager/PreferencesManager.kt
+++ b/app/src/main/java/app/revanced/manager/domain/manager/PreferencesManager.kt
@@ -20,6 +20,8 @@ class PreferencesManager(
    val keystoreAlias = stringPreference("keystore_alias", KeystoreManager.DEFAULT)
    val keystorePass = stringPreference("keystore_pass", KeystoreManager.DEFAULT)

+    val readAnnouncements = longSetPreference("read_announcements", emptySet())
+    val selectedAnnouncementTags = stringSetPreference("selected_announcement_tags", setOf("revanced", "manager"))
    val firstLaunch = booleanPreference("first_launch", true)
    val managerAutoUpdates = booleanPreference("manager_auto_updates", false)
    val showManagerUpdateDialogOnLaunch = booleanPreference("show_manager_update_dialog_on_launch", true)
--- a/app/src/main/java/app/revanced/manager/domain/manager/base/BasePreferencesManager.kt
+++ b/app/src/main/java/app/revanced/manager/domain/manager/base/BasePreferencesManager.kt
@@ -29,6 +29,9 @@ abstract class BasePreferencesManager(private val context: Context, name: String
    protected fun stringSetPreference(key: String, default: Set<String>) =
        StringSetPreference(dataStore, key, default)

+    protected fun longSetPreference(key: String, default: Set<Long>) =
+        LongSetPreference(dataStore, key, default)
+
    protected fun booleanPreference(key: String, default: Boolean) =
        BooleanPreference(dataStore, key, default)

@@ -56,9 +59,13 @@ class EditorContext(private val prefs: MutablePreferences) {
        get() = prefs.run { read() }
        set(value) = prefs.run { write(value) }

-    operator fun Preference<Set<String>>.plusAssign(value: String) = prefs.run {
+    operator fun <T> Preference<Set<T>>.plusAssign(value: T) = prefs.run {
        write(read() + value)
    }
+
+    operator fun <T> Preference<Set<T>>.minusAssign(value: T) = prefs.run {
+        write(read() subtract setOf(value))
+    }
 }

 abstract class Preference<T>(
@@ -125,6 +132,19 @@ class StringSetPreference(
    override val key = stringSetPreferencesKey(key)
 }

+class LongSetPreference(
+    dataStore: DataStore<Preferences>,
+    key: String,
+    default: Set<Long>
+) : Preference<Set<Long>>(dataStore, default) {
+    private val key = stringSetPreferencesKey(key)
+
+    override fun Preferences.read() = this[key]?.mapTo(mutableSetOf()) { it.toLong() } ?: default
+    override fun MutablePreferences.write(value: Set<Long>) {
+        this[key] = value.mapTo(mutableSetOf()) { it.toString() }
+    }
+}
+
 class BooleanPreference(
    dataStore: DataStore<Preferences>,
    key: String,
--- a/app/src/main/java/app/revanced/manager/domain/repository/AnnouncementRepository.kt
+++ b/app/src/main/java/app/revanced/manager/domain/repository/AnnouncementRepository.kt
@@ -0,0 +1,23 @@
+package app.revanced.manager.domain.repository
+
+import app.revanced.manager.network.api.ReVancedAPI
+import app.revanced.manager.network.dto.ReVancedAnnouncement
+import app.revanced.manager.network.utils.getOrNull
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+class AnnouncementRepository(
+    private val api: ReVancedAPI
+) {
+    private val mutex = Mutex()
+    private var cachedAnnouncements: List<ReVancedAnnouncement>? = null
+
+    suspend fun getAnnouncements(forceRefresh: Boolean = false): List<ReVancedAnnouncement>? {
+        mutex.withLock {
+            if (cachedAnnouncements == null || forceRefresh) {
+                cachedAnnouncements = api.getAnnouncements().getOrNull()
+            }
+            return cachedAnnouncements
+        }
+    }
+}
--- a/app/src/main/java/app/revanced/manager/domain/repository/InstalledAppRepository.kt
+++ b/app/src/main/java/app/revanced/manager/domain/repository/InstalledAppRepository.kt
@@ -4,6 +4,8 @@ import app.revanced.manager.data.room.AppDatabase
 import app.revanced.manager.data.room.apps.installed.AppliedPatch
 import app.revanced.manager.data.room.apps.installed.InstallType
 import app.revanced.manager.data.room.apps.installed.InstalledApp
+import app.revanced.manager.data.room.apps.installed.InstalledPatchBundle
+import app.revanced.manager.patcher.patch.PatchBundleInfo
 import app.revanced.manager.util.PatchSelection
 import kotlinx.coroutines.flow.distinctUntilChanged

@@ -19,12 +21,16 @@ class InstalledAppRepository(
    suspend fun getAppliedPatches(packageName: String): PatchSelection =
        dao.getPatchesSelection(packageName).mapValues { (_, patches) -> patches.toSet() }

+    suspend fun getInstalledPatchBundles(packageName: String) =
+        dao.getInstalledPatchBundles(packageName)
+
    suspend fun addOrUpdate(
        currentPackageName: String,
        originalPackageName: String,
        version: String,
        installType: InstallType,
-        patchSelection: PatchSelection
+        patchSelection: PatchSelection,
+        bundleInfo: Map<Int, PatchBundleInfo.Global> = emptyMap()
    ) {
        dao.upsertApp(
            InstalledApp(
@@ -41,6 +47,15 @@ class InstalledAppRepository(
                        patchName = patch
                    )
                }
+            },
+            patchSelection.keys.mapNotNull { uid ->
+                val info = bundleInfo[uid] ?: return@mapNotNull null
+                InstalledPatchBundle(
+                    packageName = currentPackageName,
+                    bundleUid = uid,
+                    bundleName = info.name,
+                    bundleVersion = info.version
+                )
            }
        )
    }
--- a/app/src/main/java/app/revanced/manager/domain/repository/PatchBundleRepository.kt
+++ b/app/src/main/java/app/revanced/manager/domain/repository/PatchBundleRepository.kt
@@ -38,6 +38,7 @@ import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.runInterruptible
 import kotlinx.coroutines.withContext
 import java.io.InputStream
 import kotlin.collections.joinToString
@@ -115,32 +116,18 @@ class PatchBundleRepository(
            Log.d(tag, "Bundle: $it")
        }

-        val sources = entities.associate { it.uid to it.load() }.toPersistentMap()
+        val sources = entities
+            .associateTo(mutableMapOf()) { it.uid to it.load() }
+        sources.forEach syncName@{ (uid, src) ->
+            val newName = src.patchBundle?.manifestAttributes?.name?.takeIf { it != src.name }
+                ?: return@syncName

-        val hasOutOfDateNames = sources.values.any { it.isNameOutOfDate }
-        if (hasOutOfDateNames) dispatchAction(
-            "Sync names"
-        ) { state ->
-            val nameChanges = state.sources.mapNotNull { (_, src) ->
-                if (!src.isNameOutOfDate) return@mapNotNull null
-                val newName = src.patchBundle?.manifestAttributes?.name?.takeIf { it != src.name }
-                    ?: return@mapNotNull null
-
-                src.uid to newName
-            }
-            val sources = state.sources.toMutableMap()
-            val info = state.info.toMutableMap()
-            nameChanges.forEach { (uid, name) ->
-                updateDb(uid) { it.copy(name = name) }
-                sources[uid] = sources[uid]!!.copy(name = name)
-                info[uid] = info[uid]?.copy(name = name) ?: return@forEach
-            }
-
-            State(sources.toPersistentMap(), info.toPersistentMap())
+            updateDb(uid) { it.copy(name = newName) }
+            sources[uid] = src.copy(name = newName)
        }
-        val info = loadMetadata(sources).toPersistentMap()

-        return State(sources, info)
+        val info = loadMetadata(sources).toPersistentMap()
+        return State(sources.toPersistentMap(), info)
    }

    suspend fun reload() = dispatchAction("Full reload") {
@@ -157,38 +144,46 @@ class PatchBundleRepository(
        return all
    }

-    private suspend fun loadMetadata(sources: Map<Int, PatchBundleSource>): Map<Int, PatchBundleInfo.Global> {
+    private suspend fun loadMetadata(sources: MutableMap<Int, PatchBundleSource>): Map<Int, PatchBundleInfo.Global> {
        // Map bundles -> sources
        val map = sources.mapNotNull { (_, src) ->
            (src.patchBundle ?: return@mapNotNull null) to src
        }.toMap()

        val metadata = try {
-            PatchBundle.Loader.metadata(map.keys)
+            runInterruptible(Dispatchers.Default) {
+                PatchBundle.Loader.metadata(map.keys)
+            }
+        } catch (e: CancellationException) {
+            throw e
        } catch (error: Throwable) {
-            val uids = map.values.map { it.uid }
-
-            dispatchAction("Mark bundles as failed") { state ->
-                state.copy(sources = state.sources.mutate {
-                    uids.forEach { uid ->
-                        it[uid] = it[uid]?.copy(error = error) ?: return@forEach
-                    }
-                })
+            sources.entries.forEach { entry ->
+                entry.setValue(entry.value.copy(error = error))
            }

            Log.e(tag, "Failed to load bundles", error)
            emptyMap()
        }

-        return metadata.entries.associate { (bundle, patches) ->
-            val src = map[bundle]!!
-            src.uid to PatchBundleInfo.Global(
-                src.name,
-                bundle.manifestAttributes?.version,
-                src.uid,
-                patches
-            )
+        val output = buildMap {
+            metadata.forEach { (bundle, result) ->
+                val src = map[bundle]!!
+                val error = result.exceptionOrNull()
+                if (error != null) {
+                    sources[src.uid] = src.copy(error = error)
+                    return@forEach
+                }
+
+                this[src.uid] = PatchBundleInfo.Global(
+                    src.name,
+                    bundle.manifestAttributes?.version,
+                    src.uid,
+                    result.getOrThrow().toList()
+                )
+            }
        }
+
+        return output
    }

    suspend fun isVersionAllowed(packageName: String, version: String) =
@@ -313,9 +308,9 @@ class PatchBundleRepository(
        }

    suspend fun reloadApiBundles() = dispatchAction("Reload API bundles") {
-        this@PatchBundleRepository.sources.first().filterIsInstance<APIPatchBundle>().forEach {
-            with(it) { deleteLocalFile() }
-            updateDb(it.uid) { it.copy(versionHash = null) }
+        this@PatchBundleRepository.sources.first().filterIsInstance<APIPatchBundle>().forEach { src ->
+            with(src) { deleteLocalFile() }
+            updateDb(src.uid) { it.copy(versionHash = null) }
        }

        doReload()
--- a/app/src/main/java/app/revanced/manager/domain/repository/PatchOptionsRepository.kt
+++ b/app/src/main/java/app/revanced/manager/domain/repository/PatchOptionsRepository.kt
@@ -35,15 +35,15 @@ class PatchOptionsRepository(db: AppDatabase) {
                            bundlePatchOptions.getOrPut(dbOption.patchName, ::mutableMapOf)

                        val option =
-                            bundlePatches[sourceUid]?.get(dbOption.patchName)?.options?.find { it.key == dbOption.key }
+                            bundlePatches[sourceUid]?.get(dbOption.patchName)?.options?.find { it.name == dbOption.name }
                        if (option != null) {
                            try {
-                                deserializedPatchOptions[option.key] =
+                                deserializedPatchOptions[option.name] =
                                    dbOption.value.deserializeFor(option)
                            } catch (e: Option.SerializationException) {
                                Log.w(
                                    tag,
-                                    "Option ${dbOption.patchName}:${option.key} could not be deserialized",
+                                    "Option ${dbOption.patchName}:${option.name} could not be deserialized",
                                    e
                                )
                            }
--- a/app/src/main/java/app/revanced/manager/network/api/ReVancedAPI.kt
+++ b/app/src/main/java/app/revanced/manager/network/api/ReVancedAPI.kt
@@ -2,6 +2,8 @@ package app.revanced.manager.network.api

 import app.revanced.manager.BuildConfig
 import app.revanced.manager.domain.manager.PreferencesManager
+import app.revanced.manager.domain.manager.base.Preference
+import app.revanced.manager.network.dto.ReVancedAnnouncement
 import app.revanced.manager.network.dto.ReVancedAsset
 import app.revanced.manager.network.dto.ReVancedGitRepository
 import app.revanced.manager.network.dto.ReVancedInfo
@@ -23,21 +25,27 @@ class ReVancedAPI(
            Dispatchers.IO
        ) {
            client.request {
-                url("$api/v4/$route")
+                url("$api/v5/$route")
            }
        }

    private suspend inline fun <reified T> request(route: String) = request<T>(apiUrl(), route)

+    suspend fun getAnnouncements() = request<List<ReVancedAnnouncement>>("announcements")
+
    suspend fun getAppUpdate() =
        getLatestAppInfo().getOrThrow().takeIf { it.version.removePrefix("v") != BuildConfig.VERSION_NAME }

    suspend fun getLatestAppInfo() =
-        request<ReVancedAsset>("manager?prerelease=${prefs.useManagerPrereleases.get()}")
+        request<ReVancedAsset>("manager${prefs.useManagerPrereleases.prereleaseString()}")

-    suspend fun getPatchesUpdate() = request<ReVancedAsset>("patches?prerelease=${prefs.usePatchesPrereleases.get()}")
+    suspend fun getPatchesUpdate() = request<ReVancedAsset>("patches${prefs.usePatchesPrereleases.prereleaseString()}")

    suspend fun getContributors() = request<List<ReVancedGitRepository>>("contributors")

    suspend fun getInfo(api: String? = null) = request<ReVancedInfo>(api ?: apiUrl(), "about")
+
+    private companion object {
+        suspend fun Preference<Boolean>.prereleaseString() = if (get()) "/prerelease" else ""
+    }
 }
--- a/app/src/main/java/app/revanced/manager/network/dto/ReVancedAnnouncement.kt
+++ b/app/src/main/java/app/revanced/manager/network/dto/ReVancedAnnouncement.kt
@@ -0,0 +1,27 @@
+package app.revanced.manager.network.dto
+
+import android.os.Parcelable
+import kotlinx.datetime.LocalDateTime
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
+import kotlinx.parcelize.Parcelize
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlin.time.Clock
+
+@Parcelize
+@Serializable
+data class ReVancedAnnouncement(
+    val id: Long,
+    val author: String,
+    val title: String,
+    val content: String,
+    val tags: List<String>,
+    @SerialName("created_at")
+    val createdAt: LocalDateTime,
+    @SerialName("archived_at")
+    val archivedAt: LocalDateTime?,
+    val level: Int,
+) : Parcelable {
+    val isArchived get() = archivedAt?.toInstant(TimeZone.UTC)?.let { it < Clock.System.now() } ?: false
+}
--- a/app/src/main/java/app/revanced/manager/patcher/Session.kt
+++ b/app/src/main/java/app/revanced/manager/patcher/Session.kt
@@ -4,66 +4,71 @@ import app.revanced.library.ApkUtils.applyTo
 import app.revanced.manager.patcher.Session.Companion.component1
 import app.revanced.manager.patcher.Session.Companion.component2
 import app.revanced.manager.patcher.logger.Logger
-import app.revanced.patcher.Patcher
-import app.revanced.patcher.PatcherConfig
+import app.revanced.patcher.PatchesResult
 import app.revanced.patcher.patch.Patch
 import app.revanced.patcher.patch.PatchResult
+import app.revanced.patcher.patcher
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.withContext
 import java.io.Closeable
 import java.io.File
 import java.nio.file.Files
 import java.nio.file.StandardCopyOption

-internal typealias PatchList = List<Patch<*>>
+internal typealias PatchList = List<Patch>
+private typealias Patcher = (emit: (PatchResult) -> Unit) -> PatchesResult

 class Session(
    cacheDir: String,
-    frameworkDir: String,
-    aaptPath: String,
+    private val frameworkDir: String,
+    private val aaptPath: String,
    private val logger: Logger,
    private val input: File,
    private val onEvent: (ProgressEvent) -> Unit,
 ) : Closeable {
    private val tempDir = File(cacheDir).resolve("patcher").also { it.mkdirs() }
-    private val patcher = Patcher(
-        PatcherConfig(
-            apkFile = input,
-            temporaryFilesPath = tempDir,
-            frameworkFileDirectory = frameworkDir,
-            aaptBinaryPath = aaptPath
-        )
-    )

-    private suspend fun Patcher.applyPatchesVerbose(selectedPatches: PatchList) {
-        this().collect { (patch, exception) ->
-            val index = selectedPatches.indexOf(patch)
-            if (index == -1) return@collect

-            if (exception != null) {
+    private suspend fun applyPatchesVerbose(patcher: Patcher, indices: Map<Patch, Int>) =
+        withContext(
+            Dispatchers.Default
+        ) {
+            val context = currentCoroutineContext()
+            patcher { (patch, exception) ->
+                // Make the patching process cancelable.
+                context.ensureActive()
+
+                val index = indices[patch] ?: return@patcher
+
+                if (exception != null) {
+                    onEvent(
+                        ProgressEvent.Failed(
+                            StepId.ExecutePatch(index),
+                            exception.toRemoteError(),
+                        )
+                    )
+                    logger.error("${patch.name} failed:")
+                    logger.error(exception.stackTraceToString())
+                    throw exception
+                }
+
                onEvent(
-                    ProgressEvent.Failed(
+                    ProgressEvent.Completed(
                        StepId.ExecutePatch(index),
-                        exception.toRemoteError(),
                    )
                )
-                logger.error("${patch.name} failed:")
-                logger.error(exception.stackTraceToString())
-                throw exception
+
+                logger.info("${patch.name} succeeded")
            }
-
-            onEvent(
-                ProgressEvent.Completed(
-                    StepId.ExecutePatch(index),
-                )
-            )
-
-            logger.info("${patch.name} succeeded")
        }
-    }

    suspend fun run(output: File, selectedPatches: PatchList) {
-        runStep(StepId.ExecutePatches, onEvent) {
+        val indices = HashMap<Patch, Int>(selectedPatches.size)
+        selectedPatches.forEachIndexed { idx, patch -> indices[patch] = idx }
+
+        val result = runStep(StepId.ExecutePatches, onEvent) {
            java.util.logging.Logger.getLogger("").apply {
                handlers.forEach {
                    it.close()
@@ -73,18 +78,21 @@ class Session(
                addHandler(logger.handler)
            }

-            with(patcher) {
-                logger.info("Merging integrations")
-                this += selectedPatches.toSet()
-
-                logger.info("Applying patches...")
-                applyPatchesVerbose(selectedPatches.sortedBy { it.name })
+            val patcher = patcher(
+                apkFile = input,
+                temporaryFilesPath = tempDir,
+                frameworkFileDirectory = frameworkDir,
+                aaptBinaryPath = File(aaptPath)
+            ) { _packageName, _version ->
+                selectedPatches.toSet()
            }
+
+            logger.info("Applying patches...")
+            applyPatchesVerbose(patcher, indices)
        }

        runStep(StepId.WriteAPK, onEvent) {
            logger.info("Writing patched files...")
-            val result = patcher.get()

            val patched = tempDir.resolve("result.apk")
            withContext(Dispatchers.IO) {
@@ -102,7 +110,6 @@ class Session(

    override fun close() {
        tempDir.deleteRecursively()
-        patcher.close()
    }

    companion object {
--- a/app/src/main/java/app/revanced/manager/patcher/patch/PatchBundle.kt
+++ b/app/src/main/java/app/revanced/manager/patcher/patch/PatchBundle.kt
@@ -2,7 +2,8 @@ package app.revanced.manager.patcher.patch

 import kotlinx.parcelize.IgnoredOnParcel
 import android.os.Parcelable
-import app.revanced.patcher.patch.loadPatchesFromDex
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.loadPatches
 import kotlinx.parcelize.Parcelize
 import java.io.File
 import java.io.IOException
@@ -54,31 +55,45 @@ data class PatchBundle(val patchesJar: String) : Parcelable {
    )

    object Loader {
-        private fun patches(bundles: Iterable<PatchBundle>) =
-            loadPatchesFromDex(
-                bundles.map { File(it.patchesJar) }.toSet()
-            ).byPatchesFile.mapKeys { (file, _) ->
-                val absPath = file.absolutePath
-                bundles.single { absPath == it.patchesJar }
+        private fun patches(bundles: Iterable<PatchBundle>) = buildMap {
+            val bundleMap = bundles.associateBy { it.patchesJar }
+
+            loadPatches(
+                *bundleMap.keys.map(::File).toTypedArray(),
+                onFailedToLoad = { file, throwable ->
+                    this[bundleMap[file.absolutePath]!!] = Result.failure(throwable)
+                }
+            ).patchesByFile.forEach { (file, patches) ->
+                putIfAbsent(bundleMap[file.absolutePath]!!, Result.success(patches))
+            }
+        }
+
+        fun metadata(bundles: Iterable<PatchBundle>): Map<PatchBundle, Result<Set<PatchInfo>>> =
+            patches(bundles).mapValues { (_, result) ->
+                result.map { patches ->
+                    patches.mapTo(
+                        HashSet(patches.size),
+                        ::PatchInfo
+                    )
+                }
            }

-        fun metadata(bundles: Iterable<PatchBundle>) =
-            patches(bundles).mapValues { (_, patches) -> patches.map(::PatchInfo) }
+        fun patches(bundles: Iterable<PatchBundle>, packageName: String): Map<PatchBundle, Set<Patch>> =
+            patches(bundles).mapValues { (_, result) ->
+                val patches = result.getOrDefault(emptySet())

-        fun patches(bundles: Iterable<PatchBundle>, packageName: String) =
-            patches(bundles).mapValues { (_, patches) ->
-                patches.filter { patch ->
+                patches.filterTo(HashSet(patches.size)) { patch ->
                    val compatiblePackages = patch.compatiblePackages
                        ?: // The patch has no compatibility constraints, which means it is universal.
-                        return@filter true
+                        return@filterTo true

                    if (!compatiblePackages.any { (name, _) -> name == packageName }) {
                        // Patch is not compatible with this package.
-                        return@filter false
+                        return@filterTo false
                    }

                    true
-                }.toSet()
+                }
            }
    }
-}
+}
--- a/app/src/main/java/app/revanced/manager/patcher/patch/PatchBundleInfo.kt
+++ b/app/src/main/java/app/revanced/manager/patcher/patch/PatchBundleInfo.kt
@@ -137,7 +137,7 @@ sealed class PatchBundleInfo {
                    it.options.all option@{ option ->
                        if (!option.required || option.default != null) return@option true

-                        option.key in opts
+                        option.name in opts
                    }
                }
        }
--- a/app/src/main/java/app/revanced/manager/patcher/patch/PatchInfo.kt
+++ b/app/src/main/java/app/revanced/manager/patcher/patch/PatchInfo.kt
@@ -17,7 +17,7 @@ data class PatchInfo(
    val compatiblePackages: ImmutableList<CompatiblePackage>?,
    val options: ImmutableList<Option<*>>?
 ) {
-    constructor(patch: Patch<*>) : this(
+    constructor(patch: Patch) : this(
        patch.name.orEmpty(),
        patch.description,
        patch.use,
@@ -49,7 +49,7 @@ data class PatchInfo(
     * The resulting patch cannot be executed.
     * This is necessary because some functions in ReVanced Library only accept full [Patch] objects.
     */
-    fun toPatcherPatch(): Patch<*> =
+    fun toPatcherPatch(): Patch =
        resourcePatch(name = name, description = description, use = include) {
            compatiblePackages?.let { pkgs ->
                compatibleWith(*pkgs.map { it.packageName to it.versions }.toTypedArray())
@@ -65,8 +65,7 @@ data class CompatiblePackage(

@Immutable
 data class Option<T>(
-    val title: String,
-    val key: String,
+    val name: String,
    val description: String,
    val required: Boolean,
    val type: KType,
@@ -75,8 +74,7 @@ data class Option<T>(
    val validator: (T?) -> Boolean,
 ) {
    constructor(option: PatchOption<T>) : this(
-        option.title ?: option.key,
-        option.key,
+        option.name,
        option.description.orEmpty(),
        option.required,
        option.type,
--- a/app/src/main/java/app/revanced/manager/ui/component/bundle/BundlePatchesDialog.kt
+++ b/app/src/main/java/app/revanced/manager/ui/component/bundle/BundlePatchesDialog.kt
@@ -212,7 +212,7 @@ fun PatchItem(
                                    verticalArrangement = Arrangement.spacedBy(4.dp),
                                ) {
                                    Text(
-                                        text = option.title,
+                                        text = option.name,
                                        style = MaterialTheme.typography.titleMedium,
                                        color = MaterialTheme.colorScheme.primary
                                    )
--- a/app/src/main/java/app/revanced/manager/ui/component/haptics/HapticTriStateCheckbox.kt
+++ b/app/src/main/java/app/revanced/manager/ui/component/haptics/HapticTriStateCheckbox.kt
@@ -0,0 +1,31 @@
+package app.revanced.manager.ui.component.haptics
+
+import android.view.HapticFeedbackConstants
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.material3.CheckboxColors
+import androidx.compose.material3.CheckboxDefaults
+import androidx.compose.material3.TriStateCheckbox
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.state.ToggleableState
+import app.revanced.manager.util.withHapticFeedback
+
+@Composable
+fun HapticTriStateCheckbox(
+    state: ToggleableState,
+    onClick: (() -> Unit)?,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+    colors: CheckboxColors = CheckboxDefaults.colors(),
+    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() }
+) {
+    TriStateCheckbox(
+        state = state,
+        onClick = onClick?.withHapticFeedback(HapticFeedbackConstants.CLOCK_TICK),
+        modifier = modifier,
+        enabled = enabled,
+        colors = colors,
+        interactionSource = interactionSource
+    )
+}
--- a/app/src/main/java/app/revanced/manager/ui/component/patches/OptionFields.kt
+++ b/app/src/main/java/app/revanced/manager/ui/component/patches/OptionFields.kt
@@ -205,7 +205,7 @@ fun <T : Any> OptionItem(
    WithOptionEditor(editor, option, value, setValue, selectionWarningEnabled) {
        ListItem(
            modifier = Modifier.clickable(onClick = ::clickAction),
-            headlineContent = { Text(option.title) },
+            headlineContent = { Text(option.name) },
            supportingContent = {
                Column {
                    Text(option.description)
@@ -250,7 +250,7 @@ private object StringOptionEditor : OptionEditor<String> {

        AlertDialog(
            onDismissRequest = scope.dismissDialog,
-            title = { Text(scope.option.title) },
+            title = { Text(scope.option.name) },
            text = {
                OutlinedTextField(
                    value = fieldValue,
@@ -330,7 +330,7 @@ private abstract class NumberOptionEditor<T : Number> : OptionEditor<T> {

    @Composable
    override fun Dialog(scope: OptionEditorScope<T>) {
-        NumberDialog(scope.option.title, scope.value, scope.option.validator) {
+        NumberDialog(scope.option.name, scope.value, scope.option.validator) {
            if (it == null) return@NumberDialog scope.dismissDialog()

            scope.submitDialog(it)
@@ -455,7 +455,7 @@ private class PresetOptionEditor<T : Any>(private val innerEditor: OptionEditor<
                        Text(stringResource(R.string.cancel))
                    }
                },
-                title = { Text(scope.option.title) },
+                title = { Text(scope.option.name) },
                textHorizontalPadding = PaddingValues(horizontal = 0.dp),
                text = {
                    val presets = remember(scope.option.presets) {
@@ -496,8 +496,7 @@ private class PresetOptionEditor<T : Any>(private val innerEditor: OptionEditor<
 private class ListOptionEditor<T : Serializable>(private val elementEditor: OptionEditor<T>) :
    OptionEditor<List<T>> {
    private fun createElementOption(option: Option<List<T>>) = Option<T>(
-        option.title,
-        option.key,
+        option.name,
        option.description,
        option.required,
        option.type.arguments.first().type!!,
@@ -566,7 +565,7 @@ private class ListOptionEditor<T : Serializable>(private val elementEditor: Opti
                            R.plurals.selected_count,
                            deletionTargets.size,
                            deletionTargets.size
-                        ) else scope.option.title,
+                        ) else scope.option.name,
                        onBackClick = back,
                        backIcon = {
                            if (deleteMode) {
--- a/app/src/main/java/app/revanced/manager/ui/model/navigation/Nav.kt
+++ b/app/src/main/java/app/revanced/manager/ui/model/navigation/Nav.kt
@@ -1,6 +1,7 @@
 package app.revanced.manager.ui.model.navigation

 import android.os.Parcelable
+import app.revanced.manager.network.dto.ReVancedAnnouncement
 import app.revanced.manager.ui.model.SelectedApp
 import app.revanced.manager.util.Options
 import app.revanced.manager.util.PatchSelection
@@ -22,6 +23,12 @@ data class InstalledApplicationInfo(val packageName: String)
@Serializable
 data class Update(val downloadOnScreenEntry: Boolean = false)

+@Serializable
+data object Announcements
+
+@Serializable
+data object Announcement : ComplexParameter<ReVancedAnnouncement>
+
@Serializable
 data object SelectedApplicationInfo : ComplexParameter<SelectedApplicationInfo.ViewModelParams> {
    @Parcelize
--- a/app/src/main/java/app/revanced/manager/ui/screen/AnnouncementScreen.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/AnnouncementScreen.kt
@@ -0,0 +1,136 @@
+package app.revanced.manager.ui.screen
+
+import android.annotation.SuppressLint
+import android.view.MotionEvent
+import android.webkit.WebView
+import android.widget.FrameLayout
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.TwoRowsTopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.view.children
+import app.revanced.manager.R
+import app.revanced.manager.network.dto.ReVancedAnnouncement
+import app.revanced.manager.util.relativeTime
+import org.intellij.lang.annotations.Language
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+fun AnnouncementScreen(
+    onBackClick: () -> Unit,
+    announcement: ReVancedAnnouncement
+) {
+    val scrollState = rememberScrollState()
+    val scrollBehavior = TopAppBarDefaults.enterAlwaysScrollBehavior(
+        canScroll = {
+            scrollState.canScrollBackward || scrollState.canScrollForward
+        }
+    )
+    val textColor = MaterialTheme.colorScheme.onSurface
+    val linkColor = MaterialTheme.colorScheme.primary
+
+    Scaffold(
+        topBar = {
+            TwoRowsTopAppBar(
+                title = { expanded ->
+                    Text(
+                        text = announcement.title,
+                        style = if (expanded) MaterialTheme.typography.headlineSmall else MaterialTheme.typography.titleMedium
+                    )
+                },
+                subtitle = {
+                    val createDate = announcement.createdAt.relativeTime(LocalContext.current)
+                    Text("$createDate · ${announcement.author}")
+                },
+                navigationIcon = {
+                    IconButton(onClick = onBackClick) {
+                        Icon(
+                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.back)
+                        )
+                    }
+                },
+                scrollBehavior = scrollBehavior
+            )
+        }
+    ) { paddingValues ->
+        AndroidView(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(paddingValues)
+                .nestedScroll(scrollBehavior.nestedScrollConnection)
+                .verticalScroll(scrollState)
+                .padding(horizontal = 10.dp),
+            factory = {
+                val webView = WebView(it).apply {
+                    setBackgroundColor(0)
+                    isVerticalScrollBarEnabled = false
+                    isHorizontalScrollBarEnabled = false
+                    isLongClickable = false
+                    setOnLongClickListener { true }
+                    isHapticFeedbackEnabled = false
+                    layoutParams = FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT)
+
+                    // Disable WebView's internal scrolling
+                    @SuppressLint("ClickableViewAccessibility")
+                    setOnTouchListener { _, event ->
+                        event.action == MotionEvent.ACTION_MOVE
+                    }
+                }
+                FrameLayout(it).apply {
+                    addView(webView)
+                }
+            },
+            update = {
+                val webView = it.children.first() as WebView
+                @Language("HTML")
+                val style = """
+                    <html>
+                      <head>
+                        <meta name="viewport" content="width=device-width, initial-scale=1" />
+                        <style>
+                          body {
+                            color: ${textColor.toCss()};
+                          }
+                          a {
+                            color: ${linkColor.toCss()};
+                          }
+                        </style>
+                      </head>
+                      <body>
+                        ${announcement.content}
+                      </body>
+                    </html>
+                """.trimIndent()
+                webView.loadData(style, "text/html", "UTF-8")
+            },
+            onRelease = {
+                val webView = it.children.first() as WebView
+                webView.destroy()
+            }
+        )
+    }
+}
+
+private fun Color.toCss(): String {
+    return "rgba(${red * 255f}, ${green * 255f}, ${blue * 255f}, $alpha)"
+}
--- a/app/src/main/java/app/revanced/manager/ui/screen/AnnouncementsScreen.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/AnnouncementsScreen.kt
@@ -0,0 +1,327 @@
+package app.revanced.manager.ui.screen
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ChevronRight
+import androidx.compose.material.icons.outlined.FilterAlt
+import androidx.compose.material.icons.outlined.Inventory2
+import androidx.compose.material3.Badge
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.revanced.manager.R
+import app.revanced.manager.network.dto.ReVancedAnnouncement
+import app.revanced.manager.ui.component.AppTopBar
+import app.revanced.manager.ui.component.LazyColumnWithScrollbar
+import app.revanced.manager.ui.component.LoadingIndicator
+import app.revanced.manager.ui.viewmodel.AnnouncementsViewModel
+import app.revanced.manager.util.relativeTime
+import app.revanced.manager.util.transparentListItemColors
+import org.koin.androidx.compose.koinViewModel
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AnnouncementsScreen(
+    onBackClick: () -> Unit,
+    onAnnouncementClick: (ReVancedAnnouncement) -> Unit,
+    vm: AnnouncementsViewModel = koinViewModel(),
+) {
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+    var showFilterSheet by rememberSaveable { mutableStateOf(false) }
+    val tags by vm.tags.collectAsStateWithLifecycle(null)
+    val selectedTags by vm.selectedTags.getAsState()
+    val showArchived by vm.showArchived.collectAsStateWithLifecycle()
+    val announcements by vm.announcements.collectAsStateWithLifecycle(emptyList())
+
+    if (showFilterSheet) {
+        FilterBottomSheet(
+            onDismissRequest = { showFilterSheet = false },
+            tags = tags.orEmpty(),
+            selectedTags = selectedTags,
+            showArchived = showArchived,
+            onShowArchivedChange = { vm.showArchived.value = it },
+            onReset = vm::resetTagSelection,
+            changeSelection = vm::changeTagSelection
+        )
+    }
+
+    Scaffold(
+        topBar = {
+            AppTopBar(
+                title = { Text(stringResource(R.string.announcements)) },
+                onBackClick = onBackClick,
+                actions = {
+                    if (tags != null) {
+                        IconButton(onClick = { showFilterSheet = true }) {
+                            Icon(
+                                imageVector = Icons.Outlined.FilterAlt,
+                                contentDescription = stringResource(R.string.announcements_filter_tag)
+                            )
+                        }
+                    }
+                },
+                scrollBehavior = scrollBehavior
+            )
+        }
+    ) { paddingValues ->
+        val readAnnouncements by vm.readAnnouncements.getAsState()
+        LazyColumnWithScrollbar(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(paddingValues)
+                .nestedScroll(scrollBehavior.nestedScrollConnection),
+            verticalArrangement = if (announcements.isNullOrEmpty()) Arrangement.Center else Arrangement.Top,
+            horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+            announcements?.let { announcements ->
+                if (announcements.isEmpty()) {
+                    item {
+                        Text(
+                            text = stringResource(id = R.string.no_announcements_found),
+                            style = MaterialTheme.typography.titleLarge
+                        )
+                    }
+                } else {
+                    itemsIndexed(
+                        items = announcements,
+                        key = { _, announcement ->
+                            announcement.id
+                        }
+                    ) { i, announcement ->
+                        if (i != 0) {
+                            HorizontalDivider(
+                                modifier = Modifier.fillMaxWidth()
+                            )
+                        }
+
+                        AnnouncementCard(
+                            modifier = Modifier
+                                .fillMaxWidth(),
+                            onClick = {
+                                vm.markAnnouncementRead(announcement.id)
+                                onAnnouncementClick(announcement)
+                            },
+                            title = announcement.title,
+                            date = announcement.createdAt.relativeTime(LocalContext.current),
+                            author = announcement.author,
+                            content = announcement.content,
+                            unread = announcement.id !in readAnnouncements,
+                            archived = announcement.isArchived
+                        )
+                    }
+                }
+            } ?: item {
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.Center
+                ) {
+                    LoadingIndicator()
+                }
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun FilterBottomSheet(
+    onDismissRequest: () -> Unit,
+    tags: Set<String>,
+    selectedTags: Set<String>,
+    showArchived: Boolean,
+    onShowArchivedChange: (Boolean) -> Unit,
+    onReset: () -> Unit,
+    changeSelection: (String) -> Unit
+) {
+    ModalBottomSheet(onDismissRequest = onDismissRequest) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(12.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+            Text(
+                text = stringResource(R.string.announcements_filter_tag),
+                style = MaterialTheme.typography.titleMedium
+            )
+            FlowRow(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                tags.forEach { tag ->
+                    FilterChip(
+                        selected = tag in selectedTags,
+                        onClick = {
+                            changeSelection(tag)
+                        },
+                        label = { Text(tag) }
+                    )
+                }
+            }
+
+            ListItem(
+                modifier = Modifier.clickable(onClick = { onShowArchivedChange(!showArchived) }),
+                headlineContent = { Text(text = stringResource(R.string.announcements_show_archived)) },
+                trailingContent = {
+                    Switch(
+                        checked = showArchived,
+                        onCheckedChange = onShowArchivedChange
+                    )
+                },
+                colors = transparentListItemColors
+            )
+
+            TextButton(modifier = Modifier.align(Alignment.End), onClick = onReset) {
+                Text(stringResource(R.string.reset))
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnnouncementCard(
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit,
+    title: String,
+    date: String,
+    author: String,
+    content: String,
+    unread: Boolean,
+    archived: Boolean
+) {
+    Column(
+        modifier = modifier
+            .clickable(onClick = onClick)
+            .background(if (unread) MaterialTheme.colorScheme.surfaceContainerLow else MaterialTheme.colorScheme.surface)
+            .padding(12.dp),
+        verticalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = title,
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = if (unread) FontWeight.ExtraBold else null
+                )
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(4.dp)
+                ) {
+                    Text(
+                        text = "$date • $author",
+                        style = MaterialTheme.typography.labelMedium,
+                        fontWeight = if (unread) FontWeight.ExtraBold else null
+                    )
+                    if (archived) {
+                        Icon(
+                            Icons.Outlined.Inventory2,
+                            contentDescription = null,
+                            modifier = Modifier.size(12.dp)
+                        )
+                    }
+                    if (unread) {
+                        Badge(modifier = Modifier.size(6.dp))
+                    }
+                }
+            }
+            Icon(Icons.Default.ChevronRight, contentDescription = null)
+        }
+        // TODO add announcement summary
+//        val textColor = MaterialTheme.colorScheme.onSurface
+//        val linkColor = MaterialTheme.colorScheme.primary
+//        AndroidView(
+//            factory = {
+//                WebView(it).apply {
+//                    setBackgroundColor(0)
+//                    isVerticalScrollBarEnabled = false
+//                    isHorizontalScrollBarEnabled = false
+//                    isLongClickable = false
+//                    setOnLongClickListener { true }
+//                    isHapticFeedbackEnabled = false
+//
+//                    // Disable WebView's internal scrolling
+//                    @SuppressLint("ClickableViewAccessibility")
+//                    setOnTouchListener { _, event ->
+//                        event.action == MotionEvent.ACTION_MOVE
+//                    }
+//                }
+//            },
+//            update = {
+//                @Language("HTML")
+//                val body = """
+//                  <html>
+//                    <head>
+//                      <meta name="viewport" content="width=device-width, initial-scale=1" />
+//                      <style>
+//                        * {
+//                          font-size: 12px;
+//                          font-weight: normal;
+//                        }
+//                        body {
+//                          margin: 0;
+//                          padding: 0;
+//                          color: ${textColor.toCss()};
+//                          overflow: hidden;
+//                          display: -webkit-box;
+//                          -webkit-box-orient: vertical;
+//                          -webkit-line-clamp: 3;
+//                          text-overflow: ellipsis;
+//                        }
+//                        a {
+//                          color: ${linkColor.toCss()};
+//                        }
+//                      </style>
+//                    </head>
+//                    <body>
+//                      $content
+//                    </body>
+//                  </html>
+//                """.trimIndent()
+//
+//                it.loadData(body, "text/html", "UTF-8")
+//            },
+//            onReset = {},
+//            onRelease = { it.destroy() }
+//        )
+    }
+}
+
+//private fun Color.toCss(): String {
+//    return "rgba(${red * 255f}, ${green * 255f}, ${blue * 255f}, $alpha)"
+//}
--- a/app/src/main/java/app/revanced/manager/ui/screen/AppSelectorScreen.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/AppSelectorScreen.kt
@@ -24,9 +24,9 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberTopAppBarState
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -68,20 +68,11 @@ fun AppSelectorScreen(
            uri?.let(vm::handleStorageResult)
        }

-    val suggestedVersions by vm.suggestedAppVersions.collectAsStateWithLifecycle(emptyMap())
+    val suggestedVersions by vm.suggestedAppVersions.collectAsStateWithLifecycle()

-    var filterText by rememberSaveable { mutableStateOf("") }
    var search by rememberSaveable { mutableStateOf(false) }
-
-    val appList by vm.appList.collectAsStateWithLifecycle(initialValue = emptyList())
-    val filteredAppList = remember(appList, filterText) {
-        appList.filter { app ->
-            (vm.loadLabel(app.packageInfo)).contains(
-                filterText,
-                true
-            ) or app.packageName.contains(filterText, true)
-        }
-    }
+    val appList by vm.apps.collectAsStateWithLifecycle()
+    val appsListFiltered by vm.filteredApps.collectAsStateWithLifecycle()

    vm.nonSuggestedVersionDialogSubject?.let {
        NonSuggestedVersionDialog(
@@ -90,17 +81,20 @@ fun AppSelectorScreen(
        )
    }

-    if (search)
+    if (search) {
+        val filterText by vm.filterText.collectAsState()
+
        SearchView(
            query = filterText,
-            onQueryChange = { filterText = it },
+            onQueryChange = vm::setFilterText,
            onActiveChange = { search = it },
            placeholder = { Text(stringResource(R.string.search_apps)) }
        ) {
-            if (appList.isNotEmpty() && filterText.isNotEmpty()) {
+            val appsFiltered = appsListFiltered
+            if (!appsFiltered.isNullOrEmpty() && filterText.isNotEmpty()) {
                LazyColumnWithScrollbar(modifier = Modifier.fillMaxSize()) {
                    items(
-                        items = filteredAppList,
+                        items = appsFiltered,
                        key = { it.packageName }
                    ) { app ->
                        ListItem(
@@ -109,9 +103,9 @@ fun AppSelectorScreen(
                            },
                            leadingContent = {
                                AppIcon(
-                                    app.packageInfo,
-                                    null,
-                                    Modifier.size(36.dp)
+                                    packageInfo = app.packageInfo,
+                                    contentDescription = null,
+                                    modifier = Modifier.size(36.dp)
                                )
                            },
                            headlineContent = { AppLabel(app.packageInfo) },
@@ -152,6 +146,7 @@ fun AppSelectorScreen(
                }
            }
        }
+    }

    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())

@@ -198,16 +193,33 @@ fun AppSelectorScreen(
                HorizontalDivider()
            }

-            if (appList.isNotEmpty()) {
+            val apps = appList
+            if (apps == null) {
+                item(key = "LOADING") {
+                    Box(
+                        modifier = Modifier.fillParentMaxSize(),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        LoadingIndicator()
+                    }
+                }
+            } else if (apps.isNotEmpty()) {
                items(
-                    items = appList,
-                    key = { it.packageName }
+                    items = apps,
+                    key = { "APP-" + it.packageName },
+                    contentType = { "APP" },
                ) { app ->
                    ListItem(
                        modifier = Modifier.clickable {
                            onSelect(app.packageName)
                        },
-                        leadingContent = { AppIcon(app.packageInfo, null, Modifier.size(36.dp)) },
+                        leadingContent = {
+                            AppIcon(
+                                packageInfo = app.packageInfo,
+                                contentDescription = null,
+                                modifier = Modifier.size(36.dp)
+                            )
+                        },
                        headlineContent = {
                            AppLabel(
                                app.packageInfo,
@@ -231,15 +243,6 @@ fun AppSelectorScreen(
                            }
                        }
                    )
-
-                }
-            } else {
-                item {
-                    Box(
-                        modifier = Modifier.fillParentMaxSize(), contentAlignment = Alignment.Center
-                    ) {
-                        LoadingIndicator()
-                    }
                }
            }
        }
--- a/app/src/main/java/app/revanced/manager/ui/screen/AppliedPatchesDialog.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/AppliedPatchesDialog.kt
@@ -0,0 +1,74 @@
+package app.revanced.manager.ui.screen
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ListItem
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.rememberTopAppBarState
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.revanced.manager.R
+import app.revanced.manager.data.room.apps.installed.InstalledPatchBundle
+import app.revanced.manager.ui.component.AppTopBar
+import app.revanced.manager.ui.component.FullscreenDialog
+import app.revanced.manager.ui.component.LazyColumnWithScrollbar
+import app.revanced.manager.util.PatchSelection
+import app.revanced.manager.util.transparentListItemColors
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AppliedPatchesDialog(
+    onDismissRequest: () -> Unit,
+    appliedPatches: PatchSelection?,
+    patchBundles: List<InstalledPatchBundle>
+) {
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
+
+    FullscreenDialog(onDismissRequest = onDismissRequest) {
+        Scaffold(
+            topBar = {
+                AppTopBar(
+                    title = stringResource(R.string.applied_patches),
+                    scrollBehavior = scrollBehavior,
+                    onBackClick = onDismissRequest
+                )
+            },
+        ) { paddingValues ->
+            LazyColumnWithScrollbar(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(paddingValues)
+            ) {
+                val patches = appliedPatches ?: return@LazyColumnWithScrollbar
+                val bundleMap = patchBundles.associateBy { it.bundleUid }
+
+                patches.forEach { (bundleUid, patchNames) ->
+                    val bundle = bundleMap[bundleUid]
+
+                    item(key = "header_$bundleUid") {
+                        ListHeader(title = bundle?.let {
+                            it.bundleVersion?.let { version ->
+                                "${it.bundleName} v$version"
+                            } ?: it.bundleName
+                        } ?: "${stringResource(R.string.patches)} $bundleUid")
+                    }
+
+                    items(
+                        items = patchNames.sorted(),
+                        key = { "${bundleUid}_$it" }
+                    ) { patchName ->
+                        ListItem(
+                            headlineContent = { Text(patchName) },
+                            colors = transparentListItemColors
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
--- a/app/src/main/java/app/revanced/manager/ui/screen/DashboardScreen.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/DashboardScreen.kt
@@ -19,11 +19,13 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.BatteryAlert
 import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Notifications
 import androidx.compose.material.icons.outlined.Apps
 import androidx.compose.material.icons.outlined.BugReport
 import androidx.compose.material.icons.outlined.Delete
 import androidx.compose.material.icons.outlined.DeleteOutline
 import androidx.compose.material.icons.outlined.Download
+import androidx.compose.material.icons.outlined.Notifications
 import androidx.compose.material.icons.outlined.Refresh
 import androidx.compose.material.icons.outlined.Settings
 import androidx.compose.material.icons.outlined.Source
@@ -58,6 +60,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import app.revanced.manager.R
+import app.revanced.manager.network.dto.ReVancedAnnouncement
 import app.revanced.manager.patcher.aapt.Aapt
 import app.revanced.manager.ui.component.AlertDialogExtended
 import app.revanced.manager.ui.component.AppTopBar
@@ -91,6 +94,8 @@ fun DashboardScreen(
    onAppSelectorClick: () -> Unit,
    onSettingsClick: () -> Unit,
    onUpdateClick: () -> Unit,
+    onAnnouncementsClick: () -> Unit,
+    onAnnouncementClick: (ReVancedAnnouncement) -> Unit,
    onDownloaderClick: () -> Unit,
    onAppClick: (String) -> Unit
 ) {
@@ -130,17 +135,16 @@ fun DashboardScreen(
        )
    }

-    var showUpdateDialog by rememberSaveable { mutableStateOf(vm.prefs.showManagerUpdateDialogOnLaunch.getBlocking()) }
-    val availableUpdate by remember {
-        derivedStateOf { vm.updatedManagerVersion.takeIf { showUpdateDialog } }
-    }
+    var showUpdateDialog by rememberSaveable { mutableStateOf(true) }
+    val showManagerUpdateDialogOnLaunch by vm.prefs.showManagerUpdateDialogOnLaunch.getAsState()
+    val availableUpdate = vm.updatedManagerVersion

-    availableUpdate?.let { version ->
+    if (showUpdateDialog && showManagerUpdateDialogOnLaunch && availableUpdate != null) {
        AvailableUpdateDialog(
            onDismiss = { showUpdateDialog = false },
            setShowManagerUpdateDialogOnLaunch = vm::setShowManagerUpdateDialogOnLaunch,
            onConfirm = onUpdateClick,
-            newVersion = version
+            newVersion = availableUpdate
        )
    }

@@ -220,6 +224,20 @@ fun DashboardScreen(
                                }
                            }
                        }
+                        IconButton(onClick = onAnnouncementsClick) {
+                            BadgedBox(
+                                badge = {
+                                    if (vm.unreadAnnouncement != null) {
+                                        Badge(modifier = Modifier.size(6.dp))
+                                    }
+                                }
+                            ) {
+                                Icon(
+                                    Icons.Outlined.Notifications,
+                                    stringResource(R.string.announcements)
+                                )
+                            }
+                        }
                        IconButton(onClick = onSettingsClick) {
                            Icon(Icons.Outlined.Settings, stringResource(R.string.settings))
                        }
@@ -322,7 +340,29 @@ fun DashboardScreen(
                            }
                        )
                    }
-                } else null
+                } else null,
+                vm.unreadAnnouncement?.let { announcement ->
+                    {
+                        NotificationCard(
+                            text = stringResource(R.string.new_announcement, announcement.title),
+                            icon = Icons.Filled.Notifications,
+                            actions = {
+                                TextButton(onClick = vm::markUnreadAnnouncementRead) {
+                                    Text(stringResource(R.string.dismiss))
+                                }
+                                TextButton(
+                                    onClick = {
+                                        vm.markUnreadAnnouncementRead()
+                                        onAnnouncementClick(announcement)
+                                    }
+                                ) {
+                                    Text(stringResource(R.string.view_announcement))
+                                }
+                            },
+                            isWarning = announcement.level > 0
+                        )
+                    }
+                }
            )

            HorizontalPager(
--- a/app/src/main/java/app/revanced/manager/ui/screen/InstalledAppInfoScreen.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/InstalledAppInfoScreen.kt
@@ -32,7 +32,6 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.pluralStringResource
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
@@ -44,7 +43,6 @@ import app.revanced.manager.ui.component.ColumnWithScrollbar
 import app.revanced.manager.ui.component.SegmentedButton
 import app.revanced.manager.ui.component.settings.SettingsListItem
 import app.revanced.manager.ui.viewmodel.InstalledAppInfoViewModel
-import app.revanced.manager.util.toast

@OptIn(ExperimentalMaterial3Api::class)
@Composable
@@ -53,19 +51,26 @@ fun InstalledAppInfoScreen(
    onBackClick: () -> Unit,
    viewModel: InstalledAppInfoViewModel
 ) {
-    val context = LocalContext.current

    SideEffect {
        viewModel.onBackClick = onBackClick
    }

    var showUninstallDialog by rememberSaveable { mutableStateOf(false) }
+    var showAppliedPatchesDialog by rememberSaveable { mutableStateOf(false) }

    if (showUninstallDialog)
        UninstallDialog(
            onDismiss = { showUninstallDialog = false },
            onConfirm = { viewModel.uninstall() }
        )
+    if (showAppliedPatchesDialog) {
+        AppliedPatchesDialog(
+            onDismissRequest = { showAppliedPatchesDialog = false },
+            appliedPatches = viewModel.appliedPatches,
+            patchBundles = viewModel.patchBundles
+        )
+    }

    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())

@@ -152,7 +157,7 @@ fun InstalledAppInfoScreen(
                modifier = Modifier.padding(vertical = 16.dp)
            ) {
                SettingsListItem(
-                    modifier = Modifier.clickable { context.toast("Not implemented yet!") },
+                    modifier = Modifier.clickable(onClick = { showAppliedPatchesDialog = true }),
                    headlineContent = stringResource(R.string.applied_patches),
                    supportingContent = 
                            (viewModel.appliedPatches?.values?.sumOf { it.size } ?: 0).let {
--- a/app/src/main/java/app/revanced/manager/ui/screen/InstalledAppsScreen.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/InstalledAppsScreen.kt
@@ -10,6 +10,7 @@ import androidx.compose.material3.ListItem
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -30,7 +31,7 @@ fun InstalledAppsScreen(
    onAppClick: (InstalledApp) -> Unit,
    viewModel: InstalledAppsViewModel = koinViewModel()
 ) {
-    val installedApps by viewModel.apps.collectAsStateWithLifecycle(initialValue = null)
+    val installedApps by viewModel.apps.collectAsStateWithLifecycle()

    Column {
        LazyColumnWithScrollbar(
@@ -38,38 +39,40 @@ fun InstalledAppsScreen(
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = if (installedApps.isNullOrEmpty()) Arrangement.Center else Arrangement.Top,
        ) {
-            installedApps?.let { installedApps ->
-                if (installedApps.isNotEmpty()) {
-                    items(
-                        installedApps,
-                        key = { it.currentPackageName }
-                    ) { installedApp ->
-                        viewModel.packageInfoMap[installedApp.currentPackageName].let { packageInfo ->
-                            ListItem(
-                                modifier = Modifier.clickable { onAppClick(installedApp) },
-                                leadingContent = {
-                                    AppIcon(
-                                        packageInfo,
-                                        contentDescription = null,
-                                        Modifier.size(36.dp)
-                                    )
-                                },
-                                headlineContent = { AppLabel(packageInfo, defaultText = null) },
-                                supportingContent = { Text(installedApp.currentPackageName) }
-                            )
-
-                        }
-                    }
-                } else {
-                    item {
-                        Text(
-                            text = stringResource(R.string.no_patched_apps_found),
-                            style = MaterialTheme.typography.titleLarge
-                        )
-                    }
+            val apps = installedApps
+            if (apps == null) {
+                item(key = "LOADING") {
+                    LoadingIndicator()
                }
+            } else if (apps.isNotEmpty()) {
+                items(
+                    apps,
+                    key = { "APP-" + it.currentPackageName },
+                    contentType = { "APP" },
+                ) { installedApp ->
+                    val packageInfo = viewModel.packageInfoMap[installedApp.currentPackageName]

-            } ?: item { LoadingIndicator() }
+                    ListItem(
+                        modifier = Modifier.clickable { onAppClick(installedApp) },
+                        leadingContent = {
+                            AppIcon(
+                                packageInfo,
+                                contentDescription = null,
+                                Modifier.size(36.dp)
+                            )
+                        },
+                        headlineContent = { AppLabel(packageInfo, defaultText = null) },
+                        supportingContent = { Text(installedApp.currentPackageName) }
+                    )
+                }
+            } else {
+                item(key = "NONE") {
+                    Text(
+                        text = stringResource(R.string.no_patched_apps_found),
+                        style = MaterialTheme.typography.titleLarge
+                    )
+                }
+            }
        }
    }
 }
--- a/app/src/main/java/app/revanced/manager/ui/screen/PatchesSelectorScreen.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/PatchesSelectorScreen.kt
@@ -15,9 +15,12 @@ import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.lazy.LazyListScope
 import androidx.compose.foundation.lazy.LazyListState
 import androidx.compose.foundation.lazy.items
@@ -27,13 +30,16 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
 import androidx.compose.material.icons.automirrored.outlined.HelpOutline
 import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.outlined.Deselect
 import androidx.compose.material.icons.outlined.FilterList
 import androidx.compose.material.icons.outlined.Restore
 import androidx.compose.material.icons.outlined.Save
 import androidx.compose.material.icons.outlined.Settings
+import androidx.compose.material.icons.outlined.SwapHoriz
 import androidx.compose.material.icons.outlined.WarningAmber
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.ListItem
@@ -60,7 +66,9 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.state.ToggleableState
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import app.revanced.manager.R
 import app.revanced.manager.patcher.patch.Option
@@ -74,6 +82,7 @@ import app.revanced.manager.ui.component.SearchBar
 import app.revanced.manager.ui.component.haptics.HapticCheckbox
 import app.revanced.manager.ui.component.haptics.HapticExtendedFloatingActionButton
 import app.revanced.manager.ui.component.haptics.HapticTab
+import app.revanced.manager.ui.component.haptics.HapticTriStateCheckbox
 import app.revanced.manager.ui.component.patches.OptionItem
 import app.revanced.manager.ui.component.patches.SelectionWarningDialog
 import app.revanced.manager.ui.viewmodel.PatchesSelectorViewModel
@@ -124,7 +133,39 @@ fun PatchesSelectorScreen(

    val patchLazyListStates = remember(bundles) { List(bundles.size) { LazyListState() } }

+    var showSelectionWarning by rememberSaveable { mutableStateOf(false) }
+    var showUniversalWarning by rememberSaveable { mutableStateOf(false) }
+
+    var pendingScopeAction by remember { mutableStateOf<((Int?) -> Unit)?>(null) }
+
+    fun executeScopedAction(action: (Int?) -> Unit) {
+        if (bundles.size > 1) {
+            pendingScopeAction = action
+        } else {
+            action(bundles.firstOrNull()?.uid)
+        }
+    }
+
+    pendingScopeAction?.let { action ->
+        val currentBundle = bundles.getOrNull(pagerState.currentPage) ?: return@let
+
+        ScopeDialog(
+            bundleName = currentBundle.name,
+            onDismissRequest = { pendingScopeAction = null },
+            onAllPatches = {
+                action(null)
+                pendingScopeAction = null
+            },
+            onBundleOnly = {
+                action(currentBundle.uid)
+                pendingScopeAction = null
+            }
+        )
+    }
+
    if (showBottomSheet) {
+        val currentBundle = bundles.getOrNull(pagerState.currentPage)
+
        ModalBottomSheet(
            onDismissRequest = {
                showBottomSheet = false
@@ -161,6 +202,71 @@ fun PatchesSelectorScreen(
                        label = { Text(stringResource(R.string.universal)) },
                    )
                }
+
+                HorizontalDivider(modifier = Modifier.padding(vertical = 16.dp))
+
+                Text(
+                    text = stringResource(R.string.patch_selector_sheet_actions_title),
+                    style = MaterialTheme.typography.headlineSmall,
+                    modifier = Modifier.padding(bottom = 8.dp)
+                )
+
+                fun guardedAction(action: () -> Unit) {
+                    showBottomSheet = false
+                    if (viewModel.selectionWarningEnabled) {
+                        showSelectionWarning = true
+                    } else {
+                        action()
+                    }
+                }
+
+                ActionItem(
+                    icon = Icons.Outlined.Restore,
+                    text = stringResource(R.string.restore_default_selection),
+                    onClick = {
+                        guardedAction {
+                            executeScopedAction { uid ->
+                                viewModel.restoreDefaults(uid)
+                            }
+                        }
+                    }
+                )
+
+                ActionItem(
+                    icon = Icons.Outlined.Deselect,
+                    text = stringResource(R.string.deselect_all),
+                    onClick = {
+                        guardedAction {
+                            executeScopedAction { uid ->
+                                viewModel.deselectAll(bundles, uid)
+                            }
+                        }
+                    }
+                )
+
+                ActionItem(
+                    icon = Icons.Outlined.SwapHoriz,
+                    text = stringResource(R.string.invert_selection),
+                    onClick = {
+                        guardedAction {
+                            executeScopedAction { uid ->
+                                viewModel.invertSelection(bundles, uid)
+                            }
+                        }
+                    }
+                )
+
+                if (bundles.size > 1 && currentBundle != null) {
+                    ActionItem(
+                        icon = Icons.Outlined.Deselect,
+                        text = stringResource(R.string.deselect_all_except, currentBundle.name),
+                        onClick = {
+                            guardedAction {
+                                viewModel.deselectAllExcept(bundles, currentBundle.uid)
+                            }
+                        }
+                    )
+                }
            }
        }
    }
@@ -191,9 +297,6 @@ fun PatchesSelectorScreen(
        )
    }

-    var showSelectionWarning by rememberSaveable { mutableStateOf(false) }
-    var showUniversalWarning by rememberSaveable { mutableStateOf(false) }
-
    if (showSelectionWarning)
        SelectionWarningDialog(onDismiss = { showSelectionWarning = false })

@@ -426,16 +529,38 @@ fun PatchesSelectorScreen(
                                }
                            },
                            text = {
-                                Column(horizontalAlignment = Alignment.CenterHorizontally) {
-                                    Text(
-                                        text = bundle.name,
-                                        style = MaterialTheme.typography.bodyMedium
-                                    )
-                                    Text(
-                                        text = bundle.version.orEmpty(),
-                                        style = MaterialTheme.typography.bodySmall,
-                                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                                Row(verticalAlignment = Alignment.CenterVertically) {
+                                    val selectionState = viewModel.getBundleSelectionState(bundle)
+                                    val toggleableState = when (selectionState) {
+                                        true -> ToggleableState.On
+                                        false -> ToggleableState.Off
+                                        null -> ToggleableState.Indeterminate
+                                    }
+
+                                    HapticTriStateCheckbox(
+                                        state = toggleableState,
+                                        onClick = {
+                                            when {
+                                                viewModel.selectionWarningEnabled -> showSelectionWarning = true
+                                                selectionState == false -> viewModel.restoreDefaults(bundle.uid)
+                                                else -> viewModel.deselectAll(bundles, bundle.uid)
+                                            }
+                                        }
                                    )
+
+                                    Spacer(modifier = Modifier.width(4.dp))
+
+                                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                                        Text(
+                                            text = bundle.name,
+                                            style = MaterialTheme.typography.bodyMedium
+                                        )
+                                        Text(
+                                            text = bundle.version.orEmpty(),
+                                            style = MaterialTheme.typography.bodySmall,
+                                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                                        )
+                                    }
                                }
                            },
                            selectedContentColor = MaterialTheme.colorScheme.primary,
@@ -612,6 +737,41 @@ private fun IncompatiblePatchDialog(
    }
 )

+@Composable
+private fun ActionItem(
+    icon: ImageVector,
+    text: String,
+    onClick: () -> Unit
+) {
+    ListItem(
+        modifier = Modifier.clickable(onClick = onClick),
+        leadingContent = { Icon(icon, contentDescription = null) },
+        headlineContent = { Text(text) },
+        colors = transparentListItemColors
+    )
+}
+
+@Composable
+private fun ScopeDialog(
+    bundleName: String,
+    onDismissRequest: () -> Unit,
+    onAllPatches: () -> Unit,
+    onBundleOnly: () -> Unit
+) = AlertDialog(
+    onDismissRequest = onDismissRequest,
+    title = { Text(stringResource(R.string.scope_dialog_title)) },
+    confirmButton = {
+        TextButton(onClick = onAllPatches) {
+            Text(stringResource(R.string.scope_all_patches))
+        }
+    },
+    dismissButton = {
+        TextButton(onClick = onBundleOnly) {
+            Text(stringResource(R.string.scope_bundle_patches, bundleName))
+        }
+    }
+)
+
@OptIn(ExperimentalMaterial3Api::class)
@Composable
 private fun OptionsDialog(
@@ -640,17 +800,17 @@ private fun OptionsDialog(
        ) {
            if (patch.options == null) return@LazyColumnWithScrollbar

-            items(patch.options, key = { it.key }) { option ->
-                val key = option.key
+            items(patch.options, key = { it.name }) { option ->
+                val name = option.name
                val value =
-                    if (values == null || !values.contains(key)) option.default else values[key]
+                    if (values == null || !values.contains(name)) option.default else values[name]

                @Suppress("UNCHECKED_CAST")
                OptionItem(
                    option = option as Option<Any>,
                    value = value,
                    setValue = {
-                        set(key, it)
+                        set(name, it)
                    },
                    selectionWarningEnabled = selectionWarningEnabled
                )
--- a/app/src/main/java/app/revanced/manager/ui/screen/RequiredOptionsScreen.kt
+++ b/app/src/main/java/app/revanced/manager/ui/screen/RequiredOptionsScreen.kt
@@ -144,16 +144,16 @@ fun RequiredOptionsScreen(

                            val values = vm.getOptions(bundle.uid, it)
                            it.options?.forEach { option ->
-                                val key = option.key
+                                val name = option.name
                                val value =
-                                    if (values == null || key !in values) option.default else values[key]
+                                    if (values == null || name !in values) option.default else values[name]

                                @Suppress("UNCHECKED_CAST")
                                OptionItem(
                                    option = option as Option<Any>,
                                    value = value,
                                    setValue = { new ->
-                                        vm.setOption(bundle.uid, it, key, new)
+                                        vm.setOption(bundle.uid, it, name, new)
                                    },
                                    selectionWarningEnabled = vm.selectionWarningEnabled
                                )
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/AnnouncementsViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/AnnouncementsViewModel.kt
@@ -0,0 +1,90 @@
+package app.revanced.manager.ui.viewmodel
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import app.revanced.manager.data.platform.NetworkInfo
+import app.revanced.manager.domain.manager.PreferencesManager
+import app.revanced.manager.domain.repository.AnnouncementRepository
+import app.revanced.manager.network.dto.ReVancedAnnouncement
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+class AnnouncementsViewModel(
+    private val announcementRepository: AnnouncementRepository,
+    private val network: NetworkInfo,
+    private val preferences: PreferencesManager
+) : ViewModel() {
+    private val allAnnouncements = MutableStateFlow<List<ReVancedAnnouncement>?>(null)
+
+    val tags = allAnnouncements.map { it?.tags }
+    val selectedTags = preferences.selectedAnnouncementTags
+    val readAnnouncements = preferences.readAnnouncements
+    val showArchived = MutableStateFlow(false)
+
+    val announcements = combine(
+        allAnnouncements,
+        selectedTags.flow,
+        showArchived
+    ) { source, selectedTags, showArchived ->
+        if (source == null) return@combine null
+        // Only filter by tags that actually exist
+        val availableTags = source.tags
+        val validSelected = selectedTags.intersect(availableTags)
+
+        source.filter { announcement ->
+            if (!showArchived && announcement.isArchived) return@filter false
+
+            if (!validSelected.isEmpty()) announcement.tags.any(validSelected::contains)
+            else true
+        }
+    }
+
+    init {
+        loadData()
+    }
+
+    fun markAnnouncementRead(id: Long) {
+        viewModelScope.launch {
+            preferences.edit {
+                preferences.readAnnouncements += id
+            }
+        }
+    }
+
+    fun changeTagSelection(tag: String) = viewModelScope.launch {
+        preferences.edit {
+            if (tag in selectedTags.value) selectedTags -= tag
+            else selectedTags += tag
+        }
+    }
+
+    fun resetTagSelection() = viewModelScope.launch {
+        selectedTags.update(preferences.selectedAnnouncementTags.default)
+    }
+
+    private fun loadData() {
+        viewModelScope.launch {
+            if (!network.isConnected()) {
+                allAnnouncements.value = emptyList()
+                return@launch
+            }
+
+            withContext(Dispatchers.IO) {
+                announcementRepository.getAnnouncements()?.let {
+                    allAnnouncements.value = it
+                }
+            }
+        }
+    }
+
+    private companion object {
+        val List<ReVancedAnnouncement>.tags: Set<String>
+            get() = flatMapTo(
+                mutableSetOf()
+            ) { it.tags }
+    }
+}
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/AppSelectorViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/AppSelectorViewModel.kt
@@ -19,8 +19,12 @@ import app.revanced.manager.util.PM
 import app.revanced.manager.util.toast
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.io.File
@@ -40,16 +44,51 @@ class AppSelectorViewModel(
            "input.apk"
        ).also(File::delete)
    }
-    val appList = pm.appList
+
+    val filterTextFlow = MutableStateFlow("")
+    val filterText: StateFlow<String> = filterTextFlow
+
+    val apps = pm.appList.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(),
+        initialValue = null,
+    )
+
+    val filteredApps = filterText
+        .combine(apps) { filter, apps ->
+            if (apps == null || filter.isBlank()) {
+                apps
+            } else {
+                apps.filter { app ->
+                    app.packageName.contains(filter, true) ||
+                            loadLabel(app.packageInfo).contains(filter)
+                }
+            }
+        }.stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(
+                stopTimeoutMillis = 0,
+                replayExpirationMillis = 10_000,
+            ),
+            initialValue = null,
+        )

    private val storageSelectionChannel = Channel<SelectedApp.Local>()
    val storageSelectionFlow = storageSelectionChannel.receiveAsFlow()

-    val suggestedAppVersions = patchBundleRepository.suggestedVersions.flowOn(Dispatchers.Default)
+    val suggestedAppVersions = patchBundleRepository.suggestedVersions.stateIn(
+        scope = viewModelScope,
+        started = SharingStarted.WhileSubscribed(),
+        initialValue = emptyMap(),
+    )

    var nonSuggestedVersionDialogSubject by mutableStateOf<SelectedApp.Local?>(null)
        private set

+    fun setFilterText(filter: String) {
+        filterTextFlow.value = filter
+    }
+
    fun loadLabel(app: PackageInfo?) = with(pm) { app?.label() ?: "Not installed" }

    fun dismissNonSuggestedVersionDialog() {
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/AppliedPatchesViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/AppliedPatchesViewModel.kt
@@ -0,0 +1,37 @@
+package app.revanced.manager.ui.viewmodel
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import app.revanced.manager.data.room.apps.installed.InstalledPatchBundle
+import app.revanced.manager.domain.repository.InstalledAppRepository
+import app.revanced.manager.util.PatchSelection
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+
+class AppliedPatchesViewModel(
+    packageName: String
+) : ViewModel(), KoinComponent {
+    private val installedAppRepository: InstalledAppRepository by inject()
+
+    var appliedPatches: PatchSelection? by mutableStateOf(null)
+        private set
+    var patchBundles: List<InstalledPatchBundle> by mutableStateOf(emptyList())
+        private set
+
+    init {
+        viewModelScope.launch {
+            appliedPatches = withContext(Dispatchers.IO) {
+                installedAppRepository.getAppliedPatches(packageName)
+            }
+            patchBundles = withContext(Dispatchers.IO) {
+                installedAppRepository.getInstalledPatchBundles(packageName)
+            }
+        }
+    }
+}
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/DashboardViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/DashboardViewModel.kt
@@ -16,21 +16,29 @@ import app.revanced.manager.R
 import app.revanced.manager.data.platform.NetworkInfo
 import app.revanced.manager.domain.bundles.PatchBundleSource.Extensions.asRemoteOrNull
 import app.revanced.manager.domain.manager.PreferencesManager
+import app.revanced.manager.domain.repository.AnnouncementRepository
 import app.revanced.manager.domain.repository.DownloaderRepository
 import app.revanced.manager.domain.repository.PatchBundleRepository
 import app.revanced.manager.network.api.ReVancedAPI
+import app.revanced.manager.network.dto.ReVancedAnnouncement
 import app.revanced.manager.util.PM
 import app.revanced.manager.util.uiSafe
+import kotlin.time.Clock
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toInstant
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext

 class DashboardViewModel(
    private val app: Application,
    private val patchBundleRepository: PatchBundleRepository,
    private val downloaderRepository: DownloaderRepository,
+    private val announcementRepository: AnnouncementRepository,
    private val reVancedAPI: ReVancedAPI,
    private val networkInfo: NetworkInfo,
    val prefs: PreferencesManager,
@@ -57,12 +65,16 @@ class DashboardViewModel(
    var showBatteryOptimizationsWarning by mutableStateOf(false)
        private set

+    var unreadAnnouncement by mutableStateOf<ReVancedAnnouncement?>(null)
+        private set
+
    private val bundleListEventsChannel = Channel<BundleListViewModel.Event>()
    val bundleListEventsFlow = bundleListEventsChannel.receiveAsFlow()

    init {
        viewModelScope.launch {
            checkForManagerUpdates()
+            checkForAnnouncements()
            updateBatteryOptimizationsWarning()
        }
    }
@@ -79,6 +91,36 @@ class DashboardViewModel(
        }
    }

+    private suspend fun checkForAnnouncements() {
+        uiSafe(app, R.string.failed_to_check_updates, "Failed to check for announcements") {
+            val announcements = withContext(Dispatchers.IO) {
+                announcementRepository.getAnnouncements()
+            } ?: throw IllegalStateException("Announcements could not be retrieved")
+
+            val readAnnouncements = prefs.readAnnouncements.get()
+
+            unreadAnnouncement = announcements.firstOrNull { announcement ->
+                val hasRelevantTag = announcement.tags.any {
+                    it == "✨ ReVanced" || it == "💊 Manager"
+                }
+                val isUnread = announcement.id !in readAnnouncements
+
+                !announcement.isArchived && hasRelevantTag && isUnread
+            }
+        }
+    }
+
+    fun markUnreadAnnouncementRead() {
+        viewModelScope.launch {
+            unreadAnnouncement?.let {
+                prefs.edit {
+                    prefs.readAnnouncements += it.id
+                }
+            }
+            unreadAnnouncement = null
+        }
+    }
+
    fun updateBatteryOptimizationsWarning() {
        showBatteryOptimizationsWarning =
            !powerManager.isIgnoringBatteryOptimizations(app.packageName)
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/InstalledAppInfoViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/InstalledAppInfoViewModel.kt
@@ -11,6 +11,7 @@ import androidx.lifecycle.viewModelScope
 import app.revanced.manager.R
 import app.revanced.manager.data.room.apps.installed.InstallType
 import app.revanced.manager.data.room.apps.installed.InstalledApp
+import app.revanced.manager.data.room.apps.installed.InstalledPatchBundle
 import app.revanced.manager.domain.installer.RootInstaller
 import app.revanced.manager.domain.repository.InstalledAppRepository
 import app.revanced.manager.util.PM
@@ -41,6 +42,8 @@ class InstalledAppInfoViewModel(
    var appInfo: PackageInfo? by mutableStateOf(null)
        private set
    var appliedPatches: PatchSelection? by mutableStateOf(null)
+    var patchBundles: List<InstalledPatchBundle> by mutableStateOf(emptyList())
+        private set
    var isMounted by mutableStateOf(false)
        private set

@@ -54,6 +57,9 @@ class InstalledAppInfoViewModel(
                appliedPatches = withContext(Dispatchers.IO) {
                    installedAppRepository.getAppliedPatches(it.currentPackageName)
                }
+                patchBundles = withContext(Dispatchers.IO) {
+                    installedAppRepository.getInstalledPatchBundles(it.currentPackageName)
+                }
            }
        }
    }
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/InstalledAppsViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/InstalledAppsViewModel.kt
@@ -5,13 +5,16 @@ import androidx.compose.runtime.mutableStateMapOf
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import app.revanced.manager.data.room.apps.installed.InstallType
-import app.revanced.manager.domain.installer.RootServiceException
+import app.revanced.manager.data.room.apps.installed.InstalledApp
 import app.revanced.manager.domain.installer.RootInstaller
+import app.revanced.manager.domain.installer.RootServiceException
 import app.revanced.manager.domain.repository.InstalledAppRepository
 import app.revanced.manager.util.PM
-import app.revanced.manager.util.collectEach
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.flowOn
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext

@@ -20,32 +23,42 @@ class InstalledAppsViewModel(
    private val pm: PM,
    private val rootInstaller: RootInstaller
 ) : ViewModel() {
-    val apps = installedAppsRepository.getAll().flowOn(Dispatchers.IO)
+    val apps = installedAppsRepository.getAll()
+        .stateIn(
+            scope = viewModelScope,
+            started = SharingStarted.WhileSubscribed(),
+            initialValue = null,
+        )

    val packageInfoMap = mutableStateMapOf<String, PackageInfo?>()

    init {
        viewModelScope.launch {
-            apps.collectEach { installedApp ->
-                packageInfoMap[installedApp.currentPackageName] = withContext(Dispatchers.IO) {
-                    try {
-                        if (
-                            installedApp.installType == InstallType.MOUNT && !rootInstaller.isAppInstalled(installedApp.currentPackageName)
-                        ) {
-                            installedAppsRepository.delete(installedApp)
-                            return@withContext null
-                        }
-                    } catch (_: RootServiceException) {  }
+            apps.filterNotNull().collectLatest(::fetchPackageInfos)
+        }
+    }

-                    val packageInfo = pm.getPackageInfo(installedApp.currentPackageName)
-
-                    if (packageInfo == null && installedApp.installType != InstallType.MOUNT) {
-                        installedAppsRepository.delete(installedApp)
+    private suspend fun fetchPackageInfos(apps: List<InstalledApp>) {
+        for (app in apps) {
+            packageInfoMap[app.currentPackageName] = withContext(Dispatchers.IO) {
+                try {
+                    if (app.installType == InstallType.MOUNT &&
+                        !rootInstaller.isAppInstalled(app.currentPackageName)
+                    ) {
+                        installedAppsRepository.delete(app)
                        return@withContext null
                    }
-
-                    packageInfo
+                } catch (_: RootServiceException) {
                }
+
+                val packageInfo = pm.getPackageInfo(app.currentPackageName)
+
+                if (packageInfo == null && app.installType != InstallType.MOUNT) {
+                    installedAppsRepository.delete(app)
+                    return@withContext null
+                }
+
+                packageInfo
            }
        }
    }
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/MainViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/MainViewModel.kt
@@ -1,18 +1,19 @@
 package app.revanced.manager.ui.viewmodel

-import android.app.Activity
 import android.app.Application
-import android.content.Intent
-import android.util.Base64
+import android.content.Context.MODE_PRIVATE
+import android.content.SharedPreferences
 import android.util.Log
-import androidx.activity.result.ActivityResult
+import androidx.core.content.edit
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import app.revanced.manager.R
+import app.revanced.manager.data.room.apps.installed.InstallType
 import app.revanced.manager.domain.bundles.PatchBundleSource.Extensions.asRemoteOrNull
 import app.revanced.manager.domain.manager.KeystoreManager
 import app.revanced.manager.domain.manager.PreferencesManager
 import app.revanced.manager.domain.repository.DownloadedAppRepository
+import app.revanced.manager.domain.repository.InstalledAppRepository
 import app.revanced.manager.domain.repository.PatchBundleRepository
 import app.revanced.manager.domain.repository.PatchSelectionRepository
 import app.revanced.manager.domain.repository.SerializedSelection
@@ -27,11 +28,16 @@ import kotlinx.coroutines.launch
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.json.Json
+import org.json.JSONObject
+import java.io.File
+
+private const val LEGACY_LIST_PREFIX = "VGhpcyBpcyB0aGUgcHJlZml4IGZvciBhIGxpc3Qu!"

 class MainViewModel(
    private val patchBundleRepository: PatchBundleRepository,
    private val patchSelectionRepository: PatchSelectionRepository,
    private val downloadedAppRepository: DownloadedAppRepository,
+    private val installedAppRepository: InstalledAppRepository,
    private val keystoreManager: KeystoreManager,
    private val app: Application,
    val prefs: PreferencesManager,
@@ -39,8 +45,6 @@ class MainViewModel(
 ) : ViewModel() {
    private val appSelectChannel = Channel<SelectedApp>()
    val appSelectFlow = appSelectChannel.receiveAsFlow()
-    private val legacyImportActivityChannel = Channel<Intent>()
-    val legacyImportActivityFlow = legacyImportActivityChannel.receiveAsFlow()

    private suspend fun suggestedVersion(packageName: String) =
        patchBundleRepository.suggestedVersions.first()[packageName]
@@ -72,43 +76,55 @@ class MainViewModel(
    init {
        viewModelScope.launch {
            if (!prefs.firstLaunch.get()) return@launch
-            legacyImportActivityChannel.send(Intent().apply {
-                setClassName(
-                    "app.revanced.manager.flutter",
-                    "app.revanced.manager.flutter.ExportSettingsActivity"
-                )
-            })
+            val flutterPrefs = app.getSharedPreferences("FlutterSharedPreferences", MODE_PRIVATE)
+            if (flutterPrefs.all.isNotEmpty()) applyLegacySettings(flutterPrefs)
        }
    }

-    fun applyLegacySettings(result: ActivityResult) {
-        if (result.resultCode != Activity.RESULT_OK) {
-            app.toast(app.getString(R.string.legacy_import_failed))
-            Log.e(
-                tag,
-                "Got unknown result code while importing legacy settings: ${result.resultCode}"
-            )
-            return
+    fun applyLegacySettings(flutterPrefs: SharedPreferences) {
+        Log.d(tag, "Migrating flutter preferences")
+        val data = JSONObject().apply {
+            put("keystorePassword", "s3cur3p@ssw0rd")
+
+            val allEntries: Map<String, *> = flutterPrefs.all
+            for ((key, value) in allEntries) {
+                put(key.replace("flutter.", ""), value)
+            }
        }

-        val jsonStr = result.data?.getStringExtra("data")
-        if (jsonStr == null) {
-            app.toast(app.getString(R.string.legacy_import_failed))
-            Log.e(tag, "Legacy settings data is null")
-            return
+        val storedPatchesFile = File(app.filesDir.parentFile.absolutePath, "/app_flutter/selected-patches.json")
+        val patches: SerializedSelection? =
+            if (storedPatchesFile.exists()) {
+                json.decodeFromString<SerializedSelection>(storedPatchesFile.readText())
+            } else {
+                null
+            }
+
+        val keystoreFile = File(app.getExternalFilesDir(null), "/revanced-manager.keystore")
+        val keystore: ByteArray? = if (keystoreFile.exists()) {
+            val bytes = keystoreFile.readBytes()
+
+            keystoreFile.delete()
+
+            bytes
+        } else {
+            null
        }
+
+        flutterPrefs.edit(commit = true) { clear() }
+
        val settings = try {
-            json.decodeFromString<LegacySettings>(jsonStr)
+            json.decodeFromString<LegacySettings>(data.toString())
        } catch (e: SerializationException) {
            app.toast(app.getString(R.string.legacy_import_failed))
            Log.e(tag, "Legacy settings data could not be deserialized", e)
            return
        }

-        applyLegacySettings(settings)
+        applyLegacySettings(settings, patches, keystore)
    }

-    private fun applyLegacySettings(settings: LegacySettings) = viewModelScope.launch {
+    private fun applyLegacySettings(settings: LegacySettings, patches: SerializedSelection?, keystore: ByteArray?) = viewModelScope.launch {
        settings.themeMode?.let { theme ->
            val themeMap = mapOf(
                0 to Theme.SYSTEM,
@@ -144,20 +160,39 @@ class MainViewModel(
        settings.patchesChangeEnabled?.let { disableSelectionWarning ->
            prefs.disableSelectionWarning.update(disableSelectionWarning)
        }
-        settings.keystore?.let { keystore ->
-            val keystoreBytes = Base64.decode(keystore, Base64.DEFAULT)
+        keystore?.let { keystoreBytes ->
            keystoreManager.import(
                "alias",
                settings.keystorePassword,
                keystoreBytes.inputStream()
            )
        }
-        settings.patches?.let { selection ->
+        patches?.let { selection ->
            patchSelectionRepository.import(0, selection)
        }
+        settings.patchedApps?.let { apps ->
+            json.decodeFromString<List<String>>(apps.removePrefix(LEGACY_LIST_PREFIX)).forEach { appJson ->
+                val patchedApp = json.decodeFromString<LegacyPatchedApp>(appJson)
+                installedAppRepository.addOrUpdate(
+                    patchedApp.packageName,
+                    patchedApp.packageName,
+                    patchedApp.version,
+                    if (patchedApp.isRooted) InstallType.MOUNT else InstallType.DEFAULT,
+                    mapOf(0 to patchedApp.appliedPatches.toSet())
+                )
+            }
+        }
        Log.d(tag, "Imported legacy settings")
    }

+    @Serializable
+    private data class LegacyPatchedApp(
+        val packageName: String,
+        val version: String,
+        val isRooted: Boolean,
+        val appliedPatches: List<String>,
+    )
+
    @Serializable
    private data class LegacySettings(
        val keystorePassword: String,
@@ -168,7 +203,6 @@ class MainViewModel(
        val experimentalPatchesEnabled: Boolean? = null,
        val patchesAutoUpdate: Boolean? = null,
        val patchesChangeEnabled: Boolean? = null,
-        val keystore: String? = null,
-        val patches: SerializedSelection? = null,
+        val patchedApps: String? = null,
    )
 }
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/PatcherViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/PatcherViewModel.kt
@@ -28,6 +28,7 @@ import app.revanced.manager.data.room.apps.installed.InstallType
 import app.revanced.manager.data.room.apps.installed.InstalledApp
 import app.revanced.manager.domain.installer.RootInstaller
 import app.revanced.manager.domain.repository.InstalledAppRepository
+import app.revanced.manager.domain.repository.PatchBundleRepository
 import app.revanced.manager.domain.worker.WorkerRepository
 import app.revanced.manager.patcher.ProgressEvent
 import app.revanced.manager.patcher.StepId
@@ -59,6 +60,7 @@ import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.async
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.time.withTimeout
@@ -88,6 +90,7 @@ class PatcherViewModel(
    private val pm: PM by inject()
    private val workerRepository: WorkerRepository by inject()
    private val installedAppRepository: InstalledAppRepository by inject()
+    private val patchBundleRepository: PatchBundleRepository by inject()
    private val rootInstaller: RootInstaller by inject()
    private val savedStateHandle: SavedStateHandle = get()
    private val ackpineInstaller: PackageInstaller = get()
@@ -378,13 +381,15 @@ class PatcherViewModel(
            Session.State.Succeeded -> {
                app.toast(app.getString(R.string.install_app_success))
                installedPackageName = installerPkgName
+                val bundleInfo = patchBundleRepository.bundleInfoFlow.first()
                installedAppRepository.addOrUpdate(
                    installerPkgName,
                    packageName,
                    input.selectedApp.version
                        ?: withContext(Dispatchers.IO) { pm.getPackageInfo(outputFile)?.versionName!! },
                    InstallType.DEFAULT,
-                    input.selectedPatches
+                    input.selectedPatches,
+                    bundleInfo
                )
            }
        }
@@ -457,12 +462,14 @@ class PatcherViewModel(
                            label
                        )

+                        val bundleInfo = patchBundleRepository.bundleInfoFlow.first()
                        installedAppRepository.addOrUpdate(
                            currentPackageInfo.packageName,
                            packageName,
                            inputVersion,
                            InstallType.MOUNT,
-                            input.selectedPatches
+                            input.selectedPatches,
+                            bundleInfo
                        )

                        rootInstaller.mount(packageName)
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/PatchesSelectorViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/PatchesSelectorViewModel.kt
@@ -129,7 +129,7 @@ class PatchesSelectorViewModel(input: SelectedApplicationInfo.PatchesSelector.Vi
                isSelected(
                    bundle.uid,
                    patch
-                ) && patch.options?.any { it.required && it.default == null && it.key !in opts } ?: false
+                ) && patch.options?.any { it.required && it.default == null && it.name !in opts } ?: false
            }.toList()
        }.filter { (_, patches) -> patches.isNotEmpty() }
    }
@@ -180,13 +180,13 @@ class PatchesSelectorViewModel(input: SelectedApplicationInfo.PatchesSelector.Vi

    fun getOptions(bundle: Int, patch: PatchInfo) = patchOptions[bundle]?.get(patch.name)

-    fun setOption(bundle: Int, patch: PatchInfo, key: String, value: Any?) {
+    fun setOption(bundle: Int, patch: PatchInfo, name: String, value: Any?) {
        // All patches
        val patchesToOpts = patchOptions.getOrElse(bundle, ::persistentMapOf)
        // The key-value options of an individual patch
        val patchToOpts = patchesToOpts
            .getOrElse(patch.name, ::persistentMapOf)
-            .put(key, value)
+            .put(name, value)

        patchOptions[bundle] = patchesToOpts.put(patch.name, patchToOpts)
    }
@@ -209,6 +209,74 @@ class PatchesSelectorViewModel(input: SelectedApplicationInfo.PatchesSelector.Vi
        filter = filter xor flag
    }

+    fun getBundleSelectionState(bundle: PatchBundleInfo.Scoped): Boolean? {
+        val patches = bundle.patchSequence(allowIncompatiblePatches).toList()
+        if (patches.isEmpty()) return false
+
+        val selectedCount = patches.count { isSelected(bundle.uid, it) }
+        return when (selectedCount) {
+            patches.size -> true
+            0 -> false
+            else -> null
+        }
+    }
+
+    private suspend fun currentSelection(): PersistentPatchSelection =
+        customPatchSelection ?: defaultPatchSelection.first()
+
+    private suspend fun updateSelection(
+        update: (PersistentPatchSelection) -> PersistentPatchSelection
+    ) {
+        hasModifiedSelection = true
+        customPatchSelection = update(currentSelection())
+    }
+
+    fun deselectAll(bundles: List<PatchBundleInfo.Scoped>, bundleUid: Int?) = viewModelScope.launch {
+        updateSelection { selection ->
+            bundles.fold(selection) { acc, bundle ->
+                if (bundleUid != null && bundle.uid != bundleUid) return@fold acc
+                acc.put(bundle.uid, persistentSetOf())
+            }
+        }
+    }
+
+    fun invertSelection(bundles: List<PatchBundleInfo.Scoped>, bundleUid: Int?) = viewModelScope.launch {
+        updateSelection { selection ->
+            bundles.fold(selection) { acc, bundle ->
+                if (bundleUid != null && bundle.uid != bundleUid) return@fold acc
+
+                val currentSelected = acc[bundle.uid] ?: persistentSetOf()
+                val inverted = bundle.patchSequence(allowIncompatiblePatches)
+                    .filter { it.name !in currentSelected }
+                    .map { it.name }
+                    .toPersistentSet()
+                acc.put(bundle.uid, inverted)
+            }
+        }
+    }
+
+    fun restoreDefaults(bundleUid: Int?) = viewModelScope.launch {
+        if (bundleUid == null) {
+            customPatchSelection = null
+            hasModifiedSelection = false
+            return@launch
+        }
+
+        val defaults = defaultPatchSelection.first()
+        updateSelection { selection ->
+            selection.put(bundleUid, defaults[bundleUid] ?: persistentSetOf())
+        }
+    }
+
+    fun deselectAllExcept(bundles: List<PatchBundleInfo.Scoped>, keepBundleUid: Int) = viewModelScope.launch {
+        updateSelection { selection ->
+            bundles.fold(selection) { acc, bundle ->
+                if (bundle.uid == keepBundleUid) return@fold acc
+                acc.put(bundle.uid, persistentSetOf())
+            }
+        }
+    }
+
    companion object {
        const val SHOW_INCOMPATIBLE = 1 // 2^0
        const val SHOW_UNIVERSAL = 2 // 2^1
--- a/app/src/main/java/app/revanced/manager/ui/viewmodel/SelectedAppInfoViewModel.kt
+++ b/app/src/main/java/app/revanced/manager/ui/viewmodel/SelectedAppInfoViewModel.kt
@@ -325,7 +325,7 @@ class SelectedAppInfoViewModel(
                        bundleOptions.forEach patch@{ (patchName, values) ->
                            // Get all valid option keys for the patch.
                            val validOptionKeys =
-                                patches[patchName]?.options?.map { it.key }?.toSet() ?: return@patch
+                                patches[patchName]?.options?.map { it.name }?.toSet() ?: return@patch

                            this@bundleOptions[patchName] = values.filterKeys { key ->
                                key in validOptionKeys
--- a/app/src/main/jniLibs/arm64-v8a/libaapt2.so
+++ b/app/src/main/jniLibs/arm64-v8a/libaapt2.so
--- a/app/src/main/jniLibs/armeabi-v7a/libaapt2.so
+++ b/app/src/main/jniLibs/armeabi-v7a/libaapt2.so
--- a/app/src/main/jniLibs/x86/libaapt2.so
+++ b/app/src/main/jniLibs/x86/libaapt2.so
--- a/app/src/main/jniLibs/x86_64/libaapt2.so
+++ b/app/src/main/jniLibs/x86_64/libaapt2.so
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -14,7 +14,7 @@ Second \"item\" text"</string>
 -->
 <resources>
    <string name="app_name">ReVanced Manager</string>
-    <string name="patcher">Patcher test</string>
+    <string name="patcher">Patcher</string>
    <string name="patches">Patches</string>
    <string name="cli">CLI</string>
    <string name="manager">Manager</string>
@@ -82,6 +82,9 @@ Second \"item\" text"</string>
    <string name="auto_updates_dialog_patches">ReVanced Patches</string>
    <string name="auto_updates_dialog_note">These settings can be changed later.</string>

+    <string name="announcements_filter_tag">Filter by tag</string>
+    <string name="announcements_show_archived">Show archived</string>
+
    <string name="general">General</string>
    <string name="general_description">Language, theme, dynamic color</string>
    <string name="updates">Updates</string>
@@ -110,24 +113,24 @@ Second \"item\" text"</string>
    <string name="safeguards">Safeguards</string>
    <string name="patch_compat_check">Disable version compatibility check</string>
    <string name="patch_compat_check_description">Do not restrict patches to compatible app versions</string>
-    <string name="patch_compat_check_confirmation">"Selecting incompatible patches can result in a broken app.
+    <string name="patch_compat_check_confirmation">Selecting incompatible patches can result in a broken app.

-Do you want to proceed anyways?"</string>
+Do you want to proceed anyways?</string>
    <string name="suggested_version_safeguard">Require suggested app version</string>
    <string name="suggested_version_safeguard_description">Enforce selection of the suggested app version</string>
-    <string name="suggested_version_safeguard_confirmation">"Selecting an app that is not the suggested version may cause unexpected issues.
+    <string name="suggested_version_safeguard_confirmation">Selecting an app that is not the suggested version may cause unexpected issues.

-Do you want to proceed anyways?"</string>
+Do you want to proceed anyways?</string>
    <string name="patch_selection_safeguard">Allow changing patch selection and options</string>
    <string name="patch_selection_safeguard_description">Do not prevent selecting or deselecting patches and customization of options</string>
-    <string name="patch_selection_safeguard_confirmation">"Changing the selection of patches may cause unexpected issues.
+    <string name="patch_selection_safeguard_confirmation">Changing the selection of patches may cause unexpected issues.

-Enable anyways?"</string>
+Enable anyways?</string>
    <string name="universal_patches_safeguard">Allow using universal patches</string>
    <string name="universal_patches_safeguard_description">Do not prevent using universal patches</string>
-    <string name="universal_patches_safeguard_confirmation">"Universal patches are not as well tested as those that target specific apps.
+    <string name="universal_patches_safeguard_confirmation">Universal patches are not as well tested as those that target specific apps.

-Enable anyways?"</string>
+Enable anyways?</string>
    <string name="import_keystore">Import keystore</string>
    <string name="import_keystore_description">Import a custom keystore</string>
    <string name="import_keystore_dialog_title">Enter keystore credentials</string>
@@ -143,9 +146,9 @@ Enable anyways?"</string>
    <string name="export_keystore_success">Exported keystore</string>
    <string name="regenerate_keystore">Regenerate keystore</string>
    <string name="regenerate_keystore_description">Generate a new keystore</string>
-    <string name="regenerate_keystore_dialog_description">"You are about to regenerate your keystore the manager will use during the patching process.
+    <string name="regenerate_keystore_dialog_description">You are about to regenerate your keystore the manager will use during the patching process.

-You will not be able to update the previously installed apps from this source."</string>
+You will not be able to update the previously installed apps from this source.</string>
    <string name="regenerate_keystore_success">The keystore has been successfully replaced</string>
    <string name="import_patch_selection">Import patch selection</string>
    <string name="import_patch_selection_description">Import patch selection from a JSON file</string>
@@ -270,23 +273,23 @@ You will not be able to update the previously installed apps from this source."<
    <string name="patch_selection_reset_toast">Patch selection and options has been reset to recommended defaults</string>
    <string name="patch_options_reset_toast">Patch options have been reset</string>
    <string name="non_suggested_version_warning_title">Non suggested version</string>
-    <string name="non_suggested_version_warning_description">"The version of the app you have selected does not match the suggested version.
+    <string name="non_suggested_version_warning_description">The version of the app you have selected does not match the suggested version.
 Please use the suggested version: %s

-To continue anyway, disable \"Require suggested app version\" in the advanced settings."</string>
+To continue anyway, disable \"Require suggested app version\" in the advanced settings.</string>
    <string name="selection_warning_title">Stop using defaults?</string>
-    <string name="selection_warning_description">"It is recommended to use the default patch selection and options. Changing them may result in unexpected issues.
+    <string name="selection_warning_description">It is recommended to use the default patch selection and options. Changing them may result in unexpected issues.

-You need to turn on \"Allow changing patch selection and options\" in the advanced settings before toggling patches."</string>
-    <string name="universal_patch_warning_description">"Universal patches have a more generalized use and do not work as reliably as patches that target specific apps. You may encounter issues while using them.
+You need to turn on \"Allow changing patch selection and options\" in the advanced settings before toggling patches.</string>
+    <string name="universal_patch_warning_description">Universal patches have a more generalized use and do not work as reliably as patches that target specific apps. You may encounter issues while using them.

-You need to turn on \"Allow using universal patches\" in the advanced settings before using universal patches."</string>
+You need to turn on \"Allow using universal patches\" in the advanced settings before using universal patches.</string>
    <string name="this_version">This version</string>
    <string name="universal">Any app</string>
    <string name="search_patches">Search patches</string>
-    <string name="app_version_not_compatible">"This patch is not compatible with the selected app version (%1$s)
+    <string name="app_version_not_compatible">This patch is not compatible with the selected app version (%1$s)

-It is only compatible with the following version(s): %2$s"</string>
+It is only compatible with the following version(s): %2$s</string>
    <string name="continue_with_version">Continue with this version?</string>
    <string name="version_not_compatible">Not all patches are compatible with this version (%s). Do you want to continue anyway?</string>
    <string name="download_application">Download application?</string>
@@ -326,6 +329,15 @@ It is only compatible with the following version(s): %2$s"</string>
    <string name="patch_selector_sheet_filter_title">Filter</string>
    <string name="patch_selector_sheet_filter_compat_title">Compatibility</string>

+    <string name="patch_selector_sheet_actions_title">Actions</string>
+    <string name="restore_default_selection">Restore default selection</string>
+    <string name="deselect_all">Deselect all</string>
+    <string name="invert_selection">Invert selection</string>
+    <string name="deselect_all_except">Deselect all except %s</string>
+    <string name="scope_dialog_title">Apply to</string>
+    <string name="scope_all_patches">All patches</string>
+    <string name="scope_bundle_patches">%s only</string>
+
    <string name="string_option_menu_description">More options</string>
    <string name="option_preset_custom_value">Custom value</string>

@@ -380,6 +392,7 @@ It is only compatible with the following version(s): %2$s"</string>
    <string name="less">Less</string>
    <string name="continue_">Continue</string>
    <string name="dismiss">Dismiss</string>
+    <string name="view_announcement">View announcement</string>
    <string name="permanent_dismiss">Do not show this again</string>
    <string name="donate">Donate</string>
    <string name="website">Website</string>
@@ -398,6 +411,8 @@ It is only compatible with the following version(s): %2$s"</string>
    <string name="patches_delete_single_dialog_description">Are you sure you want to delete \"%s\"?</string>
    <string name="patches_delete_multiple_dialog_description">Are you sure you want to delete the selected patches?</string>

+    <string name="announcements">Announcements</string>
+    <string name="archive">Archive</string>
    <string name="about_revanced_manager">About ReVanced Manager</string>
    <string name="revanced_manager_description">ReVanced Manager is an Android application that uses ReVanced Patcher to patch Android apps. It allows you to download and patch apps with custom patches, and manage the patching process.</string>
    <string name="developer_options_taps">%d taps remaining</string>
@@ -428,8 +443,8 @@ It is only compatible with the following version(s): %2$s"</string>
    <string name="save_with_count">Save (%1$s)</string>
    <string name="update">Update</string>
    <string name="empty">Empty</string>
-    <string name="installing_message">"Tap on <b>Update</b> when prompted.
-ReVanced Manager will close when updating."</string>
+    <string name="installing_message">Tap on <b>Update</b> when prompted.
+ReVanced Manager will close when updating.</string>
    <string name="no_changelogs_found">No changelogs found</string>
    <string name="just_now">Just now</string>
    <string name="minutes_ago">%sm ago</string>
@@ -443,14 +458,15 @@ ReVanced Manager will close when updating."</string>

    <string name="failed_to_check_updates">Failed to check for updates: %s</string>
    <string name="no_update_available">No update available</string>
+    <string name="no_announcements_found">No announcements found</string>
    <string name="update_check">Checking for updates…</string>
    <string name="dismiss_temporary">Not now</string>
    <string name="update_available_dialog_description">A new version of ReVanced Manager (%s) is available.</string>
    <string name="failed_to_download_update">Failed to download update: %s</string>
    <string name="download">Download</string>
-    <string name="download_confirmation_metered">"You are currently on a metered connection, and data charges from your service provider may apply.
+    <string name="download_confirmation_metered">You are currently on a metered connection, and data charges from your service provider may apply.

-Do you still want to continue?"</string>
+Do you still want to continue?</string>
    <string name="download_update_confirmation">Download update?</string>
    <string name="no_contributors_found">No contributors found</string>
    <string name="select">Select</string>
@@ -488,9 +504,9 @@ Do you still want to continue?"</string>
    <string name="patches_prereleases">Use pre-releases</string>
    <string name="patches_prereleases_description">Use pre-release versions of %s</string>
    <string name="patches_url">Patches URL</string>
-    <string name="incompatible_patches_dialog">"These patches are not compatible with the selected app version (%1$s).
+    <string name="incompatible_patches_dialog">These patches are not compatible with the selected app version (%1$s).

-Click on the patches to see more details."</string>
+Click on the patches to see more details.</string>
    <string name="incompatible_patch">Incompatible patch</string>
    <string name="any_version">Any</string>
    <string name="never_show_again">Never show again</string>
@@ -499,4 +515,5 @@ Click on the patches to see more details."</string>
    <string name="failed_to_import_keystore">Failed to import keystore</string>
    <string name="export">Export</string>
    <string name="confirm">Confirm</string>
+    <string name="new_announcement">New announcement:\n%s</string>
 </resources>
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,6 +1,6 @@
 [versions]
 ktx = "1.17.0"
-material3 = "1.4.0"
+material3 = "1.5.0-alpha14"
 ui-tooling = "1.10.0"
 viewmodel-lifecycle = "2.10.0"
 splash-screen = "1.2.0"
@@ -9,7 +9,7 @@ appcompat = "1.7.1"
 preferences-datastore = "1.2.0"
 work-runtime = "2.11.0"
 compose-bom = "2025.12.01"
-navigation = "2.9.6"
+navigation = "2.9.7"
 accompanist = "0.37.3"
 placeholder = "1.0.12"
 reorderable = "3.0.0"
@@ -17,13 +17,13 @@ serialization = "1.9.0"
 collection = "0.4.0"
 datetime = "0.7.1"
 room-version = "2.8.4"
-revanced-patcher = "21.0.0"
-revanced-library = "3.0.2"
+revanced-patcher = "22.0.0"
+revanced-library = "4.0.0"
 koin = "4.1.1"
 ktor = "3.3.3"
 markdown-renderer = "0.39.0"
 fading-edges = "1.0.4"
-kotlin = "2.3.0"
+kotlin = "2.3.10"
 android-gradle-plugin = "8.13.2"
 dev-tools-gradle-plugin = "2.3.4"
 about-libraries = "13.2.1"
@@ -81,8 +81,8 @@ room-ktx = { group = "androidx.room", name = "room-ktx", version.ref = "room-ver
 room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room-version" }

 # Patcher
-revanced-patcher = { group = "app.revanced", name = "revanced-patcher", version.ref = "revanced-patcher" }
-revanced-library = { group = "app.revanced", name = "revanced-library", version.ref = "revanced-library" }
+revanced-patcher = { group = "app.revanced", name = "patcher-android", version.ref = "revanced-patcher" }
+revanced-library = { group = "app.revanced", name = "library-android", version.ref = "revanced-library" }

 # Koin
 koin-android = { group = "io.insert-koin", name = "koin-android", version.ref = "koin" }
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,5 +1,6 @@
 pluginManagement {
    repositories {
+        mavenLocal()
        mavenCentral()
        google()
        gradlePluginPortal()
@@ -8,6 +9,7 @@ pluginManagement {
 dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
+        mavenLocal()
        mavenCentral()
        google()
        maven("https://jitpack.io")
Author	SHA1	Message	Date
semantic-release-bot	e115e8cd90	chore: Release v1.26.0-dev.32 [skip ci] # app [1.26.0-dev.32](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.31...v1.26.0-dev.32) (2026-03-08) ### Features * migrate to API v5 ([`2270f32`](`2270f329de`))	2026-03-08 20:23:49 +00:00
Ax333l	2270f329de	feat: migrate to API v5	2026-03-08 21:16:49 +01:00
semantic-release-bot	55f0cdebd5	chore: Release v1.26.0-dev.31 [skip ci] # app [1.26.0-dev.31](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.30...v1.26.0-dev.31) (2026-03-04) ### Features * Don't mark all announcements as read on first launch, and set the correct default tags ([`398ca00`](`398ca006b6`))	2026-03-04 03:54:17 +00:00
Ushie	398ca006b6	feat: Don't mark all announcements as read on first launch, and set the correct default tags	2026-03-04 06:46:40 +03:00
semantic-release-bot	d368c0ff6f	chore: Release v1.26.0-dev.30 [skip ci] # app [1.26.0-dev.30](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.29...v1.26.0-dev.30) (2026-03-02) ### Features * Update AAPT2 to built-tools v35. ([`1ba11b3`](`1ba11b3021`))	2026-03-02 17:24:20 +00:00
oSumAtrIX	1ba11b3021	feat: Update AAPT2 to built-tools v35. The binaries provenance is attested by GitHub at https://github.com/ReVanced/aapt2/attestations. The artifacts are available at https://github.com/ReVanced/aapt2/releases/tag/v1.0.0.	2026-03-02 18:16:54 +01:00
oSumAtrIX	d29e736c4a	ci: Do not archive PR build artifacts	2026-03-02 12:57:53 +01:00
semantic-release-bot	896d8cc874	chore: Release v1.26.0-dev.29 [skip ci] # app [1.26.0-dev.29](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.28...v1.26.0-dev.29) (2026-02-28) ### Bug Fixes * Exclude desktop AAPT and disable R8 optimizations ([`6ce5b67`](`6ce5b672fe`)) * unexclude other destabilizers ([`2c3d436`](`2c3d436b25`))	2026-02-28 14:01:21 +00:00
Ax333l	6ce5b672fe	fix: Exclude desktop AAPT and disable R8 optimizations	2026-02-28 14:54:13 +01:00
planshim	2c3d436b25	fix: unexclude other destabilizers	2026-02-28 07:13:07 +03:00
semantic-release-bot	af564eab1b	chore: Release v1.26.0-dev.28 [skip ci] # app [1.26.0-dev.28](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.27...v1.26.0-dev.28) (2026-02-28) ### Features * Add patch selection filters ([#2956](https://github.com/ReVanced/revanced-manager/issues/2956)) ([`0be493d`](`0be493da66`))	2026-02-28 04:04:06 +00:00
AunAli K.	0be493da66	feat: Add patch selection filters (#2956 ) Co-authored-by: planshim <100317079+planshim@users.noreply.github.com>	2026-02-28 06:55:03 +03:00
semantic-release-bot	8f23114bc3	chore: Release v1.26.0-dev.27 [skip ci] # app [1.26.0-dev.27](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.26...v1.26.0-dev.27) (2026-02-28) ### Features * Show patch bundle version used to patch an app ([#2966](https://github.com/ReVanced/revanced-manager/issues/2966)) ([`11bd46c`](`11bd46ce26`))	2026-02-28 02:09:32 +00:00
AunAli K.	11bd46ce26	feat: Show patch bundle version used to patch an app (#2966 ) Co-authored-by: planshim <100317079+planshim@users.noreply.github.com>	2026-02-28 05:01:23 +03:00
semantic-release-bot	e03f3666c8	chore: Release v1.26.0-dev.26 [skip ci] # app [1.26.0-dev.26](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.25...v1.26.0-dev.26) (2026-02-27) ### Features * improve InstalledAppsScreen caching/perf ([#2963](https://github.com/ReVanced/revanced-manager/issues/2963)) ([`323d217`](`323d2170ef`))	2026-02-27 23:09:46 +00:00
rushii	323d2170ef	feat: improve InstalledAppsScreen caching/perf (#2963 ) Co-authored-by: planshim <100317079+planshim@users.noreply.github.com>	2026-02-28 02:00:38 +03:00
semantic-release-bot	940669b3e4	chore: Release v1.26.0-dev.25 [skip ci] # app [1.26.0-dev.25](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.24...v1.26.0-dev.25) (2026-02-27) ### Features * improve AppSelectorScreen caching/perf ([#2961](https://github.com/ReVanced/revanced-manager/issues/2961)) ([`81e5a93`](`81e5a9315d`))	2026-02-27 22:08:17 +00:00
rushii	81e5a9315d	feat: improve AppSelectorScreen caching/perf (#2961 ) Co-authored-by: planshim <100317079+planshim@users.noreply.github.com>	2026-02-28 00:59:47 +03:00
semantic-release-bot	b38d0b7022	chore: Release v1.26.0-dev.24 [skip ci] # app [1.26.0-dev.24](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.23...v1.26.0-dev.24) (2026-02-27) ### Bug Fixes * Incorrect patcher string value ([`f19080a`](`f19080a986`)) * Never show again toggle doing nothing for Update dialog ([`6f4219c`](`6f4219c01b`)) * Release builds not working ([`00b3c59`](`00b3c59572`)) * Remove quotes from strings ([`fc30ba5`](`fc30ba5e83`)) * we actually don't want to exclude reflection symbols ([`3222840`](`32228404c4`)) ### Features * Add announcements ([#2948](https://github.com/ReVanced/revanced-manager/issues/2948)) ([`813df46`](`813df46847`)) * Update to Patcher v22 ([#2939](https://github.com/ReVanced/revanced-manager/issues/2939)) ([`8667051`](`8667051283`))	2026-02-27 15:59:57 +00:00
semantic-release-bot	b838851ebe	chore: Release API v1.0.0-dev.2 [skip ci] # api [1.0.0-dev.2](https://github.com/ReVanced/revanced-manager/compare/api@1.0.0-dev.1...api@1.0.0-dev.2) (2026-02-27) ### Features * Update to Patcher v22 ([#2939](https://github.com/ReVanced/revanced-manager/issues/2939)) ([`8667051`](`8667051283`))	2026-02-27 15:59:00 +00:00
Ax333l	00b3c59572	fix: Release builds not working	2026-02-27 16:50:49 +01:00
Ushie	fc30ba5e83	fix: Remove quotes from strings	2026-02-27 08:52:59 +03:00
Plance Shimney	32228404c4	fix: we actually don't want to exclude reflection symbols	2026-02-25 20:36:58 +03:00
Ushie	f19080a986	fix: Incorrect patcher string value	2026-02-23 01:29:48 +03:00
Tornike Khintibidze	813df46847	feat: Add announcements (#2948 ) Co-authored-by: Ushie <ushiekane@gmail.com> Co-authored-by: Ax333l <main@axelen.xyz>	2026-02-23 01:23:18 +03:00
Ushie	6f4219c01b	fix: Never show again toggle doing nothing for Update dialog	2026-02-22 08:02:24 +03:00
Ax333l	8667051283	feat: Update to Patcher v22 (#2939 )	2026-02-22 00:52:09 +01:00
rushii	e0ce6b4ef3	build: Optimize packaging rules (#2949 )	2026-02-22 00:08:41 +01:00
semantic-release-bot	b50688ee10	chore: Release v1.26.0-dev.23 [skip ci] # app [1.26.0-dev.23](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.22...v1.26.0-dev.23) (2026-02-19) ### Bug Fixes * Flutter migration ([#2946](https://github.com/ReVanced/revanced-manager/issues/2946)) ([`31a0f75`](`31a0f751aa`))	2026-02-19 22:06:14 +00:00
Jānis	31a0f751aa	fix: Flutter migration (#2946 )	2026-02-19 22:57:23 +01:00
semantic-release-bot	4f65555b56	chore: Release v1.26.0-dev.22 [skip ci] # app [1.26.0-dev.22](https://github.com/ReVanced/revanced-manager/compare/v1.26.0-dev.21...v1.26.0-dev.22) (2026-02-19) ### Bug Fixes * Create modules path in root installer ([`4fc2ba3`](`4fc2ba339b`))	2026-02-19 17:46:45 +00:00
Ax333l	4fc2ba339b	fix: Create modules path in root installer	2026-02-19 18:38:20 +01:00