From fef069e34a9a1aac4df85064a48a5b0e2081f320 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Fri, 8 May 2026 21:54:56 +0200
Subject: [PATCH 01/13] Add anime source API interfaces and models

---
 .../animesource/AnimeCatalogueSource.kt       |  48 +++
 .../tachiyomi/animesource/AnimeSource.kt      |  66 ++++
 .../animesource/AnimeSourceFactory.kt         |   5 +
 .../animesource/ConfigurableAnimeSource.kt    |  20 ++
 .../tachiyomi/animesource/UnmeteredSource.kt  |   3 +
 .../animesource/model/AnimeFilter.kt          |  43 +++
 .../animesource/model/AnimeFilterList.kt      |  17 +
 .../animesource/model/AnimeUpdateStrategy.kt  |   7 +
 .../tachiyomi/animesource/model/AnimesPage.kt |   3 +
 .../tachiyomi/animesource/model/Hoster.kt     |  81 +++++
 .../tachiyomi/animesource/model/SAnime.kt     |  60 ++++
 .../tachiyomi/animesource/model/SAnimeImpl.kt |  26 ++
 .../tachiyomi/animesource/model/SEpisode.kt   |  32 ++
 .../animesource/model/SEpisodeImpl.kt         |  16 +
 .../tachiyomi/animesource/model/Video.kt      | 204 +++++++++++
 .../animesource/online/AnimeHttpSource.kt     | 317 ++++++++++++++++++
 .../online/ParsedAnimeHttpSource.kt           | 114 +++++++
 .../online/ResolvableAnimeSource.kt           |  20 ++
 18 files changed, 1082 insertions(+)
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeCatalogueSource.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeSource.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeSourceFactory.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/ConfigurableAnimeSource.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/UnmeteredSource.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeFilter.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeFilterList.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeUpdateStrategy.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimesPage.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Hoster.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SAnime.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SAnimeImpl.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SEpisode.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SEpisodeImpl.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/AnimeHttpSource.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/ParsedAnimeHttpSource.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/ResolvableAnimeSource.kt

diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeCatalogueSource.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeCatalogueSource.kt
new file mode 100644
index 0000000000..5320a3551b
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeCatalogueSource.kt
@@ -0,0 +1,48 @@
+package eu.kanade.tachiyomi.animesource
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
+import rx.Observable
+import tachiyomi.core.common.util.lang.awaitSingle
+
+interface AnimeCatalogueSource : AnimeSource {
+
+    override val lang: String
+
+    val supportsLatest: Boolean
+
+    @Suppress("DEPRECATION")
+    suspend fun getPopularAnime(page: Int): AnimesPage {
+        return fetchPopularAnime(page).awaitSingle()
+    }
+
+    @Suppress("DEPRECATION")
+    suspend fun getSearchAnime(page: Int, query: String, filters: AnimeFilterList): AnimesPage {
+        return fetchSearchAnime(page, query, filters).awaitSingle()
+    }
+
+    @Suppress("DEPRECATION")
+    suspend fun getLatestUpdates(page: Int): AnimesPage {
+        return fetchLatestUpdates(page).awaitSingle()
+    }
+
+    fun getFilterList(): AnimeFilterList
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getPopularAnime"),
+    )
+    fun fetchPopularAnime(page: Int): Observable<AnimesPage>
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getSearchAnime"),
+    )
+    fun fetchSearchAnime(page: Int, query: String, filters: AnimeFilterList): Observable<AnimesPage>
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getLatestUpdates"),
+    )
+    fun fetchLatestUpdates(page: Int): Observable<AnimesPage>
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeSource.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeSource.kt
new file mode 100644
index 0000000000..843038b0a9
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeSource.kt
@@ -0,0 +1,66 @@
+package eu.kanade.tachiyomi.animesource
+
+import eu.kanade.tachiyomi.animesource.model.Hoster
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import rx.Observable
+import tachiyomi.core.common.util.lang.awaitSingle
+
+interface AnimeSource {
+
+    val id: Long
+
+    val name: String
+
+    val lang: String
+        get() = ""
+
+    @Suppress("DEPRECATION")
+    suspend fun getAnimeDetails(anime: SAnime): SAnime {
+        return fetchAnimeDetails(anime).awaitSingle()
+    }
+
+    @Suppress("DEPRECATION")
+    suspend fun getEpisodeList(anime: SAnime): List<SEpisode> {
+        return fetchEpisodeList(anime).awaitSingle()
+    }
+
+    suspend fun getHosterList(episode: SEpisode): List<Hoster> = throw IllegalStateException("Not used")
+
+    suspend fun getVideoList(hoster: Hoster): List<Video> = throw IllegalStateException("Not used")
+
+    @Suppress("DEPRECATION")
+    suspend fun getVideoList(episode: SEpisode): List<Video> {
+        return fetchVideoList(episode).awaitSingle()
+    }
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getAnimeDetails"),
+    )
+    fun fetchAnimeDetails(anime: SAnime): Observable<SAnime> =
+        throw IllegalStateException("Not used")
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getEpisodeList"),
+    )
+    fun fetchEpisodeList(anime: SAnime): Observable<List<SEpisode>> =
+        throw IllegalStateException("Not used")
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getVideoList"),
+    )
+    fun fetchVideoList(episode: SEpisode): Observable<List<Video>> =
+        throw IllegalStateException("Not used")
+
+    // KMK -->
+    suspend fun getRelatedAnimeList(
+        anime: SAnime,
+        exceptionHandler: (Throwable) -> Unit,
+        pushResults: suspend (relatedAnime: Pair<String, List<SAnime>>, completed: Boolean) -> Unit,
+    ): Unit = throw UnsupportedOperationException()
+    // KMK <--
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeSourceFactory.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeSourceFactory.kt
new file mode 100644
index 0000000000..53d91fe2de
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/AnimeSourceFactory.kt
@@ -0,0 +1,5 @@
+package eu.kanade.tachiyomi.animesource
+
+interface AnimeSourceFactory {
+    fun createSources(): List<AnimeSource>
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/ConfigurableAnimeSource.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/ConfigurableAnimeSource.kt
new file mode 100644
index 0000000000..7172da9982
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/ConfigurableAnimeSource.kt
@@ -0,0 +1,20 @@
+package eu.kanade.tachiyomi.animesource
+
+import android.app.Application
+import android.content.Context
+import android.content.SharedPreferences
+import eu.kanade.tachiyomi.source.PreferenceScreen
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+interface ConfigurableAnimeSource : AnimeSource {
+
+    fun getSourcePreferences(): SharedPreferences =
+        Injekt.get<Application>().getSharedPreferences(preferenceKey(), Context.MODE_PRIVATE)
+
+    fun setupPreferenceScreen(screen: PreferenceScreen)
+}
+
+fun ConfigurableAnimeSource.preferenceKey(): String = "source_$id"
+
+fun ConfigurableAnimeSource.sourcePreferences(): SharedPreferences = getSourcePreferences()
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/UnmeteredSource.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/UnmeteredSource.kt
new file mode 100644
index 0000000000..cd5a8cec28
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/UnmeteredSource.kt
@@ -0,0 +1,3 @@
+package eu.kanade.tachiyomi.animesource
+
+interface UnmeteredSource
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeFilter.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeFilter.kt
new file mode 100644
index 0000000000..ae46a77ea2
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeFilter.kt
@@ -0,0 +1,43 @@
+package eu.kanade.tachiyomi.animesource.model
+
+sealed class AnimeFilter<T>(val name: String, var state: T) {
+    open class Header(name: String) : AnimeFilter<Any>(name, 0)
+    open class Separator(name: String = "") : AnimeFilter<Any>(name, 0)
+    abstract class Select<V>(name: String, val values: Array<V>, state: Int = 0) : AnimeFilter<Int>(
+        name,
+        state,
+    )
+    abstract class Text(name: String, state: String = "") : AnimeFilter<String>(name, state)
+    abstract class CheckBox(name: String, state: Boolean = false) : AnimeFilter<Boolean>(name, state)
+    abstract class TriState(name: String, state: Int = STATE_IGNORE) : AnimeFilter<Int>(name, state) {
+        fun isIgnored() = state == STATE_IGNORE
+        fun isIncluded() = state == STATE_INCLUDE
+        fun isExcluded() = state == STATE_EXCLUDE
+
+        companion object {
+            const val STATE_IGNORE = 0
+            const val STATE_INCLUDE = 1
+            const val STATE_EXCLUDE = 2
+        }
+    }
+
+    abstract class Group<V>(name: String, state: List<V>) : AnimeFilter<List<V>>(name, state)
+
+    abstract class Sort(name: String, val values: Array<String>, state: Selection? = null) :
+        AnimeFilter<Sort.Selection?>(name, state) {
+        data class Selection(val index: Int, val ascending: Boolean)
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is AnimeFilter<*>) return false
+
+        return name == other.name && state == other.state
+    }
+
+    override fun hashCode(): Int {
+        var result = name.hashCode()
+        result = 31 * result + (state?.hashCode() ?: 0)
+        return result
+    }
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeFilterList.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeFilterList.kt
new file mode 100644
index 0000000000..4304d187eb
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeFilterList.kt
@@ -0,0 +1,17 @@
+package eu.kanade.tachiyomi.animesource.model
+
+import androidx.compose.runtime.Stable
+
+@Stable
+data class AnimeFilterList(val list: List<AnimeFilter<*>>) : List<AnimeFilter<*>> by list {
+
+    constructor(vararg fs: AnimeFilter<*>) : this(if (fs.isNotEmpty()) fs.asList() else emptyList())
+
+    override fun equals(other: Any?): Boolean {
+        return false
+    }
+
+    override fun hashCode(): Int {
+        return list.hashCode()
+    }
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeUpdateStrategy.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeUpdateStrategy.kt
new file mode 100644
index 0000000000..e30bc52169
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimeUpdateStrategy.kt
@@ -0,0 +1,7 @@
+package eu.kanade.tachiyomi.animesource.model
+
+@Suppress("UNUSED")
+enum class AnimeUpdateStrategy {
+    ALWAYS_UPDATE,
+    ONLY_FETCH_ONCE,
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimesPage.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimesPage.kt
new file mode 100644
index 0000000000..948b02eef5
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/AnimesPage.kt
@@ -0,0 +1,3 @@
+package eu.kanade.tachiyomi.animesource.model
+
+data class AnimesPage(val animes: List<SAnime>, val hasNextPage: Boolean)
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Hoster.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Hoster.kt
new file mode 100644
index 0000000000..783b70e8c5
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Hoster.kt
@@ -0,0 +1,81 @@
+package eu.kanade.tachiyomi.animesource.model
+
+import eu.kanade.tachiyomi.animesource.model.SerializableVideo.Companion.serialize
+import eu.kanade.tachiyomi.animesource.model.SerializableVideo.Companion.toVideoList
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+open class Hoster(
+    val hosterUrl: String = "",
+    val hosterName: String = "",
+    val videoList: List<Video>? = null,
+    val internalData: String = "",
+) {
+    @Transient
+    @Volatile
+    var status: State = State.IDLE
+
+    enum class State {
+        IDLE,
+        LOADING,
+        READY,
+        ERROR,
+    }
+
+    fun copy(
+        hosterUrl: String = this.hosterUrl,
+        hosterName: String = this.hosterName,
+        videoList: List<Video>? = this.videoList,
+        internalData: String = this.internalData,
+    ): Hoster {
+        return Hoster(hosterUrl, hosterName, videoList, internalData).also { it.status = this.status }
+    }
+
+    companion object {
+        const val NO_HOSTER_LIST = "no_hoster_list"
+
+        fun List<Video>.toHosterList(): List<Hoster> {
+            return listOf(
+                Hoster(
+                    hosterUrl = "",
+                    hosterName = NO_HOSTER_LIST,
+                    videoList = this,
+                ),
+            )
+        }
+    }
+}
+
+@Serializable
+data class SerializableHoster(
+    val hosterUrl: String = "",
+    val hosterName: String = "",
+    val videoList: String? = null,
+    val internalData: String = "",
+) {
+    companion object {
+        fun List<Hoster>.serialize(): String =
+            Json.encodeToString(
+                this.map { host ->
+                    SerializableHoster(
+                        host.hosterUrl,
+                        host.hosterName,
+                        host.videoList?.serialize(),
+                        host.internalData,
+                    )
+                },
+            )
+
+        fun String.toHosterList(): List<Hoster> =
+            Json.decodeFromString<List<SerializableHoster>>(this)
+                .map { sHost ->
+                    Hoster(
+                        sHost.hosterUrl,
+                        sHost.hosterName,
+                        sHost.videoList?.toVideoList(),
+                        sHost.internalData,
+                    )
+                }
+    }
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SAnime.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SAnime.kt
new file mode 100644
index 0000000000..e7f52ef4ef
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SAnime.kt
@@ -0,0 +1,60 @@
+@file:Suppress("PropertyName")
+
+package eu.kanade.tachiyomi.animesource.model
+
+import java.io.Serializable
+
+interface SAnime : Serializable {
+
+    var url: String
+
+    var title: String
+
+    var artist: String?
+
+    var author: String?
+
+    var description: String?
+
+    var genre: String?
+
+    var status: Int
+
+    var thumbnail_url: String?
+
+    var update_strategy: AnimeUpdateStrategy
+
+    var initialized: Boolean
+
+    fun getGenres(): List<String>? {
+        if (genre.isNullOrBlank()) return null
+        return genre?.split(", ")?.map { it.trim() }?.filterNot { it.isBlank() }?.distinct()
+    }
+
+    fun copy() = create().also {
+        it.url = url
+        it.title = title
+        it.artist = artist
+        it.author = author
+        it.description = description
+        it.genre = genre
+        it.status = status
+        it.thumbnail_url = thumbnail_url
+        it.update_strategy = update_strategy
+        it.initialized = initialized
+    }
+
+    companion object {
+        const val UNKNOWN = 0
+        const val ONGOING = 1
+        const val COMPLETED = 2
+        const val LICENSED = 3
+        const val PUBLISHING_FINISHED = 4
+        const val CANCELLED = 5
+        const val ON_HIATUS = 6
+
+        fun create(): SAnime {
+            return SAnimeImpl()
+        }
+    }
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SAnimeImpl.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SAnimeImpl.kt
new file mode 100644
index 0000000000..d0e9c98d40
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SAnimeImpl.kt
@@ -0,0 +1,26 @@
+@file:Suppress("PropertyName")
+
+package eu.kanade.tachiyomi.animesource.model
+
+class SAnimeImpl : SAnime {
+
+    override lateinit var url: String
+
+    override lateinit var title: String
+
+    override var artist: String? = null
+
+    override var author: String? = null
+
+    override var description: String? = null
+
+    override var genre: String? = null
+
+    override var status: Int = 0
+
+    override var thumbnail_url: String? = null
+
+    override var initialized: Boolean = false
+
+    override var update_strategy: AnimeUpdateStrategy = AnimeUpdateStrategy.ALWAYS_UPDATE
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SEpisode.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SEpisode.kt
new file mode 100644
index 0000000000..180579ca50
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SEpisode.kt
@@ -0,0 +1,32 @@
+@file:Suppress("PropertyName")
+
+package eu.kanade.tachiyomi.animesource.model
+
+import java.io.Serializable
+
+interface SEpisode : Serializable {
+
+    var url: String
+
+    var name: String
+
+    var date_upload: Long
+
+    var episode_number: Float
+
+    var scanlator: String?
+
+    fun copyFrom(other: SEpisode) {
+        name = other.name
+        url = other.url
+        date_upload = other.date_upload
+        episode_number = other.episode_number
+        scanlator = other.scanlator
+    }
+
+    companion object {
+        fun create(): SEpisode {
+            return SEpisodeImpl()
+        }
+    }
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SEpisodeImpl.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SEpisodeImpl.kt
new file mode 100644
index 0000000000..05c0d3927a
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/SEpisodeImpl.kt
@@ -0,0 +1,16 @@
+@file:Suppress("PropertyName")
+
+package eu.kanade.tachiyomi.animesource.model
+
+class SEpisodeImpl : SEpisode {
+
+    override lateinit var url: String
+
+    override lateinit var name: String
+
+    override var date_upload: Long = 0
+
+    override var episode_number: Float = -1f
+
+    override var scanlator: String? = null
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
new file mode 100644
index 0000000000..db12d0153e
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
@@ -0,0 +1,204 @@
+package eu.kanade.tachiyomi.animesource.model
+
+import android.net.Uri
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import okhttp3.Headers
+
+@Serializable
+data class Track(val url: String, val lang: String)
+
+@Serializable
+enum class ChapterType {
+    Opening,
+    Ending,
+    Recap,
+    MixedOp,
+    Other,
+}
+
+@Serializable
+data class TimeStamp(
+    val start: Double,
+    val end: Double,
+    val name: String,
+    val type: ChapterType = ChapterType.Other,
+)
+
+open class Video(
+    var videoUrl: String = "",
+    val videoTitle: String = "",
+    val resolution: Int? = null,
+    val bitrate: Int? = null,
+    val headers: Headers? = null,
+    val preferred: Boolean = false,
+    val subtitleTracks: List<Track> = emptyList(),
+    val audioTracks: List<Track> = emptyList(),
+    val timestamps: List<TimeStamp> = emptyList(),
+    val internalData: String = "",
+    val initialized: Boolean = false,
+    val videoPageUrl: String = "",
+) {
+
+    @Deprecated("Use videoTitle instead", ReplaceWith("videoTitle"))
+    val quality: String
+        get() = videoTitle
+
+    @Deprecated("Use videoPageUrl instead", ReplaceWith("videoPageUrl"))
+    val url: String
+        get() = videoPageUrl
+
+    constructor(
+        url: String,
+        quality: String,
+        videoUrl: String?,
+        headers: Headers? = null,
+        subtitleTracks: List<Track> = emptyList(),
+        audioTracks: List<Track> = emptyList(),
+    ) : this(
+        videoPageUrl = url,
+        videoTitle = quality,
+        videoUrl = videoUrl ?: "",
+        headers = headers,
+        subtitleTracks = subtitleTracks,
+        audioTracks = audioTracks,
+    )
+
+    constructor(
+        videoUrl: String = "",
+        videoTitle: String = "",
+        resolution: Int? = null,
+        bitrate: Int? = null,
+        headers: Headers? = null,
+        preferred: Boolean = false,
+        subtitleTracks: List<Track> = emptyList(),
+        audioTracks: List<Track> = emptyList(),
+        timestamps: List<TimeStamp> = emptyList(),
+        internalData: String = "",
+    ) : this(
+        videoUrl = videoUrl,
+        videoTitle = videoTitle,
+        resolution = resolution,
+        bitrate = bitrate,
+        headers = headers,
+        preferred = preferred,
+        subtitleTracks = subtitleTracks,
+        audioTracks = audioTracks,
+        timestamps = timestamps,
+        internalData = internalData,
+        videoPageUrl = "",
+    )
+
+    @Suppress("UNUSED_PARAMETER")
+    constructor(
+        url: String,
+        quality: String,
+        videoUrl: String?,
+        uri: Uri? = null,
+        headers: Headers? = null,
+    ) : this(url, quality, videoUrl, headers)
+
+    @Transient
+    @Volatile
+    var status: State = State.QUEUE
+
+    fun copy(
+        videoUrl: String = this.videoUrl,
+        videoTitle: String = this.videoTitle,
+        resolution: Int? = this.resolution,
+        bitrate: Int? = this.bitrate,
+        headers: Headers? = this.headers,
+        preferred: Boolean = this.preferred,
+        subtitleTracks: List<Track> = this.subtitleTracks,
+        audioTracks: List<Track> = this.audioTracks,
+        timestamps: List<TimeStamp> = this.timestamps,
+        internalData: String = this.internalData,
+        initialized: Boolean = this.initialized,
+        videoPageUrl: String = this.videoPageUrl,
+    ): Video {
+        return Video(
+            videoUrl = videoUrl,
+            videoTitle = videoTitle,
+            resolution = resolution,
+            bitrate = bitrate,
+            headers = headers,
+            preferred = preferred,
+            subtitleTracks = subtitleTracks,
+            audioTracks = audioTracks,
+            timestamps = timestamps,
+            internalData = internalData,
+            initialized = initialized,
+            videoPageUrl = videoPageUrl,
+        )
+    }
+
+    enum class State {
+        QUEUE,
+        LOAD_VIDEO,
+        READY,
+        ERROR,
+    }
+}
+
+@Serializable
+data class SerializableVideo(
+    val videoUrl: String = "",
+    val videoTitle: String = "",
+    val resolution: Int? = null,
+    val bitrate: Int? = null,
+    val headers: List<Pair<String, String>>? = null,
+    val preferred: Boolean = false,
+    val subtitleTracks: List<Track> = emptyList(),
+    val audioTracks: List<Track> = emptyList(),
+    val timestamps: List<TimeStamp> = emptyList(),
+    val internalData: String = "",
+    val initialized: Boolean = false,
+    val videoPageUrl: String = "",
+) {
+
+    companion object {
+        fun List<Video>.serialize(): String =
+            Json.encodeToString(
+                this.map { vid ->
+                    SerializableVideo(
+                        vid.videoUrl,
+                        vid.videoTitle,
+                        vid.resolution,
+                        vid.bitrate,
+                        vid.headers?.toList(),
+                        vid.preferred,
+                        vid.subtitleTracks,
+                        vid.audioTracks,
+                        vid.timestamps,
+                        vid.internalData,
+                        vid.initialized,
+                        vid.videoPageUrl,
+                    )
+                },
+            )
+
+        fun String.toVideoList(): List<Video> =
+            Json.decodeFromString<List<SerializableVideo>>(this)
+                .map { sVid ->
+                    Video(
+                        sVid.videoUrl,
+                        sVid.videoTitle,
+                        sVid.resolution,
+                        sVid.bitrate,
+                        sVid.headers?.let { pairs ->
+                            Headers.Builder().apply {
+                                pairs.forEach { (name, value) -> add(name, value) }
+                            }.build()
+                        },
+                        sVid.preferred,
+                        sVid.subtitleTracks,
+                        sVid.audioTracks,
+                        sVid.timestamps,
+                        sVid.internalData,
+                        sVid.initialized,
+                        sVid.videoPageUrl,
+                    )
+                }
+    }
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/AnimeHttpSource.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/AnimeHttpSource.kt
new file mode 100644
index 0000000000..baf95694a4
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/AnimeHttpSource.kt
@@ -0,0 +1,317 @@
+package eu.kanade.tachiyomi.animesource.online
+
+import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
+import eu.kanade.tachiyomi.animesource.model.Hoster
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.network.ProgressListener
+import eu.kanade.tachiyomi.network.asObservableSuccess
+import eu.kanade.tachiyomi.network.awaitSuccess
+import eu.kanade.tachiyomi.network.newCachelessCallWithProgress
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import rx.Observable
+import tachiyomi.core.common.util.lang.awaitSingle
+import uy.kohesive.injekt.injectLazy
+import java.net.URI
+import java.net.URISyntaxException
+import java.security.MessageDigest
+
+@Suppress("unused")
+abstract class AnimeHttpSource : AnimeCatalogueSource {
+
+    protected val network: NetworkHelper by injectLazy()
+
+    abstract val baseUrl: String
+
+    open val versionId = 1
+
+    override val id by lazy { generateId(name, lang, versionId) }
+
+    open val headers: Headers by lazy { headersBuilder().build() }
+
+    open val client: OkHttpClient
+        get() = network.client
+
+    @Suppress("MemberVisibilityCanBePrivate")
+    protected fun generateId(name: String, lang: String, versionId: Int): Long {
+        val key = "${name.lowercase()}/$lang/$versionId"
+        val bytes = MessageDigest.getInstance("MD5").digest(key.toByteArray())
+        return (0..7).map { bytes[it].toLong() and 0xff shl 8 * (7 - it) }.reduce(Long::or) and Long.MAX_VALUE
+    }
+
+    protected open fun headersBuilder() = Headers.Builder().apply {
+        add("User-Agent", network.defaultUserAgentProvider())
+    }
+
+    override fun toString() = "$name (${lang.uppercase()})"
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getPopularAnime"),
+    )
+    override fun fetchPopularAnime(page: Int): Observable<AnimesPage> {
+        return client.newCall(popularAnimeRequest(page))
+            .asObservableSuccess()
+            .map { response ->
+                popularAnimeParse(response)
+            }
+    }
+
+    protected abstract fun popularAnimeRequest(page: Int): Request
+
+    protected abstract fun popularAnimeParse(response: Response): AnimesPage
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getSearchAnime"),
+    )
+    override fun fetchSearchAnime(page: Int, query: String, filters: AnimeFilterList): Observable<AnimesPage> {
+        return Observable.defer {
+            try {
+                client.newCall(searchAnimeRequest(page, query, filters)).asObservableSuccess()
+            } catch (e: NoClassDefFoundError) {
+                throw RuntimeException(e)
+            }
+        }
+            .map { response ->
+                searchAnimeParse(response)
+            }
+    }
+
+    protected abstract fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request
+
+    protected abstract fun searchAnimeParse(response: Response): AnimesPage
+
+    @Deprecated(
+        "Use the non-RxJava API instead",
+        ReplaceWith("getLatestUpdates"),
+    )
+    override fun fetchLatestUpdates(page: Int): Observable<AnimesPage> {
+        return client.newCall(latestUpdatesRequest(page))
+            .asObservableSuccess()
+            .map { response ->
+                latestUpdatesParse(response)
+            }
+    }
+
+    protected abstract fun latestUpdatesRequest(page: Int): Request
+
+    protected abstract fun latestUpdatesParse(response: Response): AnimesPage
+
+    @Suppress("DEPRECATION")
+    override suspend fun getAnimeDetails(anime: SAnime): SAnime {
+        return fetchAnimeDetails(anime).awaitSingle()
+    }
+
+    @Deprecated("Use the non-RxJava API instead", replaceWith = ReplaceWith("getAnimeDetails"))
+    override fun fetchAnimeDetails(anime: SAnime): Observable<SAnime> {
+        return client.newCall(animeDetailsRequest(anime))
+            .asObservableSuccess()
+            .map { response ->
+                animeDetailsParse(response).apply { initialized = true }
+            }
+    }
+
+    open fun animeDetailsRequest(anime: SAnime): Request {
+        return GET(baseUrl + anime.url, headers)
+    }
+
+    protected abstract fun animeDetailsParse(response: Response): SAnime
+
+    @Suppress("DEPRECATION")
+    override suspend fun getEpisodeList(anime: SAnime): List<SEpisode> {
+        return fetchEpisodeList(anime).awaitSingle()
+    }
+
+    @Deprecated("Use the non-RxJava API instead", replaceWith = ReplaceWith("getEpisodeList"))
+    override fun fetchEpisodeList(anime: SAnime): Observable<List<SEpisode>> {
+        return client.newCall(episodeListRequest(anime))
+            .asObservableSuccess()
+            .map { response ->
+                episodeListParse(response)
+            }
+    }
+
+    protected open fun episodeListRequest(anime: SAnime): Request {
+        return GET(baseUrl + anime.url, headers)
+    }
+
+    protected abstract fun episodeListParse(response: Response): List<SEpisode>
+
+    protected open fun episodeVideoParse(response: Response): SEpisode = throw UnsupportedOperationException("Not used")
+
+    override suspend fun getHosterList(episode: SEpisode): List<Hoster> {
+        return client.newCall(hosterListRequest(episode))
+            .awaitSuccess()
+            .let { response ->
+                hosterListParse(response).sortHosters()
+            }
+    }
+
+    protected open fun hosterListRequest(episode: SEpisode): Request {
+        return GET(baseUrl + episode.url, headers)
+    }
+
+    protected abstract fun hosterListParse(response: Response): List<Hoster>
+
+    override suspend fun getVideoList(hoster: Hoster): List<Video> {
+        return client.newCall(videoListRequest(hoster))
+            .awaitSuccess()
+            .let { response ->
+                videoListParse(response, hoster).sortVideos()
+            }
+    }
+
+    protected open fun videoListRequest(hoster: Hoster): Request {
+        return GET(hoster.hosterUrl, headers)
+    }
+
+    protected abstract fun videoListParse(response: Response, hoster: Hoster): List<Video>
+
+    open suspend fun resolveVideo(video: Video): Video? {
+        return video
+    }
+
+    @Suppress("DEPRECATION")
+    override suspend fun getVideoList(episode: SEpisode): List<Video> {
+        return fetchVideoList(episode).awaitSingle()
+    }
+
+    @Suppress("DEPRECATION")
+    @Deprecated("Use the non-RxJava API instead", replaceWith = ReplaceWith("getVideoList"))
+    override fun fetchVideoList(episode: SEpisode): Observable<List<Video>> {
+        return client.newCall(videoListRequest(episode))
+            .asObservableSuccess()
+            .map { response ->
+                videoListParse(response).sort()
+            }
+    }
+
+    protected open fun videoListRequest(episode: SEpisode): Request {
+        return GET(baseUrl + episode.url, headers)
+    }
+
+    protected open fun videoListParse(response: Response): List<Video> =
+        throw UnsupportedOperationException("Not used")
+
+    protected open fun List<Hoster>.sortHosters(): List<Hoster> {
+        return this
+    }
+
+    protected open fun List<Video>.sortVideos(): List<Video> {
+        return this
+    }
+
+    @Deprecated("Use .sortVideos() instead", replaceWith = ReplaceWith("sortVideos"))
+    protected open fun List<Video>.sort(): List<Video> {
+        return this
+    }
+
+    @Suppress("DEPRECATION")
+    open suspend fun getVideoUrl(video: Video): String {
+        return fetchVideoUrl(video).awaitSingle()
+    }
+
+    @Deprecated("Use the non-RxJava API instead", replaceWith = ReplaceWith("getVideoUrl"))
+    open fun fetchVideoUrl(video: Video): Observable<String> {
+        return client.newCall(videoUrlRequest(video))
+            .asObservableSuccess()
+            .map { videoUrlParse(it) }
+    }
+
+    protected open fun videoUrlRequest(video: Video): Request {
+        return GET(video.videoPageUrl, headers)
+    }
+
+    protected abstract fun videoUrlParse(response: Response): String
+
+    suspend fun getVideo(
+        request: Request,
+        listener: ProgressListener,
+    ): Response {
+        return client.newCachelessCallWithProgress(request, listener)
+            .awaitSuccess()
+    }
+
+    fun getVideoSize(
+        video: Video,
+        tries: Int,
+    ): Long {
+        val rangeHeaders = Headers.Builder().addAll(video.headers ?: headers).add("Range", "bytes=0-1").build()
+        val request = GET(video.videoUrl, rangeHeaders)
+        repeat(tries + 1) {
+            val size = client.newCall(request).execute().use { response ->
+                response.header("Content-Range")
+            }?.substringAfterLast('/')?.toLongOrNull()
+            if (size != null && size >= 0) return size
+        }
+        return -1L
+    }
+
+    fun videoRequest(
+        video: Video,
+        start: Long,
+        end: Long,
+    ): Request {
+        val headers = video.headers ?: headers
+        val newHeaders =
+            if (end - start > 0L) {
+                Headers.Builder().addAll(headers).add("Range", "bytes=$start-$end").build()
+            } else if (start >= 0L) {
+                Headers.Builder().addAll(headers).add("Range", "bytes=$start-").build()
+            } else {
+                null
+            }
+        return GET(video.videoUrl, newHeaders ?: headers)
+    }
+
+    fun safeVideoRequest(
+        video: Video,
+    ): Request {
+        return GET(video.videoUrl, video.headers ?: headers)
+    }
+
+    fun SEpisode.setUrlWithoutDomain(url: String) {
+        this.url = getUrlWithoutDomain(url)
+    }
+
+    fun SAnime.setUrlWithoutDomain(url: String) {
+        this.url = getUrlWithoutDomain(url)
+    }
+
+    private fun getUrlWithoutDomain(orig: String): String {
+        return try {
+            val uri = URI(orig.replace(" ", "%20"))
+            var out = uri.path
+            if (uri.query != null) {
+                out += "?" + uri.query
+            }
+            if (uri.fragment != null) {
+                out += "#" + uri.fragment
+            }
+            out
+        } catch (e: URISyntaxException) {
+            orig
+        }
+    }
+
+    open fun getAnimeUrl(anime: SAnime): String {
+        return animeDetailsRequest(anime).url.toString()
+    }
+
+    open fun getEpisodeUrl(episode: SEpisode): String {
+        return episode.url
+    }
+
+    open fun prepareNewEpisode(episode: SEpisode, anime: SAnime) {}
+
+    override fun getFilterList() = AnimeFilterList()
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/ParsedAnimeHttpSource.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/ParsedAnimeHttpSource.kt
new file mode 100644
index 0000000000..7910bad6a2
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/ParsedAnimeHttpSource.kt
@@ -0,0 +1,114 @@
+package eu.kanade.tachiyomi.animesource.online
+
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
+import eu.kanade.tachiyomi.animesource.model.Hoster
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+
+@Suppress("unused")
+abstract class ParsedAnimeHttpSource : AnimeHttpSource() {
+
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        val document = response.asJsoup()
+
+        val animes = document.select(popularAnimeSelector()).map { element ->
+            popularAnimeFromElement(element)
+        }
+
+        val hasNextPage = popularAnimeNextPageSelector()?.let { selector ->
+            document.select(selector).first()
+        } != null
+
+        return AnimesPage(animes, hasNextPage)
+    }
+
+    protected abstract fun popularAnimeSelector(): String
+
+    protected abstract fun popularAnimeFromElement(element: Element): SAnime
+
+    protected abstract fun popularAnimeNextPageSelector(): String?
+
+    override fun searchAnimeParse(response: Response): AnimesPage {
+        val document = response.asJsoup()
+
+        val animes = document.select(searchAnimeSelector()).map { element ->
+            searchAnimeFromElement(element)
+        }
+
+        val hasNextPage = searchAnimeNextPageSelector()?.let { selector ->
+            document.select(selector).first()
+        } != null
+
+        return AnimesPage(animes, hasNextPage)
+    }
+
+    protected abstract fun searchAnimeSelector(): String
+
+    protected abstract fun searchAnimeFromElement(element: Element): SAnime
+
+    protected abstract fun searchAnimeNextPageSelector(): String?
+
+    override fun latestUpdatesParse(response: Response): AnimesPage {
+        val document = response.asJsoup()
+
+        val animes = document.select(latestUpdatesSelector()).map { element ->
+            latestUpdatesFromElement(element)
+        }
+
+        val hasNextPage = latestUpdatesNextPageSelector()?.let { selector ->
+            document.select(selector).first()
+        } != null
+
+        return AnimesPage(animes, hasNextPage)
+    }
+
+    protected abstract fun latestUpdatesSelector(): String
+
+    protected abstract fun latestUpdatesFromElement(element: Element): SAnime
+
+    protected abstract fun latestUpdatesNextPageSelector(): String?
+
+    override fun animeDetailsParse(response: Response): SAnime {
+        return animeDetailsParse(response.asJsoup())
+    }
+
+    protected abstract fun animeDetailsParse(document: Document): SAnime
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val document = response.asJsoup()
+        return document.select(episodeListSelector()).map { episodeFromElement(it) }
+    }
+
+    protected abstract fun episodeListSelector(): String
+
+    protected abstract fun episodeFromElement(element: Element): SEpisode
+
+    override fun hosterListParse(response: Response): List<Hoster> {
+        val document = response.asJsoup()
+        return document.select(hosterListSelector()).map(::hosterFromElement)
+    }
+
+    protected abstract fun hosterListSelector(): String
+
+    protected abstract fun hosterFromElement(element: Element): Hoster
+
+    override fun videoListParse(response: Response): List<Video> {
+        val document = response.asJsoup()
+        return document.select(videoListSelector()).map { videoFromElement(it) }
+    }
+
+    protected abstract fun videoListSelector(): String
+
+    protected abstract fun videoFromElement(element: Element): Video
+
+    override fun videoUrlParse(response: Response): String {
+        return videoUrlParse(response.asJsoup())
+    }
+
+    protected abstract fun videoUrlParse(document: Document): String
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/ResolvableAnimeSource.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/ResolvableAnimeSource.kt
new file mode 100644
index 0000000000..a15bb022ff
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/online/ResolvableAnimeSource.kt
@@ -0,0 +1,20 @@
+package eu.kanade.tachiyomi.animesource.online
+
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+
+interface ResolvableAnimeSource : AnimeSource {
+
+    fun getUriType(uri: String): UriType
+
+    suspend fun getAnime(uri: String): SAnime?
+
+    suspend fun getEpisode(uri: String): SEpisode?
+}
+
+sealed interface UriType {
+    data object Anime : UriType
+    data object Episode : UriType
+    data object Unknown : UriType
+}

From da44d2d102d45ff3cd023c4d6264c3587b380062 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Fri, 8 May 2026 22:38:11 +0200
Subject: [PATCH 02/13] Add anime domain models, database tables and data layer

---
 .../eu/kanade/domain/AnimeDomainModule.kt     |  36 +++++
 app/src/main/java/eu/kanade/tachiyomi/App.kt  |   2 +
 .../java/eu/kanade/tachiyomi/di/AppModule.kt  |   6 +
 .../java/tachiyomi/data/DatabaseAdapter.kt    |   8 +
 .../java/tachiyomi/data/anime/AnimeMapper.kt  |  58 ++++++++
 .../data/anime/AnimeRepositoryImpl.kt         | 139 ++++++++++++++++++
 .../tachiyomi/data/episode/EpisodeMapper.kt   |  43 ++++++
 .../data/episode/EpisodeRepositoryImpl.kt     | 113 ++++++++++++++
 .../main/sqldelight/tachiyomi/data/animes.sq  | 128 ++++++++++++++++
 .../sqldelight/tachiyomi/data/episodes.sq     | 106 +++++++++++++
 .../domain/anime/interactor/GetAnime.kt       |  33 +++++
 .../anime/interactor/GetFavoriteAnime.kt      |  37 +++++
 .../anime/interactor/SetAnimeEpisodeFlags.kt  |  94 ++++++++++++
 .../domain/anime/interactor/UpdateAnime.kt    |  17 +++
 .../tachiyomi/domain/anime/model/Anime.kt     | 123 ++++++++++++++++
 .../domain/anime/model/AnimeUpdate.kt         |  53 +++++++
 .../anime/repository/AnimeRepository.kt       |  30 ++++
 .../domain/episode/interactor/GetEpisode.kt   |  29 ++++
 .../interactor/GetEpisodesByAnimeId.kt        |  20 +++
 .../episode/interactor/SetSeenStatus.kt       |  59 ++++++++
 .../episode/interactor/UpdateEpisode.kt       |  27 ++++
 .../tachiyomi/domain/episode/model/Episode.kt |  54 +++++++
 .../domain/episode/model/EpisodeUpdate.kt     |  39 +++++
 .../episode/repository/EpisodeRepository.kt   |  26 ++++
 source-api/consumer-proguard.pro              |   6 +-
 25 files changed, 1285 insertions(+), 1 deletion(-)
 create mode 100644 app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
 create mode 100644 data/src/main/java/tachiyomi/data/anime/AnimeMapper.kt
 create mode 100644 data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
 create mode 100644 data/src/main/java/tachiyomi/data/episode/EpisodeMapper.kt
 create mode 100644 data/src/main/java/tachiyomi/data/episode/EpisodeRepositoryImpl.kt
 create mode 100644 data/src/main/sqldelight/tachiyomi/data/animes.sq
 create mode 100644 data/src/main/sqldelight/tachiyomi/data/episodes.sq
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/interactor/GetAnime.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/interactor/GetFavoriteAnime.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/interactor/SetAnimeEpisodeFlags.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/interactor/UpdateAnime.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/model/Anime.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/model/AnimeUpdate.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisode.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisodesByAnimeId.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/episode/interactor/SetSeenStatus.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/episode/interactor/UpdateEpisode.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/episode/model/Episode.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/episode/model/EpisodeUpdate.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/episode/repository/EpisodeRepository.kt

diff --git a/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt b/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
new file mode 100644
index 0000000000..38a6d5e9f5
--- /dev/null
+++ b/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
@@ -0,0 +1,36 @@
+package eu.kanade.domain
+
+import tachiyomi.data.anime.AnimeRepositoryImpl
+import tachiyomi.data.episode.EpisodeRepositoryImpl
+import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.interactor.GetFavoriteAnime
+import tachiyomi.domain.anime.interactor.SetAnimeEpisodeFlags
+import tachiyomi.domain.anime.interactor.UpdateAnime
+import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.episode.interactor.GetEpisode
+import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
+import tachiyomi.domain.episode.interactor.SetSeenStatus
+import tachiyomi.domain.episode.interactor.UpdateEpisode
+import tachiyomi.domain.episode.repository.EpisodeRepository
+import uy.kohesive.injekt.api.InjektModule
+import uy.kohesive.injekt.api.InjektRegistrar
+import uy.kohesive.injekt.api.addFactory
+import uy.kohesive.injekt.api.addSingletonFactory
+import uy.kohesive.injekt.api.get
+
+class AnimeDomainModule : InjektModule {
+
+    override fun InjektRegistrar.registerInjectables() {
+        addSingletonFactory<AnimeRepository> { AnimeRepositoryImpl(get()) }
+        addFactory { GetAnime(get()) }
+        addFactory { UpdateAnime(get()) }
+        addFactory { GetFavoriteAnime(get()) }
+        addFactory { SetAnimeEpisodeFlags(get()) }
+
+        addSingletonFactory<EpisodeRepository> { EpisodeRepositoryImpl(get()) }
+        addFactory { GetEpisode(get()) }
+        addFactory { GetEpisodesByAnimeId(get()) }
+        addFactory { UpdateEpisode(get()) }
+        addFactory { SetSeenStatus(get()) }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/App.kt b/app/src/main/java/eu/kanade/tachiyomi/App.kt
index e655ca4413..1a0d823dd0 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/App.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/App.kt
@@ -35,6 +35,7 @@ import com.elvishew.xlog.printer.Printer
 import com.elvishew.xlog.printer.file.backup.NeverBackupStrategy
 import com.elvishew.xlog.printer.file.naming.DateFileNameGenerator
 import dev.mihon.injekt.patchInjekt
+import eu.kanade.domain.AnimeDomainModule
 import eu.kanade.domain.DomainModule
 import eu.kanade.domain.KMKDomainModule
 import eu.kanade.domain.SYDomainModule
@@ -141,6 +142,7 @@ class App : Application(), DefaultLifecycleObserver, SingletonImageLoader.Factor
         Injekt.importModule(PreferenceModule(this))
         Injekt.importModule(AppModule(this))
         Injekt.importModule(DomainModule())
+        Injekt.importModule(AnimeDomainModule())
         // KMK -->
         Injekt.importModule(KMKDomainModule())
         // KMK <--
diff --git a/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt b/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
index f71e49cc60..523a156233 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
@@ -49,6 +49,8 @@ import tachiyomi.core.common.storage.AndroidStorageFolderProvider
 import tachiyomi.core.common.storage.UniFileTempFileManager
 import tachiyomi.data.AndroidDatabaseHandler
 import tachiyomi.data.Database
+import tachiyomi.data.Animes
+import tachiyomi.data.AnimeUpdateStrategyColumnAdapter
 import tachiyomi.data.DatabaseHandler
 import tachiyomi.data.DateColumnAdapter
 import tachiyomi.data.History
@@ -131,6 +133,10 @@ class AppModule(val app: Application) : InjektModule {
                     genreAdapter = StringListColumnAdapter,
                     update_strategyAdapter = UpdateStrategyColumnAdapter,
                 ),
+                animesAdapter = Animes.Adapter(
+                    genreAdapter = StringListColumnAdapter,
+                    update_strategyAdapter = AnimeUpdateStrategyColumnAdapter,
+                ),
             )
         }
         addSingletonFactory<DatabaseHandler> { AndroidDatabaseHandler(get(), get()) }
diff --git a/data/src/main/java/tachiyomi/data/DatabaseAdapter.kt b/data/src/main/java/tachiyomi/data/DatabaseAdapter.kt
index 596a31286d..e9d571e997 100644
--- a/data/src/main/java/tachiyomi/data/DatabaseAdapter.kt
+++ b/data/src/main/java/tachiyomi/data/DatabaseAdapter.kt
@@ -1,6 +1,7 @@
 package tachiyomi.data
 
 import app.cash.sqldelight.ColumnAdapter
+import eu.kanade.tachiyomi.animesource.model.AnimeUpdateStrategy
 import eu.kanade.tachiyomi.source.model.UpdateStrategy
 import java.util.Date
 
@@ -27,3 +28,10 @@ object UpdateStrategyColumnAdapter : ColumnAdapter<UpdateStrategy, Long> {
 
     override fun encode(value: UpdateStrategy): Long = value.ordinal.toLong()
 }
+
+object AnimeUpdateStrategyColumnAdapter : ColumnAdapter<AnimeUpdateStrategy, Long> {
+    override fun decode(databaseValue: Long): AnimeUpdateStrategy =
+        AnimeUpdateStrategy.entries.getOrElse(databaseValue.toInt()) { AnimeUpdateStrategy.ALWAYS_UPDATE }
+
+    override fun encode(value: AnimeUpdateStrategy): Long = value.ordinal.toLong()
+}
diff --git a/data/src/main/java/tachiyomi/data/anime/AnimeMapper.kt b/data/src/main/java/tachiyomi/data/anime/AnimeMapper.kt
new file mode 100644
index 0000000000..b8f373c096
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/anime/AnimeMapper.kt
@@ -0,0 +1,58 @@
+package tachiyomi.data.anime
+
+import eu.kanade.tachiyomi.animesource.model.AnimeUpdateStrategy
+import tachiyomi.domain.anime.model.Anime
+
+object AnimeMapper {
+    fun mapAnime(
+        id: Long,
+        source: Long,
+        url: String,
+        artist: String?,
+        author: String?,
+        description: String?,
+        genre: List<String>?,
+        title: String,
+        status: Long,
+        thumbnailUrl: String?,
+        favorite: Boolean,
+        lastUpdate: Long?,
+        nextUpdate: Long?,
+        initialized: Boolean,
+        viewerFlags: Long,
+        episodeFlags: Long,
+        coverLastModified: Long,
+        dateAdded: Long,
+        updateStrategy: AnimeUpdateStrategy,
+        calculateInterval: Long,
+        lastModifiedAt: Long,
+        favoriteModifiedAt: Long?,
+        version: Long,
+        @Suppress("UNUSED_PARAMETER")
+        isSyncing: Long,
+    ): Anime = Anime(
+        id = id,
+        source = source,
+        favorite = favorite,
+        lastUpdate = lastUpdate ?: 0,
+        nextUpdate = nextUpdate ?: 0,
+        fetchInterval = calculateInterval.toInt(),
+        dateAdded = dateAdded,
+        viewerFlags = viewerFlags,
+        episodeFlags = episodeFlags,
+        coverLastModified = coverLastModified,
+        url = url,
+        title = title,
+        artist = artist,
+        author = author,
+        thumbnailUrl = thumbnailUrl,
+        description = description,
+        genre = genre,
+        status = status,
+        updateStrategy = updateStrategy,
+        initialized = initialized,
+        lastModifiedAt = lastModifiedAt,
+        favoriteModifiedAt = favoriteModifiedAt,
+        version = version,
+    )
+}
diff --git a/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
new file mode 100644
index 0000000000..bd92de108f
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
@@ -0,0 +1,139 @@
+package tachiyomi.data.anime
+
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.data.AnimeUpdateStrategyColumnAdapter
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.data.StringListColumnAdapter
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.model.AnimeUpdate
+import tachiyomi.domain.anime.repository.AnimeRepository
+
+class AnimeRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : AnimeRepository {
+
+    override suspend fun getAnimeById(id: Long): Anime {
+        return handler.awaitOne { animesQueries.getAnimeById(id, AnimeMapper::mapAnime) }
+    }
+
+    override suspend fun getAnimeByIdAsFlow(id: Long): Flow<Anime> {
+        return handler.subscribeToOne { animesQueries.getAnimeById(id, AnimeMapper::mapAnime) }
+    }
+
+    override suspend fun getAnimeByUrlAndSourceId(url: String, sourceId: Long): Anime? {
+        return handler.awaitOneOrNull {
+            animesQueries.getAnimeByUrlAndSource(
+                url,
+                sourceId,
+                AnimeMapper::mapAnime,
+            )
+        }
+    }
+
+    override fun getAnimeByUrlAndSourceIdAsFlow(url: String, sourceId: Long): Flow<Anime?> {
+        return handler.subscribeToOneOrNull {
+            animesQueries.getAnimeByUrlAndSource(
+                url,
+                sourceId,
+                AnimeMapper::mapAnime,
+            )
+        }
+    }
+
+    override suspend fun getFavorites(): List<Anime> {
+        return handler.awaitList { animesQueries.getFavorites(AnimeMapper::mapAnime) }
+    }
+
+    override fun getFavoritesBySourceId(sourceId: Long): Flow<List<Anime>> {
+        return handler.subscribeToList { animesQueries.getFavoriteBySourceId(sourceId, AnimeMapper::mapAnime) }
+    }
+
+    override suspend fun update(update: AnimeUpdate): Boolean {
+        return try {
+            partialUpdate(update)
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    override suspend fun updateAll(animeUpdates: List<AnimeUpdate>): Boolean {
+        return try {
+            partialUpdate(*animeUpdates.toTypedArray())
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            false
+        }
+    }
+
+    override suspend fun insert(anime: Anime): Long {
+        return handler.await(inTransaction = true) {
+            animesQueries.insert(
+                source = anime.source,
+                url = anime.url,
+                artist = anime.artist,
+                author = anime.author,
+                description = anime.description,
+                genre = anime.genre,
+                title = anime.title,
+                status = anime.status,
+                thumbnailUrl = anime.thumbnailUrl,
+                favorite = anime.favorite,
+                lastUpdate = anime.lastUpdate,
+                nextUpdate = anime.nextUpdate,
+                initialized = anime.initialized,
+                viewerFlags = anime.viewerFlags,
+                episodeFlags = anime.episodeFlags,
+                coverLastModified = anime.coverLastModified,
+                dateAdded = anime.dateAdded,
+                updateStrategy = anime.updateStrategy,
+                calculateInterval = anime.fetchInterval.toLong(),
+                version = anime.version,
+            )
+            animesQueries.selectLastInsertedRowId().executeAsOne()
+        }
+    }
+
+    override suspend fun deleteAnime(animeId: Long) {
+        handler.await { animesQueries.deleteById(animeId) }
+    }
+
+    override suspend fun getAll(): List<Anime> {
+        return handler.awaitList { animesQueries.getAllAnime(AnimeMapper::mapAnime) }
+    }
+
+    private suspend fun partialUpdate(vararg animeUpdates: AnimeUpdate) {
+        handler.await(inTransaction = true) {
+            animeUpdates.forEach { value ->
+                animesQueries.update(
+                    source = value.source,
+                    url = value.url,
+                    artist = value.artist,
+                    author = value.author,
+                    description = value.description,
+                    genre = value.genre?.let(StringListColumnAdapter::encode),
+                    title = value.title,
+                    status = value.status,
+                    thumbnailUrl = value.thumbnailUrl,
+                    favorite = value.favorite,
+                    lastUpdate = value.lastUpdate,
+                    nextUpdate = value.nextUpdate,
+                    calculateInterval = value.fetchInterval?.toLong(),
+                    initialized = value.initialized,
+                    viewer = value.viewerFlags,
+                    episodeFlags = value.episodeFlags,
+                    coverLastModified = value.coverLastModified,
+                    dateAdded = value.dateAdded,
+                    animeId = value.id,
+                    updateStrategy = value.updateStrategy?.let(AnimeUpdateStrategyColumnAdapter::encode),
+                    version = value.version,
+                    isSyncing = 0,
+                )
+            }
+        }
+    }
+}
diff --git a/data/src/main/java/tachiyomi/data/episode/EpisodeMapper.kt b/data/src/main/java/tachiyomi/data/episode/EpisodeMapper.kt
new file mode 100644
index 0000000000..a52c66ed5d
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/episode/EpisodeMapper.kt
@@ -0,0 +1,43 @@
+package tachiyomi.data.episode
+
+import tachiyomi.domain.episode.model.Episode
+
+object EpisodeMapper {
+    fun mapEpisode(
+        id: Long,
+        animeId: Long,
+        url: String,
+        name: String,
+        scanlator: String?,
+        seen: Boolean,
+        bookmark: Boolean,
+        fillermark: Boolean,
+        lastSecondSeen: Long,
+        totalSeconds: Long,
+        episodeNumber: Double,
+        sourceOrder: Long,
+        dateFetch: Long,
+        dateUpload: Long,
+        lastModifiedAt: Long,
+        version: Long,
+        @Suppress("UNUSED_PARAMETER")
+        isSyncing: Long,
+    ): Episode = Episode(
+        id = id,
+        animeId = animeId,
+        seen = seen,
+        bookmark = bookmark,
+        fillermark = fillermark,
+        lastSecondSeen = lastSecondSeen,
+        totalSeconds = totalSeconds,
+        dateFetch = dateFetch,
+        sourceOrder = sourceOrder,
+        url = url,
+        name = name,
+        dateUpload = dateUpload,
+        episodeNumber = episodeNumber,
+        scanlator = scanlator,
+        lastModifiedAt = lastModifiedAt,
+        version = version,
+    )
+}
diff --git a/data/src/main/java/tachiyomi/data/episode/EpisodeRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/episode/EpisodeRepositoryImpl.kt
new file mode 100644
index 0000000000..d2f5adc75b
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/episode/EpisodeRepositoryImpl.kt
@@ -0,0 +1,113 @@
+package tachiyomi.data.episode
+
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.episode.model.EpisodeUpdate
+import tachiyomi.domain.episode.repository.EpisodeRepository
+
+class EpisodeRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : EpisodeRepository {
+
+    override suspend fun addAll(episodes: List<Episode>): List<Episode> {
+        return try {
+            handler.await(inTransaction = true) {
+                episodes.map { episode ->
+                    episodesQueries.insert(
+                        episode.animeId,
+                        episode.url,
+                        episode.name,
+                        episode.scanlator,
+                        episode.seen,
+                        episode.bookmark,
+                        episode.fillermark,
+                        episode.lastSecondSeen,
+                        episode.totalSeconds,
+                        episode.episodeNumber,
+                        episode.sourceOrder,
+                        episode.dateFetch,
+                        episode.dateUpload,
+                        episode.version,
+                    )
+                    val lastInsertId = episodesQueries.selectLastInsertedRowId().executeAsOne()
+                    episode.copy(id = lastInsertId)
+                }
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+
+    override suspend fun update(episodeUpdate: EpisodeUpdate) {
+        partialUpdate(episodeUpdate)
+    }
+
+    override suspend fun updateAll(episodeUpdates: List<EpisodeUpdate>) {
+        partialUpdate(*episodeUpdates.toTypedArray())
+    }
+
+    private suspend fun partialUpdate(vararg episodeUpdates: EpisodeUpdate) {
+        handler.await(inTransaction = true) {
+            episodeUpdates.forEach { episodeUpdate ->
+                episodesQueries.update(
+                    animeId = episodeUpdate.animeId,
+                    url = episodeUpdate.url,
+                    name = episodeUpdate.name,
+                    scanlator = episodeUpdate.scanlator,
+                    seen = episodeUpdate.seen,
+                    bookmark = episodeUpdate.bookmark,
+                    fillermark = episodeUpdate.fillermark,
+                    lastSecondSeen = episodeUpdate.lastSecondSeen,
+                    totalSeconds = episodeUpdate.totalSeconds,
+                    episodeNumber = episodeUpdate.episodeNumber,
+                    sourceOrder = episodeUpdate.sourceOrder,
+                    dateFetch = episodeUpdate.dateFetch,
+                    dateUpload = episodeUpdate.dateUpload,
+                    episodeId = episodeUpdate.id,
+                    version = episodeUpdate.version,
+                    isSyncing = 0,
+                )
+            }
+        }
+    }
+
+    override suspend fun removeEpisodesWithIds(episodeIds: List<Long>) {
+        try {
+            handler.await { episodesQueries.removeEpisodesWithIds(episodeIds) }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+
+    override suspend fun getEpisodesByAnimeId(animeId: Long): List<Episode> {
+        return handler.awaitList {
+            episodesQueries.getEpisodesByAnimeId(animeId, EpisodeMapper::mapEpisode)
+        }
+    }
+
+    override fun getEpisodesByAnimeIdAsFlow(animeId: Long): Flow<List<Episode>> {
+        return handler.subscribeToList {
+            episodesQueries.getEpisodesByAnimeId(animeId, EpisodeMapper::mapEpisode)
+        }
+    }
+
+    override suspend fun getBookmarkedEpisodesByAnimeId(animeId: Long): List<Episode> {
+        return handler.awaitList {
+            episodesQueries.getBookmarkedEpisodesByAnimeId(animeId, EpisodeMapper::mapEpisode)
+        }
+    }
+
+    override suspend fun getEpisodeById(id: Long): Episode? {
+        return handler.awaitOneOrNull { episodesQueries.getEpisodeById(id, EpisodeMapper::mapEpisode) }
+    }
+
+    override suspend fun getEpisodeByUrlAndAnimeId(url: String, animeId: Long): Episode? {
+        return handler.awaitOneOrNull {
+            episodesQueries.getEpisodeByUrlAndAnimeId(url, animeId, EpisodeMapper::mapEpisode)
+        }
+    }
+}
diff --git a/data/src/main/sqldelight/tachiyomi/data/animes.sq b/data/src/main/sqldelight/tachiyomi/data/animes.sq
new file mode 100644
index 0000000000..684457ebdf
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/data/animes.sq
@@ -0,0 +1,128 @@
+import eu.kanade.tachiyomi.animesource.model.AnimeUpdateStrategy;
+import kotlin.collections.List;
+import kotlin.Boolean;
+import kotlin.String;
+
+CREATE TABLE animes(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    source INTEGER NOT NULL,
+    url TEXT NOT NULL,
+    artist TEXT,
+    author TEXT,
+    description TEXT,
+    genre TEXT AS List<String>,
+    title TEXT NOT NULL,
+    status INTEGER NOT NULL,
+    thumbnail_url TEXT,
+    favorite INTEGER AS Boolean NOT NULL,
+    last_update INTEGER,
+    next_update INTEGER,
+    initialized INTEGER AS Boolean NOT NULL,
+    viewer INTEGER NOT NULL,
+    episode_flags INTEGER NOT NULL,
+    cover_last_modified INTEGER NOT NULL,
+    date_added INTEGER NOT NULL,
+    update_strategy INTEGER AS AnimeUpdateStrategy NOT NULL DEFAULT 0,
+    calculate_interval INTEGER DEFAULT 0 NOT NULL,
+    last_modified_at INTEGER NOT NULL DEFAULT 0,
+    favorite_modified_at INTEGER,
+    version INTEGER NOT NULL DEFAULT 0,
+    is_syncing INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX library_favorite_anime_index ON animes(favorite) WHERE favorite = 1;
+CREATE INDEX animes_url_index ON animes(url);
+
+CREATE TRIGGER update_last_favorited_at_animes
+AFTER UPDATE OF favorite ON animes
+BEGIN
+  UPDATE animes
+  SET favorite_modified_at = strftime('%s', 'now')
+  WHERE _id = new._id;
+END;
+
+CREATE TRIGGER update_last_modified_at_animes
+AFTER UPDATE ON animes
+FOR EACH ROW
+BEGIN
+  UPDATE animes
+  SET last_modified_at = strftime('%s', 'now')
+  WHERE _id = new._id;
+END;
+
+CREATE TRIGGER update_anime_version AFTER UPDATE ON animes
+BEGIN
+    UPDATE animes SET version = version + 1
+    WHERE _id = new._id AND new.is_syncing = 0 AND (
+        new.url != old.url OR
+        new.description != old.description OR
+        new.favorite != old.favorite
+    );
+END;
+
+getAnimeById:
+SELECT *
+FROM animes
+WHERE _id = :id;
+
+getAnimeByUrlAndSource:
+SELECT *
+FROM animes
+WHERE url = :url
+AND source = :source
+LIMIT 1;
+
+getFavorites:
+SELECT *
+FROM animes
+WHERE favorite = 1;
+
+getFavoriteBySourceId:
+SELECT *
+FROM animes
+WHERE favorite = 1
+AND source = :sourceId;
+
+getAllAnime:
+SELECT *
+FROM animes;
+
+resetIsSyncing:
+UPDATE animes
+SET is_syncing = 0
+WHERE is_syncing = 1;
+
+insert:
+INSERT INTO animes(source, url, artist, author, description, genre, title, status, thumbnail_url, favorite, last_update, next_update, initialized, viewer, episode_flags, cover_last_modified, date_added, update_strategy, calculate_interval, last_modified_at, version)
+VALUES (:source, :url, :artist, :author, :description, :genre, :title, :status, :thumbnailUrl, :favorite, :lastUpdate, :nextUpdate, :initialized, :viewerFlags, :episodeFlags, :coverLastModified, :dateAdded, :updateStrategy, :calculateInterval, 0, :version);
+
+update:
+UPDATE animes SET
+    source = coalesce(:source, source),
+    url = coalesce(:url, url),
+    artist = coalesce(:artist, artist),
+    author = coalesce(:author, author),
+    description = coalesce(:description, description),
+    genre = coalesce(:genre, genre),
+    title = coalesce(:title, title),
+    status = coalesce(:status, status),
+    thumbnail_url = coalesce(:thumbnailUrl, thumbnail_url),
+    favorite = coalesce(:favorite, favorite),
+    last_update = coalesce(:lastUpdate, last_update),
+    next_update = coalesce(:nextUpdate, next_update),
+    initialized = coalesce(:initialized, initialized),
+    viewer = coalesce(:viewer, viewer),
+    episode_flags = coalesce(:episodeFlags, episode_flags),
+    cover_last_modified = coalesce(:coverLastModified, cover_last_modified),
+    date_added = coalesce(:dateAdded, date_added),
+    update_strategy = coalesce(:updateStrategy, update_strategy),
+    calculate_interval = coalesce(:calculateInterval, calculate_interval),
+    version = coalesce(:version, version),
+    is_syncing = coalesce(:isSyncing, is_syncing)
+WHERE _id = :animeId;
+
+selectLastInsertedRowId:
+SELECT last_insert_rowid();
+
+deleteById:
+DELETE FROM animes WHERE _id = :id;
diff --git a/data/src/main/sqldelight/tachiyomi/data/episodes.sq b/data/src/main/sqldelight/tachiyomi/data/episodes.sq
new file mode 100644
index 0000000000..b694c084c4
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/data/episodes.sq
@@ -0,0 +1,106 @@
+import kotlin.Boolean;
+
+CREATE TABLE episodes(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    anime_id INTEGER NOT NULL,
+    url TEXT NOT NULL,
+    name TEXT NOT NULL,
+    scanlator TEXT,
+    seen INTEGER AS Boolean NOT NULL,
+    bookmark INTEGER AS Boolean NOT NULL,
+    fillermark INTEGER AS Boolean NOT NULL,
+    last_second_seen INTEGER NOT NULL,
+    total_seconds INTEGER NOT NULL,
+    episode_number REAL NOT NULL,
+    source_order INTEGER NOT NULL,
+    date_fetch INTEGER NOT NULL,
+    date_upload INTEGER NOT NULL,
+    last_modified_at INTEGER NOT NULL DEFAULT 0,
+    version INTEGER NOT NULL DEFAULT 0,
+    is_syncing INTEGER NOT NULL DEFAULT 0,
+    FOREIGN KEY(anime_id) REFERENCES animes (_id)
+    ON DELETE CASCADE
+);
+
+CREATE INDEX episodes_anime_id_index ON episodes(anime_id);
+CREATE INDEX episodes_unseen_by_anime_index ON episodes(anime_id, seen) WHERE seen = 0;
+
+CREATE TRIGGER update_last_modified_at_episodes
+AFTER UPDATE ON episodes
+FOR EACH ROW
+BEGIN
+  UPDATE episodes
+  SET last_modified_at = strftime('%s', 'now')
+  WHERE _id = new._id;
+END;
+
+CREATE TRIGGER update_episode_and_anime_version AFTER UPDATE ON episodes
+WHEN new.is_syncing = 0 AND (
+    new.seen != old.seen OR
+    new.bookmark != old.bookmark OR
+    new.last_second_seen != old.last_second_seen
+)
+BEGIN
+    UPDATE episodes SET version = version + 1
+    WHERE _id = new._id;
+
+    UPDATE animes SET version = version + 1
+    WHERE _id = new.anime_id AND (SELECT is_syncing FROM animes WHERE _id = new.anime_id) = 0;
+END;
+
+getEpisodeById:
+SELECT *
+FROM episodes
+WHERE _id = :id;
+
+getEpisodesByAnimeId:
+SELECT *
+FROM episodes
+WHERE anime_id = :animeId;
+
+getBookmarkedEpisodesByAnimeId:
+SELECT *
+FROM episodes
+WHERE bookmark
+AND anime_id = :animeId;
+
+getEpisodeByUrlAndAnimeId:
+SELECT *
+FROM episodes
+WHERE url = :episodeUrl
+AND anime_id = :animeId;
+
+removeEpisodesWithIds:
+DELETE FROM episodes
+WHERE _id IN :episodeIds;
+
+resetIsSyncing:
+UPDATE episodes
+SET is_syncing = 0
+WHERE is_syncing = 1;
+
+insert:
+INSERT INTO episodes(anime_id, url, name, scanlator, seen, bookmark, fillermark, last_second_seen, total_seconds, episode_number, source_order, date_fetch, date_upload, last_modified_at, version, is_syncing)
+VALUES (:animeId, :url, :name, :scanlator, :seen, :bookmark, :fillermark, :lastSecondSeen, :totalSeconds, :episodeNumber, :sourceOrder, :dateFetch, :dateUpload, 0, :version, 0);
+
+update:
+UPDATE episodes
+SET anime_id = coalesce(:animeId, anime_id),
+    url = coalesce(:url, url),
+    name = coalesce(:name, name),
+    scanlator = coalesce(:scanlator, scanlator),
+    seen = coalesce(:seen, seen),
+    bookmark = coalesce(:bookmark, bookmark),
+    fillermark = coalesce(:fillermark, fillermark),
+    last_second_seen = coalesce(:lastSecondSeen, last_second_seen),
+    total_seconds = coalesce(:totalSeconds, total_seconds),
+    episode_number = coalesce(:episodeNumber, episode_number),
+    source_order = coalesce(:sourceOrder, source_order),
+    date_fetch = coalesce(:dateFetch, date_fetch),
+    date_upload = coalesce(:dateUpload, date_upload),
+    version = coalesce(:version, version),
+    is_syncing = coalesce(:isSyncing, is_syncing)
+WHERE _id = :episodeId;
+
+selectLastInsertedRowId:
+SELECT last_insert_rowid();
diff --git a/domain/src/main/java/tachiyomi/domain/anime/interactor/GetAnime.kt b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetAnime.kt
new file mode 100644
index 0000000000..9c1e587449
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetAnime.kt
@@ -0,0 +1,33 @@
+package tachiyomi.domain.anime.interactor
+
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.repository.AnimeRepository
+
+class GetAnime(
+    private val animeRepository: AnimeRepository,
+) {
+
+    suspend fun await(id: Long): Anime? {
+        return try {
+            animeRepository.getAnimeById(id)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+
+    suspend fun subscribe(id: Long): Flow<Anime> {
+        return animeRepository.getAnimeByIdAsFlow(id)
+    }
+
+    fun subscribe(url: String, sourceId: Long): Flow<Anime?> {
+        return animeRepository.getAnimeByUrlAndSourceIdAsFlow(url, sourceId)
+    }
+
+    suspend fun await(url: String, sourceId: Long): Anime? {
+        return animeRepository.getAnimeByUrlAndSourceId(url, sourceId)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/interactor/GetFavoriteAnime.kt b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetFavoriteAnime.kt
new file mode 100644
index 0000000000..160aadb786
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetFavoriteAnime.kt
@@ -0,0 +1,37 @@
+package tachiyomi.domain.anime.interactor
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.retry
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.repository.AnimeRepository
+import kotlin.time.Duration.Companion.seconds
+
+class GetFavoriteAnime(
+    private val animeRepository: AnimeRepository,
+) {
+
+    suspend fun await(): List<Anime> {
+        return animeRepository.getFavorites()
+    }
+
+    fun subscribe(sourceId: Long): Flow<List<Anime>> {
+        return animeRepository.getFavoritesBySourceId(sourceId)
+            // KMK -->
+            .retry {
+                if (it is NullPointerException) {
+                    delay(0.5.seconds)
+                    true
+                } else {
+                    false
+                }
+            }
+            .catch {
+                logcat(LogPriority.ERROR, it)
+            }
+        // KMK <--
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/interactor/SetAnimeEpisodeFlags.kt b/domain/src/main/java/tachiyomi/domain/anime/interactor/SetAnimeEpisodeFlags.kt
new file mode 100644
index 0000000000..898ab5188e
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/interactor/SetAnimeEpisodeFlags.kt
@@ -0,0 +1,94 @@
+package tachiyomi.domain.anime.interactor
+
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.model.AnimeUpdate
+import tachiyomi.domain.anime.repository.AnimeRepository
+
+class SetAnimeEpisodeFlags(
+    private val animeRepository: AnimeRepository,
+) {
+
+    suspend fun awaitSetDownloadedFilter(anime: Anime, flag: Long): Boolean {
+        return animeRepository.update(
+            AnimeUpdate(
+                id = anime.id,
+                episodeFlags = anime.episodeFlags.setFlag(flag, Anime.EPISODE_DOWNLOADED_MASK),
+            ),
+        )
+    }
+
+    suspend fun awaitSetUnseenFilter(anime: Anime, flag: Long): Boolean {
+        return animeRepository.update(
+            AnimeUpdate(
+                id = anime.id,
+                episodeFlags = anime.episodeFlags.setFlag(flag, Anime.EPISODE_UNSEEN_MASK),
+            ),
+        )
+    }
+
+    suspend fun awaitSetBookmarkFilter(anime: Anime, flag: Long): Boolean {
+        return animeRepository.update(
+            AnimeUpdate(
+                id = anime.id,
+                episodeFlags = anime.episodeFlags.setFlag(flag, Anime.EPISODE_BOOKMARKED_MASK),
+            ),
+        )
+    }
+
+    suspend fun awaitSetDisplayMode(anime: Anime, flag: Long): Boolean {
+        return animeRepository.update(
+            AnimeUpdate(
+                id = anime.id,
+                episodeFlags = anime.episodeFlags.setFlag(flag, Anime.EPISODE_DISPLAY_MASK),
+            ),
+        )
+    }
+
+    suspend fun awaitSetSortingModeOrFlipOrder(anime: Anime, flag: Long): Boolean {
+        val newFlags = anime.episodeFlags.let {
+            if (anime.sorting == flag) {
+                it.setFlag(
+                    if (anime.sortDescending()) Anime.EPISODE_SORT_ASC else Anime.EPISODE_SORT_DESC,
+                    Anime.EPISODE_SORT_DIR_MASK,
+                )
+            } else {
+                it
+                    .setFlag(flag, Anime.EPISODE_SORTING_MASK)
+                    .setFlag(Anime.EPISODE_SORT_ASC, Anime.EPISODE_SORT_DIR_MASK)
+            }
+        }
+        return animeRepository.update(
+            AnimeUpdate(
+                id = anime.id,
+                episodeFlags = newFlags,
+            ),
+        )
+    }
+
+    suspend fun awaitSetAllFlags(
+        animeId: Long,
+        unseenFilter: Long,
+        downloadedFilter: Long,
+        bookmarkedFilter: Long,
+        sortingMode: Long,
+        sortingDirection: Long,
+        displayMode: Long,
+    ): Boolean {
+        return animeRepository.update(
+            AnimeUpdate(
+                id = animeId,
+                episodeFlags = 0L
+                    .setFlag(unseenFilter, Anime.EPISODE_UNSEEN_MASK)
+                    .setFlag(downloadedFilter, Anime.EPISODE_DOWNLOADED_MASK)
+                    .setFlag(bookmarkedFilter, Anime.EPISODE_BOOKMARKED_MASK)
+                    .setFlag(sortingMode, Anime.EPISODE_SORTING_MASK)
+                    .setFlag(sortingDirection, Anime.EPISODE_SORT_DIR_MASK)
+                    .setFlag(displayMode, Anime.EPISODE_DISPLAY_MASK),
+            ),
+        )
+    }
+
+    private fun Long.setFlag(flag: Long, mask: Long): Long {
+        return this and mask.inv() or (flag and mask)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/interactor/UpdateAnime.kt b/domain/src/main/java/tachiyomi/domain/anime/interactor/UpdateAnime.kt
new file mode 100644
index 0000000000..aaf3081aac
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/interactor/UpdateAnime.kt
@@ -0,0 +1,17 @@
+package tachiyomi.domain.anime.interactor
+
+import tachiyomi.domain.anime.model.AnimeUpdate
+import tachiyomi.domain.anime.repository.AnimeRepository
+
+class UpdateAnime(
+    private val animeRepository: AnimeRepository,
+) {
+
+    suspend fun await(animeUpdate: AnimeUpdate): Boolean {
+        return animeRepository.update(animeUpdate)
+    }
+
+    suspend fun awaitAll(animeUpdates: List<AnimeUpdate>): Boolean {
+        return animeRepository.updateAll(animeUpdates)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/model/Anime.kt b/domain/src/main/java/tachiyomi/domain/anime/model/Anime.kt
new file mode 100644
index 0000000000..925b835a6b
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/model/Anime.kt
@@ -0,0 +1,123 @@
+package tachiyomi.domain.anime.model
+
+import androidx.compose.runtime.Immutable
+import eu.kanade.tachiyomi.animesource.model.AnimeUpdateStrategy
+import tachiyomi.core.common.preference.TriState
+import java.io.Serializable
+
+@Immutable
+data class Anime(
+    val id: Long,
+    val source: Long,
+    val favorite: Boolean,
+    val lastUpdate: Long,
+    val nextUpdate: Long,
+    val fetchInterval: Int,
+    val dateAdded: Long,
+    val viewerFlags: Long,
+    val episodeFlags: Long,
+    val coverLastModified: Long,
+    val url: String,
+    val title: String,
+    val artist: String?,
+    val author: String?,
+    val thumbnailUrl: String?,
+    val description: String?,
+    val genre: List<String>?,
+    val status: Long,
+    val updateStrategy: AnimeUpdateStrategy,
+    val initialized: Boolean,
+    val lastModifiedAt: Long,
+    val favoriteModifiedAt: Long?,
+    val version: Long,
+) : Serializable {
+
+    val sorting: Long
+        get() = episodeFlags and EPISODE_SORTING_MASK
+
+    val displayMode: Long
+        get() = episodeFlags and EPISODE_DISPLAY_MASK
+
+    val unseenFilterRaw: Long
+        get() = episodeFlags and EPISODE_UNSEEN_MASK
+
+    val downloadedFilterRaw: Long
+        get() = episodeFlags and EPISODE_DOWNLOADED_MASK
+
+    val bookmarkedFilterRaw: Long
+        get() = episodeFlags and EPISODE_BOOKMARKED_MASK
+
+    val unseenFilter: TriState
+        get() = when (unseenFilterRaw) {
+            EPISODE_SHOW_UNSEEN -> TriState.ENABLED_IS
+            EPISODE_SHOW_SEEN -> TriState.ENABLED_NOT
+            else -> TriState.DISABLED
+        }
+
+    val bookmarkedFilter: TriState
+        get() = when (bookmarkedFilterRaw) {
+            EPISODE_SHOW_BOOKMARKED -> TriState.ENABLED_IS
+            EPISODE_SHOW_NOT_BOOKMARKED -> TriState.ENABLED_NOT
+            else -> TriState.DISABLED
+        }
+
+    fun sortDescending(): Boolean {
+        return episodeFlags and EPISODE_SORT_DIR_MASK == EPISODE_SORT_DESC
+    }
+
+    companion object {
+        const val SHOW_ALL = 0x00000000L
+
+        const val EPISODE_SORT_DESC = 0x00000000L
+        const val EPISODE_SORT_ASC = 0x00000001L
+        const val EPISODE_SORT_DIR_MASK = 0x00000001L
+
+        const val EPISODE_SHOW_UNSEEN = 0x00000002L
+        const val EPISODE_SHOW_SEEN = 0x00000004L
+        const val EPISODE_UNSEEN_MASK = 0x00000006L
+
+        const val EPISODE_SHOW_DOWNLOADED = 0x00000008L
+        const val EPISODE_SHOW_NOT_DOWNLOADED = 0x00000010L
+        const val EPISODE_DOWNLOADED_MASK = 0x00000018L
+
+        const val EPISODE_SHOW_BOOKMARKED = 0x00000020L
+        const val EPISODE_SHOW_NOT_BOOKMARKED = 0x00000040L
+        const val EPISODE_BOOKMARKED_MASK = 0x00000060L
+
+        const val EPISODE_SORTING_SOURCE = 0x00000000L
+        const val EPISODE_SORTING_NUMBER = 0x00000100L
+        const val EPISODE_SORTING_UPLOAD_DATE = 0x00000200L
+        const val EPISODE_SORTING_ALPHABET = 0x00000300L
+        const val EPISODE_SORTING_MASK = 0x00000300L
+
+        const val EPISODE_DISPLAY_NAME = 0x00000000L
+        const val EPISODE_DISPLAY_NUMBER = 0x00100000L
+        const val EPISODE_DISPLAY_MASK = 0x00100000L
+
+        fun create() = Anime(
+            id = -1L,
+            url = "",
+            title = "",
+            source = -1L,
+            favorite = false,
+            lastUpdate = 0L,
+            nextUpdate = 0L,
+            fetchInterval = 0,
+            dateAdded = 0L,
+            viewerFlags = 0L,
+            episodeFlags = 0L,
+            coverLastModified = 0L,
+            artist = null,
+            author = null,
+            thumbnailUrl = null,
+            description = null,
+            genre = null,
+            status = 0L,
+            updateStrategy = AnimeUpdateStrategy.ALWAYS_UPDATE,
+            initialized = false,
+            lastModifiedAt = 0L,
+            favoriteModifiedAt = null,
+            version = 0L,
+        )
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/model/AnimeUpdate.kt b/domain/src/main/java/tachiyomi/domain/anime/model/AnimeUpdate.kt
new file mode 100644
index 0000000000..61382559a5
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/model/AnimeUpdate.kt
@@ -0,0 +1,53 @@
+package tachiyomi.domain.anime.model
+
+import eu.kanade.tachiyomi.animesource.model.AnimeUpdateStrategy
+
+data class AnimeUpdate(
+    val id: Long,
+    val source: Long? = null,
+    val favorite: Boolean? = null,
+    val lastUpdate: Long? = null,
+    val nextUpdate: Long? = null,
+    val fetchInterval: Int? = null,
+    val dateAdded: Long? = null,
+    val viewerFlags: Long? = null,
+    val episodeFlags: Long? = null,
+    val coverLastModified: Long? = null,
+    val url: String? = null,
+    val title: String? = null,
+    val artist: String? = null,
+    val author: String? = null,
+    val description: String? = null,
+    val genre: List<String>? = null,
+    val status: Long? = null,
+    val thumbnailUrl: String? = null,
+    val updateStrategy: AnimeUpdateStrategy? = null,
+    val initialized: Boolean? = null,
+    val version: Long? = null,
+)
+
+fun Anime.toAnimeUpdate(): AnimeUpdate {
+    return AnimeUpdate(
+        id = id,
+        source = source,
+        favorite = favorite,
+        lastUpdate = lastUpdate,
+        nextUpdate = nextUpdate,
+        fetchInterval = fetchInterval,
+        dateAdded = dateAdded,
+        viewerFlags = viewerFlags,
+        episodeFlags = episodeFlags,
+        coverLastModified = coverLastModified,
+        url = url,
+        title = title,
+        artist = artist,
+        author = author,
+        thumbnailUrl = thumbnailUrl,
+        description = description,
+        genre = genre,
+        status = status,
+        updateStrategy = updateStrategy,
+        initialized = initialized,
+        version = version,
+    )
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt b/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
new file mode 100644
index 0000000000..3ada66f050
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
@@ -0,0 +1,30 @@
+package tachiyomi.domain.anime.repository
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.model.AnimeUpdate
+
+interface AnimeRepository {
+
+    suspend fun getAnimeById(id: Long): Anime
+
+    suspend fun getAnimeByIdAsFlow(id: Long): Flow<Anime>
+
+    suspend fun getAnimeByUrlAndSourceId(url: String, sourceId: Long): Anime?
+
+    fun getAnimeByUrlAndSourceIdAsFlow(url: String, sourceId: Long): Flow<Anime?>
+
+    suspend fun getFavorites(): List<Anime>
+
+    fun getFavoritesBySourceId(sourceId: Long): Flow<List<Anime>>
+
+    suspend fun update(update: AnimeUpdate): Boolean
+
+    suspend fun updateAll(animeUpdates: List<AnimeUpdate>): Boolean
+
+    suspend fun insert(anime: Anime): Long
+
+    suspend fun deleteAnime(animeId: Long)
+
+    suspend fun getAll(): List<Anime>
+}
diff --git a/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisode.kt b/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisode.kt
new file mode 100644
index 0000000000..8c08b18164
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisode.kt
@@ -0,0 +1,29 @@
+package tachiyomi.domain.episode.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.episode.repository.EpisodeRepository
+
+class GetEpisode(
+    private val episodeRepository: EpisodeRepository,
+) {
+
+    suspend fun await(id: Long): Episode? {
+        return try {
+            episodeRepository.getEpisodeById(id)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+
+    suspend fun await(url: String, animeId: Long): Episode? {
+        return try {
+            episodeRepository.getEpisodeByUrlAndAnimeId(url, animeId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            null
+        }
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisodesByAnimeId.kt b/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisodesByAnimeId.kt
new file mode 100644
index 0000000000..3ef2e483cf
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisodesByAnimeId.kt
@@ -0,0 +1,20 @@
+package tachiyomi.domain.episode.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.episode.repository.EpisodeRepository
+
+class GetEpisodesByAnimeId(
+    private val episodeRepository: EpisodeRepository,
+) {
+
+    suspend fun await(animeId: Long): List<Episode> {
+        return try {
+            episodeRepository.getEpisodesByAnimeId(animeId)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            emptyList()
+        }
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/episode/interactor/SetSeenStatus.kt b/domain/src/main/java/tachiyomi/domain/episode/interactor/SetSeenStatus.kt
new file mode 100644
index 0000000000..98b5858c66
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/episode/interactor/SetSeenStatus.kt
@@ -0,0 +1,59 @@
+package tachiyomi.domain.episode.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.common.util.lang.withNonCancellableContext
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.episode.model.EpisodeUpdate
+import tachiyomi.domain.episode.repository.EpisodeRepository
+
+class SetSeenStatus(
+    private val episodeRepository: EpisodeRepository,
+) {
+
+    private val mapper = { episode: Episode, seen: Boolean ->
+        EpisodeUpdate(
+            seen = seen,
+            lastSecondSeen = if (!seen) 0 else null,
+            id = episode.id,
+        )
+    }
+
+    suspend fun await(seen: Boolean, vararg episodes: Episode): Result = withNonCancellableContext {
+        val episodesToUpdate = episodes.filter {
+            when (seen) {
+                true -> !it.seen
+                false -> it.seen || it.lastSecondSeen > 0
+            }
+        }
+        if (episodesToUpdate.isEmpty()) {
+            return@withNonCancellableContext Result.NoEpisodes
+        }
+
+        try {
+            episodeRepository.updateAll(
+                episodesToUpdate.map { mapper(it, seen) },
+            )
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            return@withNonCancellableContext Result.InternalError(e)
+        }
+
+        Result.Success
+    }
+
+    suspend fun await(animeId: Long, seen: Boolean): Result = withNonCancellableContext {
+        await(
+            seen = seen,
+            episodes = episodeRepository
+                .getEpisodesByAnimeId(animeId)
+                .toTypedArray(),
+        )
+    }
+
+    sealed interface Result {
+        data object Success : Result
+        data object NoEpisodes : Result
+        data class InternalError(val error: Throwable) : Result
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/episode/interactor/UpdateEpisode.kt b/domain/src/main/java/tachiyomi/domain/episode/interactor/UpdateEpisode.kt
new file mode 100644
index 0000000000..8d826c0a47
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/episode/interactor/UpdateEpisode.kt
@@ -0,0 +1,27 @@
+package tachiyomi.domain.episode.interactor
+
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.episode.model.EpisodeUpdate
+import tachiyomi.domain.episode.repository.EpisodeRepository
+
+class UpdateEpisode(
+    private val episodeRepository: EpisodeRepository,
+) {
+
+    suspend fun await(episodeUpdate: EpisodeUpdate) {
+        try {
+            episodeRepository.update(episodeUpdate)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+
+    suspend fun awaitAll(episodeUpdates: List<EpisodeUpdate>) {
+        try {
+            episodeRepository.updateAll(episodeUpdates)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+        }
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/episode/model/Episode.kt b/domain/src/main/java/tachiyomi/domain/episode/model/Episode.kt
new file mode 100644
index 0000000000..d19c403224
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/episode/model/Episode.kt
@@ -0,0 +1,54 @@
+package tachiyomi.domain.episode.model
+
+data class Episode(
+    val id: Long,
+    val animeId: Long,
+    val seen: Boolean,
+    val bookmark: Boolean,
+    val fillermark: Boolean,
+    val lastSecondSeen: Long,
+    val totalSeconds: Long,
+    val dateFetch: Long,
+    val sourceOrder: Long,
+    val url: String,
+    val name: String,
+    val dateUpload: Long,
+    val episodeNumber: Double,
+    val scanlator: String?,
+    val lastModifiedAt: Long,
+    val version: Long,
+) {
+    val isRecognizedNumber: Boolean
+        get() = episodeNumber >= 0.0
+
+    fun copyFrom(other: Episode): Episode {
+        return copy(
+            name = other.name,
+            url = other.url,
+            dateUpload = other.dateUpload,
+            episodeNumber = other.episodeNumber,
+            scanlator = other.scanlator?.ifBlank { null },
+        )
+    }
+
+    companion object {
+        fun create() = Episode(
+            id = -1,
+            animeId = -1,
+            seen = false,
+            bookmark = false,
+            fillermark = false,
+            lastSecondSeen = 0,
+            totalSeconds = 0,
+            dateFetch = 0,
+            sourceOrder = 0,
+            url = "",
+            name = "",
+            dateUpload = -1,
+            episodeNumber = -1.0,
+            scanlator = null,
+            lastModifiedAt = 0,
+            version = 1,
+        )
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/episode/model/EpisodeUpdate.kt b/domain/src/main/java/tachiyomi/domain/episode/model/EpisodeUpdate.kt
new file mode 100644
index 0000000000..0ee4c50f38
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/episode/model/EpisodeUpdate.kt
@@ -0,0 +1,39 @@
+package tachiyomi.domain.episode.model
+
+data class EpisodeUpdate(
+    val id: Long,
+    val animeId: Long? = null,
+    val seen: Boolean? = null,
+    val bookmark: Boolean? = null,
+    val fillermark: Boolean? = null,
+    val lastSecondSeen: Long? = null,
+    val totalSeconds: Long? = null,
+    val dateFetch: Long? = null,
+    val sourceOrder: Long? = null,
+    val url: String? = null,
+    val name: String? = null,
+    val dateUpload: Long? = null,
+    val episodeNumber: Double? = null,
+    val scanlator: String? = null,
+    val version: Long? = null,
+)
+
+fun Episode.toEpisodeUpdate(): EpisodeUpdate {
+    return EpisodeUpdate(
+        id = id,
+        animeId = animeId,
+        seen = seen,
+        bookmark = bookmark,
+        fillermark = fillermark,
+        lastSecondSeen = lastSecondSeen,
+        totalSeconds = totalSeconds,
+        dateFetch = dateFetch,
+        sourceOrder = sourceOrder,
+        url = url,
+        name = name,
+        dateUpload = dateUpload,
+        episodeNumber = episodeNumber,
+        scanlator = scanlator,
+        version = version,
+    )
+}
diff --git a/domain/src/main/java/tachiyomi/domain/episode/repository/EpisodeRepository.kt b/domain/src/main/java/tachiyomi/domain/episode/repository/EpisodeRepository.kt
new file mode 100644
index 0000000000..45d5b862ea
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/episode/repository/EpisodeRepository.kt
@@ -0,0 +1,26 @@
+package tachiyomi.domain.episode.repository
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.episode.model.EpisodeUpdate
+
+interface EpisodeRepository {
+
+    suspend fun addAll(episodes: List<Episode>): List<Episode>
+
+    suspend fun update(episodeUpdate: EpisodeUpdate)
+
+    suspend fun updateAll(episodeUpdates: List<EpisodeUpdate>)
+
+    suspend fun removeEpisodesWithIds(episodeIds: List<Long>)
+
+    suspend fun getEpisodesByAnimeId(animeId: Long): List<Episode>
+
+    fun getEpisodesByAnimeIdAsFlow(animeId: Long): Flow<List<Episode>>
+
+    suspend fun getBookmarkedEpisodesByAnimeId(animeId: Long): List<Episode>
+
+    suspend fun getEpisodeById(id: Long): Episode?
+
+    suspend fun getEpisodeByUrlAndAnimeId(url: String, animeId: Long): Episode?
+}
diff --git a/source-api/consumer-proguard.pro b/source-api/consumer-proguard.pro
index a040a24cb3..2546396a4b 100644
--- a/source-api/consumer-proguard.pro
+++ b/source-api/consumer-proguard.pro
@@ -2,6 +2,10 @@
 -keep class eu.kanade.tachiyomi.source.online.** { public protected *; }
 -keep class eu.kanade.tachiyomi.source.** extends eu.kanade.tachiyomi.source.Source { public protected *; }
 
+-keep class eu.kanade.tachiyomi.animesource.model.** { public protected *; }
+-keep class eu.kanade.tachiyomi.animesource.online.** { public protected *; }
+-keep class eu.kanade.tachiyomi.animesource.** extends eu.kanade.tachiyomi.animesource.AnimeSource { public protected *; }
+
 -keep,allowoptimization class eu.kanade.tachiyomi.util.JsoupExtensionsKt { public protected *; }
 
--keep class exh.metadata.** { public protected *; }
\ No newline at end of file
+-keep class exh.metadata.** { public protected *; }

From e86a0026f0fe2e8af6ca791e2d7b3e4c45f6e82a Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sat, 9 May 2026 03:00:23 +0200
Subject: [PATCH 03/13] Working basic MPV player

---
 app/build.gradle.kts                          |  15 ++
 app/proguard-rules.pro                        |   4 +
 app/src/main/AndroidManifest.xml              |  17 +-
 .../eu/kanade/domain/ui/model/NavTabLayout.kt |   3 +-
 .../kanade/tachiyomi/di/PreferenceModule.kt   |   4 +
 .../tachiyomi/ui/anime/AnimeListScreen.kt     | 169 +++++++++++++
 .../ui/anime/AnimeListScreenModel.kt          |  56 ++++
 .../eu/kanade/tachiyomi/ui/anime/AnimeTab.kt  |  30 +++
 .../tachiyomi/ui/anime/OpenVideoDialog.kt     |  61 +++++
 .../eu/kanade/tachiyomi/ui/home/HomeScreen.kt |   4 +
 .../tachiyomi/ui/player/PlayerActivity.kt     | 213 ++++++++++++++++
 .../tachiyomi/ui/player/PlayerScreen.kt       |  60 +++++
 .../kanade/tachiyomi/ui/player/PlayerUtils.kt |  12 +
 .../tachiyomi/ui/player/PlayerViewModel.kt    | 239 ++++++++++++++++++
 .../player/controls/PlayerControlsOverlay.kt  | 160 ++++++++++++
 .../tachiyomi/ui/player/controls/TimeBar.kt   |  69 +++++
 .../kanade/tachiyomi/ui/player/mpv/MPVView.kt | 124 +++++++++
 .../tachiyomi/ui/player/mpv/PlayerObserver.kt |  45 ++++
 .../ui/player/setting/PlayerOrientation.kt    |  18 ++
 .../ui/player/setting/PlayerPreferences.kt    |  19 ++
 .../sqldelight/tachiyomi/migrations/45.sqm    | 104 ++++++++
 gradle/libs.versions.toml                     |   6 +
 .../moko-resources/base/strings.xml           |   7 +
 23 files changed, 1437 insertions(+), 2 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreenModel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/anime/OpenVideoDialog.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerUtils.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/TimeBar.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerOrientation.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
 create mode 100644 data/src/main/sqldelight/tachiyomi/migrations/45.sqm

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index ad771b759c..a1a685d0c3 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -139,6 +139,16 @@ android {
                 "libimagedecoder",
                 "libquickjs",
                 "libsqlite3x",
+                "libmpv",
+                "libavcodec",
+                "libavformat",
+                "libswscale",
+                "libavutil",
+                "libswresample",
+                "libavfilter",
+                "libass",
+                "libdav1d",
+                "libplacebo",
             )
                 .map { "**/$it.so" }
         }
@@ -345,6 +355,11 @@ dependencies {
 
     testImplementation(kotlinx.coroutines.test)
 
+    // MPV player
+    implementation(libs.aniyomi.mpv)
+    implementation(libs.ffmpeg.kit)
+    implementation(libs.smart.exception.java)
+
     // SY -->
     // Better logging (EH)
     implementation(sylibs.xlog)
diff --git a/app/proguard-rules.pro b/app/proguard-rules.pro
index ba79259daa..ecd583c0c2 100644
--- a/app/proguard-rules.pro
+++ b/app/proguard-rules.pro
@@ -18,6 +18,10 @@
 -keep class com.canopus.** { *; }
 -keepclassmembers class com.canopus.** { *; }
 
+# MPV native player
+-keep class is.xyz.mpv.** { *; }
+-keepclassmembers class is.xyz.mpv.** { *; }
+
 # Injekt type resolution - FullTypeReference needs generic type info
 -keep class * extends uy.kohesive.injekt.api.TypeReference { *; }
 -keep class * extends uy.kohesive.injekt.api.FullTypeReference { *; }
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 29f838a431..075a452fd6 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -14,7 +14,8 @@
       <!-- Permission to save cover into Pictures. It isn't required from API 29 -->
     <uses-permission
         android:name="android.permission.WRITE_EXTERNAL_STORAGE"
-        android:maxSdkVersion="28" />
+        android:maxSdkVersion="28"
+        tools:replace="android:maxSdkVersion" />
       <!-- For access custom cover on Android 12 & below (API 32) -->
     <uses-permission
         android:name="android.permission.READ_EXTERNAL_STORAGE"
@@ -174,6 +175,20 @@
             android:exported="false"
             android:theme="@style/Theme.Tachiyomi" />
 
+        <activity
+            android:name=".ui.player.PlayerActivity"
+            android:exported="true"
+            android:launchMode="singleTask"
+            android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize|uiMode"
+            android:theme="@style/Theme.Tachiyomi"
+            android:supportsPictureInPicture="false">
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="video/*" />
+            </intent-filter>
+        </activity>
+
         <activity
             android:name=".ui.security.UnlockActivity"
             android:exported="false"
diff --git a/app/src/main/java/eu/kanade/domain/ui/model/NavTabLayout.kt b/app/src/main/java/eu/kanade/domain/ui/model/NavTabLayout.kt
index 75cfce1ee1..935b215e91 100644
--- a/app/src/main/java/eu/kanade/domain/ui/model/NavTabLayout.kt
+++ b/app/src/main/java/eu/kanade/domain/ui/model/NavTabLayout.kt
@@ -35,9 +35,10 @@ data class NavTabLayout(
         const val KEY_BROWSE = "Browse"
         const val KEY_DICTIONARY = "Dictionary"
         const val KEY_NOVELS = "Novels"
+        const val KEY_ANIME = "Anime"
 
         val ALL_KEYS = listOf(
-            KEY_LIBRARY, KEY_NOVELS, KEY_UPDATES, KEY_HISTORY,
+            KEY_LIBRARY, KEY_NOVELS, KEY_ANIME, KEY_UPDATES, KEY_HISTORY,
             KEY_BROWSE, KEY_DICTIONARY,
         )
 
diff --git a/app/src/main/java/eu/kanade/tachiyomi/di/PreferenceModule.kt b/app/src/main/java/eu/kanade/tachiyomi/di/PreferenceModule.kt
index 65f89cad29..61ec90e05b 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/di/PreferenceModule.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/di/PreferenceModule.kt
@@ -11,6 +11,7 @@ import eu.kanade.tachiyomi.core.security.PrivacyPreferences
 import eu.kanade.tachiyomi.core.security.SecurityPreferences
 import eu.kanade.tachiyomi.network.NetworkPreferences
 import eu.kanade.tachiyomi.ui.dictionary.DictionaryPreferences
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
 import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
 import com.canopus.chimareader.data.NovelReaderSettings
 import eu.kanade.tachiyomi.util.system.isDebugBuildType
@@ -63,6 +64,9 @@ class PreferenceModule(val app: Application) : InjektModule {
         addSingletonFactory {
             ReaderPreferences(get())
         }
+        addSingletonFactory {
+            PlayerPreferences(get())
+        }
         addSingletonFactory {
             DictionaryPreferences(get())
         }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
new file mode 100644
index 0000000000..bd56c4411a
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
@@ -0,0 +1,169 @@
+package eu.kanade.tachiyomi.ui.anime
+
+import android.content.Intent
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+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.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material3.FloatingActionButton
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+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.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import eu.kanade.tachiyomi.ui.player.PlayerActivity
+import eu.kanade.tachiyomi.ui.player.formatTime
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.ScrollbarLazyColumn
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.screens.EmptyScreen
+import tachiyomi.presentation.core.screens.LoadingScreen
+
+@Composable
+fun AnimeListScreen(
+    screenModel: AnimeListScreenModel,
+) {
+    val state by screenModel.state.collectAsState()
+    val context = LocalContext.current
+    var showDialog by remember { mutableStateOf(false) }
+
+    val filePickerLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.OpenDocument(),
+    ) { uri ->
+        if (uri != null) {
+            context.contentResolver.takePersistableUriPermission(
+                uri,
+                Intent.FLAG_GRANT_READ_URI_PERMISSION,
+            )
+            context.startActivity(PlayerActivity.newIntent(context, uri.toString()))
+        }
+    }
+
+    Scaffold(
+        floatingActionButton = {
+            FloatingActionButton(onClick = { showDialog = true }) {
+                Icon(Icons.Default.Add, contentDescription = stringResource(MR.strings.action_open_video))
+            }
+        },
+    ) { contentPadding ->
+        when (val s = state) {
+            is AnimeListScreenModel.State.Loading -> {
+                LoadingScreen(modifier = Modifier.padding(contentPadding))
+            }
+            is AnimeListScreenModel.State.Success -> {
+                if (s.items.isEmpty()) {
+                    EmptyScreen(
+                        message = stringResource(MR.strings.anime_empty_message),
+                        modifier = Modifier.padding(contentPadding),
+                    )
+                } else {
+                    ScrollbarLazyColumn(
+                        contentPadding = contentPadding,
+                        modifier = Modifier.fillMaxSize(),
+                    ) {
+                        items(
+                            items = s.items,
+                            key = { it.anime.id },
+                        ) { item ->
+                            AnimeListItem(
+                                title = item.anime.title,
+                                episodeName = item.lastEpisode?.name,
+                                progress = item.lastEpisode?.let {
+                                    if (it.totalSeconds > 0) {
+                                        "${formatTime(it.lastSecondSeen)} / ${formatTime(it.totalSeconds)}"
+                                    } else if (it.lastSecondSeen > 0) {
+                                        formatTime(it.lastSecondSeen)
+                                    } else {
+                                        null
+                                    }
+                                },
+                                onClick = {
+                                    val episodeId = item.lastEpisode?.id ?: return@AnimeListItem
+                                    context.startActivity(
+                                        PlayerActivity.newIntent(context, item.anime.id, episodeId),
+                                    )
+                                },
+                            )
+                            HorizontalDivider()
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (showDialog) {
+        OpenVideoDialog(
+            onDismiss = { showDialog = false },
+            onOpenUrl = { url ->
+                showDialog = false
+                context.startActivity(PlayerActivity.newIntent(context, url))
+            },
+            onPickFile = {
+                showDialog = false
+                filePickerLauncher.launch(arrayOf("video/*"))
+            },
+        )
+    }
+}
+
+@Composable
+private fun AnimeListItem(
+    title: String,
+    episodeName: String?,
+    progress: String?,
+    onClick: () -> Unit,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(horizontal = 16.dp, vertical = 12.dp),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Column(modifier = Modifier.weight(1f)) {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.bodyLarge,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
+            if (episodeName != null) {
+                Text(
+                    text = episodeName,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                )
+            }
+        }
+        if (progress != null) {
+            Text(
+                text = progress,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreenModel.kt
new file mode 100644
index 0000000000..6c1f1ee789
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreenModel.kt
@@ -0,0 +1,56 @@
+package eu.kanade.tachiyomi.ui.anime
+
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import logcat.LogPriority
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
+import tachiyomi.domain.episode.model.Episode
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeListScreenModel(
+    private val animeRepository: AnimeRepository = Injekt.get(),
+    private val getEpisodesByAnimeId: GetEpisodesByAnimeId = Injekt.get(),
+) : StateScreenModel<AnimeListScreenModel.State>(State.Loading) {
+
+    sealed interface State {
+        data object Loading : State
+        data class Success(val items: List<AnimeWithEpisode>) : State
+    }
+
+    data class AnimeWithEpisode(
+        val anime: Anime,
+        val lastEpisode: Episode?,
+    )
+
+    init {
+        loadAnime()
+    }
+
+    fun loadAnime() {
+        screenModelScope.launchIO {
+            try {
+                val animes = animeRepository.getAll()
+                val items = coroutineScope {
+                    animes.map { anime ->
+                        async {
+                            val episodes = getEpisodesByAnimeId.await(anime.id)
+                            AnimeWithEpisode(anime, episodes.maxByOrNull { it.lastSecondSeen })
+                        }
+                    }.awaitAll()
+                }
+                mutableState.value = State.Success(items)
+            } catch (e: Exception) {
+                logcat(LogPriority.ERROR, e) { "Failed to load anime list" }
+                mutableState.value = State.Success(emptyList())
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
new file mode 100644
index 0000000000..a19473e2fe
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
@@ -0,0 +1,30 @@
+package eu.kanade.tachiyomi.ui.anime
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.PlayCircle
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.vector.rememberVectorPainter
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.tab.TabOptions
+import eu.kanade.presentation.util.Tab
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+
+data object AnimeTab : Tab {
+
+    override val options: TabOptions
+        @Composable
+        get() {
+            return TabOptions(
+                index = 6u,
+                title = stringResource(MR.strings.label_anime),
+                icon = rememberVectorPainter(Icons.Outlined.PlayCircle),
+            )
+        }
+
+    @Composable
+    override fun Content() {
+        val screenModel = rememberScreenModel { AnimeListScreenModel() }
+        AnimeListScreen(screenModel)
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/OpenVideoDialog.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/OpenVideoDialog.kt
new file mode 100644
index 0000000000..f33df7d3c2
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/OpenVideoDialog.kt
@@ -0,0 +1,61 @@
+package eu.kanade.tachiyomi.ui.anime
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+
+@Composable
+fun OpenVideoDialog(
+    onDismiss: () -> Unit,
+    onOpenUrl: (String) -> Unit,
+    onPickFile: () -> Unit,
+) {
+    var url by remember { mutableStateOf("") }
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(MR.strings.action_open_video)) },
+        text = {
+            Column {
+                OutlinedTextField(
+                    value = url,
+                    onValueChange = { url = it },
+                    label = { Text(stringResource(MR.strings.label_video_url)) },
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                Spacer(Modifier.height(8.dp))
+                TextButton(onClick = onPickFile) {
+                    Text(stringResource(MR.strings.action_pick_local_file))
+                }
+            }
+        },
+        confirmButton = {
+            TextButton(
+                onClick = { onOpenUrl(url) },
+                enabled = url.isNotBlank(),
+            ) {
+                Text(stringResource(MR.strings.action_open))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(MR.strings.action_cancel))
+            }
+        },
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/home/HomeScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/home/HomeScreen.kt
index 5f5c1ef80e..509d4d60f8 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/home/HomeScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/home/HomeScreen.kt
@@ -49,6 +49,7 @@ import eu.kanade.tachiyomi.ui.history.HistoryTab
 import eu.kanade.tachiyomi.ui.library.LibraryTab
 import eu.kanade.tachiyomi.ui.libraryUpdateError.LibraryUpdateErrorScreen
 import eu.kanade.tachiyomi.ui.manga.MangaScreen
+import eu.kanade.tachiyomi.ui.anime.AnimeTab
 import eu.kanade.tachiyomi.ui.library.novels.NovelsTab
 import eu.kanade.tachiyomi.ui.more.MoreTab
 import eu.kanade.tachiyomi.ui.updates.UpdatesTab
@@ -86,6 +87,7 @@ object HomeScreen : Screen() {
         NavTabLayout.KEY_BROWSE to BrowseTab,
         NavTabLayout.KEY_DICTIONARY to DictionaryTab,
         NavTabLayout.KEY_NOVELS to NovelsTab,
+        NavTabLayout.KEY_ANIME to AnimeTab,
     )
 
     @Composable
@@ -203,6 +205,7 @@ object HomeScreen : Screen() {
                             }
                             Tab.Dictionary -> DictionaryTab
                             Tab.Novels -> NovelsTab
+                            Tab.Anime -> AnimeTab
                             is Tab.More -> MoreTab
                         }
 
@@ -368,6 +371,7 @@ object HomeScreen : Screen() {
         data class Browse(val toExtensions: Boolean = false) : Tab
         data object Dictionary : Tab
         data object Novels : Tab
+        data object Anime : Tab
         data class More(
             val toDownloads: Boolean,
             // KMK -->
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
new file mode 100644
index 0000000000..64f309a44e
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
@@ -0,0 +1,213 @@
+package eu.kanade.tachiyomi.ui.player
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import android.view.WindowManager
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.activity.viewModels
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import androidx.lifecycle.lifecycleScope
+import eu.kanade.tachiyomi.ui.player.mpv.MPVView
+import eu.kanade.tachiyomi.ui.player.mpv.PlayerObserver
+import eu.kanade.tachiyomi.ui.player.setting.PlayerOrientation
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import `is`.xyz.mpv.MPVLib
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.withTimeoutOrNull
+import kotlin.time.Duration.Companion.seconds
+import logcat.LogPriority
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class PlayerActivity : ComponentActivity() {
+
+    private val viewModel by viewModels<PlayerViewModel>()
+    private val playerPreferences: PlayerPreferences by lazy { Injekt.get() }
+
+    private var mpvView: MPVView? = null
+    private var playerObserver: PlayerObserver? = null
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        setupImmersiveMode()
+        setupScreenFlags()
+        setupOrientation()
+
+        setContent {
+            PlayerScreen(
+                viewModel = viewModel,
+                onMPVViewCreated = ::onMPVViewReady,
+                onPlayPause = ::togglePlayPause,
+                onSeek = ::seekToPercent,
+                onSeekRelative = ::seekRelative,
+                onBack = { finish() },
+            )
+        }
+
+        viewModel.eventFlow
+            .onEach { event ->
+                when (event) {
+                    is PlayerViewModel.Event.Error -> {
+                        logcat(LogPriority.ERROR) { "Player error: ${event.message}" }
+                        finish()
+                    }
+                    is PlayerViewModel.Event.PlaybackCompleted -> {}
+                }
+            }
+            .launchIn(lifecycleScope)
+    }
+
+    private fun onMPVViewReady(view: MPVView) {
+        mpvView = view
+
+        val configDir = filesDir.resolve("mpv").absolutePath
+        val cacheDir = cacheDir.resolve("mpv").absolutePath
+        logcat(LogPriority.DEBUG, tag = "Player") { "Initializing MPV" }
+        view.initialize(configDir, cacheDir)
+        logcat(LogPriority.DEBUG, tag = "Player") { "MPV initialized" }
+
+        val observer = PlayerObserver(
+            onPositionChanged = { pos -> viewModel.updatePosition(pos) },
+            onDurationChanged = { dur -> viewModel.updateDuration(dur) },
+            onPauseChanged = { paused -> viewModel.updatePlaybackState(!paused) },
+            onEofReached = { viewModel.onPlaybackCompleted() },
+        )
+        playerObserver = observer
+        MPVLib.addObserver(observer)
+
+        val animeId = intent.getLongExtra(PlayerViewModel.KEY_ANIME_ID, -1L)
+        val episodeId = intent.getLongExtra(PlayerViewModel.KEY_EPISODE_ID, -1L)
+        val videoUrl = resolveVideoUrl(intent)
+
+        lifecycleScope.launchIO {
+            viewModel.init(animeId, episodeId, videoUrl)
+
+            val state = viewModel.state.value
+            val episode = state.episode
+            if (episode == null) {
+                logcat(LogPriority.ERROR, tag = "Player") { "Episode not loaded after init" }
+                return@launchIO
+            }
+            val url = episode.url
+            logcat(LogPriority.DEBUG, tag = "Player") { "Episode URL: $url" }
+            if (url.isNotBlank()) {
+                val resumePos = state.currentPositionSec
+                    .takeIf { it > 0 } ?: episode.lastSecondSeen
+                val playUrl = resolvePlaybackUrl(url)
+                logcat(LogPriority.DEBUG, tag = "Player") { "Playing: $playUrl (resume=$resumePos)" }
+                withContext(Dispatchers.Main) {
+                    view.playFile(playUrl)
+                    logcat(LogPriority.DEBUG, tag = "Player") { "playFile called" }
+                    if (resumePos > 0) {
+                        view.seekTo(resumePos.toInt())
+                    }
+                }
+            }
+        }
+    }
+
+    private fun togglePlayPause() {
+        mpvView?.cyclePause()
+    }
+
+    private fun seekToPercent(percent: Float) {
+        val duration = mpvView?.duration ?: return
+        mpvView?.seekTo((percent * duration).toInt())
+    }
+
+    private fun seekRelative(deltaSec: Int) {
+        mpvView?.seekRelative(deltaSec)
+    }
+
+    override fun onStop() {
+        super.onStop()
+        if (isFinishing) viewModel.saveProgress()
+    }
+
+    override fun onDestroy() {
+        playerObserver?.let { MPVLib.removeObserver(it) }
+        mpvView?.destroy()
+        mpvView = null
+        super.onDestroy()
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        super.onNewIntent(intent)
+        setIntent(intent)
+    }
+
+    private fun setupImmersiveMode() {
+        enableEdgeToEdge()
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            window.isNavigationBarContrastEnforced = false
+        }
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+        val insetsController = WindowInsetsControllerCompat(window, window.decorView)
+        insetsController.systemBarsBehavior =
+            WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+        insetsController.hide(WindowInsetsCompat.Type.systemBars())
+    }
+
+    private fun setupScreenFlags() {
+        if (playerPreferences.keepScreenOn().get()) {
+            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        }
+    }
+
+    private fun setupOrientation() {
+        val orientation = PlayerOrientation.fromPreference(
+            playerPreferences.defaultPlayerOrientation().get(),
+        )
+        requestedOrientation = orientation.flag
+    }
+
+    private fun resolvePlaybackUrl(url: String): String {
+        if (url.startsWith("content://")) {
+            val uri = Uri.parse(url)
+            val fd = contentResolver.openFileDescriptor(uri, "r")?.detachFd()
+                ?: return url
+            return "fdclose://$fd"
+        }
+        return url
+    }
+
+    private fun resolveVideoUrl(intent: Intent): String? {
+        if (intent.action == Intent.ACTION_VIEW) {
+            return intent.data?.toString()
+        }
+        return intent.getStringExtra(EXTRA_VIDEO_URL)
+    }
+
+    companion object {
+        private const val EXTRA_VIDEO_URL = "video_url"
+
+        fun newIntent(context: Context, animeId: Long, episodeId: Long): Intent {
+            return Intent(context, PlayerActivity::class.java).apply {
+                putExtra(PlayerViewModel.KEY_ANIME_ID, animeId)
+                putExtra(PlayerViewModel.KEY_EPISODE_ID, episodeId)
+                addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+            }
+        }
+
+        fun newIntent(context: Context, videoUrl: String): Intent {
+            return Intent(context, PlayerActivity::class.java).apply {
+                putExtra(EXTRA_VIDEO_URL, videoUrl)
+                addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
new file mode 100644
index 0000000000..367c7939d0
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
@@ -0,0 +1,60 @@
+package eu.kanade.tachiyomi.ui.player
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.CircularProgressIndicator
+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
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.viewinterop.AndroidView
+import eu.kanade.tachiyomi.ui.player.controls.PlayerControlsOverlay
+import eu.kanade.tachiyomi.ui.player.mpv.MPVView
+
+@Composable
+fun PlayerScreen(
+    viewModel: PlayerViewModel,
+    onMPVViewCreated: (MPVView) -> Unit,
+    onPlayPause: () -> Unit,
+    onSeek: (Float) -> Unit,
+    onSeekRelative: (Int) -> Unit,
+    onBack: () -> Unit,
+) {
+    val state by viewModel.state.collectAsState()
+
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(Color.Black),
+    ) {
+        AndroidView(
+            factory = { context ->
+                MPVView(context).also(onMPVViewCreated)
+            },
+            modifier = Modifier.fillMaxSize(),
+        )
+
+        if (state.isLoading) {
+            CircularProgressIndicator(
+                color = Color.White,
+                modifier = Modifier.align(Alignment.Center),
+            )
+        }
+
+        PlayerControlsOverlay(
+            isPlaying = state.isPlaying,
+            animeTitle = state.anime?.title,
+            episodeName = state.episode?.name,
+            currentPositionSec = state.currentPositionSec,
+            durationSec = state.durationSec,
+            doubleTapSeekSec = state.doubleTapSeekSec,
+            onPlayPause = onPlayPause,
+            onSeek = onSeek,
+            onSeekRelative = onSeekRelative,
+            onBack = onBack,
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerUtils.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerUtils.kt
new file mode 100644
index 0000000000..4bcc976954
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerUtils.kt
@@ -0,0 +1,12 @@
+package eu.kanade.tachiyomi.ui.player
+
+import java.util.Locale
+
+fun formatTime(seconds: Long): String {
+    if (seconds < 0) return "0:00"
+    val h = seconds / 3600
+    val m = (seconds % 3600) / 60
+    val s = seconds % 60
+    return if (h > 0) String.format(Locale.US, "%d:%02d:%02d", h, m, s)
+    else String.format(Locale.US, "%d:%02d", m, s)
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
new file mode 100644
index 0000000000..8844e6b4c4
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
@@ -0,0 +1,239 @@
+package eu.kanade.tachiyomi.ui.player
+
+import androidx.compose.runtime.Immutable
+import androidx.lifecycle.SavedStateHandle
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import kotlinx.coroutines.async
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.sample
+import kotlinx.coroutines.flow.update
+import logcat.LogPriority
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.lang.launchNonCancellable
+import tachiyomi.core.common.util.lang.withIOContext
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.episode.interactor.GetEpisode
+import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
+import tachiyomi.domain.episode.interactor.UpdateEpisode
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.episode.model.EpisodeUpdate
+import tachiyomi.domain.episode.repository.EpisodeRepository
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import kotlin.time.Duration.Companion.seconds
+
+class PlayerViewModel @JvmOverloads constructor(
+    private val savedState: SavedStateHandle,
+    private val getAnime: GetAnime = Injekt.get(),
+    private val getEpisode: GetEpisode = Injekt.get(),
+    private val getEpisodesByAnimeId: GetEpisodesByAnimeId = Injekt.get(),
+    private val updateEpisode: UpdateEpisode = Injekt.get(),
+    private val playerPreferences: PlayerPreferences = Injekt.get(),
+    private val animeRepository: AnimeRepository = Injekt.get(),
+    private val episodeRepository: EpisodeRepository = Injekt.get(),
+) : ViewModel() {
+
+    private val mutableState = MutableStateFlow(
+        State(doubleTapSeekSec = playerPreferences.doubleTapSeekLength().get()),
+    )
+    val state = mutableState.asStateFlow()
+
+    private val eventChannel = Channel<Event>()
+    val eventFlow = eventChannel.receiveAsFlow()
+
+    private val progressSaveFlow = MutableSharedFlow<Pair<Long, Long>>(extraBufferCapacity = 1)
+
+    private var animeId: Long = savedState[KEY_ANIME_ID] ?: -1L
+    private var episodeId: Long = savedState[KEY_EPISODE_ID] ?: -1L
+
+    init {
+        progressSaveFlow
+            .sample(playerPreferences.progressSaveIntervalSec().get().seconds)
+            .onEach { (pos, dur) -> persistProgress(pos, dur) }
+            .launchIn(viewModelScope)
+    }
+
+    suspend fun init(animeId: Long, episodeId: Long, videoUrl: String?) {
+        if (this.animeId > 0 && this.episodeId > 0 && mutableState.value.episode != null) return
+        try {
+            if (animeId > 0 && episodeId > 0) {
+                this.animeId = animeId
+                this.episodeId = episodeId
+                savedState[KEY_ANIME_ID] = animeId
+                savedState[KEY_EPISODE_ID] = episodeId
+                loadFromDb()
+            } else if (!videoUrl.isNullOrBlank()) {
+                createOrGetAnimeForUrl(videoUrl)
+                loadFromDb()
+            } else {
+                eventChannel.send(Event.Error("No video URL or episode ID provided"))
+                return
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Failed to initialize player" }
+            eventChannel.send(Event.Error(e.message ?: "Failed to initialize player"))
+        }
+    }
+
+    private suspend fun loadFromDb() {
+        try {
+            val (anime, episode) = coroutineScope {
+                val animeDeferred = async { withIOContext { getAnime.await(animeId) } }
+                val episodeDeferred = async { withIOContext { getEpisode.await(episodeId) } }
+                animeDeferred.await() to episodeDeferred.await()
+            }
+            if (anime == null || episode == null) {
+                eventChannel.send(Event.Error("Anime or episode not found"))
+                return
+            }
+            mutableState.update { it.copy(anime = anime, episode = episode, isLoading = false) }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Failed to load anime/episode" }
+            eventChannel.send(Event.Error(e.message ?: "Unknown error"))
+        }
+    }
+
+    fun updatePlaybackState(isPlaying: Boolean) {
+        mutableState.update { it.copy(isPlaying = isPlaying) }
+    }
+
+    fun updatePosition(positionSec: Long) {
+        if (positionSec == mutableState.value.currentPositionSec) return
+        val duration = mutableState.value.durationSec
+        mutableState.update { it.copy(currentPositionSec = positionSec) }
+        progressSaveFlow.tryEmit(positionSec to duration)
+    }
+
+    fun updateDuration(durationSec: Long) {
+        mutableState.update { it.copy(durationSec = durationSec) }
+    }
+
+    fun onPlaybackCompleted() {
+        val state = mutableState.value
+        val episode = state.episode ?: return
+        val duration = state.durationSec
+        val position = state.currentPositionSec
+        viewModelScope.launchIO {
+            val seen = duration > 0 && position >= duration * 0.9
+            updateEpisode.await(
+                EpisodeUpdate(
+                    id = episode.id,
+                    seen = if (seen) true else null,
+                    lastSecondSeen = position,
+                    totalSeconds = duration,
+                ),
+            )
+            eventChannel.send(Event.PlaybackCompleted)
+        }
+    }
+
+    fun saveProgress() {
+        val state = mutableState.value
+        if (state.currentPositionSec > 0) {
+            viewModelScope.launchNonCancellable {
+                persistProgress(state.currentPositionSec, state.durationSec)
+            }
+        }
+    }
+
+    private suspend fun persistProgress(positionSec: Long, durationSec: Long) {
+        val ep = mutableState.value.episode ?: return
+        try {
+            withIOContext {
+                updateEpisode.await(
+                    EpisodeUpdate(
+                        id = ep.id,
+                        lastSecondSeen = positionSec,
+                        totalSeconds = durationSec,
+                    ),
+                )
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Failed to save playback progress" }
+        }
+    }
+
+    private suspend fun createOrGetAnimeForUrl(videoUrl: String) {
+        withIOContext {
+            val existingAnime = animeRepository.getAnimeByUrlAndSourceId(videoUrl, LOCAL_ANIME_SOURCE_ID)
+            if (existingAnime != null) {
+                animeId = existingAnime.id
+                val episodes = getEpisodesByAnimeId.await(existingAnime.id)
+                val episode = episodes.firstOrNull { it.url == videoUrl } ?: episodes.firstOrNull()
+                if (episode != null) {
+                    episodeId = episode.id
+                    savedState[KEY_ANIME_ID] = animeId
+                    savedState[KEY_EPISODE_ID] = episodeId
+                    return@withIOContext
+                }
+                // Stale anime with no episodes — create the missing episode
+                val newEpisode = insertEpisode(existingAnime.id, videoUrl, existingAnime.title)
+                    ?: error("Failed to create episode")
+                episodeId = newEpisode.id
+                savedState[KEY_ANIME_ID] = animeId
+                savedState[KEY_EPISODE_ID] = episodeId
+                return@withIOContext
+            }
+
+            val title = videoUrl.substringAfterLast('/').substringBeforeLast('.').ifBlank { "Video" }
+            val anime = Anime.create().copy(
+                url = videoUrl,
+                title = title,
+                source = LOCAL_ANIME_SOURCE_ID,
+                favorite = false,
+            )
+            animeId = animeRepository.insert(anime)
+
+            val newEpisode = insertEpisode(animeId, videoUrl, title)
+                ?: error("Failed to create episode")
+            episodeId = newEpisode.id
+
+            savedState[KEY_ANIME_ID] = animeId
+            savedState[KEY_EPISODE_ID] = episodeId
+        }
+    }
+
+    private suspend fun insertEpisode(animeId: Long, url: String, name: String): Episode? {
+        val episode = Episode.create().copy(
+            animeId = animeId,
+            url = url,
+            name = name,
+            episodeNumber = 1.0,
+        )
+        return episodeRepository.addAll(listOf(episode)).firstOrNull()
+    }
+
+    @Immutable
+    data class State(
+        val anime: Anime? = null,
+        val episode: Episode? = null,
+        val isLoading: Boolean = true,
+        val isPlaying: Boolean = false,
+        val currentPositionSec: Long = 0,
+        val durationSec: Long = 0,
+        val doubleTapSeekSec: Int = 10,
+    )
+
+    sealed interface Event {
+        data class Error(val message: String) : Event
+        data object PlaybackCompleted : Event
+    }
+
+    companion object {
+        const val KEY_ANIME_ID = "anime_id"
+        const val KEY_EPISODE_ID = "episode_id"
+        const val LOCAL_ANIME_SOURCE_ID = 0L
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
new file mode 100644
index 0000000000..402456aec0
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
@@ -0,0 +1,160 @@
+package eu.kanade.tachiyomi.ui.player.controls
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Pause
+import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.delay
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+import kotlin.time.Duration.Companion.seconds
+
+@Composable
+fun PlayerControlsOverlay(
+    isPlaying: Boolean,
+    animeTitle: String?,
+    episodeName: String?,
+    currentPositionSec: Long,
+    durationSec: Long,
+    doubleTapSeekSec: Int,
+    onPlayPause: () -> Unit,
+    onSeek: (Float) -> Unit,
+    onSeekRelative: (Int) -> Unit,
+    onBack: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    var controlsVisible by remember { mutableStateOf(true) }
+
+    LaunchedEffect(controlsVisible, isPlaying) {
+        if (controlsVisible && isPlaying) {
+            delay(3.seconds)
+            controlsVisible = false
+        }
+    }
+
+    Box(
+        modifier = modifier
+            .fillMaxSize()
+            .pointerInput(doubleTapSeekSec) {
+                detectTapGestures(
+                    onTap = { controlsVisible = !controlsVisible },
+                    onDoubleTap = { offset ->
+                        val isLeftSide = offset.x < size.width / 2
+                        onSeekRelative(if (isLeftSide) -doubleTapSeekSec else doubleTapSeekSec)
+                    },
+                )
+            },
+    ) {
+        AnimatedVisibility(
+            visible = controlsVisible,
+            enter = fadeIn(),
+            exit = fadeOut(),
+        ) {
+            Box(modifier = Modifier.fillMaxSize()) {
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .background(
+                            Brush.verticalGradient(
+                                colors = listOf(Color.Black.copy(alpha = 0.7f), Color.Transparent),
+                            ),
+                        )
+                        .statusBarsPadding()
+                        .padding(horizontal = 4.dp, vertical = 4.dp),
+                ) {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        IconButton(onClick = onBack) {
+                            Icon(
+                                Icons.AutoMirrored.Filled.ArrowBack,
+                                contentDescription = null,
+                                tint = Color.White,
+                            )
+                        }
+                        Column(modifier = Modifier.weight(1f)) {
+                            animeTitle?.let {
+                                Text(
+                                    text = it,
+                                    style = MaterialTheme.typography.titleMedium,
+                                    color = Color.White,
+                                    maxLines = 1,
+                                )
+                            }
+                            episodeName?.let {
+                                Text(
+                                    text = it,
+                                    style = MaterialTheme.typography.bodySmall,
+                                    color = Color.White.copy(alpha = 0.7f),
+                                    maxLines = 1,
+                                )
+                            }
+                        }
+                    }
+                }
+
+                IconButton(
+                    onClick = onPlayPause,
+                    modifier = Modifier.align(Alignment.Center),
+                ) {
+                    Icon(
+                        imageVector = if (isPlaying) Icons.Default.Pause else Icons.Default.PlayArrow,
+                        contentDescription = stringResource(
+                            if (isPlaying) MR.strings.action_pause else MR.strings.action_play,
+                        ),
+                        tint = Color.White,
+                        modifier = Modifier.size(64.dp),
+                    )
+                }
+
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .align(Alignment.BottomCenter)
+                        .background(
+                            Brush.verticalGradient(
+                                colors = listOf(Color.Transparent, Color.Black.copy(alpha = 0.7f)),
+                            ),
+                        )
+                        .navigationBarsPadding()
+                        .padding(bottom = 8.dp),
+                ) {
+                    TimeBar(
+                        currentPositionSec = currentPositionSec,
+                        durationSec = durationSec,
+                        onSeek = onSeek,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/TimeBar.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/TimeBar.kt
new file mode 100644
index 0000000000..fc6d346d64
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/TimeBar.kt
@@ -0,0 +1,69 @@
+package eu.kanade.tachiyomi.ui.player.controls
+
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.SliderDefaults
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import eu.kanade.tachiyomi.ui.player.formatTime
+
+@Composable
+fun TimeBar(
+    currentPositionSec: Long,
+    durationSec: Long,
+    onSeek: (Float) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    var seekingProgress by remember { mutableFloatStateOf(-1f) }
+    val progress = when {
+        seekingProgress >= 0f -> seekingProgress
+        durationSec > 0 -> currentPositionSec.toFloat() / durationSec
+        else -> 0f
+    }
+
+    Row(
+        modifier = modifier,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = formatTime(
+                if (seekingProgress >= 0f) (seekingProgress * durationSec).toLong() else currentPositionSec,
+            ),
+            style = MaterialTheme.typography.bodySmall,
+            color = Color.White,
+            modifier = Modifier.padding(horizontal = 8.dp),
+        )
+        Slider(
+            value = progress,
+            onValueChange = { seekingProgress = it },
+            onValueChangeFinished = {
+                if (seekingProgress >= 0f) {
+                    onSeek(seekingProgress)
+                    seekingProgress = -1f
+                }
+            },
+            colors = SliderDefaults.colors(
+                thumbColor = Color.White,
+                activeTrackColor = Color.White,
+                inactiveTrackColor = Color.White.copy(alpha = 0.3f),
+            ),
+            modifier = Modifier.weight(1f),
+        )
+        Text(
+            text = formatTime(durationSec),
+            style = MaterialTheme.typography.bodySmall,
+            color = Color.White,
+            modifier = Modifier.padding(horizontal = 8.dp),
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
new file mode 100644
index 0000000000..e0c17ae014
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
@@ -0,0 +1,124 @@
+package eu.kanade.tachiyomi.ui.player.mpv
+
+import android.content.Context
+import android.view.SurfaceHolder
+import android.view.SurfaceView
+import eu.kanade.tachiyomi.util.system.isDebugBuildType
+import `is`.xyz.mpv.MPVLib
+import java.io.File
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+
+class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
+
+    private var isInitialized = false
+    private var lastSurfaceWidth = -1
+    private var lastSurfaceHeight = -1
+
+    init {
+        holder.addCallback(this)
+    }
+
+    fun initialize(configDir: String, cacheDir: String) {
+        if (isInitialized) return
+
+        File(configDir).mkdirs()
+        File(cacheDir).mkdirs()
+
+        MPVLib.create(context, if (isDebugBuildType) "v" else "warn")
+        MPVLib.setOptionString("config", "no")
+        MPVLib.setOptionString("gpu-context", "android")
+        MPVLib.setOptionString("opengl-es", "yes")
+        MPVLib.setOptionString("vo", "gpu")
+        MPVLib.setOptionString("ao", "audiotrack")
+        MPVLib.setOptionString("hwdec", "auto")
+        MPVLib.setOptionString("hwdec-codecs", "all")
+        MPVLib.setOptionString("save-position-on-quit", "no")
+        MPVLib.setOptionString("force-window", "no")
+        MPVLib.setOptionString("keep-open", "always")
+        MPVLib.setOptionString("demux-max-bytes", "32MiB")
+        MPVLib.setOptionString("demux-max-back-bytes", "16MiB")
+        MPVLib.setOptionString("sub-auto", "fuzzy")
+        MPVLib.setOptionString("sub-font-size", "55")
+        MPVLib.setOptionString("sub-border-size", "3")
+
+        MPVLib.init()
+        isInitialized = true
+
+        MPVLib.observeProperty(PROP_TIME_POS, MPVLib.mpvFormat.MPV_FORMAT_INT64)
+        MPVLib.observeProperty(PROP_DURATION, MPVLib.mpvFormat.MPV_FORMAT_INT64)
+        MPVLib.observeProperty(PROP_PAUSE, MPVLib.mpvFormat.MPV_FORMAT_FLAG)
+        MPVLib.observeProperty(PROP_EOF_REACHED, MPVLib.mpvFormat.MPV_FORMAT_FLAG)
+    }
+
+    override fun surfaceCreated(holder: SurfaceHolder) {
+        logcat(LogPriority.DEBUG, tag = "Player") { "surfaceCreated, isInitialized=$isInitialized" }
+        if (isInitialized) {
+            MPVLib.attachSurface(holder.surface)
+            MPVLib.setOptionString("force-window", "yes")
+            logcat(LogPriority.DEBUG, tag = "Player") { "Surface attached" }
+        }
+    }
+
+    override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
+        if (width == lastSurfaceWidth && height == lastSurfaceHeight) return
+        lastSurfaceWidth = width
+        lastSurfaceHeight = height
+        MPVLib.setPropertyString("android-surface-size", "${width}x$height")
+    }
+
+    override fun surfaceDestroyed(holder: SurfaceHolder) {
+        MPVLib.setOptionString("force-window", "no")
+        MPVLib.detachSurface()
+    }
+
+    fun playFile(url: String) {
+        if (!isInitialized) {
+            logcat(LogPriority.ERROR) { "playFile called but MPV not initialized" }
+            return
+        }
+        logcat(LogPriority.DEBUG, tag = "Player") { "MPV loadfile: $url" }
+        MPVLib.command(arrayOf("loadfile", url))
+        logcat(LogPriority.DEBUG, tag = "Player") { "MPV loadfile command sent" }
+    }
+
+    val timePos: Int?
+        get() = MPVLib.getPropertyInt(PROP_TIME_POS)
+
+    val duration: Int?
+        get() = MPVLib.getPropertyInt(PROP_DURATION)
+
+    val paused: Boolean
+        get() = MPVLib.getPropertyBoolean(PROP_PAUSE) ?: false
+
+    fun cyclePause() {
+        MPVLib.command(arrayOf("cycle", "pause"))
+    }
+
+    fun seekTo(positionSec: Int) {
+        if (!isInitialized) return
+        MPVLib.command(arrayOf("seek", positionSec.toString(), "absolute"))
+    }
+
+    fun seekRelative(deltaSec: Int) {
+        if (!isInitialized) return
+        MPVLib.command(arrayOf("seek", deltaSec.toString(), "relative"))
+    }
+
+    fun destroy() {
+        if (!isInitialized) return
+        isInitialized = false
+        try {
+            MPVLib.destroy()
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Error destroying MPV" }
+        }
+    }
+
+    companion object {
+        const val PROP_TIME_POS = "time-pos"
+        const val PROP_DURATION = "duration"
+        const val PROP_PAUSE = "pause"
+        const val PROP_EOF_REACHED = "eof-reached"
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
new file mode 100644
index 0000000000..6f0fbcc55b
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
@@ -0,0 +1,45 @@
+package eu.kanade.tachiyomi.ui.player.mpv
+
+import `is`.xyz.mpv.MPVLib
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+
+class PlayerObserver(
+    private val onPositionChanged: (positionSec: Long) -> Unit = {},
+    private val onDurationChanged: (durationSec: Long) -> Unit = {},
+    private val onPauseChanged: (paused: Boolean) -> Unit = {},
+    private val onEofReached: () -> Unit = {},
+) : MPVLib.EventObserver {
+
+    override fun eventProperty(property: String) {}
+
+    override fun eventProperty(property: String, value: Long) {
+        dispatchNumericProperty(property, value)
+    }
+
+    override fun eventProperty(property: String, value: Boolean) {
+        when (property) {
+            MPVView.PROP_PAUSE -> onPauseChanged(value)
+            MPVView.PROP_EOF_REACHED -> if (value) onEofReached()
+        }
+    }
+
+    override fun eventProperty(property: String, value: Double) {
+        dispatchNumericProperty(property, value.toLong())
+    }
+
+    override fun eventProperty(property: String, value: String) {}
+
+    override fun event(eventId: Int) {}
+
+    override fun efEvent(err: String?) {
+        logcat(LogPriority.ERROR) { err ?: "Playback error" }
+    }
+
+    private fun dispatchNumericProperty(property: String, value: Long) {
+        when (property) {
+            MPVView.PROP_TIME_POS -> onPositionChanged(value)
+            MPVView.PROP_DURATION -> onDurationChanged(value)
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerOrientation.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerOrientation.kt
new file mode 100644
index 0000000000..4a7bb62e5f
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerOrientation.kt
@@ -0,0 +1,18 @@
+package eu.kanade.tachiyomi.ui.player.setting
+
+import android.content.pm.ActivityInfo
+
+enum class PlayerOrientation(val flag: Int) {
+    FREE(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED),
+    PORTRAIT(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT),
+    LANDSCAPE(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE),
+    LOCKED_PORTRAIT(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT),
+    LOCKED_LANDSCAPE(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE),
+    REVERSE_PORTRAIT(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT),
+    ;
+
+    companion object {
+        fun fromPreference(preference: Int): PlayerOrientation =
+            entries.find { it.flag == preference } ?: FREE
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
new file mode 100644
index 0000000000..91ec302e7a
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
@@ -0,0 +1,19 @@
+package eu.kanade.tachiyomi.ui.player.setting
+
+import tachiyomi.core.common.preference.PreferenceStore
+
+class PlayerPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun defaultPlayerOrientation() = preferenceStore.getInt(
+        "player_default_orientation",
+        PlayerOrientation.FREE.flag,
+    )
+
+    fun doubleTapSeekLength() = preferenceStore.getInt("player_double_tap_seek_length", 10)
+
+    fun keepScreenOn() = preferenceStore.getBoolean("player_keep_screen_on", true)
+
+    fun progressSaveIntervalSec() = preferenceStore.getInt("player_progress_save_interval", 5)
+}
diff --git a/data/src/main/sqldelight/tachiyomi/migrations/45.sqm b/data/src/main/sqldelight/tachiyomi/migrations/45.sqm
new file mode 100644
index 0000000000..9a7dc23066
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/migrations/45.sqm
@@ -0,0 +1,104 @@
+CREATE TABLE IF NOT EXISTS animes(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    source INTEGER NOT NULL,
+    url TEXT NOT NULL,
+    artist TEXT,
+    author TEXT,
+    description TEXT,
+    genre TEXT,
+    title TEXT NOT NULL,
+    status INTEGER NOT NULL,
+    thumbnail_url TEXT,
+    favorite INTEGER NOT NULL,
+    last_update INTEGER,
+    next_update INTEGER,
+    initialized INTEGER NOT NULL,
+    viewer INTEGER NOT NULL,
+    episode_flags INTEGER NOT NULL,
+    cover_last_modified INTEGER NOT NULL,
+    date_added INTEGER NOT NULL,
+    update_strategy INTEGER NOT NULL DEFAULT 0,
+    calculate_interval INTEGER DEFAULT 0 NOT NULL,
+    last_modified_at INTEGER NOT NULL DEFAULT 0,
+    favorite_modified_at INTEGER,
+    version INTEGER NOT NULL DEFAULT 0,
+    is_syncing INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX IF NOT EXISTS library_favorite_anime_index ON animes(favorite) WHERE favorite = 1;
+CREATE INDEX IF NOT EXISTS animes_url_index ON animes(url);
+
+CREATE TRIGGER IF NOT EXISTS update_last_favorited_at_animes
+AFTER UPDATE OF favorite ON animes
+BEGIN
+  UPDATE animes
+  SET favorite_modified_at = strftime('%s', 'now')
+  WHERE _id = new._id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_last_modified_at_animes
+AFTER UPDATE ON animes
+FOR EACH ROW
+BEGIN
+  UPDATE animes
+  SET last_modified_at = strftime('%s', 'now')
+  WHERE _id = new._id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_anime_version AFTER UPDATE ON animes
+BEGIN
+    UPDATE animes SET version = version + 1
+    WHERE _id = new._id AND new.is_syncing = 0 AND (
+        new.url != old.url OR
+        new.description != old.description OR
+        new.favorite != old.favorite
+    );
+END;
+
+CREATE TABLE IF NOT EXISTS episodes(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    anime_id INTEGER NOT NULL,
+    url TEXT NOT NULL,
+    name TEXT NOT NULL,
+    scanlator TEXT,
+    seen INTEGER NOT NULL,
+    bookmark INTEGER NOT NULL,
+    fillermark INTEGER NOT NULL,
+    last_second_seen INTEGER NOT NULL,
+    total_seconds INTEGER NOT NULL,
+    episode_number REAL NOT NULL,
+    source_order INTEGER NOT NULL,
+    date_fetch INTEGER NOT NULL,
+    date_upload INTEGER NOT NULL,
+    last_modified_at INTEGER NOT NULL DEFAULT 0,
+    version INTEGER NOT NULL DEFAULT 0,
+    is_syncing INTEGER NOT NULL DEFAULT 0,
+    FOREIGN KEY(anime_id) REFERENCES animes (_id)
+    ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS episodes_anime_id_index ON episodes(anime_id);
+CREATE INDEX IF NOT EXISTS episodes_unseen_by_anime_index ON episodes(anime_id, seen) WHERE seen = 0;
+
+CREATE TRIGGER IF NOT EXISTS update_last_modified_at_episodes
+AFTER UPDATE ON episodes
+FOR EACH ROW
+BEGIN
+  UPDATE episodes
+  SET last_modified_at = strftime('%s', 'now')
+  WHERE _id = new._id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_episode_and_anime_version AFTER UPDATE ON episodes
+WHEN new.is_syncing = 0 AND (
+    new.seen != old.seen OR
+    new.bookmark != old.bookmark OR
+    new.last_second_seen != old.last_second_seen
+)
+BEGIN
+    UPDATE episodes SET version = version + 1
+    WHERE _id = new._id;
+
+    UPDATE animes SET version = version + 1
+    WHERE _id = new.anime_id AND (SELECT is_syncing FROM animes WHERE _id = new.anime_id) = 0;
+END;
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 5bef25079c..c580385e83 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -16,6 +16,8 @@ materialKolor = "5.0.0-alpha06"
 image-cropper = "4.7.0"
 datastore = "1.1.2"
 media3 = "1.5.1"
+aniyomi-mpv-lib = "1.17.n"
+ffmpeg-kit = "1.17"
 
 
 [libraries]
@@ -78,6 +80,10 @@ haze = "dev.chrisbanes.haze:haze:1.7.2"
 media3-exoplayer = { module = "androidx.media3:media3-exoplayer", version.ref = "media3" }
 media3-common = { module = "androidx.media3:media3-common", version.ref = "media3" }
 
+aniyomi-mpv = { module = "com.github.aniyomiorg:aniyomi-mpv-lib", version.ref = "aniyomi-mpv-lib" }
+ffmpeg-kit = { module = "com.github.jmir1:ffmpeg-kit", version.ref = "ffmpeg-kit" }
+smart-exception-java = "com.arthenica:smart-exception-java:0.2.1"
+
 
 swipe = "me.saket.swipe:swipe:1.3.0"
 
diff --git a/i18n/src/commonMain/moko-resources/base/strings.xml b/i18n/src/commonMain/moko-resources/base/strings.xml
index a063261d4f..e378d2f84d 100644
--- a/i18n/src/commonMain/moko-resources/base/strings.xml
+++ b/i18n/src/commonMain/moko-resources/base/strings.xml
@@ -33,6 +33,13 @@
     <string name="label_data_storage">Data and storage</string>
     <string name="label_dictionary">Dictionary</string>
     <string name="label_novels">Novels</string>
+    <string name="label_anime">Anime</string>
+    <string name="anime_empty_message">No anime yet — tap + to open a video</string>
+    <string name="action_open_video">Open video</string>
+    <string name="action_pick_local_file">Pick local file</string>
+    <string name="action_open">Open</string>
+    <string name="label_video_url">Video URL</string>
+    <string name="action_play">Play</string>
     <string name="novel_missing_file">Missing File — tap to import</string>
     <string name="backup_option_novels">Novel progress &amp; stats</string>
     <string name="label_stats">Statistics</string>

From 3b159d46c016e059fb8e3e8e4e9e80ac2b10b497 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sat, 9 May 2026 05:54:22 +0200
Subject: [PATCH 04/13] Subtitles support, dictionary on subtitles tap

---
 .../eu/kanade/tachiyomi/ui/anime/AnimeTab.kt  |   5 +
 .../tachiyomi/ui/player/PlayerActivity.kt     | 209 +++++++++++++++++-
 .../tachiyomi/ui/player/PlayerScreen.kt       |  47 +++-
 .../tachiyomi/ui/player/PlayerViewModel.kt    |  87 +++++++-
 .../player/controls/PlayerControlsOverlay.kt  | 131 +++++++++++
 .../ui/player/controls/SubtitleTapOverlay.kt  | 114 ++++++++++
 .../kanade/tachiyomi/ui/player/mpv/MPVView.kt | 118 +++++++++-
 .../tachiyomi/ui/player/mpv/PlayerObserver.kt |  14 +-
 .../ui/player/setting/PlayerPreferences.kt    |   2 +
 .../moko-resources/base/strings.xml           |   5 +
 10 files changed, 701 insertions(+), 31 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/SubtitleTapOverlay.kt

diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
index a19473e2fe..d45363b1dd 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
@@ -4,6 +4,7 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.PlayCircle
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.vector.rememberVectorPainter
+import androidx.lifecycle.compose.LifecycleResumeEffect
 import cafe.adriel.voyager.core.model.rememberScreenModel
 import cafe.adriel.voyager.navigator.tab.TabOptions
 import eu.kanade.presentation.util.Tab
@@ -25,6 +26,10 @@ data object AnimeTab : Tab {
     @Composable
     override fun Content() {
         val screenModel = rememberScreenModel { AnimeListScreenModel() }
+        LifecycleResumeEffect(Unit) {
+            screenModel.loadAnime()
+            onPauseOrDispose { }
+        }
         AnimeListScreen(screenModel)
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
index 64f309a44e..69085e37f4 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
@@ -1,31 +1,51 @@
 package eu.kanade.tachiyomi.ui.player
 
+import android.annotation.SuppressLint
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
 import android.os.Build
 import android.os.Bundle
+import android.view.KeyEvent
 import android.view.WindowManager
+import android.webkit.WebView
 import androidx.activity.ComponentActivity
+import androidx.activity.compose.BackHandler
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.activity.viewModels
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import androidx.core.view.WindowInsetsControllerCompat
+import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import chimahon.MediaInfo
+import eu.kanade.presentation.theme.TachiyomiTheme
+import eu.kanade.tachiyomi.ui.dictionary.DictionaryPreferences
+import eu.kanade.tachiyomi.ui.dictionary.getDictionaryBootstrapHtml
+import eu.kanade.tachiyomi.ui.dictionary.getDictionaryPaths
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 import eu.kanade.tachiyomi.ui.player.mpv.PlayerObserver
 import eu.kanade.tachiyomi.ui.player.setting.PlayerOrientation
 import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import eu.kanade.tachiyomi.ui.reader.viewer.OcrLookupPopup
 import `is`.xyz.mpv.MPVLib
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.withContext
 import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.withTimeoutOrNull
-import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import logcat.LogPriority
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.core.common.util.system.logcat
@@ -40,6 +60,14 @@ class PlayerActivity : ComponentActivity() {
     private var mpvView: MPVView? = null
     private var playerObserver: PlayerObserver? = null
 
+    private var popupWebView: WebView? = null
+
+    private val dictionaryPreferences: DictionaryPreferences by lazy { Injekt.get() }
+    private val dictionaryRepository: chimahon.DictionaryRepository by lazy { Injekt.get() }
+
+    @Volatile private var cachedActiveProfile: chimahon.anki.AnkiProfile? = null
+    @Volatile private var cachedTermPaths: List<String>? = null
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
@@ -47,6 +75,23 @@ class PlayerActivity : ComponentActivity() {
         setupScreenFlags()
         setupOrientation()
 
+        lifecycleScope.launchIO {
+            val profile = dictionaryPreferences.profileStore.getActiveProfile()
+            val termPaths = getDictionaryPaths(this@PlayerActivity, profile)
+            cachedActiveProfile = profile
+            cachedTermPaths = termPaths
+            dictionaryRepository.warmUp(termPaths)
+        }
+
+        lifecycleScope.launch {
+            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                dictionaryPreferences.rawActiveProfileId().changes().collect {
+                    cachedActiveProfile = null
+                    cachedTermPaths = null
+                }
+            }
+        }
+
         setContent {
             PlayerScreen(
                 viewModel = viewModel,
@@ -55,6 +100,59 @@ class PlayerActivity : ComponentActivity() {
                 onSeek = ::seekToPercent,
                 onSeekRelative = ::seekRelative,
                 onBack = { finish() },
+                onSelectSubtitle = ::selectSubtitleTrack,
+                onSelectAudio = ::selectAudioTrack,
+                onSubtitleWordTapped = ::onSubtitleWordTapped,
+                lookupContent = {
+                    val state by viewModel.state.collectAsState()
+                    val ls = state.lookupState
+                    if (ls != null) {
+                        BackHandler { viewModel.dismissLookup() }
+
+                        Box(
+                            modifier = Modifier
+                                .fillMaxSize()
+                                .background(Color.Black.copy(alpha = 0.4f))
+                                .clickable(
+                                    interactionSource = remember { MutableInteractionSource() },
+                                    indication = null,
+                                ) { viewModel.dismissLookup() },
+                        )
+
+                        val webView = remember { ensurePopupWebView() }
+                        val mediaInfo = state.anime?.let { anime ->
+                            MediaInfo(
+                                mangaTitle = anime.title,
+                                chapterName = state.episode?.name ?: "",
+                            )
+                        }
+
+                        TachiyomiTheme {
+                            OcrLookupPopup(
+                                lookupString = ls.word,
+                                fullText = ls.sentence,
+                                charOffset = ls.charOffset,
+                                onDismiss = { viewModel.dismissLookup() },
+                                webView = webView,
+                                repository = dictionaryRepository,
+                                anchorX = ls.anchorX,
+                                anchorY = ls.anchorY,
+                                isVertical = false,
+                                mediaInfo = mediaInfo,
+                                onRequestScreenshot = { captureVideoFrame() },
+                                onCropTriggered = null,
+                                initialLookupDeferred = viewModel.lookupDeferred,
+                                usePopup = false,
+                                onTermMatched = { charCount ->
+                                    viewModel.updateHighlightRange(
+                                        ls.charOffset until (ls.charOffset + charCount),
+                                    )
+                                },
+                                modifier = Modifier,
+                            )
+                        }
+                    }
+                },
             )
         }
 
@@ -66,6 +164,8 @@ class PlayerActivity : ComponentActivity() {
                         finish()
                     }
                     is PlayerViewModel.Event.PlaybackCompleted -> {}
+                    is PlayerViewModel.Event.PauseForLookup -> mpvView?.pause()
+                    is PlayerViewModel.Event.ResumeFromLookup -> mpvView?.resume()
                 }
             }
             .launchIn(lifecycleScope)
@@ -85,6 +185,8 @@ class PlayerActivity : ComponentActivity() {
             onDurationChanged = { dur -> viewModel.updateDuration(dur) },
             onPauseChanged = { paused -> viewModel.updatePlaybackState(!paused) },
             onEofReached = { viewModel.onPlaybackCompleted() },
+            onSubTextChanged = { text -> viewModel.updateSubText(text) },
+            onTrackListChanged = ::onTrackListChanged,
         )
         playerObserver = observer
         MPVLib.addObserver(observer)
@@ -110,14 +212,103 @@ class PlayerActivity : ComponentActivity() {
                 val playUrl = resolvePlaybackUrl(url)
                 logcat(LogPriority.DEBUG, tag = "Player") { "Playing: $playUrl (resume=$resumePos)" }
                 withContext(Dispatchers.Main) {
-                    view.playFile(playUrl)
+                    view.playFile(playUrl, resumePos)
                     logcat(LogPriority.DEBUG, tag = "Player") { "playFile called" }
-                    if (resumePos > 0) {
-                        view.seekTo(resumePos.toInt())
+                }
+            }
+        }
+    }
+
+    private fun getOrRefreshLookupPaths(): Pair<chimahon.anki.AnkiProfile, List<String>> {
+        val profile = cachedActiveProfile
+            ?: dictionaryPreferences.profileStore.getActiveProfile().also { cachedActiveProfile = it }
+        val paths = cachedTermPaths
+            ?: getDictionaryPaths(this, profile).also { cachedTermPaths = it }
+        return profile to paths
+    }
+
+    private fun onSubtitleWordTapped(
+        word: String,
+        fullText: String,
+        charOffset: Int,
+        anchorX: Float,
+        anchorY: Float,
+    ) {
+        val (_, termPaths) = getOrRefreshLookupPaths()
+        viewModel.startLookup(word, fullText, charOffset, anchorX, anchorY, termPaths)
+    }
+
+    private fun captureVideoFrame(): android.graphics.Bitmap? {
+        return mpvView?.grabThumbnail(1280)
+    }
+
+    @SuppressLint("SetJavaScriptEnabled")
+    private fun ensurePopupWebView(): WebView {
+        return popupWebView ?: WebView(this).also {
+            popupWebView = it
+            it.settings.javaScriptEnabled = true
+            it.settings.domStorageEnabled = true
+            it.settings.blockNetworkLoads = true
+            it.settings.loadsImagesAutomatically = true
+            it.setBackgroundColor(0x00000000)
+            it.loadDataWithBaseURL(
+                "https://chima.local/popup/",
+                getDictionaryBootstrapHtml(this),
+                "text/html",
+                "utf-8",
+                null,
+            )
+        }
+    }
+
+    override fun dispatchKeyEvent(event: KeyEvent): Boolean {
+        if (viewModel.state.value.lookupState != null) {
+            popupWebView?.let { webView ->
+                if (event.action == KeyEvent.ACTION_DOWN) {
+                    when (event.keyCode) {
+                        KeyEvent.KEYCODE_VOLUME_UP -> {
+                            webView.evaluateJavascript("window.DictionaryRenderer?.navigate(-1);", null)
+                            return true
+                        }
+                        KeyEvent.KEYCODE_VOLUME_DOWN -> {
+                            webView.evaluateJavascript("window.DictionaryRenderer?.navigate(1);", null)
+                            return true
+                        }
                     }
                 }
             }
         }
+        return super.dispatchKeyEvent(event)
+    }
+
+    private fun onTrackListChanged() {
+        val view = mpvView ?: return
+        val (subs, audio) = view.loadTracks()
+
+        val preferred = playerPreferences.preferredSubLanguage().get()
+        if (preferred.isNotBlank() && subs.isNotEmpty()) {
+            val match = subs.firstOrNull { it.language.equals(preferred, ignoreCase = true) }
+            if (match != null && view.sid != match.id) {
+                view.sid = match.id
+            }
+        }
+
+        viewModel.updateTracks(subs, audio, view.sid, view.aid)
+    }
+
+    private fun selectSubtitleTrack(id: Int) {
+        val view = mpvView ?: return
+        view.sid = id
+        viewModel.updateSelectedSubId(id)
+
+        val track = viewModel.state.value.subtitleTracks.firstOrNull { it.id == id }
+        playerPreferences.preferredSubLanguage().set(track?.language ?: "")
+    }
+
+    private fun selectAudioTrack(id: Int) {
+        val view = mpvView ?: return
+        view.aid = id
+        viewModel.updateSelectedAudioId(id)
     }
 
     private fun togglePlayPause() {
@@ -135,13 +326,15 @@ class PlayerActivity : ComponentActivity() {
 
     override fun onStop() {
         super.onStop()
-        if (isFinishing) viewModel.saveProgress()
+        viewModel.saveProgress()
     }
 
     override fun onDestroy() {
         playerObserver?.let { MPVLib.removeObserver(it) }
         mpvView?.destroy()
         mpvView = null
+        popupWebView?.destroy()
+        popupWebView = null
         super.onDestroy()
     }
 
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
index 367c7939d0..577d3d9f03 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
@@ -12,6 +12,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.viewinterop.AndroidView
 import eu.kanade.tachiyomi.ui.player.controls.PlayerControlsOverlay
+import eu.kanade.tachiyomi.ui.player.controls.SubtitleTapOverlay
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 
 @Composable
@@ -22,6 +23,10 @@ fun PlayerScreen(
     onSeek: (Float) -> Unit,
     onSeekRelative: (Int) -> Unit,
     onBack: () -> Unit,
+    onSelectSubtitle: (Int) -> Unit = {},
+    onSelectAudio: (Int) -> Unit = {},
+    onSubtitleWordTapped: (word: String, fullText: String, charOffset: Int, anchorX: Float, anchorY: Float) -> Unit = { _, _, _, _, _ -> },
+    lookupContent: @Composable () -> Unit = {},
 ) {
     val state by viewModel.state.collectAsState()
 
@@ -44,17 +49,35 @@ fun PlayerScreen(
             )
         }
 
-        PlayerControlsOverlay(
-            isPlaying = state.isPlaying,
-            animeTitle = state.anime?.title,
-            episodeName = state.episode?.name,
-            currentPositionSec = state.currentPositionSec,
-            durationSec = state.durationSec,
-            doubleTapSeekSec = state.doubleTapSeekSec,
-            onPlayPause = onPlayPause,
-            onSeek = onSeek,
-            onSeekRelative = onSeekRelative,
-            onBack = onBack,
-        )
+        if (state.lookupState == null) {
+            PlayerControlsOverlay(
+                isPlaying = state.isPlaying,
+                animeTitle = state.anime?.title,
+                episodeName = state.episode?.name,
+                currentPositionSec = state.currentPositionSec,
+                durationSec = state.durationSec,
+                doubleTapSeekSec = state.doubleTapSeekSec,
+                onPlayPause = onPlayPause,
+                onSeek = onSeek,
+                onSeekRelative = onSeekRelative,
+                onBack = onBack,
+                subtitleTracks = state.subtitleTracks,
+                audioTracks = state.audioTracks,
+                selectedSubId = state.selectedSubId,
+                selectedAudioId = state.selectedAudioId,
+                onSelectSubtitle = onSelectSubtitle,
+                onSelectAudio = onSelectAudio,
+            )
+        }
+
+        lookupContent()
+
+        if (state.currentSubText.isNotBlank()) {
+            SubtitleTapOverlay(
+                subText = state.currentSubText,
+                onWordTapped = onSubtitleWordTapped,
+                highlightRange = state.highlightRange,
+            )
+        }
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
index 8844e6b4c4..d8f6924c03 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
@@ -4,7 +4,11 @@ import androidx.compose.runtime.Immutable
 import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import chimahon.DictionaryRepository
+import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.coroutineScope
@@ -43,6 +47,7 @@ class PlayerViewModel @JvmOverloads constructor(
     private val playerPreferences: PlayerPreferences = Injekt.get(),
     private val animeRepository: AnimeRepository = Injekt.get(),
     private val episodeRepository: EpisodeRepository = Injekt.get(),
+    private val dictionaryRepository: DictionaryRepository = Injekt.get(),
 ) : ViewModel() {
 
     private val mutableState = MutableStateFlow(
@@ -58,6 +63,9 @@ class PlayerViewModel @JvmOverloads constructor(
     private var animeId: Long = savedState[KEY_ANIME_ID] ?: -1L
     private var episodeId: Long = savedState[KEY_EPISODE_ID] ?: -1L
 
+    var lookupDeferred: Deferred<DictionaryRepository.LookupResult2>? = null
+        private set
+
     init {
         progressSaveFlow
             .sample(playerPreferences.progressSaveIntervalSec().get().seconds)
@@ -120,6 +128,64 @@ class PlayerViewModel @JvmOverloads constructor(
         mutableState.update { it.copy(durationSec = durationSec) }
     }
 
+    fun updateSubText(text: String) {
+        if (text == mutableState.value.currentSubText) return
+        mutableState.update { it.copy(currentSubText = text) }
+    }
+
+    fun updateTracks(subs: List<MPVView.Track>, audio: List<MPVView.Track>, selectedSub: Int, selectedAudio: Int) {
+        mutableState.update {
+            it.copy(
+                subtitleTracks = subs,
+                audioTracks = audio,
+                selectedSubId = selectedSub,
+                selectedAudioId = selectedAudio,
+            )
+        }
+    }
+
+    fun updateSelectedSubId(id: Int) {
+        mutableState.update { it.copy(selectedSubId = id) }
+    }
+
+    fun updateSelectedAudioId(id: Int) {
+        mutableState.update { it.copy(selectedAudioId = id) }
+    }
+
+    fun startLookup(
+        word: String,
+        fullText: String,
+        charOffset: Int,
+        anchorX: Float,
+        anchorY: Float,
+        termPaths: List<String>,
+    ) {
+        lookupDeferred?.cancel()
+        mutableState.update { it.copy(highlightRange = null) }
+
+        lookupDeferred = viewModelScope.async(Dispatchers.IO) {
+            dictionaryRepository.lookup(word, termPaths)
+        }
+
+        mutableState.update {
+            it.copy(
+                lookupState = SubtitleLookupState(word, fullText, charOffset, anchorX, anchorY),
+            )
+        }
+        viewModelScope.launchIO { eventChannel.send(Event.PauseForLookup) }
+    }
+
+    fun dismissLookup() {
+        mutableState.update { it.copy(lookupState = null, highlightRange = null) }
+        lookupDeferred?.cancel()
+        lookupDeferred = null
+        viewModelScope.launchIO { eventChannel.send(Event.ResumeFromLookup) }
+    }
+
+    fun updateHighlightRange(range: IntRange) {
+        mutableState.update { it.copy(highlightRange = range) }
+    }
+
     fun onPlaybackCompleted() {
         val state = mutableState.value
         val episode = state.episode ?: return
@@ -141,7 +207,7 @@ class PlayerViewModel @JvmOverloads constructor(
 
     fun saveProgress() {
         val state = mutableState.value
-        if (state.currentPositionSec > 0) {
+        if (state.currentPositionSec > 0 && state.episode != null) {
             viewModelScope.launchNonCancellable {
                 persistProgress(state.currentPositionSec, state.durationSec)
             }
@@ -178,7 +244,6 @@ class PlayerViewModel @JvmOverloads constructor(
                     savedState[KEY_EPISODE_ID] = episodeId
                     return@withIOContext
                 }
-                // Stale anime with no episodes — create the missing episode
                 val newEpisode = insertEpisode(existingAnime.id, videoUrl, existingAnime.title)
                     ?: error("Failed to create episode")
                 episodeId = newEpisode.id
@@ -215,6 +280,15 @@ class PlayerViewModel @JvmOverloads constructor(
         return episodeRepository.addAll(listOf(episode)).firstOrNull()
     }
 
+    @Immutable
+    data class SubtitleLookupState(
+        val word: String,
+        val sentence: String,
+        val charOffset: Int,
+        val anchorX: Float,
+        val anchorY: Float,
+    )
+
     @Immutable
     data class State(
         val anime: Anime? = null,
@@ -224,11 +298,20 @@ class PlayerViewModel @JvmOverloads constructor(
         val currentPositionSec: Long = 0,
         val durationSec: Long = 0,
         val doubleTapSeekSec: Int = 10,
+        val currentSubText: String = "",
+        val subtitleTracks: List<MPVView.Track> = emptyList(),
+        val audioTracks: List<MPVView.Track> = emptyList(),
+        val selectedSubId: Int = -1,
+        val selectedAudioId: Int = -1,
+        val lookupState: SubtitleLookupState? = null,
+        val highlightRange: IntRange? = null,
     )
 
     sealed interface Event {
         data class Error(val message: String) : Event
         data object PlaybackCompleted : Event
+        data object PauseForLookup : Event
+        data object ResumeFromLookup : Event
     }
 
     companion object {
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
index 402456aec0..712da557e5 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
@@ -8,20 +8,28 @@ import androidx.compose.foundation.gestures.detectTapGestures
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 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.height
 import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.ClosedCaption
 import androidx.compose.material.icons.filled.Pause
 import androidx.compose.material.icons.filled.PlayArrow
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.minimumInteractiveComponentSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -30,12 +38,16 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 import kotlinx.coroutines.delay
 import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.ScrollbarLazyColumn
 import tachiyomi.presentation.core.i18n.stringResource
 import kotlin.time.Duration.Companion.seconds
 
@@ -51,9 +63,16 @@ fun PlayerControlsOverlay(
     onSeek: (Float) -> Unit,
     onSeekRelative: (Int) -> Unit,
     onBack: () -> Unit,
+    subtitleTracks: List<MPVView.Track> = emptyList(),
+    audioTracks: List<MPVView.Track> = emptyList(),
+    selectedSubId: Int = -1,
+    selectedAudioId: Int = -1,
+    onSelectSubtitle: (Int) -> Unit = {},
+    onSelectAudio: (Int) -> Unit = {},
     modifier: Modifier = Modifier,
 ) {
     var controlsVisible by remember { mutableStateOf(true) }
+    var showTrackDialog by remember { mutableStateOf(false) }
 
     LaunchedEffect(controlsVisible, isPlaying) {
         if (controlsVisible && isPlaying) {
@@ -118,6 +137,15 @@ fun PlayerControlsOverlay(
                                 )
                             }
                         }
+                        if (subtitleTracks.isNotEmpty() || audioTracks.isNotEmpty()) {
+                            IconButton(onClick = { showTrackDialog = true }) {
+                                Icon(
+                                    Icons.Default.ClosedCaption,
+                                    contentDescription = stringResource(MR.strings.player_tracks),
+                                    tint = Color.White,
+                                )
+                            }
+                        }
                     }
                 }
 
@@ -157,4 +185,107 @@ fun PlayerControlsOverlay(
             }
         }
     }
+
+    if (showTrackDialog) {
+        TrackSelectionDialog(
+            subtitleTracks = subtitleTracks,
+            audioTracks = audioTracks,
+            selectedSubId = selectedSubId,
+            selectedAudioId = selectedAudioId,
+            onSelectSubtitle = onSelectSubtitle,
+            onSelectAudio = onSelectAudio,
+            onDismiss = { showTrackDialog = false },
+        )
+    }
+}
+
+@Composable
+private fun TrackSelectionDialog(
+    subtitleTracks: List<MPVView.Track>,
+    audioTracks: List<MPVView.Track>,
+    selectedSubId: Int,
+    selectedAudioId: Int,
+    onSelectSubtitle: (Int) -> Unit,
+    onSelectAudio: (Int) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    Dialog(onDismissRequest = onDismiss) {
+        Surface(
+            shape = MaterialTheme.shapes.extraLarge,
+            color = MaterialTheme.colorScheme.surface,
+            tonalElevation = 6.dp,
+        ) {
+            ScrollbarLazyColumn(modifier = Modifier.padding(vertical = 16.dp)) {
+                if (subtitleTracks.isNotEmpty()) {
+                    item {
+                        Text(
+                            text = stringResource(MR.strings.player_subtitles),
+                            style = MaterialTheme.typography.titleMedium,
+                            modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
+                        )
+                    }
+                    item {
+                        TrackRow(
+                            name = stringResource(MR.strings.off),
+                            selected = selectedSubId == -1,
+                            onClick = { onSelectSubtitle(-1); onDismiss() },
+                        )
+                    }
+                    items(subtitleTracks.size) { index ->
+                        val track = subtitleTracks[index]
+                        TrackRow(
+                            name = track.name,
+                            selected = track.id == selectedSubId,
+                            onClick = { onSelectSubtitle(track.id); onDismiss() },
+                        )
+                    }
+                }
+
+                if (audioTracks.size > 1) {
+                    item {
+                        Spacer(Modifier.height(8.dp))
+                        Text(
+                            text = stringResource(MR.strings.player_audio),
+                            style = MaterialTheme.typography.titleMedium,
+                            modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
+                        )
+                    }
+                    items(audioTracks.size) { index ->
+                        val track = audioTracks[index]
+                        TrackRow(
+                            name = track.name,
+                            selected = track.id == selectedAudioId,
+                            onClick = { onSelectAudio(track.id); onDismiss() },
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun TrackRow(
+    name: String,
+    selected: Boolean,
+    onClick: () -> Unit,
+) {
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier
+            .clip(RoundedCornerShape(8.dp))
+            .selectable(selected = selected, onClick = onClick)
+            .fillMaxWidth()
+            .minimumInteractiveComponentSize(),
+    ) {
+        RadioButton(
+            selected = selected,
+            onClick = null,
+        )
+        Text(
+            text = name,
+            style = MaterialTheme.typography.bodyLarge,
+            modifier = Modifier.padding(start = 24.dp),
+        )
+    }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/SubtitleTapOverlay.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/SubtitleTapOverlay.kt
new file mode 100644
index 0000000000..943278055e
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/SubtitleTapOverlay.kt
@@ -0,0 +1,114 @@
+package eu.kanade.tachiyomi.ui.player.controls
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Shadow
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.positionInRoot
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+
+private val ASS_OVERRIDE_REGEX = Regex("""\{\\[^}]*\}""")
+
+private fun stripAssOverrides(text: String): String {
+    return ASS_OVERRIDE_REGEX.replace(text, "").replace("\\N", "\n").replace("\\n", "\n")
+}
+
+private val HIGHLIGHT_COLOR = Color(0xFF4FC3F7)
+
+private val subtitleStyle = TextStyle(
+    color = Color.White,
+    fontSize = 24.sp,
+    textAlign = TextAlign.Center,
+    shadow = Shadow(
+        color = Color.Black,
+        offset = Offset(1f, 1f),
+        blurRadius = 8f,
+    ),
+)
+
+private val highlightStyle = subtitleStyle.copy(color = HIGHLIGHT_COLOR)
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun SubtitleTapOverlay(
+    subText: String,
+    onWordTapped: (word: String, fullText: String, charOffset: Int, anchorX: Float, anchorY: Float) -> Unit,
+    highlightRange: IntRange? = null,
+    modifier: Modifier = Modifier,
+) {
+    val cleanText = remember(subText) { stripAssOverrides(subText) }
+
+    if (cleanText.isBlank()) return
+
+    Box(modifier = modifier.fillMaxSize()) {
+        Box(
+            modifier = Modifier
+                .align(Alignment.BottomCenter)
+                .navigationBarsPadding()
+                .padding(horizontal = 24.dp, vertical = 72.dp),
+        ) {
+            FlowRow(
+                horizontalArrangement = Arrangement.Center,
+                modifier = Modifier.fillMaxWidth(),
+            ) {
+                var charIndex = 0
+                for (char in cleanText) {
+                    if (char == '\n') {
+                        charIndex++
+                        continue
+                    }
+                    val idx = charIndex
+                    key(idx) {
+                        val isHighlighted = highlightRange != null && idx in highlightRange
+                        val style = if (isHighlighted) highlightStyle else subtitleStyle
+
+                        val anchorX = remember { mutableFloatStateOf(0f) }
+                        val anchorY = remember { mutableFloatStateOf(0f) }
+
+                        val charModifier = Modifier
+                            .onGloballyPositioned { coords ->
+                                val pos = coords.positionInRoot()
+                                anchorX.floatValue = pos.x + coords.size.width / 2f
+                                anchorY.floatValue = pos.y
+                            }
+                            .clickable(
+                                interactionSource = remember { MutableInteractionSource() },
+                                indication = null,
+                            ) {
+                                val lookupLen = minOf(10, cleanText.length - idx)
+                                val lookupWord = cleanText.substring(idx, idx + lookupLen)
+                                onWordTapped(lookupWord, cleanText, idx, anchorX.floatValue, anchorY.floatValue)
+                            }
+
+                        Text(
+                            text = char.toString(),
+                            style = style,
+                            modifier = charModifier,
+                        )
+                    }
+                    charIndex++
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
index e0c17ae014..a9746640e3 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
@@ -1,8 +1,11 @@
 package eu.kanade.tachiyomi.ui.player.mpv
 
 import android.content.Context
+import android.content.res.AssetManager
+import android.graphics.Bitmap
 import android.view.SurfaceHolder
 import android.view.SurfaceView
+import androidx.core.content.ContextCompat
 import eu.kanade.tachiyomi.util.system.isDebugBuildType
 import `is`.xyz.mpv.MPVLib
 import java.io.File
@@ -24,31 +27,48 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
 
         File(configDir).mkdirs()
         File(cacheDir).mkdirs()
+        copyAssets(context, configDir)
 
         MPVLib.create(context, if (isDebugBuildType) "v" else "warn")
-        MPVLib.setOptionString("config", "no")
+        MPVLib.addLogObserver(logObserver)
+
+        MPVLib.setOptionString("config", "yes")
+        MPVLib.setOptionString("config-dir", configDir)
+        MPVLib.setOptionString("gpu-shader-cache-dir", cacheDir)
+        MPVLib.setOptionString("icc-cache-dir", cacheDir)
         MPVLib.setOptionString("gpu-context", "android")
         MPVLib.setOptionString("opengl-es", "yes")
         MPVLib.setOptionString("vo", "gpu")
         MPVLib.setOptionString("ao", "audiotrack")
-        MPVLib.setOptionString("hwdec", "auto")
+        MPVLib.setOptionString("hwdec", "mediacodec-copy")
         MPVLib.setOptionString("hwdec-codecs", "all")
         MPVLib.setOptionString("save-position-on-quit", "no")
-        MPVLib.setOptionString("force-window", "no")
         MPVLib.setOptionString("keep-open", "always")
         MPVLib.setOptionString("demux-max-bytes", "32MiB")
         MPVLib.setOptionString("demux-max-back-bytes", "16MiB")
         MPVLib.setOptionString("sub-auto", "fuzzy")
-        MPVLib.setOptionString("sub-font-size", "55")
+        MPVLib.setOptionString("sub-font-size", "36")
         MPVLib.setOptionString("sub-border-size", "3")
 
+        try {
+            val display = ContextCompat.getDisplayOrDefault(context)
+            val fps = display.mode.refreshRate
+            MPVLib.setOptionString("display-fps-override", fps.toString())
+        } catch (_: Exception) {}
+
         MPVLib.init()
         isInitialized = true
 
+        MPVLib.setOptionString("force-window", "no")
+        MPVLib.setOptionString("idle", "once")
+        MPVLib.setPropertyString("sub-visibility", "no")
+
         MPVLib.observeProperty(PROP_TIME_POS, MPVLib.mpvFormat.MPV_FORMAT_INT64)
         MPVLib.observeProperty(PROP_DURATION, MPVLib.mpvFormat.MPV_FORMAT_INT64)
         MPVLib.observeProperty(PROP_PAUSE, MPVLib.mpvFormat.MPV_FORMAT_FLAG)
         MPVLib.observeProperty(PROP_EOF_REACHED, MPVLib.mpvFormat.MPV_FORMAT_FLAG)
+        MPVLib.observeProperty(PROP_SUB_TEXT, MPVLib.mpvFormat.MPV_FORMAT_STRING)
+        MPVLib.observeProperty(PROP_TRACK_LIST, MPVLib.mpvFormat.MPV_FORMAT_NONE)
     }
 
     override fun surfaceCreated(holder: SurfaceHolder) {
@@ -72,14 +92,18 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
         MPVLib.detachSurface()
     }
 
-    fun playFile(url: String) {
+    fun playFile(url: String, startPositionSec: Long = 0) {
         if (!isInitialized) {
             logcat(LogPriority.ERROR) { "playFile called but MPV not initialized" }
             return
         }
-        logcat(LogPriority.DEBUG, tag = "Player") { "MPV loadfile: $url" }
+        logcat(LogPriority.DEBUG, tag = "Player") { "MPV loadfile: $url start=$startPositionSec" }
+        if (startPositionSec > 0) {
+            MPVLib.setOptionString("start", "+$startPositionSec")
+        } else {
+            MPVLib.setOptionString("start", "none")
+        }
         MPVLib.command(arrayOf("loadfile", url))
-        logcat(LogPriority.DEBUG, tag = "Player") { "MPV loadfile command sent" }
     }
 
     val timePos: Int?
@@ -105,10 +129,70 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
         MPVLib.command(arrayOf("seek", deltaSec.toString(), "relative"))
     }
 
+    fun pause() {
+        if (!isInitialized) return
+        MPVLib.setPropertyBoolean(PROP_PAUSE, true)
+    }
+
+    fun resume() {
+        if (!isInitialized) return
+        MPVLib.setPropertyBoolean(PROP_PAUSE, false)
+    }
+
+    var sid: Int
+        get() = MPVLib.getPropertyString("sid")?.toIntOrNull() ?: -1
+        set(value) {
+            if (value == -1) MPVLib.setPropertyString("sid", "no")
+            else MPVLib.setPropertyInt("sid", value)
+        }
+
+    var aid: Int
+        get() = MPVLib.getPropertyString("aid")?.toIntOrNull() ?: -1
+        set(value) {
+            if (value == -1) MPVLib.setPropertyString("aid", "no")
+            else MPVLib.setPropertyInt("aid", value)
+        }
+
+    data class Track(val id: Int, val name: String, val language: String?)
+
+    fun loadTracks(): Pair<List<Track>, List<Track>> {
+        val count = MPVLib.getPropertyInt("track-list/count") ?: 0
+        val subs = mutableListOf<Track>()
+        val audio = mutableListOf<Track>()
+        for (i in 0 until count) {
+            val type = MPVLib.getPropertyString("track-list/$i/type") ?: continue
+            val id = MPVLib.getPropertyInt("track-list/$i/id") ?: continue
+            val title = MPVLib.getPropertyString("track-list/$i/title") ?: ""
+            val lang = MPVLib.getPropertyString("track-list/$i/lang")
+            val displayName = buildString {
+                append("#$id")
+                if (title.isNotBlank()) append(" $title")
+                if (!lang.isNullOrBlank()) append(" ($lang)")
+            }
+            val track = Track(id, displayName, lang)
+            when (type) {
+                "sub" -> subs.add(track)
+                "audio" -> audio.add(track)
+            }
+        }
+        return subs to audio
+    }
+
+    fun grabThumbnail(width: Int): Bitmap? {
+        if (!isInitialized) return null
+        return try {
+            MPVLib.grabThumbnail(width)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Failed to grab thumbnail" }
+            null
+        }
+    }
+
     fun destroy() {
         if (!isInitialized) return
         isInitialized = false
         try {
+            MPVLib.removeLogObserver(logObserver)
             MPVLib.destroy()
         } catch (e: Exception) {
             logcat(LogPriority.ERROR, e) { "Error destroying MPV" }
@@ -120,5 +204,25 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
         const val PROP_DURATION = "duration"
         const val PROP_PAUSE = "pause"
         const val PROP_EOF_REACHED = "eof-reached"
+        const val PROP_SUB_TEXT = "sub-text"
+        const val PROP_TRACK_LIST = "track-list"
+
+        private val logObserver = MPVLib.LogObserver { prefix, level, text ->
+            logcat(LogPriority.DEBUG, tag = "mpv") { "[$prefix] $text" }
+        }
+
+        private fun copyAssets(context: Context, configDir: String) {
+            val assetFiles = arrayOf("subfont.ttf", "cacert.pem")
+            for (fileName in assetFiles) {
+                try {
+                    val outFile = File(configDir, fileName)
+                    if (outFile.exists()) continue
+                    context.assets.open(fileName, AssetManager.ACCESS_STREAMING)
+                        .use { input -> outFile.outputStream().use { output -> input.copyTo(output) } }
+                } catch (e: Exception) {
+                    logcat(LogPriority.WARN) { "Failed to copy asset $fileName: ${e.message}" }
+                }
+            }
+        }
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
index 6f0fbcc55b..e9bb681823 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
@@ -9,9 +9,15 @@ class PlayerObserver(
     private val onDurationChanged: (durationSec: Long) -> Unit = {},
     private val onPauseChanged: (paused: Boolean) -> Unit = {},
     private val onEofReached: () -> Unit = {},
+    private val onSubTextChanged: (text: String) -> Unit = {},
+    private val onTrackListChanged: () -> Unit = {},
 ) : MPVLib.EventObserver {
 
-    override fun eventProperty(property: String) {}
+    override fun eventProperty(property: String) {
+        when (property) {
+            MPVView.PROP_TRACK_LIST -> onTrackListChanged()
+        }
+    }
 
     override fun eventProperty(property: String, value: Long) {
         dispatchNumericProperty(property, value)
@@ -28,7 +34,11 @@ class PlayerObserver(
         dispatchNumericProperty(property, value.toLong())
     }
 
-    override fun eventProperty(property: String, value: String) {}
+    override fun eventProperty(property: String, value: String) {
+        when (property) {
+            MPVView.PROP_SUB_TEXT -> onSubTextChanged(value)
+        }
+    }
 
     override fun event(eventId: Int) {}
 
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
index 91ec302e7a..bd88fee098 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
@@ -16,4 +16,6 @@ class PlayerPreferences(
     fun keepScreenOn() = preferenceStore.getBoolean("player_keep_screen_on", true)
 
     fun progressSaveIntervalSec() = preferenceStore.getInt("player_progress_save_interval", 5)
+
+    fun preferredSubLanguage() = preferenceStore.getString("player_preferred_sub_language", "")
 }
diff --git a/i18n/src/commonMain/moko-resources/base/strings.xml b/i18n/src/commonMain/moko-resources/base/strings.xml
index e378d2f84d..3c782aaebd 100644
--- a/i18n/src/commonMain/moko-resources/base/strings.xml
+++ b/i18n/src/commonMain/moko-resources/base/strings.xml
@@ -1157,4 +1157,9 @@
     <string name="pref_dict_pitch_diagram">Graph</string>
     <string name="pref_dict_pitch_number">012</string>
     <string name="pref_dict_pitch_text">Text</string>
+
+    <!-- Player -->
+    <string name="player_subtitles">Subtitles</string>
+    <string name="player_audio">Audio</string>
+    <string name="player_tracks">Tracks</string>
 </resources>

From 4a2c49be823db87a03116eb31dace61b9c435737 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sat, 9 May 2026 17:50:31 +0200
Subject: [PATCH 05/13] Add anime details screen and library UI

---
 .../kanade/presentation/anime/AnimeScreen.kt  | 151 +++++++++++++++
 .../anime/components/AnimeEpisodeListItem.kt  |  75 ++++++++
 .../anime/components/AnimeInfoHeader.kt       | 153 +++++++++++++++
 .../eu/kanade/presentation/more/MoreScreen.kt |   7 +
 .../screen/SettingsAppearanceScreen.kt        |   1 +
 .../appearance/NavigationStyleScreen.kt       |   3 +
 .../tachiyomi/ui/anime/AnimeListScreen.kt     |  75 ++++++--
 .../ui/anime/AnimeListScreenModel.kt          |  20 +-
 .../kanade/tachiyomi/ui/anime/AnimeScreen.kt  |  58 ++++++
 .../tachiyomi/ui/anime/AnimeScreenModel.kt    | 174 ++++++++++++++++++
 .../eu/kanade/tachiyomi/ui/anime/AnimeTab.kt  |   8 +-
 .../eu/kanade/tachiyomi/ui/more/MoreTab.kt    |   1 +
 .../kanade/tachiyomi/ui/player/PlayerUtils.kt |   9 +
 .../tachiyomi/ui/player/PlayerViewModel.kt    |  24 ++-
 .../data/anime/AnimeRepositoryImpl.kt         |   2 +-
 .../domain/anime/interactor/GetAnime.kt       |   2 +-
 .../anime/repository/AnimeRepository.kt       |   2 +-
 .../interactor/GetEpisodesByAnimeId.kt        |   5 +
 .../moko-resources/base/strings.xml           |   6 +
 19 files changed, 748 insertions(+), 28 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt

diff --git a/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt b/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
new file mode 100644
index 0000000000..2c553098c8
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
@@ -0,0 +1,151 @@
+package eu.kanade.presentation.anime
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.ArrowBack
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.PlayArrow
+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.MaterialTheme
+import androidx.compose.material3.SmallExtendedFloatingActionButton
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import eu.kanade.presentation.anime.components.AnimeEpisodeListItem
+import eu.kanade.presentation.anime.components.AnimeInfoHeader
+import eu.kanade.tachiyomi.ui.anime.AnimeScreenModel
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.i18n.stringResource
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AnimeScreenContent(
+    state: AnimeScreenModel.State.Success,
+    navigateUp: () -> Unit,
+    onEpisodeClicked: (Episode) -> Unit,
+    onContinueWatching: () -> Unit,
+    onToggleFavorite: () -> Unit,
+    onDeleteClicked: () -> Unit,
+    onDismissDialog: () -> Unit,
+    onConfirmDelete: () -> Unit,
+) {
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = {
+                    Text(
+                        text = state.anime.title,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                },
+                navigationIcon = {
+                    IconButton(onClick = navigateUp) {
+                        Icon(
+                            imageVector = Icons.AutoMirrored.Outlined.ArrowBack,
+                            contentDescription = null,
+                        )
+                    }
+                },
+                actions = {
+                    IconButton(onClick = onDeleteClicked) {
+                        Icon(
+                            imageVector = Icons.Filled.Delete,
+                            contentDescription = stringResource(MR.strings.action_delete),
+                        )
+                    }
+                },
+                scrollBehavior = scrollBehavior,
+            )
+        },
+        floatingActionButton = {
+            if (state.nextUnseenEpisode != null) {
+                SmallExtendedFloatingActionButton(
+                    onClick = onContinueWatching,
+                    icon = {
+                        Icon(
+                            imageVector = Icons.Filled.PlayArrow,
+                            contentDescription = null,
+                        )
+                    },
+                    text = { Text(stringResource(MR.strings.anime_continue_watching)) },
+                )
+            }
+        },
+    ) { contentPadding ->
+        LazyColumn(
+            contentPadding = PaddingValues(
+                bottom = contentPadding.calculateBottomPadding() + 80.dp,
+            ),
+            modifier = Modifier
+                .padding(top = contentPadding.calculateTopPadding())
+                .nestedScroll(scrollBehavior.nestedScrollConnection),
+        ) {
+            item(key = "info_header") {
+                AnimeInfoHeader(
+                    anime = state.anime,
+                    onFavoriteToggle = onToggleFavorite,
+                )
+            }
+
+            item(key = "episode_header") {
+                HorizontalDivider()
+                Text(
+                    text = stringResource(MR.strings.anime_episode_count, state.allEpisodeCount),
+                    style = MaterialTheme.typography.titleSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
+                )
+            }
+
+            items(
+                items = state.episodes,
+                key = { it.id },
+            ) { episode ->
+                AnimeEpisodeListItem(
+                    episode = episode,
+                    onClick = { onEpisodeClicked(episode) },
+                )
+                HorizontalDivider()
+            }
+        }
+    }
+
+    when (state.dialog) {
+        is AnimeScreenModel.Dialog.ConfirmDelete -> {
+            AlertDialog(
+                onDismissRequest = onDismissDialog,
+                title = { Text(stringResource(MR.strings.action_delete)) },
+                text = { Text(stringResource(MR.strings.anime_delete_confirm)) },
+                confirmButton = {
+                    TextButton(onClick = onConfirmDelete) {
+                        Text(stringResource(MR.strings.action_delete))
+                    }
+                },
+                dismissButton = {
+                    TextButton(onClick = onDismissDialog) {
+                        Text(stringResource(MR.strings.action_cancel))
+                    }
+                },
+            )
+        }
+        null -> {}
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
new file mode 100644
index 0000000000..d1778a71a5
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
@@ -0,0 +1,75 @@
+package eu.kanade.presentation.anime.components
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Bookmark
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import eu.kanade.tachiyomi.ui.player.buildProgressString
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.presentation.core.components.material.DISABLED_ALPHA
+
+@Composable
+fun AnimeEpisodeListItem(
+    episode: Episode,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val textColor = if (episode.seen) {
+        MaterialTheme.colorScheme.onSurface.copy(alpha = DISABLED_ALPHA)
+    } else {
+        MaterialTheme.colorScheme.onSurface
+    }
+
+    Row(
+        modifier = modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(horizontal = 16.dp, vertical = 12.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        if (episode.bookmark) {
+            Icon(
+                imageVector = Icons.Filled.Bookmark,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.padding(end = 4.dp),
+            )
+        }
+
+        CompositionLocalProvider(LocalContentColor provides textColor) {
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = episode.name,
+                    style = MaterialTheme.typography.bodyLarge,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                )
+
+                val progress = buildProgressString(episode.lastSecondSeen, episode.totalSeconds)
+                if (progress != null) {
+                    Text(
+                        text = progress,
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant.copy(
+                            alpha = if (episode.seen) DISABLED_ALPHA else 1f,
+                        ),
+                        maxLines = 1,
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
new file mode 100644
index 0000000000..28117e334f
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
@@ -0,0 +1,153 @@
+package eu.kanade.presentation.anime.components
+
+import androidx.compose.animation.animateContentSize
+import androidx.compose.foundation.clickable
+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.aspectRatio
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Favorite
+import androidx.compose.material.icons.filled.PlayCircle
+import androidx.compose.material.icons.outlined.FavoriteBorder
+import androidx.compose.material3.AssistChip
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+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.draw.clip
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
+import tachiyomi.domain.anime.model.Anime
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun AnimeInfoHeader(
+    anime: Anime,
+    onFavoriteToggle: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = modifier
+            .fillMaxWidth()
+            .padding(16.dp),
+    ) {
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            verticalAlignment = Alignment.Top,
+        ) {
+            if (anime.thumbnailUrl != null) {
+                AsyncImage(
+                    model = anime.thumbnailUrl,
+                    contentDescription = null,
+                    contentScale = ContentScale.Crop,
+                    modifier = Modifier
+                        .width(100.dp)
+                        .aspectRatio(2f / 3f)
+                        .clip(RoundedCornerShape(4.dp)),
+                )
+            } else {
+                Icon(
+                    imageVector = Icons.Filled.PlayCircle,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier
+                        .size(100.dp)
+                        .padding(16.dp),
+                )
+            }
+
+            Spacer(Modifier.width(16.dp))
+
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    text = anime.title,
+                    style = MaterialTheme.typography.titleLarge,
+                    maxLines = 3,
+                    overflow = TextOverflow.Ellipsis,
+                )
+
+                val author = anime.author
+                if (!author.isNullOrBlank()) {
+                    Text(
+                        text = author,
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                }
+
+                Spacer(Modifier.height(8.dp))
+
+                IconButton(onClick = onFavoriteToggle) {
+                    Icon(
+                        imageVector = if (anime.favorite) Icons.Filled.Favorite else Icons.Outlined.FavoriteBorder,
+                        contentDescription = null,
+                        tint = if (anime.favorite) {
+                            MaterialTheme.colorScheme.error
+                        } else {
+                            MaterialTheme.colorScheme.onSurface
+                        },
+                    )
+                }
+            }
+        }
+
+        val description = anime.description
+        if (!description.isNullOrBlank()) {
+            Spacer(Modifier.height(12.dp))
+            ExpandableDescription(description)
+        }
+
+        val genres = anime.genre
+        if (!genres.isNullOrEmpty()) {
+            Spacer(Modifier.height(8.dp))
+            FlowRow(
+                horizontalArrangement = Arrangement.spacedBy(4.dp),
+                verticalArrangement = Arrangement.spacedBy(4.dp),
+            ) {
+                genres.forEach { genre ->
+                    AssistChip(
+                        onClick = {},
+                        label = { Text(genre, style = MaterialTheme.typography.labelSmall) },
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ExpandableDescription(description: String) {
+    var expanded by rememberSaveable { mutableStateOf(false) }
+
+    Text(
+        text = description,
+        style = MaterialTheme.typography.bodyMedium,
+        color = MaterialTheme.colorScheme.onSurfaceVariant,
+        maxLines = if (expanded) Int.MAX_VALUE else 3,
+        overflow = TextOverflow.Ellipsis,
+        modifier = Modifier
+            .animateContentSize()
+            .clickable { expanded = !expanded },
+    )
+}
diff --git a/app/src/main/java/eu/kanade/presentation/more/MoreScreen.kt b/app/src/main/java/eu/kanade/presentation/more/MoreScreen.kt
index 31cc40b8a8..f13ad9d878 100644
--- a/app/src/main/java/eu/kanade/presentation/more/MoreScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/more/MoreScreen.kt
@@ -23,6 +23,7 @@ import androidx.compose.material.icons.outlined.GetApp
 import androidx.compose.material.icons.outlined.History
 import androidx.compose.material.icons.outlined.Info
 import androidx.compose.material.icons.outlined.NewReleases
+import androidx.compose.material.icons.outlined.PlayCircle
 import androidx.compose.material.icons.outlined.Public
 import androidx.compose.material.icons.outlined.QueryStats
 import androidx.compose.material.icons.outlined.Search
@@ -84,6 +85,7 @@ fun MoreScreen(
     onClickBrowse: () -> Unit,
     onClickDictionary: () -> Unit,
     onClickNovels: () -> Unit,
+    onClickAnime: () -> Unit,
     // KMK -->
     onClickLibraryUpdateErrors: () -> Unit,
     // KMK <--
@@ -218,6 +220,11 @@ fun MoreScreen(
                             icon = Icons.Outlined.Book,
                             onPreferenceClick = onClickNovels,
                         )
+                        NavTabLayout.KEY_ANIME -> TextPreferenceWidget(
+                            title = stringResource(MR.strings.label_anime),
+                            icon = Icons.Outlined.PlayCircle,
+                            onPreferenceClick = onClickAnime,
+                        )
                     }
                 }
             }
diff --git a/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsAppearanceScreen.kt b/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsAppearanceScreen.kt
index 99e329c538..ac7c26d5e3 100644
--- a/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsAppearanceScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsAppearanceScreen.kt
@@ -343,6 +343,7 @@ object SettingsAppearanceScreen : SearchableSettings {
                         eu.kanade.domain.ui.model.NavTabLayout.KEY_BROWSE -> "Browse"
                         eu.kanade.domain.ui.model.NavTabLayout.KEY_DICTIONARY -> "Dictionary"
                         eu.kanade.domain.ui.model.NavTabLayout.KEY_NOVELS -> "Novels"
+                        eu.kanade.domain.ui.model.NavTabLayout.KEY_ANIME -> "Anime"
                         else -> key
                     }
                 }
diff --git a/app/src/main/java/eu/kanade/presentation/more/settings/screen/appearance/NavigationStyleScreen.kt b/app/src/main/java/eu/kanade/presentation/more/settings/screen/appearance/NavigationStyleScreen.kt
index 7e9140aadc..24b98245f4 100644
--- a/app/src/main/java/eu/kanade/presentation/more/settings/screen/appearance/NavigationStyleScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/more/settings/screen/appearance/NavigationStyleScreen.kt
@@ -16,6 +16,7 @@ import androidx.compose.material.icons.outlined.CollectionsBookmark
 import androidx.compose.material.icons.outlined.DragHandle
 import androidx.compose.material.icons.outlined.History
 import androidx.compose.material.icons.outlined.NewReleases
+import androidx.compose.material.icons.outlined.PlayCircle
 import androidx.compose.material.icons.outlined.Public
 import androidx.compose.material.icons.outlined.Search
 import androidx.compose.material3.ElevatedCard
@@ -77,6 +78,7 @@ class NavigationStyleScreen : Screen() {
             NavTabLayout.KEY_BROWSE to stringResource(MR.strings.browse),
             NavTabLayout.KEY_DICTIONARY to stringResource(MR.strings.label_dictionary),
             NavTabLayout.KEY_NOVELS to stringResource(MR.strings.label_novels),
+            NavTabLayout.KEY_ANIME to stringResource(MR.strings.label_anime),
         )
 
         // Section titles
@@ -212,6 +214,7 @@ private fun getTabIcon(key: String): ImageVector {
         NavTabLayout.KEY_BROWSE -> Icons.Outlined.Public
         NavTabLayout.KEY_DICTIONARY -> Icons.Outlined.Search
         NavTabLayout.KEY_NOVELS -> Icons.Outlined.Book
+        NavTabLayout.KEY_ANIME -> Icons.Outlined.PlayCircle
         else -> Icons.Outlined.Public
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
index bd56c4411a..bc399d381e 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
@@ -5,14 +5,19 @@ import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
 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.items
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.PlayCircle
 import androidx.compose.material3.FloatingActionButton
 import androidx.compose.material3.HorizontalDivider
 import androidx.compose.material3.Icon
@@ -26,12 +31,17 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
 import eu.kanade.tachiyomi.ui.player.PlayerActivity
-import eu.kanade.tachiyomi.ui.player.formatTime
+import eu.kanade.tachiyomi.ui.player.buildProgressString
 import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.Badge
+import tachiyomi.presentation.core.components.BadgeGroup
 import tachiyomi.presentation.core.components.ScrollbarLazyColumn
 import tachiyomi.presentation.core.components.material.Scaffold
 import tachiyomi.presentation.core.i18n.stringResource
@@ -41,6 +51,7 @@ import tachiyomi.presentation.core.screens.LoadingScreen
 @Composable
 fun AnimeListScreen(
     screenModel: AnimeListScreenModel,
+    onAnimeClick: (Long) -> Unit,
 ) {
     val state by screenModel.state.collectAsState()
     val context = LocalContext.current
@@ -86,28 +97,25 @@ fun AnimeListScreen(
                         ) { item ->
                             AnimeListItem(
                                 title = item.anime.title,
+                                thumbnailUrl = item.anime.thumbnailUrl,
                                 episodeName = item.lastEpisode?.name,
+                                unseenCount = item.unseenCount,
                                 progress = item.lastEpisode?.let {
-                                    if (it.totalSeconds > 0) {
-                                        "${formatTime(it.lastSecondSeen)} / ${formatTime(it.totalSeconds)}"
-                                    } else if (it.lastSecondSeen > 0) {
-                                        formatTime(it.lastSecondSeen)
-                                    } else {
-                                        null
-                                    }
-                                },
-                                onClick = {
-                                    val episodeId = item.lastEpisode?.id ?: return@AnimeListItem
-                                    context.startActivity(
-                                        PlayerActivity.newIntent(context, item.anime.id, episodeId),
-                                    )
+                                    buildProgressString(it.lastSecondSeen, it.totalSeconds)
                                 },
+                                onClick = { onAnimeClick(item.anime.id) },
                             )
                             HorizontalDivider()
                         }
                     }
                 }
             }
+            is AnimeListScreenModel.State.Error -> {
+                EmptyScreen(
+                    message = s.error.localizedMessage ?: stringResource(MR.strings.unknown_error),
+                    modifier = Modifier.padding(contentPadding),
+                )
+            }
         }
     }
 
@@ -129,7 +137,9 @@ fun AnimeListScreen(
 @Composable
 private fun AnimeListItem(
     title: String,
+    thumbnailUrl: String?,
     episodeName: String?,
+    unseenCount: Int,
     progress: String?,
     onClick: () -> Unit,
 ) {
@@ -138,10 +148,42 @@ private fun AnimeListItem(
             .fillMaxWidth()
             .clickable(onClick = onClick)
             .padding(horizontal = 16.dp, vertical = 12.dp),
-        horizontalArrangement = Arrangement.SpaceBetween,
         verticalAlignment = Alignment.CenterVertically,
     ) {
-        Column(modifier = Modifier.weight(1f)) {
+        Box {
+            if (thumbnailUrl != null) {
+                AsyncImage(
+                    model = thumbnailUrl,
+                    contentDescription = null,
+                    contentScale = ContentScale.Crop,
+                    modifier = Modifier
+                        .width(48.dp)
+                        .aspectRatio(2f / 3f)
+                        .clip(RoundedCornerShape(4.dp)),
+                )
+            } else {
+                Icon(
+                    imageVector = Icons.Filled.PlayCircle,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier
+                        .width(48.dp)
+                        .aspectRatio(2f / 3f),
+                )
+            }
+
+            if (unseenCount > 0) {
+                BadgeGroup(modifier = Modifier.align(Alignment.TopEnd)) {
+                    Badge(text = unseenCount.toString())
+                }
+            }
+        }
+
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(start = 12.dp),
+        ) {
             Text(
                 text = title,
                 style = MaterialTheme.typography.bodyLarge,
@@ -158,6 +200,7 @@ private fun AnimeListItem(
                 )
             }
         }
+
         if (progress != null) {
             Text(
                 text = progress,
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreenModel.kt
index 6c1f1ee789..72a720b937 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreenModel.kt
@@ -2,6 +2,7 @@ package eu.kanade.tachiyomi.ui.anime
 
 import cafe.adriel.voyager.core.model.StateScreenModel
 import cafe.adriel.voyager.core.model.screenModelScope
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
@@ -20,36 +21,41 @@ class AnimeListScreenModel(
     private val getEpisodesByAnimeId: GetEpisodesByAnimeId = Injekt.get(),
 ) : StateScreenModel<AnimeListScreenModel.State>(State.Loading) {
 
+    private var loadJob: Job? = null
+
     sealed interface State {
         data object Loading : State
         data class Success(val items: List<AnimeWithEpisode>) : State
+        data class Error(val error: Exception) : State
     }
 
     data class AnimeWithEpisode(
         val anime: Anime,
         val lastEpisode: Episode?,
+        val unseenCount: Int = 0,
     )
 
-    init {
-        loadAnime()
-    }
-
     fun loadAnime() {
-        screenModelScope.launchIO {
+        loadJob?.cancel()
+        loadJob = screenModelScope.launchIO {
             try {
                 val animes = animeRepository.getAll()
                 val items = coroutineScope {
                     animes.map { anime ->
                         async {
                             val episodes = getEpisodesByAnimeId.await(anime.id)
-                            AnimeWithEpisode(anime, episodes.maxByOrNull { it.lastSecondSeen })
+                            AnimeWithEpisode(
+                                anime = anime,
+                                lastEpisode = episodes.filter { it.lastSecondSeen > 0 }.maxByOrNull { it.lastModifiedAt },
+                                unseenCount = episodes.count { !it.seen },
+                            )
                         }
                     }.awaitAll()
                 }
                 mutableState.value = State.Success(items)
             } catch (e: Exception) {
                 logcat(LogPriority.ERROR, e) { "Failed to load anime list" }
-                mutableState.value = State.Success(emptyList())
+                mutableState.value = State.Error(e)
             }
         }
     }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
new file mode 100644
index 0000000000..de0b24c185
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
@@ -0,0 +1,58 @@
+package eu.kanade.tachiyomi.ui.anime
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.platform.LocalContext
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.anime.AnimeScreenContent
+import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.ui.player.PlayerActivity
+import tachiyomi.presentation.core.screens.LoadingScreen
+
+class AnimeScreen(
+    private val animeId: Long,
+) : Screen() {
+
+    @Composable
+    override fun Content() {
+        val navigator = LocalNavigator.currentOrThrow
+        val context = LocalContext.current
+        val screenModel = rememberScreenModel { AnimeScreenModel(animeId = animeId) }
+        val state by screenModel.state.collectAsState()
+
+        when (val s = state) {
+            is AnimeScreenModel.State.Loading -> {
+                LoadingScreen()
+            }
+            is AnimeScreenModel.State.Success -> {
+                AnimeScreenContent(
+                    state = s,
+                    navigateUp = navigator::pop,
+                    onEpisodeClicked = { episode ->
+                        context.startActivity(
+                            PlayerActivity.newIntent(context, animeId, episode.id),
+                        )
+                    },
+                    onContinueWatching = {
+                        val episode = s.nextUnseenEpisode ?: return@AnimeScreenContent
+                        context.startActivity(
+                            PlayerActivity.newIntent(context, animeId, episode.id),
+                        )
+                    },
+                    onToggleFavorite = screenModel::toggleFavorite,
+                    onDeleteClicked = {
+                        screenModel.showDialog(AnimeScreenModel.Dialog.ConfirmDelete)
+                    },
+                    onDismissDialog = screenModel::dismissDialog,
+                    onConfirmDelete = {
+                        screenModel.deleteAnime()
+                        navigator.pop()
+                    },
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
new file mode 100644
index 0000000000..59fad622ad
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
@@ -0,0 +1,174 @@
+package eu.kanade.tachiyomi.ui.anime
+
+import androidx.compose.runtime.Immutable
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.update
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.lang.launchNonCancellable
+import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.interactor.SetAnimeEpisodeFlags
+import tachiyomi.domain.anime.interactor.UpdateAnime
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.model.AnimeUpdate
+import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
+import tachiyomi.domain.episode.interactor.SetSeenStatus
+import tachiyomi.domain.episode.interactor.UpdateEpisode
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.episode.model.EpisodeUpdate
+import tachiyomi.domain.manga.model.applyFilter
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeScreenModel(
+    private val animeId: Long,
+    private val getAnime: GetAnime = Injekt.get(),
+    private val getEpisodesByAnimeId: GetEpisodesByAnimeId = Injekt.get(),
+    private val updateAnime: UpdateAnime = Injekt.get(),
+    private val updateEpisode: UpdateEpisode = Injekt.get(),
+    private val setSeenStatus: SetSeenStatus = Injekt.get(),
+    private val setAnimeEpisodeFlags: SetAnimeEpisodeFlags = Injekt.get(),
+    private val animeRepository: AnimeRepository = Injekt.get(),
+) : StateScreenModel<AnimeScreenModel.State>(State.Loading) {
+
+    init {
+        screenModelScope.launchIO {
+            combine(
+                getAnime.subscribe(animeId),
+                getEpisodesByAnimeId.subscribe(animeId),
+            ) { anime, episodes ->
+                val sortedEpisodes = applySort(anime, episodes)
+                val filteredEpisodes = applyFilters(anime, sortedEpisodes)
+                State.Success(
+                    anime = anime,
+                    episodes = filteredEpisodes,
+                    allEpisodeCount = episodes.size,
+                    nextUnseenEpisode = episodes.asSequence().filter { !it.seen }.minByOrNull { it.sourceOrder },
+                )
+            }.collectLatest { newState ->
+                mutableState.update { old ->
+                    val dialog = (old as? State.Success)?.dialog
+                    newState.copy(dialog = dialog)
+                }
+            }
+        }
+    }
+
+    private fun applySort(anime: Anime, episodes: List<Episode>): List<Episode> {
+        val comparator: Comparator<Episode> = when (anime.sorting) {
+            Anime.EPISODE_SORTING_NUMBER -> compareBy { it.episodeNumber }
+            Anime.EPISODE_SORTING_UPLOAD_DATE -> compareBy { it.dateUpload }
+            Anime.EPISODE_SORTING_ALPHABET -> compareBy { it.name }
+            else -> compareBy { it.sourceOrder }
+        }
+        return if (anime.sortDescending()) {
+            episodes.sortedWith(comparator.reversed())
+        } else {
+            episodes.sortedWith(comparator)
+        }
+    }
+
+    private fun applyFilters(anime: Anime, episodes: List<Episode>): List<Episode> {
+        return episodes.filter { episode ->
+            applyFilter(anime.unseenFilter) { !episode.seen } &&
+                applyFilter(anime.bookmarkedFilter) { episode.bookmark }
+        }
+    }
+
+    fun toggleFavorite() {
+        screenModelScope.launchNonCancellable {
+            val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
+            updateAnime.await(
+                AnimeUpdate(
+                    id = anime.id,
+                    favorite = !anime.favorite,
+                    dateAdded = if (!anime.favorite) System.currentTimeMillis() else 0L,
+                ),
+            )
+        }
+    }
+
+    fun markEpisodesSeen(episodes: List<Episode>, seen: Boolean) {
+        screenModelScope.launchNonCancellable {
+            setSeenStatus.await(
+                seen = seen,
+                episodes = episodes.toTypedArray(),
+            )
+        }
+    }
+
+    fun toggleBookmark(episodes: List<Episode>) {
+        screenModelScope.launchNonCancellable {
+            val updates = episodes.map {
+                EpisodeUpdate(id = it.id, bookmark = !it.bookmark)
+            }
+            updateEpisode.awaitAll(updates)
+        }
+    }
+
+    fun deleteAnime() {
+        screenModelScope.launchNonCancellable {
+            animeRepository.deleteAnime(animeId)
+        }
+    }
+
+    fun setSortMode(mode: Long) {
+        screenModelScope.launchNonCancellable {
+            val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
+            setAnimeEpisodeFlags.awaitSetSortingModeOrFlipOrder(anime, mode)
+        }
+    }
+
+    fun setUnseenFilter(flag: Long) {
+        screenModelScope.launchNonCancellable {
+            val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
+            setAnimeEpisodeFlags.awaitSetUnseenFilter(anime, flag)
+        }
+    }
+
+    fun setBookmarkFilter(flag: Long) {
+        screenModelScope.launchNonCancellable {
+            val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
+            setAnimeEpisodeFlags.awaitSetBookmarkFilter(anime, flag)
+        }
+    }
+
+    fun showDialog(dialog: Dialog) {
+        mutableState.update { state ->
+            when (state) {
+                is State.Success -> state.copy(dialog = dialog)
+                else -> state
+            }
+        }
+    }
+
+    fun dismissDialog() {
+        mutableState.update { state ->
+            when (state) {
+                is State.Success -> state.copy(dialog = null)
+                else -> state
+            }
+        }
+    }
+
+    sealed interface State {
+        @Immutable
+        data object Loading : State
+
+        @Immutable
+        data class Success(
+            val anime: Anime,
+            val episodes: List<Episode>,
+            val allEpisodeCount: Int = 0,
+            val nextUnseenEpisode: Episode? = null,
+            val dialog: Dialog? = null,
+        ) : State
+    }
+
+    sealed interface Dialog {
+        data object ConfirmDelete : Dialog
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
index d45363b1dd..4e3438d572 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
@@ -6,6 +6,8 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.vector.rememberVectorPainter
 import androidx.lifecycle.compose.LifecycleResumeEffect
 import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
 import cafe.adriel.voyager.navigator.tab.TabOptions
 import eu.kanade.presentation.util.Tab
 import tachiyomi.i18n.MR
@@ -25,11 +27,15 @@ data object AnimeTab : Tab {
 
     @Composable
     override fun Content() {
+        val navigator = LocalNavigator.currentOrThrow
         val screenModel = rememberScreenModel { AnimeListScreenModel() }
         LifecycleResumeEffect(Unit) {
             screenModel.loadAnime()
             onPauseOrDispose { }
         }
-        AnimeListScreen(screenModel)
+        AnimeListScreen(
+            screenModel = screenModel,
+            onAnimeClick = { animeId -> navigator.push(AnimeScreen(animeId)) },
+        )
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/more/MoreTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/more/MoreTab.kt
index bf0231f239..728ac356e1 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/more/MoreTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/more/MoreTab.kt
@@ -95,6 +95,7 @@ data object MoreTab : Tab {
             onClickBrowse = { navigator.push(eu.kanade.tachiyomi.ui.browse.BrowseTab) },
             onClickDictionary = { navigator.push(eu.kanade.tachiyomi.ui.dictionary.DictionaryTab) },
             onClickNovels = { navigator.push(eu.kanade.tachiyomi.ui.library.novels.NovelsTab) },
+            onClickAnime = { navigator.push(eu.kanade.tachiyomi.ui.anime.AnimeTab) },
             // SY <--
             // KMK -->
             onClickLibraryUpdateErrors = { navigator.push(LibraryUpdateErrorScreen()) },
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerUtils.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerUtils.kt
index 4bcc976954..0dd3efa03f 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerUtils.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerUtils.kt
@@ -10,3 +10,12 @@ fun formatTime(seconds: Long): String {
     return if (h > 0) String.format(Locale.US, "%d:%02d:%02d", h, m, s)
     else String.format(Locale.US, "%d:%02d", m, s)
 }
+
+fun buildProgressString(lastSecondSeen: Long, totalSeconds: Long): String? {
+    if (lastSecondSeen <= 0 && totalSeconds <= 0) return null
+    return if (totalSeconds > 0) {
+        "${formatTime(lastSecondSeen)} / ${formatTime(totalSeconds)}"
+    } else {
+        formatTime(lastSecondSeen)
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
index d8f6924c03..68effd6e51 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
@@ -1,6 +1,9 @@
 package eu.kanade.tachiyomi.ui.player
 
+import android.app.Application
+import android.provider.OpenableColumns
 import androidx.compose.runtime.Immutable
+import androidx.core.net.toUri
 import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
@@ -48,6 +51,7 @@ class PlayerViewModel @JvmOverloads constructor(
     private val animeRepository: AnimeRepository = Injekt.get(),
     private val episodeRepository: EpisodeRepository = Injekt.get(),
     private val dictionaryRepository: DictionaryRepository = Injekt.get(),
+    private val application: Application = Injekt.get(),
 ) : ViewModel() {
 
     private val mutableState = MutableStateFlow(
@@ -252,7 +256,7 @@ class PlayerViewModel @JvmOverloads constructor(
                 return@withIOContext
             }
 
-            val title = videoUrl.substringAfterLast('/').substringBeforeLast('.').ifBlank { "Video" }
+            val title = resolveVideoTitle(videoUrl)
             val anime = Anime.create().copy(
                 url = videoUrl,
                 title = title,
@@ -270,6 +274,24 @@ class PlayerViewModel @JvmOverloads constructor(
         }
     }
 
+    private fun resolveVideoTitle(videoUrl: String): String {
+        if (videoUrl.startsWith("content://")) {
+            try {
+                val uri = videoUrl.toUri()
+                application.contentResolver.query(uri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)
+                    ?.use { cursor ->
+                        if (cursor.moveToFirst()) {
+                            val name = cursor.getString(0)
+                            if (!name.isNullOrBlank()) {
+                                return name.substringBeforeLast('.')
+                            }
+                        }
+                    }
+            } catch (_: Exception) {}
+        }
+        return videoUrl.substringAfterLast('/').substringBeforeLast('.').ifBlank { "Video" }
+    }
+
     private suspend fun insertEpisode(animeId: Long, url: String, name: String): Episode? {
         val episode = Episode.create().copy(
             animeId = animeId,
diff --git a/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
index bd92de108f..aacadcb29e 100644
--- a/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
+++ b/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
@@ -18,7 +18,7 @@ class AnimeRepositoryImpl(
         return handler.awaitOne { animesQueries.getAnimeById(id, AnimeMapper::mapAnime) }
     }
 
-    override suspend fun getAnimeByIdAsFlow(id: Long): Flow<Anime> {
+    override fun getAnimeByIdAsFlow(id: Long): Flow<Anime> {
         return handler.subscribeToOne { animesQueries.getAnimeById(id, AnimeMapper::mapAnime) }
     }
 
diff --git a/domain/src/main/java/tachiyomi/domain/anime/interactor/GetAnime.kt b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetAnime.kt
index 9c1e587449..a78d6da83b 100644
--- a/domain/src/main/java/tachiyomi/domain/anime/interactor/GetAnime.kt
+++ b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetAnime.kt
@@ -19,7 +19,7 @@ class GetAnime(
         }
     }
 
-    suspend fun subscribe(id: Long): Flow<Anime> {
+    fun subscribe(id: Long): Flow<Anime> {
         return animeRepository.getAnimeByIdAsFlow(id)
     }
 
diff --git a/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt b/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
index 3ada66f050..3eeff062db 100644
--- a/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
+++ b/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
@@ -8,7 +8,7 @@ interface AnimeRepository {
 
     suspend fun getAnimeById(id: Long): Anime
 
-    suspend fun getAnimeByIdAsFlow(id: Long): Flow<Anime>
+    fun getAnimeByIdAsFlow(id: Long): Flow<Anime>
 
     suspend fun getAnimeByUrlAndSourceId(url: String, sourceId: Long): Anime?
 
diff --git a/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisodesByAnimeId.kt b/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisodesByAnimeId.kt
index 3ef2e483cf..7397b96c45 100644
--- a/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisodesByAnimeId.kt
+++ b/domain/src/main/java/tachiyomi/domain/episode/interactor/GetEpisodesByAnimeId.kt
@@ -1,5 +1,6 @@
 package tachiyomi.domain.episode.interactor
 
+import kotlinx.coroutines.flow.Flow
 import logcat.LogPriority
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.episode.model.Episode
@@ -17,4 +18,8 @@ class GetEpisodesByAnimeId(
             emptyList()
         }
     }
+
+    fun subscribe(animeId: Long): Flow<List<Episode>> {
+        return episodeRepository.getEpisodesByAnimeIdAsFlow(animeId)
+    }
 }
diff --git a/i18n/src/commonMain/moko-resources/base/strings.xml b/i18n/src/commonMain/moko-resources/base/strings.xml
index 3c782aaebd..0fe7b71cf1 100644
--- a/i18n/src/commonMain/moko-resources/base/strings.xml
+++ b/i18n/src/commonMain/moko-resources/base/strings.xml
@@ -39,6 +39,12 @@
     <string name="action_pick_local_file">Pick local file</string>
     <string name="action_open">Open</string>
     <string name="label_video_url">Video URL</string>
+    <string name="anime_continue_watching">Continue watching</string>
+    <string name="anime_no_episodes">No episodes yet</string>
+    <string name="anime_episode_count">%d episodes</string>
+    <string name="anime_delete_confirm">Delete this anime and all its episodes?</string>
+    <string name="action_mark_as_seen">Mark as seen</string>
+    <string name="action_mark_as_unseen">Mark as unseen</string>
     <string name="action_play">Play</string>
     <string name="novel_missing_file">Missing File — tap to import</string>
     <string name="backup_option_novels">Novel progress &amp; stats</string>

From c475b85c9bc00d88bff92c86961d450a89f11c33 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sat, 9 May 2026 21:32:18 +0200
Subject: [PATCH 06/13] Extension & anime sources loading

---
 .../java/eu/kanade/domain/DomainModule.kt     |  26 +
 .../interactor/GetAnimeExtensionLanguages.kt  |  32 ++
 .../interactor/GetAnimeExtensionSources.kt    |  37 ++
 .../interactor/GetAnimeExtensionsByType.kt    |  60 +++
 .../animeextension/model/AnimeExtensions.kt   |  10 +
 .../source/service/SourcePreferences.kt       |   2 +
 .../browse/AnimeExtensionScreen.kt            | 463 ++++++++++++++++++
 .../browse/AnimeExtensionReposScreen.kt       |  94 ++++
 .../browse/AnimeExtensionReposScreenModel.kt  | 129 +++++
 .../animeextension/AnimeExtensionManager.kt   | 263 ++++++++++
 .../animeextension/api/AnimeExtensionApi.kt   | 177 +++++++
 .../api/AnimeExtensionUpdateNotifier.kt       |  50 ++
 .../animeextension/model/AnimeExtension.kt    |  77 +++
 .../animeextension/model/AnimeLoadResult.kt   |   7 +
 .../util/AnimeExtensionInstallReceiver.kt     | 120 +++++
 .../util/AnimeExtensionInstaller.kt           | 242 +++++++++
 .../util/AnimeExtensionLoader.kt              | 346 +++++++++++++
 .../animesource/AndroidAnimeSourceManager.kt  | 103 ++++
 .../data/notification/Notifications.kt        |   7 +
 .../java/eu/kanade/tachiyomi/di/AppModule.kt  |   5 +
 .../tachiyomi/ui/anime/AnimeScreenModel.kt    |  63 +++
 .../kanade/tachiyomi/ui/browse/BrowseTab.kt   |  27 +-
 .../AnimeExtensionsScreenModel.kt             | 240 +++++++++
 .../animeextension/AnimeExtensionsTab.kt      | 114 +++++
 .../animesource/AnimeSourcesScreenModel.kt    |  56 +++
 .../ui/browse/animesource/AnimeSourcesTab.kt  | 153 ++++++
 .../browse/BrowseAnimeSourceScreen.kt         | 172 +++++++
 .../browse/BrowseAnimeSourceScreenModel.kt    | 131 +++++
 .../tachiyomi/ui/player/PlayerActivity.kt     |  30 +-
 .../tachiyomi/ui/player/PlayerViewModel.kt    | 115 ++++-
 .../kanade/tachiyomi/ui/player/mpv/MPVView.kt |  30 +-
 .../AnimeExtensionRepoRepositoryImpl.kt       |  93 ++++
 .../StubAnimeSourceRepositoryImpl.kt          |  29 ++
 .../tachiyomi/data/anime_extension_repos.sq   |  57 +++
 .../tachiyomi/data/anime_sources.sq           |  24 +
 .../sqldelight/tachiyomi/migrations/46.sqm    |  13 +
 .../interactor/CreateAnimeExtensionRepo.kt    |  62 +++
 .../interactor/DeleteAnimeExtensionRepo.kt    |  11 +
 .../interactor/GetAnimeExtensionRepo.kt       |  13 +
 .../interactor/GetAnimeExtensionRepoCount.kt  |   9 +
 .../interactor/ReplaceAnimeExtensionRepo.kt   |  12 +
 .../interactor/UpdateAnimeExtensionRepo.kt    |  30 ++
 .../AnimeExtensionRepoRepository.kt           |  47 ++
 .../animesource/model/StubAnimeSource.kt      |  35 ++
 .../repository/StubAnimeSourceRepository.kt   |  12 +
 .../animesource/service/AnimeSourceManager.kt |  25 +
 .../moko-resources/base/strings.xml           |   3 +
 47 files changed, 3842 insertions(+), 14 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionLanguages.kt
 create mode 100644 app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionSources.kt
 create mode 100644 app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionsByType.kt
 create mode 100644 app/src/main/java/eu/kanade/domain/animeextension/model/AnimeExtensions.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/AnimeExtensionReposScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/AnimeExtensionReposScreenModel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animeextension/AnimeExtensionManager.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionApi.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionUpdateNotifier.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeExtension.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeLoadResult.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionInstallReceiver.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionInstaller.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionLoader.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/animesource/AndroidAnimeSourceManager.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsScreenModel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsTab.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/AnimeSourcesScreenModel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/AnimeSourcesTab.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
 create mode 100644 data/src/main/java/mihon/data/repository/AnimeExtensionRepoRepositoryImpl.kt
 create mode 100644 data/src/main/java/tachiyomi/data/animesource/StubAnimeSourceRepositoryImpl.kt
 create mode 100644 data/src/main/sqldelight/tachiyomi/data/anime_extension_repos.sq
 create mode 100644 data/src/main/sqldelight/tachiyomi/data/anime_sources.sq
 create mode 100644 data/src/main/sqldelight/tachiyomi/migrations/46.sqm
 create mode 100644 domain/src/main/java/mihon/domain/animeextensionrepo/interactor/CreateAnimeExtensionRepo.kt
 create mode 100644 domain/src/main/java/mihon/domain/animeextensionrepo/interactor/DeleteAnimeExtensionRepo.kt
 create mode 100644 domain/src/main/java/mihon/domain/animeextensionrepo/interactor/GetAnimeExtensionRepo.kt
 create mode 100644 domain/src/main/java/mihon/domain/animeextensionrepo/interactor/GetAnimeExtensionRepoCount.kt
 create mode 100644 domain/src/main/java/mihon/domain/animeextensionrepo/interactor/ReplaceAnimeExtensionRepo.kt
 create mode 100644 domain/src/main/java/mihon/domain/animeextensionrepo/interactor/UpdateAnimeExtensionRepo.kt
 create mode 100644 domain/src/main/java/mihon/domain/animeextensionrepo/repository/AnimeExtensionRepoRepository.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/animesource/model/StubAnimeSource.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/animesource/repository/StubAnimeSourceRepository.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/animesource/service/AnimeSourceManager.kt

diff --git a/app/src/main/java/eu/kanade/domain/DomainModule.kt b/app/src/main/java/eu/kanade/domain/DomainModule.kt
index 30c3244bea..d1a2e04a2c 100644
--- a/app/src/main/java/eu/kanade/domain/DomainModule.kt
+++ b/app/src/main/java/eu/kanade/domain/DomainModule.kt
@@ -1,5 +1,8 @@
 package eu.kanade.domain
 
+import eu.kanade.domain.animeextension.interactor.GetAnimeExtensionLanguages
+import eu.kanade.domain.animeextension.interactor.GetAnimeExtensionSources
+import eu.kanade.domain.animeextension.interactor.GetAnimeExtensionsByType
 import eu.kanade.domain.chapter.interactor.GetAvailableScanlators
 import eu.kanade.domain.chapter.interactor.SetReadStatus
 import eu.kanade.domain.chapter.interactor.SyncChaptersWithSource
@@ -25,7 +28,15 @@ import eu.kanade.domain.track.interactor.AddTracks
 import eu.kanade.domain.track.interactor.RefreshTracks
 import eu.kanade.domain.track.interactor.SyncChapterProgressWithTrack
 import eu.kanade.domain.track.interactor.TrackChapter
+import mihon.data.repository.AnimeExtensionRepoRepositoryImpl
 import mihon.data.repository.ExtensionRepoRepositoryImpl
+import mihon.domain.animeextensionrepo.interactor.CreateAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.DeleteAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.GetAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.GetAnimeExtensionRepoCount
+import mihon.domain.animeextensionrepo.interactor.ReplaceAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.UpdateAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.repository.AnimeExtensionRepoRepository
 import mihon.domain.chapter.interactor.FilterChaptersForDownload
 import mihon.domain.extensionrepo.interactor.CreateExtensionRepo
 import mihon.domain.extensionrepo.interactor.DeleteExtensionRepo
@@ -37,6 +48,7 @@ import mihon.domain.extensionrepo.repository.ExtensionRepoRepository
 import mihon.domain.extensionrepo.service.ExtensionRepoService
 import mihon.domain.migration.usecases.MigrateMangaUseCase
 import mihon.domain.upcoming.interactor.GetUpcomingManga
+import tachiyomi.data.animesource.StubAnimeSourceRepositoryImpl
 import tachiyomi.data.category.CategoryRepositoryImpl
 import tachiyomi.data.chapter.ChapterRepositoryImpl
 import tachiyomi.data.history.HistoryRepositoryImpl
@@ -46,6 +58,7 @@ import tachiyomi.data.source.SourceRepositoryImpl
 import tachiyomi.data.source.StubSourceRepositoryImpl
 import tachiyomi.data.track.TrackRepositoryImpl
 import tachiyomi.data.updates.UpdatesRepositoryImpl
+import tachiyomi.domain.animesource.repository.StubAnimeSourceRepository
 import tachiyomi.domain.category.interactor.CreateCategoryWithName
 import tachiyomi.domain.category.interactor.DeleteCategory
 import tachiyomi.domain.category.interactor.GetCategories
@@ -205,6 +218,19 @@ class DomainModule : InjektModule {
         addFactory { DeleteExtensionRepo(get()) }
         addFactory { ReplaceExtensionRepo(get()) }
         addFactory { UpdateExtensionRepo(get(), get()) }
+
+        addSingletonFactory<AnimeExtensionRepoRepository> { AnimeExtensionRepoRepositoryImpl(get()) }
+        addSingletonFactory<StubAnimeSourceRepository> { StubAnimeSourceRepositoryImpl(get()) }
+        addFactory { GetAnimeExtensionRepo(get()) }
+        addFactory { GetAnimeExtensionRepoCount(get()) }
+        addFactory { CreateAnimeExtensionRepo(get(), get()) }
+        addFactory { DeleteAnimeExtensionRepo(get()) }
+        addFactory { ReplaceAnimeExtensionRepo(get()) }
+        addFactory { UpdateAnimeExtensionRepo(get(), get()) }
+        addFactory { GetAnimeExtensionsByType(get(), get()) }
+        addFactory { GetAnimeExtensionLanguages(get(), get()) }
+        addFactory { GetAnimeExtensionSources(get()) }
+
         addFactory { ToggleIncognito(get()) }
         addFactory { GetIncognitoState(get(), get(), get()) }
     }
diff --git a/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionLanguages.kt b/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionLanguages.kt
new file mode 100644
index 0000000000..64a9da60ea
--- /dev/null
+++ b/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionLanguages.kt
@@ -0,0 +1,32 @@
+package eu.kanade.domain.animeextension.interactor
+
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+
+class GetAnimeExtensionLanguages(
+    private val preferences: SourcePreferences,
+    private val animeExtensionManager: AnimeExtensionManager,
+) {
+    fun subscribe(): Flow<List<String>> {
+        return combine(
+            preferences.enabledLanguages().changes(),
+            animeExtensionManager.availableExtensionsFlow,
+        ) { enabledLanguage, availableExtensions ->
+            availableExtensions
+                .flatMap { ext ->
+                    if (ext.sources.isEmpty()) {
+                        listOf(ext.lang)
+                    } else {
+                        ext.sources.map { it.lang }
+                    }
+                }
+                .distinct()
+                .sortedWith(
+                    compareBy<String> { it !in enabledLanguage }.then(LocaleHelper.comparator),
+                )
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionSources.kt b/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionSources.kt
new file mode 100644
index 0000000000..66d08c062e
--- /dev/null
+++ b/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionSources.kt
@@ -0,0 +1,37 @@
+package eu.kanade.domain.animeextension.interactor
+
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+class GetAnimeExtensionSources(
+    private val preferences: SourcePreferences,
+) {
+
+    fun subscribe(extension: AnimeExtension.Installed): Flow<List<AnimeExtensionSourceItem>> {
+        val isMultiSource = extension.sources.size > 1
+        val isMultiLangSingleSource =
+            isMultiSource && extension.sources.map { it.name }.distinct().size == 1
+
+        return preferences.disabledSources().changes().map { disabledSources ->
+            fun AnimeSource.isEnabled() = id.toString() !in disabledSources
+
+            extension.sources
+                .map { source ->
+                    AnimeExtensionSourceItem(
+                        source = source,
+                        enabled = source.isEnabled(),
+                        labelAsName = isMultiSource && !isMultiLangSingleSource,
+                    )
+                }
+        }
+    }
+}
+
+data class AnimeExtensionSourceItem(
+    val source: AnimeSource,
+    val enabled: Boolean,
+    val labelAsName: Boolean,
+)
diff --git a/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionsByType.kt b/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionsByType.kt
new file mode 100644
index 0000000000..06707f4fe7
--- /dev/null
+++ b/app/src/main/java/eu/kanade/domain/animeextension/interactor/GetAnimeExtensionsByType.kt
@@ -0,0 +1,60 @@
+package eu.kanade.domain.animeextension.interactor
+
+import eu.kanade.domain.animeextension.model.AnimeExtensions
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combine
+
+class GetAnimeExtensionsByType(
+    private val preferences: SourcePreferences,
+    private val animeExtensionManager: AnimeExtensionManager,
+) {
+
+    fun subscribe(): Flow<AnimeExtensions> {
+        val showNsfwSources = preferences.showNsfwSource().get()
+
+        return combine(
+            preferences.enabledLanguages().changes(),
+            animeExtensionManager.installedExtensionsFlow,
+            animeExtensionManager.untrustedExtensionsFlow,
+            animeExtensionManager.availableExtensionsFlow,
+        ) { enabledLanguages, _installed, _untrusted, _available ->
+            val (updates, installed) = _installed
+                .filter { (showNsfwSources || !it.isNsfw) }
+                .sortedWith(
+                    compareBy<AnimeExtension.Installed> { !it.isObsolete }
+                        .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name },
+                )
+                .partition { it.hasUpdate }
+
+            val untrusted = _untrusted
+                .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
+
+            val available = _available
+                .filter { extension ->
+                    _installed.none { it.pkgName == extension.pkgName } &&
+                        _untrusted.none { it.pkgName == extension.pkgName } &&
+                        (showNsfwSources || !extension.isNsfw)
+                }
+                .flatMap { ext ->
+                    if (ext.sources.isEmpty()) {
+                        return@flatMap if (ext.lang in enabledLanguages) listOf(ext) else emptyList()
+                    }
+                    ext.sources.filter { it.lang in enabledLanguages }
+                        .map {
+                            ext.copy(
+                                name = it.name,
+                                lang = it.lang,
+                                pkgName = "${ext.pkgName}-${it.id}",
+                                sources = listOf(it),
+                            )
+                        }
+                }
+                .sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.name })
+
+            AnimeExtensions(updates, installed, available, untrusted)
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/domain/animeextension/model/AnimeExtensions.kt b/app/src/main/java/eu/kanade/domain/animeextension/model/AnimeExtensions.kt
new file mode 100644
index 0000000000..d685b9e39d
--- /dev/null
+++ b/app/src/main/java/eu/kanade/domain/animeextension/model/AnimeExtensions.kt
@@ -0,0 +1,10 @@
+package eu.kanade.domain.animeextension.model
+
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+
+data class AnimeExtensions(
+    val updates: List<AnimeExtension.Installed>,
+    val installed: List<AnimeExtension.Installed>,
+    val available: List<AnimeExtension.Available>,
+    val untrusted: List<AnimeExtension.Untrusted>,
+)
diff --git a/app/src/main/java/eu/kanade/domain/source/service/SourcePreferences.kt b/app/src/main/java/eu/kanade/domain/source/service/SourcePreferences.kt
index be21b31ef3..da8963811d 100644
--- a/app/src/main/java/eu/kanade/domain/source/service/SourcePreferences.kt
+++ b/app/src/main/java/eu/kanade/domain/source/service/SourcePreferences.kt
@@ -59,6 +59,8 @@ class SourcePreferences(
 
     fun extensionUpdatesCount() = preferenceStore.getInt("ext_updates_count", 0)
 
+    fun animeExtensionUpdatesCount() = preferenceStore.getInt("anime_ext_updates_count", 0)
+
     fun trustedExtensions() = preferenceStore.getStringSet(
         Preference.appStateKey("trusted_extensions"),
         emptySet(),
diff --git a/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionScreen.kt b/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionScreen.kt
new file mode 100644
index 0000000000..7a85c289ab
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionScreen.kt
@@ -0,0 +1,463 @@
+package eu.kanade.presentation.browse
+
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Close
+import androidx.compose.material.icons.outlined.GetApp
+import androidx.compose.material.icons.outlined.Public
+import androidx.compose.material.icons.outlined.Refresh
+import androidx.compose.material.icons.outlined.Settings
+import androidx.compose.material.icons.outlined.VerifiedUser
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LocalTextStyle
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ProvideTextStyle
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.painter.ColorPainter
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
+import eu.kanade.presentation.browse.components.BaseBrowseItem
+import eu.kanade.presentation.components.WarningBanner
+import eu.kanade.presentation.manga.components.DotSeparatorNoSpaceText
+import eu.kanade.presentation.util.animateItemFastScroll
+import eu.kanade.presentation.util.rememberRequestPackageInstallsPermissionState
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.extension.model.InstallStep
+import eu.kanade.tachiyomi.ui.browse.animeextension.AnimeExtensionUiModel
+import eu.kanade.tachiyomi.ui.browse.animeextension.AnimeExtensionsScreenModel
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import eu.kanade.tachiyomi.util.system.launchRequestPackageInstallsPermission
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.FastScrollLazyColumn
+import tachiyomi.presentation.core.components.material.PullRefresh
+import tachiyomi.presentation.core.components.material.padding
+import tachiyomi.presentation.core.components.material.topSmallPaddingValues
+import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.screens.EmptyScreen
+import tachiyomi.presentation.core.screens.LoadingScreen
+import tachiyomi.presentation.core.theme.header
+import tachiyomi.presentation.core.util.plus
+import tachiyomi.presentation.core.util.secondaryItemAlpha
+
+@Composable
+fun AnimeExtensionScreen(
+    state: AnimeExtensionsScreenModel.State,
+    contentPadding: PaddingValues,
+    searchQuery: String?,
+    onLongClickItem: (AnimeExtension) -> Unit,
+    onClickItemCancel: (AnimeExtension) -> Unit,
+    onOpenWebView: (AnimeExtension.Available) -> Unit,
+    onInstallExtension: (AnimeExtension.Available) -> Unit,
+    onUninstallExtension: (AnimeExtension) -> Unit,
+    onUpdateExtension: (AnimeExtension.Installed) -> Unit,
+    onTrustExtension: (AnimeExtension.Untrusted) -> Unit,
+    onOpenExtension: (AnimeExtension.Installed) -> Unit,
+    onClickUpdateAll: () -> Unit,
+    onRefresh: () -> Unit,
+) {
+    PullRefresh(
+        refreshing = state.isRefreshing,
+        onRefresh = onRefresh,
+        enabled = !state.isLoading,
+    ) {
+        when {
+            state.isLoading -> LoadingScreen(Modifier.padding(contentPadding))
+            state.isEmpty -> {
+                val msg = if (!searchQuery.isNullOrEmpty()) {
+                    MR.strings.no_results_found
+                } else {
+                    MR.strings.empty_screen
+                }
+                EmptyScreen(msg, modifier = Modifier.padding(contentPadding))
+            }
+            else -> {
+                AnimeExtensionContent(
+                    state = state,
+                    contentPadding = contentPadding,
+                    onLongClickItem = onLongClickItem,
+                    onClickItemCancel = onClickItemCancel,
+                    onOpenWebView = onOpenWebView,
+                    onInstallExtension = onInstallExtension,
+                    onUninstallExtension = onUninstallExtension,
+                    onUpdateExtension = onUpdateExtension,
+                    onTrustExtension = onTrustExtension,
+                    onOpenExtension = onOpenExtension,
+                    onClickUpdateAll = onClickUpdateAll,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeExtensionContent(
+    state: AnimeExtensionsScreenModel.State,
+    contentPadding: PaddingValues,
+    onLongClickItem: (AnimeExtension) -> Unit,
+    onClickItemCancel: (AnimeExtension) -> Unit,
+    onOpenWebView: (AnimeExtension.Available) -> Unit,
+    onInstallExtension: (AnimeExtension.Available) -> Unit,
+    onUninstallExtension: (AnimeExtension) -> Unit,
+    onUpdateExtension: (AnimeExtension.Installed) -> Unit,
+    onTrustExtension: (AnimeExtension.Untrusted) -> Unit,
+    onOpenExtension: (AnimeExtension.Installed) -> Unit,
+    onClickUpdateAll: () -> Unit,
+) {
+    val context = LocalContext.current
+    var trustState by remember { mutableStateOf<AnimeExtension.Untrusted?>(null) }
+    val installGranted = rememberRequestPackageInstallsPermissionState(initialValue = true)
+
+    FastScrollLazyColumn(
+        contentPadding = contentPadding + topSmallPaddingValues,
+    ) {
+        if (!installGranted && state.installer?.requiresSystemPermission == true) {
+            item(key = "anime-extension-permissions-warning") {
+                WarningBanner(
+                    textRes = MR.strings.ext_permission_install_apps_warning,
+                    modifier = Modifier.clickable {
+                        context.launchRequestPackageInstallsPermission()
+                    },
+                )
+            }
+        }
+
+        state.items.forEach { (header, items) ->
+            item(
+                contentType = "header",
+                key = "animeExtHeader-${header.hashCode()}",
+            ) {
+                when (header) {
+                    is AnimeExtensionUiModel.Header.Resource -> {
+                        val action: @Composable RowScope.() -> Unit =
+                            if (header.textRes == MR.strings.ext_updates_pending) {
+                                {
+                                    Button(onClick = { onClickUpdateAll() }) {
+                                        Text(
+                                            text = stringResource(MR.strings.ext_update_all),
+                                            style = LocalTextStyle.current.copy(
+                                                color = MaterialTheme.colorScheme.onPrimary,
+                                            ),
+                                        )
+                                    }
+                                }
+                            } else {
+                                {}
+                            }
+                        Row(
+                            modifier = Modifier
+                                .padding(horizontal = MaterialTheme.padding.medium)
+                                .animateItemFastScroll(),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Text(
+                                text = stringResource(header.textRes),
+                                modifier = Modifier
+                                    .padding(vertical = 8.dp)
+                                    .weight(1f),
+                                style = MaterialTheme.typography.header,
+                            )
+                            action()
+                        }
+                    }
+                    is AnimeExtensionUiModel.Header.Text -> {
+                        Row(
+                            modifier = Modifier
+                                .padding(horizontal = MaterialTheme.padding.medium)
+                                .animateItemFastScroll(),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Text(
+                                text = header.text,
+                                modifier = Modifier
+                                    .padding(vertical = 8.dp)
+                                    .weight(1f),
+                                style = MaterialTheme.typography.header,
+                            )
+                        }
+                    }
+                }
+            }
+
+            items(
+                items = items,
+                contentType = { "item" },
+                key = { item ->
+                    when (item.extension) {
+                        is AnimeExtension.Untrusted -> "anime-ext-untrusted-${item.hashCode()}"
+                        is AnimeExtension.Installed -> "anime-ext-installed-${item.hashCode()}"
+                        is AnimeExtension.Available -> "anime-ext-available-${item.hashCode()}"
+                    }
+                },
+            ) { item ->
+                AnimeExtensionItem(
+                    modifier = Modifier.animateItemFastScroll(),
+                    item = item,
+                    onClickItem = {
+                        when (it) {
+                            is AnimeExtension.Available -> onInstallExtension(it)
+                            is AnimeExtension.Installed -> onOpenExtension(it)
+                            is AnimeExtension.Untrusted -> { trustState = it }
+                        }
+                    },
+                    onLongClickItem = onLongClickItem,
+                    onClickItemCancel = onClickItemCancel,
+                    onClickItemAction = {
+                        when (it) {
+                            is AnimeExtension.Available -> onInstallExtension(it)
+                            is AnimeExtension.Installed -> {
+                                if (it.hasUpdate) onUpdateExtension(it) else onOpenExtension(it)
+                            }
+                            is AnimeExtension.Untrusted -> { trustState = it }
+                        }
+                    },
+                    onClickItemSecondaryAction = {
+                        when (it) {
+                            is AnimeExtension.Available -> onOpenWebView(it)
+                            is AnimeExtension.Installed -> onOpenExtension(it)
+                            else -> {}
+                        }
+                    },
+                )
+            }
+        }
+    }
+    if (trustState != null) {
+        AlertDialog(
+            title = { Text(text = stringResource(MR.strings.untrusted_extension)) },
+            text = { Text(text = stringResource(MR.strings.untrusted_extension_message)) },
+            confirmButton = {
+                TextButton(onClick = {
+                    onTrustExtension(trustState!!)
+                    trustState = null
+                }) { Text(text = stringResource(MR.strings.ext_trust)) }
+            },
+            dismissButton = {
+                TextButton(onClick = {
+                    onUninstallExtension(trustState!!)
+                    trustState = null
+                }) { Text(text = stringResource(MR.strings.ext_uninstall)) }
+            },
+            onDismissRequest = { trustState = null },
+        )
+    }
+}
+
+@Composable
+private fun AnimeExtensionItem(
+    item: AnimeExtensionUiModel.Item,
+    onClickItem: (AnimeExtension) -> Unit,
+    onLongClickItem: (AnimeExtension) -> Unit,
+    onClickItemCancel: (AnimeExtension) -> Unit,
+    onClickItemAction: (AnimeExtension) -> Unit,
+    onClickItemSecondaryAction: (AnimeExtension) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val (extension, installStep) = item
+    BaseBrowseItem(
+        modifier = modifier
+            .combinedClickable(
+                onClick = { onClickItem(extension) },
+                onLongClick = { onLongClickItem(extension) },
+            ),
+        onClickItem = { onClickItem(extension) },
+        onLongClickItem = { onLongClickItem(extension) },
+        icon = {
+            Box(
+                modifier = Modifier.size(40.dp),
+                contentAlignment = Alignment.Center,
+            ) {
+                val idle = installStep.isCompleted()
+                if (!idle) {
+                    CircularProgressIndicator(
+                        modifier = Modifier.size(40.dp),
+                        strokeWidth = 2.dp,
+                    )
+                }
+
+                val padding by animateDpAsState(targetValue = if (idle) 0.dp else 8.dp)
+                when (extension) {
+                    is AnimeExtension.Available -> {
+                        AsyncImage(
+                            model = extension.iconUrl,
+                            contentDescription = null,
+                            placeholder = ColorPainter(Color(0x1F888888)),
+                            modifier = Modifier
+                                .matchParentSize()
+                                .padding(padding),
+                        )
+                    }
+                    is AnimeExtension.Installed -> {
+                        AsyncImage(
+                            model = extension.icon,
+                            contentDescription = null,
+                            placeholder = ColorPainter(Color(0x1F888888)),
+                            modifier = Modifier
+                                .matchParentSize()
+                                .padding(padding),
+                        )
+                    }
+                    is AnimeExtension.Untrusted -> {
+                        AsyncImage(
+                            model = R.drawable.cover_error,
+                            contentDescription = null,
+                            modifier = Modifier
+                                .matchParentSize()
+                                .padding(padding),
+                        )
+                    }
+                }
+            }
+        },
+        action = {
+            AnimeExtensionItemActions(
+                extension = extension,
+                installStep = installStep,
+                onClickItemCancel = onClickItemCancel,
+                onClickItemAction = onClickItemAction,
+                onClickItemSecondaryAction = onClickItemSecondaryAction,
+            )
+        },
+    ) {
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(start = MaterialTheme.padding.medium),
+        ) {
+            Text(
+                text = extension.name,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                style = MaterialTheme.typography.bodyMedium,
+            )
+
+            FlowRow(
+                modifier = Modifier.secondaryItemAlpha(),
+                horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.extraSmall),
+            ) {
+                ProvideTextStyle(value = MaterialTheme.typography.bodySmall) {
+                    extension.lang?.let {
+                        if (it.isNotEmpty()) {
+                            Text(text = LocaleHelper.getSourceDisplayName(it, LocalContext.current))
+                        }
+                    }
+
+                    if (extension.versionName.isNotEmpty()) {
+                        DotSeparatorNoSpaceText()
+                        Text(text = extension.versionName)
+                    }
+
+                    val warning = when {
+                        extension is AnimeExtension.Untrusted -> MR.strings.ext_untrusted
+                        extension is AnimeExtension.Installed && extension.isObsolete -> MR.strings.ext_obsolete
+                        extension.isNsfw -> MR.strings.ext_nsfw_short
+                        else -> null
+                    }
+                    if (warning != null) {
+                        DotSeparatorNoSpaceText()
+                        Text(
+                            text = stringResource(warning).uppercase(),
+                            color = MaterialTheme.colorScheme.error,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                        )
+                    }
+
+                    if (!installStep.isCompleted()) {
+                        DotSeparatorNoSpaceText()
+                        Text(
+                            text = when (installStep) {
+                                InstallStep.Pending -> stringResource(MR.strings.ext_pending)
+                                InstallStep.Downloading -> stringResource(MR.strings.ext_downloading)
+                                InstallStep.Installing -> stringResource(MR.strings.ext_installing)
+                                else -> error("Must not show non-install process text")
+                            },
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeExtensionItemActions(
+    extension: AnimeExtension,
+    installStep: InstallStep,
+    onClickItemCancel: (AnimeExtension) -> Unit,
+    onClickItemAction: (AnimeExtension) -> Unit,
+    onClickItemSecondaryAction: (AnimeExtension) -> Unit,
+) {
+    val isIdle = installStep.isCompleted()
+
+    Row(horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.small)) {
+        when {
+            !isIdle -> {
+                IconButton(onClick = { onClickItemCancel(extension) }) {
+                    Icon(Icons.Outlined.Close, contentDescription = stringResource(MR.strings.action_cancel))
+                }
+            }
+            installStep == InstallStep.Error -> {
+                IconButton(onClick = { onClickItemAction(extension) }) {
+                    Icon(Icons.Outlined.Refresh, contentDescription = stringResource(MR.strings.action_retry))
+                }
+            }
+            installStep == InstallStep.Idle -> {
+                when (extension) {
+                    is AnimeExtension.Installed -> {
+                        IconButton(onClick = { onClickItemSecondaryAction(extension) }) {
+                            Icon(Icons.Outlined.Settings, contentDescription = stringResource(MR.strings.action_settings))
+                        }
+                        if (extension.hasUpdate) {
+                            IconButton(onClick = { onClickItemAction(extension) }) {
+                                Icon(Icons.Outlined.GetApp, contentDescription = stringResource(MR.strings.ext_update))
+                            }
+                        }
+                    }
+                    is AnimeExtension.Untrusted -> {
+                        IconButton(onClick = { onClickItemAction(extension) }) {
+                            Icon(Icons.Outlined.VerifiedUser, contentDescription = stringResource(MR.strings.ext_trust))
+                        }
+                    }
+                    is AnimeExtension.Available -> {
+                        if (extension.sources.isNotEmpty()) {
+                            IconButton(onClick = { onClickItemSecondaryAction(extension) }) {
+                                Icon(Icons.Outlined.Public, contentDescription = stringResource(MR.strings.action_open_in_web_view))
+                            }
+                        }
+                        IconButton(onClick = { onClickItemAction(extension) }) {
+                            Icon(Icons.Outlined.GetApp, contentDescription = stringResource(MR.strings.ext_install))
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/AnimeExtensionReposScreen.kt b/app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/AnimeExtensionReposScreen.kt
new file mode 100644
index 0000000000..39c169d751
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/AnimeExtensionReposScreen.kt
@@ -0,0 +1,94 @@
+package eu.kanade.presentation.more.settings.screen.browse
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.platform.LocalContext
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionRepoConfirmDialog
+import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionRepoConflictDialog
+import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionRepoCreateDialog
+import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionRepoDeleteDialog
+import eu.kanade.presentation.more.settings.screen.browse.components.ExtensionReposScreen
+import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.util.system.openInBrowser
+import eu.kanade.tachiyomi.util.system.toast
+import kotlinx.collections.immutable.toImmutableSet
+import kotlinx.coroutines.flow.collectLatest
+import tachiyomi.presentation.core.screens.LoadingScreen
+
+class AnimeExtensionReposScreen : Screen() {
+
+    @Composable
+    override fun Content() {
+        val context = LocalContext.current
+        val navigator = LocalNavigator.currentOrThrow
+
+        val screenModel = rememberScreenModel { AnimeExtensionReposScreenModel() }
+        val state by screenModel.state.collectAsState()
+
+        if (state is AnimeRepoScreenState.Loading) {
+            LoadingScreen()
+            return
+        }
+
+        val successState = state as AnimeRepoScreenState.Success
+
+        ExtensionReposScreen(
+            state = RepoScreenState.Success(
+                repos = successState.repos,
+            ),
+            onClickCreate = { screenModel.showDialog(AnimeRepoDialog.Create) },
+            onOpenWebsite = { context.openInBrowser(it.website) },
+            onClickDelete = { screenModel.showDialog(AnimeRepoDialog.Delete(it)) },
+            onClickEnable = {},
+            onClickDisable = {},
+            onClickRefresh = { screenModel.refreshRepos() },
+            navigateUp = navigator::pop,
+        )
+
+        when (val dialog = successState.dialog) {
+            null -> {}
+            is AnimeRepoDialog.Create -> {
+                ExtensionRepoCreateDialog(
+                    onDismissRequest = screenModel::dismissDialog,
+                    onCreate = { screenModel.createRepo(it) },
+                    repoUrls = successState.repos.map { it.baseUrl }.toImmutableSet(),
+                )
+            }
+            is AnimeRepoDialog.Delete -> {
+                ExtensionRepoDeleteDialog(
+                    onDismissRequest = screenModel::dismissDialog,
+                    onDelete = { screenModel.deleteRepo(dialog.repo) },
+                    repo = dialog.repo,
+                )
+            }
+            is AnimeRepoDialog.Conflict -> {
+                ExtensionRepoConflictDialog(
+                    onDismissRequest = screenModel::dismissDialog,
+                    onMigrate = { screenModel.replaceRepo(dialog.newRepo) },
+                    oldRepo = dialog.oldRepo,
+                    newRepo = dialog.newRepo,
+                )
+            }
+            is AnimeRepoDialog.Confirm -> {
+                ExtensionRepoConfirmDialog(
+                    onDismissRequest = screenModel::dismissDialog,
+                    onCreate = { screenModel.createRepo(dialog.url) },
+                    repo = dialog.url,
+                )
+            }
+        }
+
+        LaunchedEffect(Unit) {
+            screenModel.events.collectLatest { event ->
+                if (event is AnimeRepoEvent.LocalizedMessage) {
+                    context.toast(event.stringRes)
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/AnimeExtensionReposScreenModel.kt b/app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/AnimeExtensionReposScreenModel.kt
new file mode 100644
index 0000000000..ec81355b32
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/more/settings/screen/browse/AnimeExtensionReposScreenModel.kt
@@ -0,0 +1,129 @@
+package eu.kanade.presentation.more.settings.screen.browse
+
+import androidx.compose.runtime.Immutable
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import dev.icerock.moko.resources.StringResource
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import kotlinx.collections.immutable.ImmutableSet
+import kotlinx.collections.immutable.toImmutableSet
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.update
+import mihon.domain.animeextensionrepo.interactor.CreateAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.DeleteAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.GetAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.ReplaceAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.UpdateAnimeExtensionRepo
+import mihon.domain.extensionrepo.model.ExtensionRepo
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.i18n.MR
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeExtensionReposScreenModel(
+    private val getAnimeExtensionRepo: GetAnimeExtensionRepo = Injekt.get(),
+    private val createAnimeExtensionRepo: CreateAnimeExtensionRepo = Injekt.get(),
+    private val deleteAnimeExtensionRepo: DeleteAnimeExtensionRepo = Injekt.get(),
+    private val replaceAnimeExtensionRepo: ReplaceAnimeExtensionRepo = Injekt.get(),
+    private val updateAnimeExtensionRepo: UpdateAnimeExtensionRepo = Injekt.get(),
+    private val animeExtensionManager: AnimeExtensionManager = Injekt.get(),
+) : StateScreenModel<AnimeRepoScreenState>(AnimeRepoScreenState.Loading) {
+
+    private val _events: Channel<AnimeRepoEvent> = Channel(Int.MAX_VALUE)
+    val events = _events.receiveAsFlow()
+
+    init {
+        screenModelScope.launchIO {
+            getAnimeExtensionRepo.subscribeAll()
+                .collectLatest { repos ->
+                    mutableState.update {
+                        AnimeRepoScreenState.Success(repos = repos.toImmutableSet())
+                    }
+                }
+        }
+    }
+
+    fun createRepo(baseUrl: String) {
+        screenModelScope.launchIO {
+            when (val result = createAnimeExtensionRepo.await(baseUrl)) {
+                CreateAnimeExtensionRepo.Result.Success -> animeExtensionManager.findAvailableExtensions()
+                CreateAnimeExtensionRepo.Result.InvalidUrl -> _events.send(AnimeRepoEvent.InvalidUrl)
+                CreateAnimeExtensionRepo.Result.RepoAlreadyExists -> _events.send(AnimeRepoEvent.RepoAlreadyExists)
+                is CreateAnimeExtensionRepo.Result.DuplicateFingerprint -> {
+                    showDialog(AnimeRepoDialog.Conflict(result.oldRepo, result.newRepo))
+                }
+                else -> {}
+            }
+        }
+    }
+
+    fun replaceRepo(newRepo: ExtensionRepo) {
+        screenModelScope.launchIO {
+            replaceAnimeExtensionRepo.await(newRepo)
+        }
+    }
+
+    fun refreshRepos() {
+        val status = state.value
+        if (status is AnimeRepoScreenState.Success) {
+            screenModelScope.launchIO {
+                updateAnimeExtensionRepo.awaitAll()
+            }
+        }
+    }
+
+    fun deleteRepo(baseUrl: String) {
+        screenModelScope.launchIO {
+            deleteAnimeExtensionRepo.await(baseUrl)
+            animeExtensionManager.findAvailableExtensions()
+        }
+    }
+
+    fun showDialog(dialog: AnimeRepoDialog) {
+        mutableState.update {
+            when (it) {
+                AnimeRepoScreenState.Loading -> it
+                is AnimeRepoScreenState.Success -> it.copy(dialog = dialog)
+            }
+        }
+    }
+
+    fun dismissDialog() {
+        mutableState.update {
+            when (it) {
+                AnimeRepoScreenState.Loading -> it
+                is AnimeRepoScreenState.Success -> it.copy(dialog = null)
+            }
+        }
+    }
+}
+
+sealed class AnimeRepoEvent {
+    sealed class LocalizedMessage(val stringRes: StringResource) : AnimeRepoEvent()
+    data object InvalidUrl : LocalizedMessage(MR.strings.invalid_repo_name)
+    data object RepoAlreadyExists : LocalizedMessage(MR.strings.error_repo_exists)
+}
+
+sealed class AnimeRepoDialog {
+    data object Create : AnimeRepoDialog()
+    data class Delete(val repo: String) : AnimeRepoDialog()
+    data class Conflict(val oldRepo: ExtensionRepo, val newRepo: ExtensionRepo) : AnimeRepoDialog()
+    data class Confirm(val url: String) : AnimeRepoDialog()
+}
+
+sealed class AnimeRepoScreenState {
+
+    @Immutable
+    data object Loading : AnimeRepoScreenState()
+
+    @Immutable
+    data class Success(
+        val repos: ImmutableSet<ExtensionRepo>,
+        val dialog: AnimeRepoDialog? = null,
+    ) : AnimeRepoScreenState() {
+        val isEmpty: Boolean
+            get() = repos.isEmpty()
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/AnimeExtensionManager.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/AnimeExtensionManager.kt
new file mode 100644
index 0000000000..9844149db1
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/AnimeExtensionManager.kt
@@ -0,0 +1,263 @@
+package eu.kanade.tachiyomi.animeextension
+
+import android.content.Context
+import android.graphics.drawable.Drawable
+import eu.kanade.domain.extension.interactor.TrustExtension
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animeextension.api.AnimeExtensionApi
+import eu.kanade.tachiyomi.animeextension.api.AnimeExtensionUpdateNotifier
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animeextension.model.AnimeLoadResult
+import eu.kanade.tachiyomi.animeextension.util.AnimeExtensionInstallReceiver
+import eu.kanade.tachiyomi.animeextension.util.AnimeExtensionInstaller
+import eu.kanade.tachiyomi.animeextension.util.AnimeExtensionLoader
+import eu.kanade.tachiyomi.extension.model.InstallStep
+import eu.kanade.tachiyomi.util.system.toast
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.stateIn
+import logcat.LogPriority
+import tachiyomi.core.common.util.lang.withUIContext
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.animesource.model.StubAnimeSource
+import tachiyomi.i18n.MR
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeExtensionManager(
+    private val context: Context,
+    private val preferences: SourcePreferences = Injekt.get(),
+    private val trustExtension: TrustExtension = Injekt.get(),
+) {
+
+    val scope = CoroutineScope(SupervisorJob())
+
+    private val _isInitialized = MutableStateFlow(false)
+    val isInitialized: StateFlow<Boolean> = _isInitialized.asStateFlow()
+
+    private val api = AnimeExtensionApi()
+
+    private val installer by lazy { AnimeExtensionInstaller(context) }
+
+    private val iconMap = mutableMapOf<String, Drawable>()
+
+    private val installedExtensionMapFlow = MutableStateFlow(emptyMap<String, AnimeExtension.Installed>())
+    val installedExtensionsFlow = installedExtensionMapFlow.mapExtensions(scope)
+
+    private val availableExtensionMapFlow = MutableStateFlow(emptyMap<String, AnimeExtension.Available>())
+    val availableExtensionsFlow = availableExtensionMapFlow.map { it.values.toList() }
+        .stateIn(scope, SharingStarted.Lazily, availableExtensionMapFlow.value.values.toList())
+
+    private val untrustedExtensionMapFlow = MutableStateFlow(emptyMap<String, AnimeExtension.Untrusted>())
+    val untrustedExtensionsFlow = untrustedExtensionMapFlow.mapExtensions(scope)
+
+    init {
+        initExtensions()
+        AnimeExtensionInstallReceiver(InstallationListener()).register(context)
+    }
+
+    fun getExtensionPackage(sourceId: Long): String? {
+        return installedExtensionsFlow.value.find { extension ->
+            extension.sources.any { it.id == sourceId }
+        }
+            ?.pkgName
+    }
+
+    fun getAppIconForSource(sourceId: Long): Drawable? {
+        val pkgName = getExtensionPackage(sourceId) ?: return null
+        return iconMap[pkgName] ?: iconMap.getOrPut(pkgName) {
+            AnimeExtensionLoader.getExtensionPackageInfoFromPkgName(context, pkgName)!!.applicationInfo!!
+                .loadIcon(context.packageManager)
+        }
+    }
+
+    private var availableExtensionsSourcesData: Map<Long, StubAnimeSource> = emptyMap()
+
+    private fun setupAvailableExtensionsSourcesDataMap(extensions: List<AnimeExtension.Available>) {
+        if (extensions.isEmpty()) return
+        availableExtensionsSourcesData = extensions
+            .flatMap { ext -> ext.sources.map { it.toStubAnimeSource() } }
+            .associateBy { it.id }
+    }
+
+    fun getSourceData(id: Long) = availableExtensionsSourcesData[id]
+
+    private fun initExtensions() {
+        val extensions = AnimeExtensionLoader.loadExtensions(context)
+
+        installedExtensionMapFlow.value = extensions
+            .filterIsInstance<AnimeLoadResult.Success>()
+            .associate { it.extension.pkgName to it.extension }
+
+        untrustedExtensionMapFlow.value = extensions
+            .filterIsInstance<AnimeLoadResult.Untrusted>()
+            .associate { it.extension.pkgName to it.extension }
+
+        _isInitialized.value = true
+    }
+
+    suspend fun findAvailableExtensions() {
+        val extensions: List<AnimeExtension.Available> = try {
+            api.findExtensions()
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e)
+            withUIContext { context.toast(MR.strings.extension_api_error) }
+            return
+        }
+
+        availableExtensionMapFlow.value = extensions.associateBy {
+            it.pkgName + ":${it.signatureHash}"
+        }
+        updatedInstalledExtensionsStatuses(extensions)
+        setupAvailableExtensionsSourcesDataMap(extensions)
+    }
+
+    private fun updatedInstalledExtensionsStatuses(availableExtensions: List<AnimeExtension.Available>) {
+        val installedExtensionsMap = installedExtensionMapFlow.value.toMutableMap()
+        var changed = false
+        for ((pkgName, extension) in installedExtensionsMap) {
+            val availableExt = availableExtensions.find {
+                it.signatureHash == extension.signatureHash && it.pkgName == pkgName
+            }
+
+            if (availableExt == null && (!extension.isObsolete || extension.hasUpdate)) {
+                installedExtensionsMap[pkgName] = extension.copy(
+                    isObsolete = true,
+                    hasUpdate = false,
+                )
+                changed = true
+            } else if (availableExt != null) {
+                val hasUpdate = extension.updateExists(availableExt)
+                if (hasUpdate != extension.hasUpdate ||
+                    availableExt.repoUrl != extension.repoUrl ||
+                    extension.isObsolete
+                ) {
+                    installedExtensionsMap[pkgName] = extension.copy(
+                        hasUpdate = hasUpdate,
+                        repoUrl = availableExt.repoUrl,
+                        isObsolete = false,
+                    )
+                    changed = true
+                }
+            }
+        }
+        if (changed) {
+            installedExtensionMapFlow.value = installedExtensionsMap
+        }
+        updatePendingUpdatesCount()
+    }
+
+    fun installExtension(extension: AnimeExtension.Available): Flow<InstallStep> {
+        return installer.downloadAndInstall(api.getApkUrl(extension), extension)
+    }
+
+    fun updateExtension(extension: AnimeExtension.Installed): Flow<InstallStep> {
+        val availableExt = availableExtensionMapFlow.value[
+            extension.pkgName + ":${extension.signatureHash}",
+        ] ?: return emptyFlow()
+        return installExtension(availableExt)
+    }
+
+    fun cancelInstallUpdateExtension(extension: AnimeExtension) {
+        installer.cancelInstall(extension.pkgName + ":${extension.signatureHash}")
+    }
+
+    fun setInstalling(downloadId: Long) {
+        installer.updateInstallStep(downloadId, InstallStep.Installing)
+    }
+
+    fun updateInstallStep(downloadId: Long, step: InstallStep) {
+        installer.updateInstallStep(downloadId, step)
+    }
+
+    fun uninstallExtension(extension: AnimeExtension) {
+        installer.uninstallApk(extension.pkgName)
+    }
+
+    suspend fun trust(extension: AnimeExtension.Untrusted) {
+        untrustedExtensionMapFlow.value[extension.pkgName] ?: return
+
+        trustExtension.trust(extension.pkgName, extension.versionCode, extension.signatureHash)
+
+        untrustedExtensionMapFlow.value -= extension.pkgName
+
+        AnimeExtensionLoader.loadExtensionFromPkgName(context, extension.pkgName)
+            .let { it as? AnimeLoadResult.Success }
+            ?.let { registerNewExtension(it.extension) }
+    }
+
+    private fun registerNewExtension(extension: AnimeExtension.Installed) {
+        installedExtensionMapFlow.value += extension
+    }
+
+    private fun registerUpdatedExtension(extension: AnimeExtension.Installed) {
+        installedExtensionMapFlow.value += extension
+    }
+
+    private fun unregisterExtension(pkgName: String) {
+        installedExtensionMapFlow.value -= pkgName
+        untrustedExtensionMapFlow.value -= pkgName
+    }
+
+    private inner class InstallationListener : AnimeExtensionInstallReceiver.Listener {
+
+        override fun onExtensionInstalled(extension: AnimeExtension.Installed) {
+            registerNewExtension(extension.withUpdateCheck())
+            updatePendingUpdatesCount()
+        }
+
+        override fun onExtensionUpdated(extension: AnimeExtension.Installed) {
+            registerUpdatedExtension(extension.withUpdateCheck())
+            updatePendingUpdatesCount()
+        }
+
+        override fun onExtensionUntrusted(extension: AnimeExtension.Untrusted) {
+            installedExtensionMapFlow.value -= extension.pkgName
+            untrustedExtensionMapFlow.value += extension
+            updatePendingUpdatesCount()
+        }
+
+        override fun onPackageUninstalled(pkgName: String) {
+            AnimeExtensionLoader.uninstallPrivateExtension(context, pkgName)
+            unregisterExtension(pkgName)
+            updatePendingUpdatesCount()
+        }
+    }
+
+    private fun AnimeExtension.Installed.withUpdateCheck(): AnimeExtension.Installed {
+        return if (updateExists()) {
+            copy(hasUpdate = true)
+        } else {
+            this
+        }
+    }
+
+    private fun AnimeExtension.Installed.updateExists(availableExtension: AnimeExtension.Available? = null): Boolean {
+        val availableExt = availableExtension
+            ?: availableExtensionMapFlow.value[pkgName + ":${signatureHash}"]
+            ?: return false
+
+        return (availableExt.versionCode > versionCode || availableExt.libVersion > libVersion)
+    }
+
+    private fun updatePendingUpdatesCount() {
+        val pendingUpdateCount = installedExtensionMapFlow.value.values.count { it.hasUpdate }
+        preferences.animeExtensionUpdatesCount().set(pendingUpdateCount)
+        if (pendingUpdateCount == 0) {
+            AnimeExtensionUpdateNotifier(context).dismiss()
+        }
+    }
+
+    private operator fun <T : AnimeExtension> Map<String, T>.plus(extension: T) = plus(extension.pkgName to extension)
+
+    private fun <T : AnimeExtension> StateFlow<Map<String, T>>.mapExtensions(scope: CoroutineScope): StateFlow<List<T>> {
+        return map { it.values.toList() }.stateIn(scope, SharingStarted.Lazily, value.values.toList())
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionApi.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionApi.kt
new file mode 100644
index 0000000000..d30cde42e9
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionApi.kt
@@ -0,0 +1,177 @@
+package eu.kanade.tachiyomi.animeextension.api
+
+import android.content.Context
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animeextension.model.AnimeLoadResult
+import eu.kanade.tachiyomi.animeextension.util.AnimeExtensionLoader
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.network.awaitSuccess
+import eu.kanade.tachiyomi.network.parseAs
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import logcat.LogPriority
+import mihon.domain.animeextensionrepo.interactor.GetAnimeExtensionRepo
+import mihon.domain.animeextensionrepo.interactor.UpdateAnimeExtensionRepo
+import mihon.domain.extensionrepo.model.ExtensionRepo
+import tachiyomi.core.common.preference.Preference
+import tachiyomi.core.common.preference.PreferenceStore
+import tachiyomi.core.common.util.lang.withIOContext
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.injectLazy
+import java.time.Instant
+import kotlin.time.Duration.Companion.days
+
+internal class AnimeExtensionApi {
+
+    private val networkService: NetworkHelper by injectLazy()
+    private val preferenceStore: PreferenceStore by injectLazy()
+    private val getAnimeExtensionRepo: GetAnimeExtensionRepo by injectLazy()
+    private val updateAnimeExtensionRepo: UpdateAnimeExtensionRepo by injectLazy()
+    private val animeExtensionManager: AnimeExtensionManager by injectLazy()
+
+    private val json: Json by injectLazy()
+
+    private val lastExtCheck: Preference<Long> by lazy {
+        preferenceStore.getLong(Preference.appStateKey("last_anime_ext_check"), 0)
+    }
+
+    suspend fun findExtensions(): List<AnimeExtension.Available> {
+        return withIOContext {
+            getAnimeExtensionRepo.getAll()
+                .map { async { getExtensions(it) } }
+                .awaitAll()
+                .flatten()
+        }
+    }
+
+    private suspend fun getExtensions(extRepo: ExtensionRepo): List<AnimeExtension.Available> {
+        val repoBaseUrl = extRepo.baseUrl
+        return try {
+            val response = networkService.client
+                .newCall(GET("$repoBaseUrl/index.min.json"))
+                .awaitSuccess()
+
+            with(json) {
+                response
+                    .parseAs<List<AnimeExtensionJsonObject>>()
+                    .toExtensions(
+                        repoBaseUrl,
+                        signature = extRepo.signingKeyFingerprint,
+                    )
+            }
+        } catch (e: Throwable) {
+            logcat(LogPriority.ERROR, e) { "Failed to get anime extensions from $repoBaseUrl" }
+            emptyList()
+        }
+    }
+
+    suspend fun checkForUpdates(
+        context: Context,
+        fromAvailableExtensionList: Boolean = false,
+    ): List<AnimeExtension.Installed>? {
+        if (!fromAvailableExtensionList &&
+            Instant.now().toEpochMilli() < lastExtCheck.get() + 1.days.inWholeMilliseconds
+        ) {
+            return null
+        }
+
+        updateAnimeExtensionRepo.awaitAll()
+
+        val extensions = if (fromAvailableExtensionList) {
+            animeExtensionManager.availableExtensionsFlow.value
+        } else {
+            findExtensions().also { lastExtCheck.set(Instant.now().toEpochMilli()) }
+        }
+
+        val installedExtensions = AnimeExtensionLoader.loadExtensions(context)
+            .filterIsInstance<AnimeLoadResult.Success>()
+            .map { it.extension }
+
+        val extensionsWithUpdate = mutableListOf<AnimeExtension.Installed>()
+        for (installedExt in installedExtensions) {
+            val pkgName = installedExt.pkgName
+            val availableExt = extensions.find { it.pkgName == pkgName } ?: continue
+            val hasUpdatedVer = availableExt.versionCode > installedExt.versionCode
+            val hasUpdatedLib = availableExt.libVersion > installedExt.libVersion
+            val hasUpdate = hasUpdatedVer || hasUpdatedLib
+            if (hasUpdate) {
+                extensionsWithUpdate.add(installedExt)
+            }
+        }
+
+        if (extensionsWithUpdate.isNotEmpty()) {
+            AnimeExtensionUpdateNotifier(context).promptUpdates(extensionsWithUpdate.map { it.name })
+        }
+
+        return extensionsWithUpdate
+    }
+
+    private fun List<AnimeExtensionJsonObject>.toExtensions(
+        repoUrl: String,
+        signature: String,
+    ): List<AnimeExtension.Available> {
+        return this
+            .filter {
+                val libVersion = it.extractLibVersion()
+                libVersion >= AnimeExtensionLoader.LIB_VERSION_MIN && libVersion <= AnimeExtensionLoader.LIB_VERSION_MAX
+            }
+            .map {
+                AnimeExtension.Available(
+                    name = it.name.substringAfter("Tachiyomi: "),
+                    pkgName = it.pkg,
+                    versionName = it.version,
+                    versionCode = it.code,
+                    libVersion = it.extractLibVersion(),
+                    lang = it.lang,
+                    isNsfw = it.nsfw == 1,
+                    sources = it.sources?.map(animeExtensionSourceMapper).orEmpty(),
+                    apkName = it.apk,
+                    iconUrl = "$repoUrl/icon/${it.pkg}.png",
+                    repoUrl = repoUrl,
+                    signatureHash = signature,
+                )
+            }
+    }
+
+    fun getApkUrl(extension: AnimeExtension.Available): String {
+        return "${extension.repoUrl}/apk/${extension.apkName}"
+    }
+
+    private fun AnimeExtensionJsonObject.extractLibVersion(): Double {
+        return version.substringBeforeLast('.').toDouble()
+    }
+}
+
+@Serializable
+private data class AnimeExtensionJsonObject(
+    val name: String,
+    val pkg: String,
+    val apk: String,
+    val lang: String,
+    val code: Long,
+    val version: String,
+    val nsfw: Int,
+    val sources: List<AnimeExtensionSourceJsonObject>?,
+)
+
+@Serializable
+private data class AnimeExtensionSourceJsonObject(
+    val id: Long,
+    val lang: String,
+    val name: String,
+    val baseUrl: String,
+)
+
+private val animeExtensionSourceMapper: (AnimeExtensionSourceJsonObject) -> AnimeExtension.Available.Source = {
+    AnimeExtension.Available.Source(
+        id = it.id,
+        lang = it.lang,
+        name = it.name,
+        baseUrl = it.baseUrl,
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionUpdateNotifier.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionUpdateNotifier.kt
new file mode 100644
index 0000000000..605f32bbaa
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionUpdateNotifier.kt
@@ -0,0 +1,50 @@
+package eu.kanade.tachiyomi.animeextension.api
+
+import android.content.Context
+import android.graphics.BitmapFactory
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.core.security.SecurityPreferences
+import eu.kanade.tachiyomi.data.notification.NotificationReceiver
+import eu.kanade.tachiyomi.data.notification.Notifications
+import eu.kanade.tachiyomi.util.system.cancelNotification
+import eu.kanade.tachiyomi.util.system.notify
+import tachiyomi.core.common.i18n.pluralStringResource
+import tachiyomi.i18n.MR
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeExtensionUpdateNotifier(
+    private val context: Context,
+    private val securityPreferences: SecurityPreferences = Injekt.get(),
+) {
+    fun promptUpdates(names: List<String>) {
+        context.notify(
+            Notifications.ID_UPDATES_TO_ANIME_EXTS,
+            Notifications.CHANNEL_ANIME_EXTENSIONS_UPDATE,
+        ) {
+            setContentTitle(
+                context.pluralStringResource(
+                    MR.plurals.update_check_notification_ext_updates,
+                    names.size,
+                    names.size,
+                ),
+            )
+            if (!securityPreferences.hideNotificationContent().get()) {
+                val extNames = names.joinToString(", ")
+                setContentText(extNames)
+                setStyle(NotificationCompat.BigTextStyle().bigText(extNames))
+            }
+            setSmallIcon(R.drawable.ic_extension_24dp)
+            setColor(ContextCompat.getColor(context, R.color.ic_launcher))
+            setLargeIcon(BitmapFactory.decodeResource(context.resources, R.drawable.chimahon))
+            setContentIntent(NotificationReceiver.openExtensionsPendingActivity(context))
+            setAutoCancel(true)
+        }
+    }
+
+    fun dismiss() {
+        context.cancelNotification(Notifications.ID_UPDATES_TO_ANIME_EXTS)
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeExtension.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeExtension.kt
new file mode 100644
index 0000000000..754fa1d72d
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeExtension.kt
@@ -0,0 +1,77 @@
+package eu.kanade.tachiyomi.animeextension.model
+
+import android.graphics.drawable.Drawable
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import tachiyomi.domain.animesource.model.StubAnimeSource
+
+sealed class AnimeExtension {
+
+    abstract val name: String
+    abstract val pkgName: String
+    abstract val versionName: String
+    abstract val versionCode: Long
+    abstract val libVersion: Double
+    abstract val lang: String?
+    abstract val isNsfw: Boolean
+    abstract val signatureHash: String
+
+    data class Installed(
+        override val name: String,
+        override val pkgName: String,
+        override val versionName: String,
+        override val versionCode: Long,
+        override val libVersion: Double,
+        override val lang: String,
+        override val isNsfw: Boolean,
+        override val signatureHash: String,
+        val pkgFactory: String?,
+        val sources: List<AnimeSource>,
+        val icon: Drawable?,
+        val hasUpdate: Boolean = false,
+        val isObsolete: Boolean = false,
+        val isShared: Boolean,
+        val repoUrl: String? = null,
+    ) : AnimeExtension()
+
+    data class Available(
+        override val name: String,
+        override val pkgName: String,
+        override val versionName: String,
+        override val versionCode: Long,
+        override val libVersion: Double,
+        override val lang: String,
+        override val isNsfw: Boolean,
+        override val signatureHash: String,
+        val sources: List<Source>,
+        val apkName: String,
+        val iconUrl: String,
+        val repoUrl: String,
+    ) : AnimeExtension() {
+
+        data class Source(
+            val id: Long,
+            val lang: String,
+            val name: String,
+            val baseUrl: String,
+        ) {
+            fun toStubAnimeSource(): StubAnimeSource {
+                return StubAnimeSource(
+                    id = this.id,
+                    lang = this.lang,
+                    name = this.name,
+                )
+            }
+        }
+    }
+
+    data class Untrusted(
+        override val name: String,
+        override val pkgName: String,
+        override val versionName: String,
+        override val versionCode: Long,
+        override val libVersion: Double,
+        override val signatureHash: String,
+        override val lang: String? = null,
+        override val isNsfw: Boolean = false,
+    ) : AnimeExtension()
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeLoadResult.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeLoadResult.kt
new file mode 100644
index 0000000000..d2bcf47d41
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeLoadResult.kt
@@ -0,0 +1,7 @@
+package eu.kanade.tachiyomi.animeextension.model
+
+sealed interface AnimeLoadResult {
+    data class Success(val extension: AnimeExtension.Installed) : AnimeLoadResult
+    data class Untrusted(val extension: AnimeExtension.Untrusted) : AnimeLoadResult
+    data object Error : AnimeLoadResult
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionInstallReceiver.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionInstallReceiver.kt
new file mode 100644
index 0000000000..21ba0cc44d
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionInstallReceiver.kt
@@ -0,0 +1,120 @@
+package eu.kanade.tachiyomi.animeextension.util
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import androidx.core.content.ContextCompat
+import androidx.core.net.toUri
+import eu.kanade.tachiyomi.BuildConfig
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animeextension.model.AnimeLoadResult
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+
+internal class AnimeExtensionInstallReceiver(private val listener: Listener) : BroadcastReceiver() {
+
+    val scope = CoroutineScope(SupervisorJob())
+
+    fun register(context: Context) {
+        ContextCompat.registerReceiver(context, this, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
+    }
+
+    private val filter = IntentFilter().apply {
+        addAction(Intent.ACTION_PACKAGE_ADDED)
+        addAction(Intent.ACTION_PACKAGE_REPLACED)
+        addAction(Intent.ACTION_PACKAGE_REMOVED)
+        addAction(ACTION_ANIME_EXTENSION_ADDED)
+        addAction(ACTION_ANIME_EXTENSION_REPLACED)
+        addAction(ACTION_ANIME_EXTENSION_REMOVED)
+        addDataScheme("package")
+    }
+
+    override fun onReceive(context: Context, intent: Intent?) {
+        if (intent == null) return
+
+        when (intent.action) {
+            Intent.ACTION_PACKAGE_ADDED, ACTION_ANIME_EXTENSION_ADDED -> {
+                if (isReplacing(intent)) return
+
+                scope.launch {
+                    when (val result = getExtensionFromIntent(context, intent)) {
+                        is AnimeLoadResult.Success -> listener.onExtensionInstalled(result.extension)
+                        is AnimeLoadResult.Untrusted -> listener.onExtensionUntrusted(result.extension)
+                        else -> {}
+                    }
+                }
+            }
+            Intent.ACTION_PACKAGE_REPLACED, ACTION_ANIME_EXTENSION_REPLACED -> {
+                scope.launch {
+                    when (val result = getExtensionFromIntent(context, intent)) {
+                        is AnimeLoadResult.Success -> listener.onExtensionUpdated(result.extension)
+                        is AnimeLoadResult.Untrusted -> listener.onExtensionUntrusted(result.extension)
+                        else -> {}
+                    }
+                }
+            }
+            Intent.ACTION_PACKAGE_REMOVED, ACTION_ANIME_EXTENSION_REMOVED -> {
+                if (isReplacing(intent)) return
+
+                val pkgName = getPackageNameFromIntent(intent)
+                if (pkgName != null) {
+                    listener.onPackageUninstalled(pkgName)
+                }
+            }
+        }
+    }
+
+    private fun isReplacing(intent: Intent): Boolean {
+        return intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)
+    }
+
+    private suspend fun getExtensionFromIntent(context: Context, intent: Intent?): AnimeLoadResult {
+        val pkgName = getPackageNameFromIntent(intent)
+        if (pkgName == null) {
+            logcat(LogPriority.WARN) { "Anime extension package name not found" }
+            return AnimeLoadResult.Error
+        }
+        return AnimeExtensionLoader.loadExtensionFromPkgName(context, pkgName)
+    }
+
+    private fun getPackageNameFromIntent(intent: Intent?): String? {
+        return intent?.data?.encodedSchemeSpecificPart ?: return null
+    }
+
+    interface Listener {
+        fun onExtensionInstalled(extension: AnimeExtension.Installed)
+        fun onExtensionUpdated(extension: AnimeExtension.Installed)
+        fun onExtensionUntrusted(extension: AnimeExtension.Untrusted)
+        fun onPackageUninstalled(pkgName: String)
+    }
+
+    companion object {
+        private const val ACTION_ANIME_EXTENSION_ADDED = "${BuildConfig.APPLICATION_ID}.ACTION_ANIME_EXTENSION_ADDED"
+        private const val ACTION_ANIME_EXTENSION_REPLACED = "${BuildConfig.APPLICATION_ID}.ACTION_ANIME_EXTENSION_REPLACED"
+        private const val ACTION_ANIME_EXTENSION_REMOVED = "${BuildConfig.APPLICATION_ID}.ACTION_ANIME_EXTENSION_REMOVED"
+
+        fun notifyAdded(context: Context, pkgName: String) {
+            notify(context, pkgName, ACTION_ANIME_EXTENSION_ADDED)
+        }
+
+        fun notifyReplaced(context: Context, pkgName: String) {
+            notify(context, pkgName, ACTION_ANIME_EXTENSION_REPLACED)
+        }
+
+        fun notifyRemoved(context: Context, pkgName: String) {
+            notify(context, pkgName, ACTION_ANIME_EXTENSION_REMOVED)
+        }
+
+        private fun notify(context: Context, pkgName: String, action: String) {
+            Intent(action).apply {
+                data = "package:$pkgName".toUri()
+                `package` = context.packageName
+                context.sendBroadcast(this)
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionInstaller.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionInstaller.kt
new file mode 100644
index 0000000000..f676a6de43
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionInstaller.kt
@@ -0,0 +1,242 @@
+package eu.kanade.tachiyomi.animeextension.util
+
+import android.app.DownloadManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.Uri
+import android.os.Environment
+import androidx.core.content.ContextCompat
+import androidx.core.content.getSystemService
+import androidx.core.net.toUri
+import eu.kanade.domain.base.BasePreferences
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.extension.installer.Installer
+import eu.kanade.tachiyomi.extension.model.InstallStep
+import eu.kanade.tachiyomi.extension.util.ExtensionInstallActivity
+import eu.kanade.tachiyomi.extension.util.ExtensionInstallService
+import eu.kanade.tachiyomi.util.storage.getUriCompat
+import eu.kanade.tachiyomi.util.system.isPackageInstalled
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.mapNotNull
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.transformWhile
+import logcat.LogPriority
+import tachiyomi.core.common.util.lang.withUIContext
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.io.File
+import kotlin.time.Duration.Companion.seconds
+
+internal class AnimeExtensionInstaller(private val context: Context) {
+
+    private val downloadManager = context.getSystemService<DownloadManager>()!!
+
+    private val downloadReceiver = DownloadCompletionReceiver()
+
+    private val activeDownloads = hashMapOf<String, Long>()
+
+    private val downloadsStateFlows = hashMapOf<Long, MutableStateFlow<InstallStep>>()
+
+    private val extensionInstaller = Injekt.get<BasePreferences>().extensionInstaller()
+
+    fun downloadAndInstall(url: String, extension: AnimeExtension): Flow<InstallStep> {
+        val pkgName = extension.pkgName + ":${extension.signatureHash}"
+
+        val oldDownload = activeDownloads[pkgName]
+        if (oldDownload != null) {
+            deleteDownload(pkgName)
+        }
+
+        downloadReceiver.register()
+
+        val downloadUri = url.toUri()
+        val request = DownloadManager.Request(downloadUri)
+            .setTitle(extension.name)
+            .setMimeType(APK_MIME)
+            .setDestinationInExternalFilesDir(context, Environment.DIRECTORY_DOWNLOADS, downloadUri.lastPathSegment)
+            .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
+
+        val id = downloadManager.enqueue(request)
+        activeDownloads[pkgName] = id
+
+        val downloadStateFlow = MutableStateFlow(InstallStep.Pending)
+        downloadsStateFlows[id] = downloadStateFlow
+
+        val pollStatusFlow = downloadStatusFlow(id).mapNotNull { downloadStatus ->
+            when (downloadStatus) {
+                DownloadManager.STATUS_PENDING -> InstallStep.Pending
+                DownloadManager.STATUS_RUNNING -> InstallStep.Downloading
+                else -> null
+            }
+        }
+
+        return merge(downloadStateFlow, pollStatusFlow).transformWhile {
+            emit(it)
+            !it.isCompleted()
+        }.onCompletion {
+            withUIContext {
+                deleteDownload(pkgName)
+            }
+        }
+    }
+
+    private fun downloadStatusFlow(id: Long): Flow<Int> = flow {
+        val query = DownloadManager.Query().setFilterById(id)
+        while (true) {
+            val downloadStatus = downloadManager.query(query).use { cursor ->
+                if (!cursor.moveToFirst()) return@flow
+                cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS))
+            }
+
+            emit(downloadStatus)
+
+            if (
+                downloadStatus == DownloadManager.STATUS_SUCCESSFUL ||
+                downloadStatus == DownloadManager.STATUS_FAILED
+            ) {
+                return@flow
+            }
+
+            delay(1.seconds)
+        }
+    }
+        .distinctUntilChanged()
+
+    fun installApk(downloadId: Long, uri: Uri) {
+        when (val installer = extensionInstaller.get()) {
+            BasePreferences.ExtensionInstaller.LEGACY -> {
+                val intent = Intent(context, ExtensionInstallActivity::class.java)
+                    .setDataAndType(uri, APK_MIME)
+                    .putExtra(EXTRA_DOWNLOAD_ID, downloadId)
+                    .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_GRANT_READ_URI_PERMISSION)
+
+                context.startActivity(intent)
+            }
+            BasePreferences.ExtensionInstaller.PRIVATE -> {
+                val animeExtensionManager = Injekt.get<AnimeExtensionManager>()
+                val tempFile = File(context.cacheDir, "anime_temp_$downloadId")
+
+                if (tempFile.exists() && !tempFile.delete()) {
+                    animeExtensionManager.updateInstallStep(downloadId, InstallStep.Error)
+                    return
+                }
+
+                try {
+                    context.contentResolver.openInputStream(uri)?.use { input ->
+                        tempFile.outputStream().use { output ->
+                            input.copyTo(output)
+                        }
+                    }
+
+                    if (AnimeExtensionLoader.installPrivateExtensionFile(context, tempFile)) {
+                        animeExtensionManager.updateInstallStep(downloadId, InstallStep.Installed)
+                    } else {
+                        animeExtensionManager.updateInstallStep(downloadId, InstallStep.Error)
+                    }
+                } catch (e: Exception) {
+                    logcat(LogPriority.ERROR, e) { "Failed to read downloaded anime extension file." }
+                    animeExtensionManager.updateInstallStep(downloadId, InstallStep.Error)
+                }
+
+                tempFile.delete()
+            }
+            else -> {
+                val intent = ExtensionInstallService.getIntent(context, downloadId, uri, installer)
+                ContextCompat.startForegroundService(context, intent)
+            }
+        }
+    }
+
+    fun cancelInstall(pkgName: String) {
+        val downloadId = activeDownloads.remove(pkgName) ?: return
+        downloadManager.remove(downloadId)
+        Installer.cancelInstallQueue(context, downloadId)
+    }
+
+    fun uninstallApk(pkgName: String) {
+        if (context.isPackageInstalled(pkgName)) {
+            @Suppress("DEPRECATION")
+            val intent = Intent(Intent.ACTION_UNINSTALL_PACKAGE, "package:$pkgName".toUri())
+                .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            context.startActivity(intent)
+        } else {
+            AnimeExtensionLoader.uninstallPrivateExtension(context, pkgName)
+            AnimeExtensionInstallReceiver.notifyRemoved(context, pkgName)
+        }
+    }
+
+    fun updateInstallStep(downloadId: Long, step: InstallStep) {
+        downloadsStateFlows[downloadId]?.let { it.value = step }
+    }
+
+    private fun deleteDownload(pkgName: String) {
+        val downloadId = activeDownloads.remove(pkgName)
+        if (downloadId != null) {
+            downloadManager.remove(downloadId)
+            downloadsStateFlows.remove(downloadId)
+        }
+        if (activeDownloads.isEmpty()) {
+            downloadReceiver.unregister()
+        }
+    }
+
+    private inner class DownloadCompletionReceiver : BroadcastReceiver() {
+
+        private var isRegistered = false
+
+        fun register() {
+            if (isRegistered) return
+            isRegistered = true
+
+            val filter = IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE)
+            ContextCompat.registerReceiver(context, this, filter, ContextCompat.RECEIVER_EXPORTED)
+        }
+
+        fun unregister() {
+            if (!isRegistered) return
+            isRegistered = false
+
+            context.unregisterReceiver(this)
+        }
+
+        override fun onReceive(context: Context, intent: Intent?) {
+            val id = intent?.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, 0) ?: return
+
+            if (id !in activeDownloads.values) return
+
+            val uri = downloadManager.getUriForDownloadedFile(id)
+
+            if (uri == null) {
+                logcat(LogPriority.ERROR) { "Couldn't locate downloaded anime extension APK" }
+                updateInstallStep(id, InstallStep.Error)
+                return
+            }
+
+            val query = DownloadManager.Query().setFilterById(id)
+            downloadManager.query(query).use { cursor ->
+                if (cursor.moveToFirst()) {
+                    val localUri = cursor.getString(
+                        cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_LOCAL_URI),
+                    ).removePrefix(FILE_SCHEME)
+
+                    installApk(id, File(localUri).getUriCompat(context))
+                }
+            }
+        }
+    }
+
+    companion object {
+        const val APK_MIME = "application/vnd.android.package-archive"
+        const val EXTRA_DOWNLOAD_ID = "AnimeExtensionInstaller.extra.DOWNLOAD_ID"
+        const val FILE_SCHEME = "file://"
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionLoader.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionLoader.kt
new file mode 100644
index 0000000000..417b49b08b
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionLoader.kt
@@ -0,0 +1,346 @@
+package eu.kanade.tachiyomi.animeextension.util
+
+import android.content.Context
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.pm.PackageInfoCompat
+import eu.kanade.domain.extension.interactor.TrustExtension
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animeextension.model.AnimeLoadResult
+import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.animesource.AnimeSourceFactory
+import eu.kanade.tachiyomi.util.lang.Hash
+import eu.kanade.tachiyomi.util.storage.copyAndSetReadOnlyTo
+import eu.kanade.tachiyomi.util.system.ChildFirstPathClassLoader
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.runBlocking
+import logcat.LogPriority
+import mihon.domain.animeextensionrepo.interactor.GetAnimeExtensionRepo
+import mihon.domain.extensionrepo.model.ExtensionRepo
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.injectLazy
+import java.io.File
+
+internal object AnimeExtensionLoader {
+
+    private val preferences: SourcePreferences by injectLazy()
+    private val trustExtension: TrustExtension by injectLazy()
+    private val getAnimeExtensionRepo: GetAnimeExtensionRepo by injectLazy()
+
+    private val loadNsfwSource by lazy {
+        preferences.showNsfwSource().get()
+    }
+
+    private const val EXTENSION_FEATURE = "tachiyomi.animeextension"
+    private const val METADATA_SOURCE_CLASS = "tachiyomi.animeextension.class"
+    private const val METADATA_SOURCE_FACTORY = "tachiyomi.animeextension.factory"
+    private const val METADATA_NSFW = "tachiyomi.animeextension.nsfw"
+    const val LIB_VERSION_MIN = 14.0
+    const val LIB_VERSION_MAX = 15.0
+
+    @Suppress("DEPRECATION")
+    private val PACKAGE_FLAGS = PackageManager.GET_CONFIGURATIONS or
+        PackageManager.GET_META_DATA or
+        PackageManager.GET_SIGNATURES or
+        (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) PackageManager.GET_SIGNING_CERTIFICATES else 0)
+
+    private const val PRIVATE_EXTENSION_EXTENSION = "ext"
+
+    private fun getPrivateExtensionDir(context: Context) = File(context.filesDir, "anime_exts")
+
+    fun installPrivateExtensionFile(context: Context, file: File): Boolean {
+        val extension = context.packageManager.getPackageArchiveInfo(file.absolutePath, PACKAGE_FLAGS)
+            ?.takeIf { isPackageAnExtension(it) } ?: return false
+        val currentExtension = getExtensionPackageInfoFromPkgName(context, extension.packageName)
+
+        if (currentExtension != null) {
+            if (PackageInfoCompat.getLongVersionCode(extension) <
+                PackageInfoCompat.getLongVersionCode(currentExtension)
+            ) {
+                logcat(LogPriority.ERROR) { "Installed anime extension version is higher. Downgrading is not allowed." }
+                return false
+            }
+
+            val extensionSignatures = getSignatures(extension)
+            if (extensionSignatures.isNullOrEmpty()) {
+                logcat(LogPriority.ERROR) { "Anime extension to be installed is not signed." }
+                return false
+            }
+
+            if (!extensionSignatures.containsAll(getSignatures(currentExtension)!!)) {
+                logcat(LogPriority.ERROR) { "Installed anime extension signature is not matched." }
+                return false
+            }
+        }
+
+        val target = File(getPrivateExtensionDir(context), "${extension.packageName}.$PRIVATE_EXTENSION_EXTENSION")
+        return try {
+            target.delete()
+            file.copyAndSetReadOnlyTo(target, overwrite = true)
+            if (currentExtension != null) {
+                AnimeExtensionInstallReceiver.notifyReplaced(context, extension.packageName)
+            } else {
+                AnimeExtensionInstallReceiver.notifyAdded(context, extension.packageName)
+            }
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Failed to copy anime extension file." }
+            target.delete()
+            false
+        }
+    }
+
+    fun uninstallPrivateExtension(context: Context, pkgName: String) {
+        File(getPrivateExtensionDir(context), "$pkgName.$PRIVATE_EXTENSION_EXTENSION").delete()
+    }
+
+    fun loadExtensions(context: Context): List<AnimeLoadResult> {
+        val pkgManager = context.packageManager
+
+        val installedPkgs = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            pkgManager.getInstalledPackages(PackageManager.PackageInfoFlags.of(PACKAGE_FLAGS.toLong()))
+        } else {
+            pkgManager.getInstalledPackages(PACKAGE_FLAGS)
+        }
+
+        val sharedExtPkgs = installedPkgs
+            .asSequence()
+            .filter { isPackageAnExtension(it) }
+            .map { ExtensionInfo(packageInfo = it, isShared = true) }
+
+        val privateExtPkgs = getPrivateExtensionDir(context)
+            .listFiles()
+            ?.filter { it.isFile && it.extension == PRIVATE_EXTENSION_EXTENSION }
+            ?.mapNotNull {
+                if (it.canWrite()) {
+                    it.setReadOnly()
+                }
+
+                val path = it.absolutePath
+                pkgManager.getPackageArchiveInfo(path, PACKAGE_FLAGS)
+                    ?.apply { applicationInfo!!.fixBasePaths(path) }
+            }
+            ?.filter { isPackageAnExtension(it) }
+            ?.map { ExtensionInfo(packageInfo = it, isShared = false) }
+            .orEmpty()
+
+        val extPkgs = (sharedExtPkgs + privateExtPkgs)
+            .distinctBy { it.packageInfo.packageName }
+            .mapNotNull { sharedPkg ->
+                val privatePkg = privateExtPkgs
+                    .singleOrNull { it.packageInfo.packageName == sharedPkg.packageInfo.packageName }
+                selectExtensionPackage(sharedPkg, privatePkg)
+            }
+            .toList()
+
+        if (extPkgs.isEmpty()) return emptyList()
+
+        return runBlocking {
+            val extRepos = getAnimeExtensionRepo.getAll()
+            val deferred = extPkgs.map {
+                async { loadExtension(context, it, extRepos) }
+            }
+            deferred.awaitAll()
+        }
+    }
+
+    suspend fun loadExtensionFromPkgName(context: Context, pkgName: String): AnimeLoadResult {
+        val extensionPackage = getExtensionInfoFromPkgName(context, pkgName)
+        if (extensionPackage == null) {
+            logcat(LogPriority.ERROR) { "Anime extension package is not found ($pkgName)" }
+            return AnimeLoadResult.Error
+        }
+        return loadExtension(context, extensionPackage)
+    }
+
+    fun getExtensionPackageInfoFromPkgName(context: Context, pkgName: String): PackageInfo? {
+        return getExtensionInfoFromPkgName(context, pkgName)?.packageInfo
+    }
+
+    private fun getExtensionInfoFromPkgName(context: Context, pkgName: String): ExtensionInfo? {
+        val privateExtensionFile = File(getPrivateExtensionDir(context), "$pkgName.$PRIVATE_EXTENSION_EXTENSION")
+        val privatePkg = if (privateExtensionFile.isFile) {
+            context.packageManager.getPackageArchiveInfo(privateExtensionFile.absolutePath, PACKAGE_FLAGS)
+                ?.takeIf { isPackageAnExtension(it) }
+                ?.let {
+                    it.applicationInfo!!.fixBasePaths(privateExtensionFile.absolutePath)
+                    ExtensionInfo(packageInfo = it, isShared = false)
+                }
+        } else {
+            null
+        }
+
+        val sharedPkg = try {
+            context.packageManager.getPackageInfo(pkgName, PACKAGE_FLAGS)
+                .takeIf { isPackageAnExtension(it) }
+                ?.let { ExtensionInfo(packageInfo = it, isShared = true) }
+        } catch (error: PackageManager.NameNotFoundException) {
+            null
+        }
+
+        return selectExtensionPackage(sharedPkg, privatePkg)
+    }
+
+    private suspend fun loadExtension(
+        context: Context,
+        extensionInfo: ExtensionInfo,
+        extRepos: List<ExtensionRepo>? = null,
+    ): AnimeLoadResult {
+        val repos = extRepos ?: getAnimeExtensionRepo.getAll()
+        val pkgManager = context.packageManager
+        val pkgInfo = extensionInfo.packageInfo
+        val appInfo = pkgInfo.applicationInfo!!
+        val pkgName = pkgInfo.packageName
+
+        val extName = pkgManager.getApplicationLabel(appInfo).toString().substringAfter("Tachiyomi: ")
+        val versionName = pkgInfo.versionName
+        val versionCode = PackageInfoCompat.getLongVersionCode(pkgInfo)
+
+        if (versionName.isNullOrEmpty()) {
+            logcat(LogPriority.WARN) { "Missing versionName for anime extension $extName" }
+            return AnimeLoadResult.Error
+        }
+
+        val libVersion = versionName.substringBeforeLast('.').toDoubleOrNull()
+        if (libVersion == null || libVersion < LIB_VERSION_MIN || libVersion > LIB_VERSION_MAX) {
+            logcat(LogPriority.WARN) {
+                "Anime lib version is $libVersion, while only versions " +
+                    "$LIB_VERSION_MIN to $LIB_VERSION_MAX are allowed"
+            }
+            return AnimeLoadResult.Error
+        }
+
+        val signatures = getSignatures(pkgInfo)
+        if (signatures.isNullOrEmpty()) {
+            logcat(LogPriority.WARN) { "Package $pkgName isn't signed" }
+            return AnimeLoadResult.Error
+        } else if (!trustExtension.isTrusted(pkgInfo, signatures)) {
+            val extension = AnimeExtension.Untrusted(
+                extName,
+                pkgName,
+                versionName,
+                versionCode,
+                libVersion,
+                signatures.last(),
+            )
+            logcat(LogPriority.WARN) { "Anime extension $pkgName isn't trusted" }
+            return AnimeLoadResult.Untrusted(extension)
+        }
+
+        val isNsfw = appInfo.metaData.getInt(METADATA_NSFW) == 1
+        if (!loadNsfwSource && isNsfw) {
+            logcat(LogPriority.WARN) { "NSFW anime extension $pkgName not allowed" }
+            return AnimeLoadResult.Error
+        }
+
+        val classLoader = try {
+            ChildFirstPathClassLoader(appInfo.sourceDir, null, context.classLoader)
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Anime extension load error: $extName ($pkgName)" }
+            return AnimeLoadResult.Error
+        }
+
+        val sources = appInfo.metaData.getString(METADATA_SOURCE_CLASS)!!
+            .split(";")
+            .map {
+                val sourceClass = it.trim()
+                if (sourceClass.startsWith(".")) {
+                    pkgInfo.packageName + sourceClass
+                } else {
+                    sourceClass
+                }
+            }
+            .flatMap {
+                try {
+                    when (val obj = Class.forName(it, false, classLoader).getDeclaredConstructor().newInstance()) {
+                        is AnimeSource -> listOf(obj)
+                        is AnimeSourceFactory -> obj.createSources()
+                        else -> throw Exception("Unknown anime source class type: ${obj.javaClass}")
+                    }
+                } catch (e: Throwable) {
+                    logcat(LogPriority.ERROR, e) { "Anime extension load error: $extName ($it)" }
+                    return AnimeLoadResult.Error
+                }
+            }
+
+        val langs = sources.filterIsInstance<AnimeCatalogueSource>()
+            .map { it.lang }
+            .toSet()
+        val lang = when (langs.size) {
+            0 -> ""
+            1 -> langs.first()
+            else -> "all"
+        }
+
+        val extension = AnimeExtension.Installed(
+            name = extName,
+            pkgName = pkgName,
+            versionName = versionName,
+            versionCode = versionCode,
+            libVersion = libVersion,
+            lang = lang,
+            isNsfw = isNsfw,
+            sources = sources,
+            pkgFactory = appInfo.metaData.getString(METADATA_SOURCE_FACTORY),
+            icon = appInfo.loadIcon(pkgManager),
+            isShared = extensionInfo.isShared,
+            signatureHash = signatures.last(),
+        )
+        return AnimeLoadResult.Success(extension)
+    }
+
+    private fun selectExtensionPackage(shared: ExtensionInfo?, private: ExtensionInfo?): ExtensionInfo? {
+        when {
+            private == null && shared != null -> return shared
+            shared == null && private != null -> return private
+            shared == null && private == null -> return null
+        }
+
+        return if (PackageInfoCompat.getLongVersionCode(shared!!.packageInfo) >=
+            PackageInfoCompat.getLongVersionCode(private!!.packageInfo)
+        ) {
+            shared
+        } else {
+            private
+        }
+    }
+
+    private fun isPackageAnExtension(pkgInfo: PackageInfo): Boolean {
+        return pkgInfo.reqFeatures.orEmpty().any { it.name == EXTENSION_FEATURE }
+    }
+
+    private fun getSignatures(pkgInfo: PackageInfo): List<String>? {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            val signingInfo = pkgInfo.signingInfo!!
+            if (signingInfo.hasMultipleSigners()) {
+                signingInfo.apkContentsSigners
+            } else {
+                signingInfo.signingCertificateHistory
+            }
+        } else {
+            @Suppress("DEPRECATION")
+            pkgInfo.signatures
+        }
+            ?.map { Hash.sha256(it.toByteArray()) }
+            ?.toList()
+    }
+
+    private fun ApplicationInfo.fixBasePaths(apkPath: String) {
+        if (sourceDir == null) {
+            sourceDir = apkPath
+        }
+        if (publicSourceDir == null) {
+            publicSourceDir = apkPath
+        }
+    }
+
+    private data class ExtensionInfo(
+        val packageInfo: PackageInfo,
+        val isShared: Boolean,
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animesource/AndroidAnimeSourceManager.kt b/app/src/main/java/eu/kanade/tachiyomi/animesource/AndroidAnimeSourceManager.kt
new file mode 100644
index 0000000000..ac47200662
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/animesource/AndroidAnimeSourceManager.kt
@@ -0,0 +1,103 @@
+package eu.kanade.tachiyomi.animesource
+
+import android.content.Context
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import tachiyomi.domain.animesource.model.StubAnimeSource
+import tachiyomi.domain.animesource.repository.StubAnimeSourceRepository
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+
+class AndroidAnimeSourceManager(
+    private val context: Context,
+    private val animeExtensionManager: AnimeExtensionManager,
+    private val animeSourceRepository: StubAnimeSourceRepository,
+) : AnimeSourceManager {
+
+    private val _isInitialized = MutableStateFlow(false)
+    override val isInitialized: StateFlow<Boolean> = _isInitialized.asStateFlow()
+
+    private val scope = CoroutineScope(Job() + Dispatchers.IO)
+
+    private val sourcesMapFlow = MutableStateFlow(HashMap<Long, eu.kanade.tachiyomi.animesource.AnimeSource>())
+
+    private val stubSourcesMap = HashMap<Long, StubAnimeSource>()
+
+    override val catalogueSources: Flow<List<AnimeCatalogueSource>> = sourcesMapFlow.map {
+        it.values.filterIsInstance<AnimeCatalogueSource>()
+    }
+
+    init {
+        scope.launch {
+            animeExtensionManager.installedExtensionsFlow
+                .collectLatest { extensions ->
+                    val mutableMap = HashMap<Long, eu.kanade.tachiyomi.animesource.AnimeSource>()
+                    extensions.forEach { extension ->
+                        extension.sources.forEach { source ->
+                            mutableMap[source.id] = source
+                            registerStubSource(StubAnimeSource.from(source))
+                        }
+                    }
+                    sourcesMapFlow.value = mutableMap
+                    _isInitialized.value = true
+                }
+        }
+
+        scope.launch {
+            animeSourceRepository.subscribeAll()
+                .collectLatest { sources ->
+                    sources.forEach {
+                        stubSourcesMap[it.id] = it
+                    }
+                }
+        }
+    }
+
+    override fun get(sourceKey: Long): eu.kanade.tachiyomi.animesource.AnimeSource? {
+        return sourcesMapFlow.value[sourceKey]
+    }
+
+    override fun getOrStub(sourceKey: Long): eu.kanade.tachiyomi.animesource.AnimeSource {
+        return sourcesMapFlow.value[sourceKey] ?: stubSourcesMap.getOrPut(sourceKey) {
+            runBlocking { createStubSource(sourceKey) }
+        }
+    }
+
+    override fun getOnlineSources() = sourcesMapFlow.value.values.filterIsInstance<AnimeHttpSource>()
+
+    override fun getCatalogueSources() = sourcesMapFlow.value.values.filterIsInstance<AnimeCatalogueSource>()
+
+    override fun getStubSources(): List<StubAnimeSource> {
+        val onlineSourceIds = getOnlineSources().map { it.id }
+        return stubSourcesMap.values.filterNot { it.id in onlineSourceIds }
+    }
+
+    private fun registerStubSource(source: StubAnimeSource) {
+        scope.launch {
+            val dbSource = animeSourceRepository.getStubSource(source.id)
+            if (dbSource == source) return@launch
+            animeSourceRepository.upsertStubSource(source.id, source.lang, source.name)
+        }
+    }
+
+    private suspend fun createStubSource(id: Long): StubAnimeSource {
+        animeSourceRepository.getStubSource(id)?.let {
+            return it
+        }
+        animeExtensionManager.getSourceData(id)?.let {
+            registerStubSource(it)
+            return it
+        }
+        return StubAnimeSource(id = id, lang = "", name = "")
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt b/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
index ddb5530f2d..9e96e10a30 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
@@ -102,6 +102,9 @@ object Notifications {
     const val ID_UPDATES_TO_EXTS = -401
     const val ID_EXTENSION_INSTALLER = -402
 
+    const val CHANNEL_ANIME_EXTENSIONS_UPDATE = "anime_ext_apk_update_channel"
+    const val ID_UPDATES_TO_ANIME_EXTS = -904
+
     private val deprecatedChannels = listOf(
         "downloader_channel",
         "downloader_complete_channel",
@@ -198,6 +201,10 @@ object Notifications {
                     setGroup(GROUP_APK_UPDATES)
                     setName(context.stringResource(MR.strings.channel_ext_updates))
                 },
+                buildNotificationChannel(CHANNEL_ANIME_EXTENSIONS_UPDATE, IMPORTANCE_DEFAULT) {
+                    setGroup(GROUP_APK_UPDATES)
+                    setName(context.stringResource(MR.strings.channel_anime_ext_updates))
+                },
                 // AM (DISCORD) -->
                 buildNotificationChannel(CHANNEL_DISCORD_RPC, IMPORTANCE_LOW) {
                     setName(context.getString(R.string.pref_discord_rpc))
diff --git a/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt b/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
index 523a156233..f35bd3cf65 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
@@ -32,6 +32,8 @@ import eu.kanade.tachiyomi.data.saver.ImageSaver
 import eu.kanade.tachiyomi.data.sync.service.GoogleDriveService
 import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.extension.ExtensionManager
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.animesource.AndroidAnimeSourceManager
 import eu.kanade.tachiyomi.network.JavaScriptEngine
 import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.source.AndroidSourceManager
@@ -57,6 +59,7 @@ import tachiyomi.data.History
 import tachiyomi.data.Mangas
 import tachiyomi.data.StringListColumnAdapter
 import tachiyomi.data.UpdateStrategyColumnAdapter
+import tachiyomi.domain.animesource.service.AnimeSourceManager
 import tachiyomi.domain.manga.interactor.GetCustomMangaInfo
 import tachiyomi.domain.source.service.SourceManager
 import tachiyomi.domain.storage.service.StorageManager
@@ -174,6 +177,8 @@ class AppModule(val app: Application) : InjektModule {
 
         addSingletonFactory<SourceManager> { AndroidSourceManager(app, get(), get()) }
         addSingletonFactory { ExtensionManager(app) }
+        addSingletonFactory { AnimeExtensionManager(app) }
+        addSingletonFactory<AnimeSourceManager> { AndroidAnimeSourceManager(app, get(), get()) }
 
         addSingletonFactory { DownloadProvider(app) }
         addSingletonFactory { DownloadManager(app) }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
index 59fad622ad..1faa0c262a 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
@@ -3,22 +3,28 @@ package eu.kanade.tachiyomi.ui.anime
 import androidx.compose.runtime.Immutable
 import cafe.adriel.voyager.core.model.StateScreenModel
 import cafe.adriel.voyager.core.model.screenModelScope
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.update
+import logcat.LogPriority
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.core.common.util.lang.launchNonCancellable
+import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.anime.interactor.GetAnime
 import tachiyomi.domain.anime.interactor.SetAnimeEpisodeFlags
 import tachiyomi.domain.anime.interactor.UpdateAnime
 import tachiyomi.domain.anime.model.Anime
 import tachiyomi.domain.anime.model.AnimeUpdate
 import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.animesource.service.AnimeSourceManager
 import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
 import tachiyomi.domain.episode.interactor.SetSeenStatus
 import tachiyomi.domain.episode.interactor.UpdateEpisode
 import tachiyomi.domain.episode.model.Episode
 import tachiyomi.domain.episode.model.EpisodeUpdate
+import tachiyomi.domain.episode.repository.EpisodeRepository
 import tachiyomi.domain.manga.model.applyFilter
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
@@ -32,9 +38,15 @@ class AnimeScreenModel(
     private val setSeenStatus: SetSeenStatus = Injekt.get(),
     private val setAnimeEpisodeFlags: SetAnimeEpisodeFlags = Injekt.get(),
     private val animeRepository: AnimeRepository = Injekt.get(),
+    private val episodeRepository: EpisodeRepository = Injekt.get(),
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
 ) : StateScreenModel<AnimeScreenModel.State>(State.Loading) {
 
     init {
+        screenModelScope.launchIO {
+            fetchEpisodesFromSourceIfNeeded()
+        }
+
         screenModelScope.launchIO {
             combine(
                 getAnime.subscribe(animeId),
@@ -57,6 +69,51 @@ class AnimeScreenModel(
         }
     }
 
+    private suspend fun fetchEpisodesFromSourceIfNeeded() {
+        val dbEpisodes = getEpisodesByAnimeId.await(animeId)
+        if (dbEpisodes.isNotEmpty()) return
+        syncEpisodesFromSource()
+    }
+
+    private suspend fun syncEpisodesFromSource() {
+        val anime = getAnime.await(animeId) ?: return
+        val source = animeSourceManager.get(anime.source) ?: return
+
+        try {
+            val sAnime = SAnime.create().apply {
+                url = anime.url
+                title = anime.title
+            }
+            val sourceEpisodes = source.getEpisodeList(sAnime)
+            val existingEpisodes = getEpisodesByAnimeId.await(animeId)
+            val existingUrls = existingEpisodes.map { it.url }.toSet()
+
+            val newEpisodes = sourceEpisodes
+                .filter { it.url !in existingUrls }
+                .mapIndexed { index, sEpisode ->
+                    episodeFromSource(animeId, sEpisode, (existingEpisodes.size + index).toLong())
+                }
+            if (newEpisodes.isNotEmpty()) {
+                episodeRepository.addAll(newEpisodes)
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Failed to fetch episodes from source" }
+        }
+    }
+
+    private fun episodeFromSource(animeId: Long, sEpisode: SEpisode, sourceOrder: Long): Episode {
+        return Episode.create().copy(
+            animeId = animeId,
+            url = sEpisode.url,
+            name = sEpisode.name,
+            dateUpload = sEpisode.date_upload,
+            episodeNumber = sEpisode.episode_number.toDouble(),
+            scanlator = sEpisode.scanlator,
+            sourceOrder = sourceOrder,
+            dateFetch = System.currentTimeMillis(),
+        )
+    }
+
     private fun applySort(anime: Anime, episodes: List<Episode>): List<Episode> {
         val comparator: Comparator<Episode> = when (anime.sorting) {
             Anime.EPISODE_SORTING_NUMBER -> compareBy { it.episodeNumber }
@@ -78,6 +135,12 @@ class AnimeScreenModel(
         }
     }
 
+    fun refreshEpisodes() {
+        screenModelScope.launchIO {
+            syncEpisodesFromSource()
+        }
+    }
+
     fun toggleFavorite() {
         screenModelScope.launchNonCancellable {
             val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
index 6f5f827d7c..0dfe06e4a3 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
@@ -22,6 +22,9 @@ import eu.kanade.presentation.util.Tab
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.connections.discord.DiscordRPCService
 import eu.kanade.tachiyomi.data.connections.discord.DiscordScreen
+import eu.kanade.tachiyomi.ui.browse.animeextension.AnimeExtensionsScreenModel
+import eu.kanade.tachiyomi.ui.browse.animeextension.animeExtensionsTab
+import eu.kanade.tachiyomi.ui.browse.animesource.animeSourcesTab
 import eu.kanade.tachiyomi.ui.browse.extension.ExtensionsScreenModel
 import eu.kanade.tachiyomi.ui.browse.extension.extensionsTab
 import eu.kanade.tachiyomi.ui.browse.feed.FeedScreenModel
@@ -79,6 +82,9 @@ data object BrowseTab : Tab {
         val extensionsScreenModel = rememberScreenModel { ExtensionsScreenModel() }
         val extensionsState by extensionsScreenModel.state.collectAsState()
 
+        val animeExtensionsScreenModel = rememberScreenModel { AnimeExtensionsScreenModel() }
+        val animeExtensionsState by animeExtensionsScreenModel.state.collectAsState()
+
         // KMK -->
         val feedScreenModel = rememberScreenModel { FeedScreenModel() }
         val bulkFavoriteScreenModel = rememberScreenModel { BulkFavoriteScreenModel() }
@@ -90,6 +96,8 @@ data object BrowseTab : Tab {
                 persistentListOf(
                     sourcesTab(),
                     extensionsTab(extensionsScreenModel),
+                    animeSourcesTab(),
+                    animeExtensionsTab(animeExtensionsScreenModel),
                     migrateSourceTab(),
                 )
 
@@ -103,6 +111,8 @@ data object BrowseTab : Tab {
                     ),
                     sourcesTab(),
                     extensionsTab(extensionsScreenModel),
+                    animeSourcesTab(),
+                    animeExtensionsTab(animeExtensionsScreenModel),
                     migrateSourceTab(),
                 )
 
@@ -116,6 +126,8 @@ data object BrowseTab : Tab {
                         // KMK <--
                     ),
                     extensionsTab(extensionsScreenModel),
+                    animeSourcesTab(),
+                    animeExtensionsTab(animeExtensionsScreenModel),
                     migrateSourceTab(),
                 )
         }
@@ -123,12 +135,23 @@ data object BrowseTab : Tab {
 
         val state = rememberPagerState { tabs.size }
 
+        val currentTabTitleRes = tabs.getOrNull(state.currentPage)?.titleRes
+        val searchQuery = when (currentTabTitleRes) {
+            MR.strings.label_anime_extensions -> animeExtensionsState.searchQuery
+            MR.strings.label_extensions -> extensionsState.searchQuery
+            else -> null
+        }
+        val onChangeSearchQuery: (String?) -> Unit = when (currentTabTitleRes) {
+            MR.strings.label_anime_extensions -> animeExtensionsScreenModel::search
+            MR.strings.label_extensions -> extensionsScreenModel::search
+            else -> {}
+        }
         TabbedScreen(
             titleRes = MR.strings.browse,
             tabs = tabs,
             state = state,
-            searchQuery = extensionsState.searchQuery,
-            onChangeSearchQuery = extensionsScreenModel::search,
+            searchQuery = searchQuery,
+            onChangeSearchQuery = onChangeSearchQuery,
             // KMK -->
             feedScreenModel = feedScreenModel,
             bulkFavoriteScreenModel = bulkFavoriteScreenModel,
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsScreenModel.kt
new file mode 100644
index 0000000000..8afd3c5c49
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsScreenModel.kt
@@ -0,0 +1,240 @@
+package eu.kanade.tachiyomi.ui.browse.animeextension
+
+import android.app.Application
+import androidx.compose.runtime.Immutable
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import dev.icerock.moko.resources.StringResource
+import eu.kanade.domain.animeextension.interactor.GetAnimeExtensionsByType
+import eu.kanade.domain.base.BasePreferences
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.presentation.components.SEARCH_DEBOUNCE_MILLIS
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.extension.model.InstallStep
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onCompletion
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.i18n.MR
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import kotlin.time.Duration.Companion.seconds
+
+class AnimeExtensionsScreenModel(
+    preferences: SourcePreferences = Injekt.get(),
+    basePreferences: BasePreferences = Injekt.get(),
+    private val animeExtensionManager: AnimeExtensionManager = Injekt.get(),
+    private val getAnimeExtensions: GetAnimeExtensionsByType = Injekt.get(),
+) : StateScreenModel<AnimeExtensionsScreenModel.State>(State()) {
+
+    private val currentDownloads = MutableStateFlow<Map<String, InstallStep>>(hashMapOf())
+
+    init {
+        val context = Injekt.get<Application>()
+        val extensionMapper: (Map<String, InstallStep>) -> ((AnimeExtension) -> AnimeExtensionUiModel.Item) = { map ->
+            {
+                AnimeExtensionUiModel.Item(
+                    it,
+                    map[it.pkgName + ":${it.signatureHash}"] ?: InstallStep.Idle,
+                )
+            }
+        }
+
+        screenModelScope.launchIO {
+            combine(
+                state.map { it.searchQuery }
+                    .distinctUntilChanged()
+                    .debounce(SEARCH_DEBOUNCE_MILLIS)
+                    .map { searchQueryPredicate(it ?: "") },
+                currentDownloads,
+                getAnimeExtensions.subscribe(),
+            ) { predicate, downloads, (_updates, _installed, _available, _untrusted) ->
+                buildMap {
+                    val updates = _updates.filter(predicate).map(extensionMapper(downloads))
+                    if (updates.isNotEmpty()) {
+                        put(AnimeExtensionUiModel.Header.Resource(MR.strings.ext_updates_pending), updates)
+                    }
+
+                    val installed = _installed.filter(predicate).map(extensionMapper(downloads))
+                    val untrusted = _untrusted.filter(predicate).map(extensionMapper(downloads))
+                    if (installed.isNotEmpty() || untrusted.isNotEmpty()) {
+                        put(AnimeExtensionUiModel.Header.Resource(MR.strings.ext_installed), installed + untrusted)
+                    }
+
+                    val languagesWithExtensions = _available
+                        .filter(predicate)
+                        .groupBy { it.lang }
+                        .toSortedMap(LocaleHelper.comparator)
+                        .map { (lang, exts) ->
+                            AnimeExtensionUiModel.Header.Text(LocaleHelper.getSourceDisplayName(lang, context)) to
+                                exts.map(extensionMapper(downloads))
+                        }
+                    if (languagesWithExtensions.isNotEmpty()) {
+                        putAll(languagesWithExtensions)
+                    }
+                }
+            }
+                .collectLatest { items ->
+                    mutableState.update { state ->
+                        state.copy(
+                            isLoading = false,
+                            items = items,
+                        )
+                    }
+                }
+        }
+
+        screenModelScope.launchIO { findAvailableExtensions() }
+
+        preferences.animeExtensionUpdatesCount().changes()
+            .onEach { mutableState.update { state -> state.copy(updates = it) } }
+            .launchIn(screenModelScope)
+
+        basePreferences.extensionInstaller().changes()
+            .onEach { mutableState.update { state -> state.copy(installer = it) } }
+            .launchIn(screenModelScope)
+    }
+
+    fun searchQueryPredicate(query: String): (AnimeExtension) -> Boolean {
+        val subqueries = query.split(",")
+            .map { it.trim() }
+            .filterNot { it.isBlank() }
+
+        if (subqueries.isEmpty()) return { true }
+
+        return { extension ->
+            subqueries.any { subquery ->
+                if (extension.name.contains(subquery, ignoreCase = true)) return@any true
+
+                when (extension) {
+                    is AnimeExtension.Installed -> extension.sources.any { source ->
+                        source.name.contains(subquery, ignoreCase = true) ||
+                            (source as? AnimeHttpSource)?.baseUrl?.contains(subquery, ignoreCase = true) == true ||
+                            source.id == subquery.toLongOrNull()
+                    }
+
+                    is AnimeExtension.Available -> extension.sources.any {
+                        it.name.contains(subquery, ignoreCase = true) ||
+                            it.baseUrl.contains(subquery, ignoreCase = true) ||
+                            it.id == subquery.toLongOrNull()
+                    }
+
+                    else -> false
+                }
+            }
+        }
+    }
+
+    fun search(query: String?) {
+        mutableState.update {
+            it.copy(searchQuery = query)
+        }
+    }
+
+    fun updateAllExtensions() {
+        screenModelScope.launchIO {
+            state.value.items.values.flatten()
+                .map { it.extension }
+                .filterIsInstance<AnimeExtension.Installed>()
+                .filter { it.hasUpdate }
+                .forEach(::updateExtension)
+        }
+    }
+
+    fun installExtension(extension: AnimeExtension.Available) {
+        screenModelScope.launchIO {
+            animeExtensionManager.installExtension(extension).collectToInstallUpdate(extension)
+        }
+    }
+
+    fun updateExtension(extension: AnimeExtension.Installed) {
+        screenModelScope.launchIO {
+            animeExtensionManager.updateExtension(extension).collectToInstallUpdate(extension)
+        }
+    }
+
+    fun cancelInstallUpdateExtension(extension: AnimeExtension) {
+        animeExtensionManager.cancelInstallUpdateExtension(extension)
+        removeDownloadState(extension)
+    }
+
+    private fun addDownloadState(extension: AnimeExtension, installStep: InstallStep) {
+        currentDownloads.update {
+            it + Pair(extension.pkgName + ":${extension.signatureHash}", installStep)
+        }
+    }
+
+    private fun removeDownloadState(extension: AnimeExtension) {
+        currentDownloads.update {
+            it - (extension.pkgName + ":${extension.signatureHash}")
+        }
+    }
+
+    private suspend fun Flow<InstallStep>.collectToInstallUpdate(extension: AnimeExtension) =
+        this
+            .onEach { installStep -> addDownloadState(extension, installStep) }
+            .onCompletion { removeDownloadState(extension) }
+            .collect()
+
+    fun uninstallExtension(extension: AnimeExtension) {
+        animeExtensionManager.uninstallExtension(extension)
+    }
+
+    fun findAvailableExtensions() {
+        screenModelScope.launchIO {
+            mutableState.update { it.copy(isRefreshing = true) }
+
+            animeExtensionManager.findAvailableExtensions()
+
+            delay(1.seconds)
+
+            mutableState.update { it.copy(isRefreshing = false) }
+        }
+    }
+
+    fun trustExtension(extension: AnimeExtension.Untrusted) {
+        screenModelScope.launch {
+            animeExtensionManager.trust(extension)
+        }
+    }
+
+    @Immutable
+    data class State(
+        val isLoading: Boolean = true,
+        val isRefreshing: Boolean = false,
+        val items: AnimeItemGroups = mutableMapOf(),
+        val updates: Int = 0,
+        val installer: BasePreferences.ExtensionInstaller? = null,
+        val searchQuery: String? = null,
+    ) {
+        val isEmpty = items.isEmpty()
+    }
+}
+
+typealias AnimeItemGroups = Map<AnimeExtensionUiModel.Header, List<AnimeExtensionUiModel.Item>>
+
+object AnimeExtensionUiModel {
+    sealed interface Header {
+        data class Resource(val textRes: StringResource) : Header
+        data class Text(val text: String) : Header
+    }
+
+    data class Item(
+        val extension: AnimeExtension,
+        val installStep: InstallStep,
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsTab.kt
new file mode 100644
index 0000000000..e109f581d4
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsTab.kt
@@ -0,0 +1,114 @@
+package eu.kanade.tachiyomi.ui.browse.animeextension
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+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.setValue
+import androidx.compose.ui.platform.LocalContext
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.browse.AnimeExtensionScreen
+import eu.kanade.presentation.components.AppBar
+import eu.kanade.presentation.components.TabContent
+import eu.kanade.presentation.more.settings.screen.browse.AnimeExtensionReposScreen
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.ui.webview.WebViewScreen
+import eu.kanade.tachiyomi.util.system.isPackageInstalled
+import kotlinx.collections.immutable.persistentListOf
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+
+@Composable
+fun animeExtensionsTab(
+    animeExtensionsScreenModel: AnimeExtensionsScreenModel,
+): TabContent {
+    val navigator = LocalNavigator.currentOrThrow
+    val context = LocalContext.current
+
+    val state by animeExtensionsScreenModel.state.collectAsState()
+    var privateExtensionToUninstall by remember { mutableStateOf<AnimeExtension?>(null) }
+
+    return TabContent(
+        titleRes = MR.strings.label_anime_extensions,
+        badgeNumber = state.updates.takeIf { it > 0 },
+        searchEnabled = true,
+        actions = persistentListOf(
+            AppBar.OverflowAction(
+                title = stringResource(MR.strings.action_webview_refresh),
+                onClick = animeExtensionsScreenModel::findAvailableExtensions,
+            ),
+            AppBar.OverflowAction(
+                title = stringResource(MR.strings.label_extension_repos),
+                onClick = { navigator.push(AnimeExtensionReposScreen()) },
+            ),
+        ),
+        content = { contentPadding, _ ->
+            BackHandler(enabled = state.searchQuery != null) {
+                animeExtensionsScreenModel.search(null)
+            }
+            AnimeExtensionScreen(
+                state = state,
+                contentPadding = contentPadding,
+                searchQuery = state.searchQuery,
+                onLongClickItem = { extension ->
+                    when (extension) {
+                        is AnimeExtension.Available -> animeExtensionsScreenModel.installExtension(extension)
+                        else -> {
+                            if (context.isPackageInstalled(extension.pkgName)) {
+                                animeExtensionsScreenModel.uninstallExtension(extension)
+                            } else {
+                                privateExtensionToUninstall = extension
+                            }
+                        }
+                    }
+                },
+                onClickItemCancel = animeExtensionsScreenModel::cancelInstallUpdateExtension,
+                onClickUpdateAll = animeExtensionsScreenModel::updateAllExtensions,
+                onOpenWebView = { extension ->
+                    extension.sources.getOrNull(0)?.let {
+                        navigator.push(
+                            WebViewScreen(
+                                url = it.baseUrl,
+                                initialTitle = it.name,
+                                sourceId = it.id,
+                            ),
+                        )
+                    }
+                },
+                onInstallExtension = animeExtensionsScreenModel::installExtension,
+                onOpenExtension = { /* TODO: AnimeExtensionDetailsScreen */ },
+                onTrustExtension = { animeExtensionsScreenModel.trustExtension(it) },
+                onUninstallExtension = { animeExtensionsScreenModel.uninstallExtension(it) },
+                onUpdateExtension = animeExtensionsScreenModel::updateExtension,
+                onRefresh = animeExtensionsScreenModel::findAvailableExtensions,
+            )
+
+            privateExtensionToUninstall?.let { extension ->
+                AlertDialog(
+                    title = { Text(text = stringResource(MR.strings.ext_confirm_remove)) },
+                    text = { Text(text = stringResource(MR.strings.remove_private_extension_message, extension.name)) },
+                    confirmButton = {
+                        TextButton(
+                            onClick = {
+                                animeExtensionsScreenModel.uninstallExtension(extension)
+                                privateExtensionToUninstall = null
+                            },
+                        ) { Text(text = stringResource(MR.strings.ext_remove)) }
+                    },
+                    dismissButton = {
+                        TextButton(onClick = { privateExtensionToUninstall = null }) {
+                            Text(text = stringResource(MR.strings.action_cancel))
+                        }
+                    },
+                    onDismissRequest = { privateExtensionToUninstall = null },
+                )
+            }
+        },
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/AnimeSourcesScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/AnimeSourcesScreenModel.kt
new file mode 100644
index 0000000000..d2fcb4f8fd
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/AnimeSourcesScreenModel.kt
@@ -0,0 +1,56 @@
+package eu.kanade.tachiyomi.ui.browse.animesource
+
+import androidx.compose.runtime.Immutable
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.update
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeSourcesScreenModel(
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+    private val preferences: SourcePreferences = Injekt.get(),
+) : StateScreenModel<AnimeSourcesScreenModel.State>(State()) {
+
+    init {
+        screenModelScope.launchIO {
+            combine(
+                animeSourceManager.catalogueSources,
+                preferences.enabledLanguages().changes(),
+                preferences.pinnedSources().changes(),
+            ) { sources, enabledLanguages, pinnedSources ->
+                sources
+                    .filter { it.lang in enabledLanguages || enabledLanguages.isEmpty() }
+                    .sortedWith(
+                        compareBy<AnimeCatalogueSource> { it.id.toString() !in pinnedSources }
+                            .thenBy(String.CASE_INSENSITIVE_ORDER) { it.name },
+                    )
+                    .groupBy { it.lang }
+                    .toSortedMap(LocaleHelper.comparator)
+            }
+                .collectLatest { grouped ->
+                    mutableState.update {
+                        it.copy(
+                            isLoading = false,
+                            items = grouped,
+                        )
+                    }
+                }
+        }
+    }
+
+    @Immutable
+    data class State(
+        val isLoading: Boolean = true,
+        val items: Map<String, List<AnimeCatalogueSource>> = emptyMap(),
+    ) {
+        val isEmpty: Boolean get() = items.isEmpty()
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/AnimeSourcesTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/AnimeSourcesTab.kt
new file mode 100644
index 0000000000..5d37d99a79
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/AnimeSourcesTab.kt
@@ -0,0 +1,153 @@
+package eu.kanade.tachiyomi.ui.browse.animesource
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.PlayCircleOutline
+import androidx.compose.material3.Icon
+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
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.core.screen.Screen
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.components.TabContent
+import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
+import eu.kanade.tachiyomi.ui.browse.animesource.browse.BrowseAnimeSourceScreen
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import kotlinx.collections.immutable.persistentListOf
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.FastScrollLazyColumn
+import tachiyomi.presentation.core.components.material.padding
+import tachiyomi.presentation.core.components.material.topSmallPaddingValues
+import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.screens.EmptyScreen
+import tachiyomi.presentation.core.screens.LoadingScreen
+import tachiyomi.presentation.core.theme.header
+import tachiyomi.presentation.core.util.plus
+import tachiyomi.presentation.core.util.secondaryItemAlpha
+
+@Composable
+fun Screen.animeSourcesTab(): TabContent {
+    val navigator = LocalNavigator.currentOrThrow
+    val screenModel = rememberScreenModel { AnimeSourcesScreenModel() }
+    val state by screenModel.state.collectAsState()
+
+    return TabContent(
+        titleRes = MR.strings.label_anime_sources,
+        actions = persistentListOf(),
+        content = { contentPadding, _ ->
+            val stateValue = state
+            when {
+                stateValue.isLoading -> LoadingScreen(Modifier.padding(contentPadding))
+                stateValue.isEmpty -> EmptyScreen(MR.strings.source_empty_screen, modifier = Modifier.padding(contentPadding))
+                else -> {
+                    AnimeSourcesList(
+                        items = stateValue.items,
+                        contentPadding = contentPadding,
+                        onClickSource = { source ->
+                            navigator.push(BrowseAnimeSourceScreen(source.id, source.name))
+                        },
+                    )
+                }
+            }
+        },
+    )
+}
+
+@Composable
+private fun AnimeSourcesList(
+    items: Map<String, List<AnimeCatalogueSource>>,
+    contentPadding: PaddingValues,
+    onClickSource: (AnimeCatalogueSource) -> Unit,
+) {
+    val context = LocalContext.current
+
+    FastScrollLazyColumn(
+        contentPadding = contentPadding + topSmallPaddingValues,
+    ) {
+        items.forEach { (lang, sources) ->
+            item(key = "anime-source-header-$lang") {
+                Row(
+                    modifier = Modifier.padding(horizontal = MaterialTheme.padding.medium),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Text(
+                        text = LocaleHelper.getSourceDisplayName(lang, context),
+                        modifier = Modifier
+                            .padding(vertical = 8.dp)
+                            .weight(1f),
+                        style = MaterialTheme.typography.header,
+                    )
+                }
+            }
+
+            items(
+                items = sources,
+                key = { "anime-source-${it.id}" },
+            ) { source ->
+                AnimeSourceItem(
+                    source = source,
+                    onClick = { onClickSource(source) },
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeSourceItem(
+    source: AnimeCatalogueSource,
+    onClick: () -> Unit,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(
+                horizontal = MaterialTheme.padding.medium,
+                vertical = MaterialTheme.padding.small,
+            ),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Icon(
+            imageVector = Icons.Outlined.PlayCircleOutline,
+            contentDescription = null,
+            modifier = Modifier.size(40.dp),
+            tint = MaterialTheme.colorScheme.primary,
+        )
+
+        Column(
+            modifier = Modifier
+                .padding(start = MaterialTheme.padding.medium)
+                .weight(1f),
+        ) {
+            Text(
+                text = source.name,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                style = MaterialTheme.typography.bodyMedium,
+            )
+            Text(
+                text = LocaleHelper.getSourceDisplayName(source.lang, LocalContext.current),
+                modifier = Modifier.secondaryItemAlpha(),
+                maxLines = 1,
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreen.kt
new file mode 100644
index 0000000000..bdab5a8641
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreen.kt
@@ -0,0 +1,172 @@
+package eu.kanade.tachiyomi.ui.browse.animesource.browse
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.ArrowBack
+import androidx.compose.material.icons.outlined.Search
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+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.draw.clip
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import coil3.compose.AsyncImage
+import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.ui.anime.AnimeScreen
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.components.material.padding
+import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.screens.EmptyScreen
+import tachiyomi.presentation.core.screens.LoadingScreen
+
+class BrowseAnimeSourceScreen(
+    private val sourceId: Long,
+    private val sourceName: String,
+) : Screen() {
+
+    @Composable
+    override fun Content() {
+        val navigator = LocalNavigator.currentOrThrow
+        val screenModel = rememberScreenModel { BrowseAnimeSourceScreenModel(sourceId) }
+        val state by screenModel.state.collectAsState()
+
+        var searchQuery by rememberSaveable { mutableStateOf("") }
+
+        LaunchedEffect(sourceId) {
+            screenModel.loadPopular()
+        }
+
+        Scaffold(
+            topBar = { scrollBehavior ->
+                eu.kanade.presentation.components.AppBar(
+                    title = sourceName,
+                    navigateUp = navigator::pop,
+                    scrollBehavior = scrollBehavior,
+                )
+            },
+        ) { contentPadding ->
+            Column(modifier = Modifier.padding(contentPadding)) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(
+                            horizontal = MaterialTheme.padding.medium,
+                            vertical = MaterialTheme.padding.small,
+                        ),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    OutlinedTextField(
+                        value = searchQuery,
+                        onValueChange = { searchQuery = it },
+                        modifier = Modifier.weight(1f),
+                        placeholder = { Text(stringResource(MR.strings.action_search_hint)) },
+                        singleLine = true,
+                    )
+                    IconButton(onClick = { screenModel.search(searchQuery) }) {
+                        Icon(Icons.Outlined.Search, contentDescription = stringResource(MR.strings.action_search))
+                    }
+                }
+
+                when {
+                    state.isLoading -> LoadingScreen()
+                    state.error -> EmptyScreen(MR.strings.internal_error)
+                    state.items.isEmpty() -> EmptyScreen(MR.strings.no_results_found)
+                    else -> {
+                        LazyVerticalGrid(
+                            columns = GridCells.Adaptive(minSize = 120.dp),
+                            contentPadding = PaddingValues(MaterialTheme.padding.small),
+                            horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.small),
+                            verticalArrangement = Arrangement.spacedBy(MaterialTheme.padding.small),
+                        ) {
+                            items(state.items, key = { it.url }) { anime ->
+                                AnimeGridItem(
+                                    anime = anime,
+                                    onClick = {
+                                        screenModel.addAnimeToDatabase(anime) { animeId ->
+                                            navigator.push(AnimeScreen(animeId))
+                                        }
+                                    },
+                                )
+                            }
+
+                            if (state.hasNextPage) {
+                                item {
+                                    LaunchedEffect(Unit) {
+                                        screenModel.loadNextPage()
+                                    }
+                                    CircularProgressIndicator(
+                                        modifier = Modifier
+                                            .padding(MaterialTheme.padding.medium)
+                                            .fillMaxWidth(),
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeGridItem(
+    anime: SAnime,
+    onClick: () -> Unit,
+) {
+    Column(
+        modifier = Modifier
+            .clip(MaterialTheme.shapes.medium)
+            .clickable(onClick = onClick)
+            .fillMaxWidth(),
+    ) {
+        AsyncImage(
+            model = anime.thumbnail_url,
+            contentDescription = null,
+            contentScale = ContentScale.Crop,
+            modifier = Modifier
+                .fillMaxWidth()
+                .aspectRatio(2f / 3f)
+                .clip(MaterialTheme.shapes.medium),
+        )
+        Text(
+            text = anime.title,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.padding(
+                horizontal = MaterialTheme.padding.extraSmall,
+                vertical = MaterialTheme.padding.extraSmall,
+            ),
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
new file mode 100644
index 0000000000..ff58cb82aa
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
@@ -0,0 +1,131 @@
+package eu.kanade.tachiyomi.ui.browse.animesource.browse
+
+import androidx.compose.runtime.Immutable
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class BrowseAnimeSourceScreenModel(
+    private val sourceId: Long,
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+    private val getAnime: GetAnime = Injekt.get(),
+    private val animeRepository: AnimeRepository = Injekt.get(),
+) : StateScreenModel<BrowseAnimeSourceScreenModel.State>(State()) {
+
+    private val source: AnimeCatalogueSource?
+        get() = animeSourceManager.get(sourceId) as? AnimeCatalogueSource
+
+    private var currentPage = 1
+    @Volatile
+    private var isLoadingMore = false
+
+    fun loadPopular() {
+        screenModelScope.launchIO {
+            mutableState.value = State(isLoading = true)
+            try {
+                val source = source ?: run {
+                    mutableState.value = State(error = true)
+                    return@launchIO
+                }
+                val result = source.getPopularAnime(1)
+                currentPage = 1
+                mutableState.value = State(
+                    items = result.animes,
+                    hasNextPage = result.hasNextPage,
+                )
+            } catch (e: Exception) {
+                mutableState.value = State(error = true)
+            }
+        }
+    }
+
+    fun search(query: String) {
+        if (query.isBlank()) {
+            loadPopular()
+            return
+        }
+        screenModelScope.launchIO {
+            mutableState.value = State(isLoading = true)
+            try {
+                val source = source ?: run {
+                    mutableState.value = State(error = true)
+                    return@launchIO
+                }
+                val result = source.getSearchAnime(1, query, AnimeFilterList())
+                currentPage = 1
+                mutableState.value = State(
+                    items = result.animes,
+                    hasNextPage = result.hasNextPage,
+                )
+            } catch (e: Exception) {
+                mutableState.value = State(error = true)
+            }
+        }
+    }
+
+    fun loadNextPage() {
+        if (isLoadingMore) return
+        val currentState = state.value
+        if (!currentState.hasNextPage) return
+
+        isLoadingMore = true
+        screenModelScope.launchIO {
+            try {
+                val source = source ?: return@launchIO
+                val nextPage = currentPage + 1
+                val result = source.getPopularAnime(nextPage)
+                currentPage = nextPage
+                mutableState.value = currentState.copy(
+                    items = currentState.items + result.animes,
+                    hasNextPage = result.hasNextPage,
+                )
+            } catch (_: Exception) {
+                // Silently fail for pagination
+            } finally {
+                isLoadingMore = false
+            }
+        }
+    }
+
+    fun addAnimeToDatabase(sAnime: SAnime, onAdded: (Long) -> Unit) {
+        screenModelScope.launchIO {
+            val existingAnime = getAnime.await(sAnime.url, sourceId)
+            if (existingAnime != null) {
+                onAdded(existingAnime.id)
+                return@launchIO
+            }
+
+            val anime = Anime.create().copy(
+                source = sourceId,
+                url = sAnime.url,
+                title = sAnime.title,
+                artist = sAnime.artist,
+                author = sAnime.author,
+                description = sAnime.description,
+                genre = sAnime.getGenres(),
+                thumbnailUrl = sAnime.thumbnail_url,
+                status = sAnime.status.toLong(),
+                initialized = true,
+            )
+            val id = animeRepository.insert(anime)
+            onAdded(id)
+        }
+    }
+
+    @Immutable
+    data class State(
+        val isLoading: Boolean = false,
+        val items: List<SAnime> = emptyList(),
+        val hasNextPage: Boolean = false,
+        val error: Boolean = false,
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
index 69085e37f4..61c5b70e79 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
@@ -204,17 +204,27 @@ class PlayerActivity : ComponentActivity() {
                 logcat(LogPriority.ERROR, tag = "Player") { "Episode not loaded after init" }
                 return@launchIO
             }
-            val url = episode.url
-            logcat(LogPriority.DEBUG, tag = "Player") { "Episode URL: $url" }
-            if (url.isNotBlank()) {
-                val resumePos = state.currentPositionSec
-                    .takeIf { it > 0 } ?: episode.lastSecondSeen
-                val playUrl = resolvePlaybackUrl(url)
-                logcat(LogPriority.DEBUG, tag = "Player") { "Playing: $playUrl (resume=$resumePos)" }
-                withContext(Dispatchers.Main) {
-                    view.playFile(playUrl, resumePos)
-                    logcat(LogPriority.DEBUG, tag = "Player") { "playFile called" }
+            val resolvedVideo = state.resolvedVideo
+            val url = resolvedVideo?.videoUrl?.takeIf { it.isNotBlank() }
+                ?: episode.url.takeIf { PlayerViewModel.isPlayableScheme(it) }
+            logcat(LogPriority.DEBUG, tag = "Player") { "Episode URL: ${episode.url}, resolved: ${resolvedVideo?.videoUrl}" }
+            if (url.isNullOrBlank()) {
+                logcat(LogPriority.ERROR, tag = "Player") { "No playable video URL found for episode" }
+                return@launchIO
+            }
+            val resumePos = state.currentPositionSec
+                .takeIf { it > 0 } ?: episode.lastSecondSeen
+            val playUrl = resolvePlaybackUrl(url)
+            val headers = resolvedVideo?.headers?.let { h ->
+                (0 until h.size).associate { i -> h.name(i) to h.value(i) }
+            }
+            logcat(LogPriority.DEBUG, tag = "Player") { "Playing: $playUrl (resume=$resumePos, headers=${headers?.keys})" }
+            withContext(Dispatchers.Main) {
+                view.playFile(playUrl, resumePos, headers)
+                resolvedVideo?.subtitleTracks?.forEach { track ->
+                    view.addSubtitleTrack(track.url, track.lang)
                 }
+                logcat(LogPriority.DEBUG, tag = "Player") { "playFile called, ${resolvedVideo?.subtitleTracks?.size ?: 0} subtitle tracks added" }
             }
         }
     }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
index 68effd6e51..51077a9efa 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
@@ -8,8 +8,13 @@ import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import chimahon.DictionaryRepository
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import tachiyomi.domain.animesource.service.AnimeSourceManager
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
@@ -52,6 +57,7 @@ class PlayerViewModel @JvmOverloads constructor(
     private val episodeRepository: EpisodeRepository = Injekt.get(),
     private val dictionaryRepository: DictionaryRepository = Injekt.get(),
     private val application: Application = Injekt.get(),
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
 ) : ViewModel() {
 
     private val mutableState = MutableStateFlow(
@@ -110,14 +116,113 @@ class PlayerViewModel @JvmOverloads constructor(
                 eventChannel.send(Event.Error("Anime or episode not found"))
                 return
             }
-            mutableState.update { it.copy(anime = anime, episode = episode, isLoading = false) }
+
+            var resolvedVideo: Video? = null
+            if (anime.source != LOCAL_ANIME_SOURCE_ID) {
+                resolvedVideo = resolveVideoFromSource(anime.source, episode)
+            }
+
+            mutableState.update {
+                it.copy(
+                    anime = anime,
+                    episode = episode,
+                    resolvedVideo = resolvedVideo,
+                    isLoading = false,
+                )
+            }
         } catch (e: Exception) {
             logcat(LogPriority.ERROR, e) { "Failed to load anime/episode" }
             eventChannel.send(Event.Error(e.message ?: "Unknown error"))
         }
     }
 
+    private suspend fun resolveVideoFromSource(sourceId: Long, episode: Episode): Video? {
+        return withIOContext {
+            try {
+                val source = animeSourceManager.get(sourceId) ?: return@withIOContext null
+                val sEpisode = SEpisode.create().apply {
+                    url = episode.url
+                    name = episode.name
+                }
+
+                val videos = try {
+                    source.getVideoList(sEpisode)
+                } catch (_: Exception) {
+                    emptyList()
+                }
+
+                resolveFirstPlayableVideo(source, videos)?.let {
+                    return@withIOContext ensureHeaders(it, source)
+                }
+
+                try {
+                    val hosters = source.getHosterList(sEpisode)
+                    for (hoster in hosters) {
+                        val hosterVideos = hoster.videoList ?: try {
+                            source.getVideoList(hoster)
+                        } catch (_: Throwable) {
+                            emptyList()
+                        }
+                        resolveFirstPlayableVideo(source, hosterVideos)?.let {
+                            return@withIOContext ensureHeaders(it, source)
+                        }
+                    }
+                } catch (e: Throwable) {
+                    logcat(LogPriority.WARN, e) { "Hoster list resolution failed" }
+                }
+
+                null
+            } catch (e: Exception) {
+                logcat(LogPriority.ERROR, e) { "Failed to resolve video URL from source" }
+                null
+            }
+        }
+    }
+
+    private fun ensureHeaders(video: Video, source: AnimeSource): Video {
+        if (video.headers != null) return video
+        val defaultHeaders = (source as? AnimeHttpSource)?.headers ?: return video
+        return video.copy(headers = defaultHeaders)
+    }
+
+    private suspend fun resolveFirstPlayableVideo(source: AnimeSource, videos: List<Video>): Video? {
+        if (videos.isEmpty()) return null
+        val httpSource = source as? AnimeHttpSource
+
+        for (video in videos) {
+            var resolved = video
+
+            if (httpSource != null) {
+                resolved = try {
+                    httpSource.resolveVideo(video) ?: continue
+                } catch (_: Exception) {
+                    video
+                }
+            }
+
+            if (resolved.videoUrl.isBlank() && resolved.videoPageUrl.isNotBlank() && httpSource != null) {
+                val url = try {
+                    httpSource.getVideoUrl(resolved)
+                } catch (_: Throwable) {
+                    null
+                }
+                if (!url.isNullOrBlank()) {
+                    resolved = resolved.copy(videoUrl = url)
+                }
+            }
+
+            val url = resolved.videoUrl
+            if (url.isNotBlank() && isStreamableUrl(url)) {
+                return resolved
+            }
+        }
+        return null
+    }
+
+    private fun isStreamableUrl(url: String): Boolean = isPlayableScheme(url)
+
     fun updatePlaybackState(isPlaying: Boolean) {
+        if (isPlaying == mutableState.value.isPlaying) return
         mutableState.update { it.copy(isPlaying = isPlaying) }
     }
 
@@ -129,6 +234,7 @@ class PlayerViewModel @JvmOverloads constructor(
     }
 
     fun updateDuration(durationSec: Long) {
+        if (durationSec == mutableState.value.durationSec) return
         mutableState.update { it.copy(durationSec = durationSec) }
     }
 
@@ -315,6 +421,7 @@ class PlayerViewModel @JvmOverloads constructor(
     data class State(
         val anime: Anime? = null,
         val episode: Episode? = null,
+        val resolvedVideo: Video? = null,
         val isLoading: Boolean = true,
         val isPlaying: Boolean = false,
         val currentPositionSec: Long = 0,
@@ -340,5 +447,11 @@ class PlayerViewModel @JvmOverloads constructor(
         const val KEY_ANIME_ID = "anime_id"
         const val KEY_EPISODE_ID = "episode_id"
         const val LOCAL_ANIME_SOURCE_ID = 0L
+        private val STREAMABLE_SCHEMES = setOf("http", "https", "rtmp", "rtsp", "file", "content")
+
+        fun isPlayableScheme(url: String): Boolean {
+            val scheme = url.substringBefore("://").lowercase()
+            return scheme in STREAMABLE_SCHEMES
+        }
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
index a9746640e3..84cd6c09d8 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
@@ -92,12 +92,13 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
         MPVLib.detachSurface()
     }
 
-    fun playFile(url: String, startPositionSec: Long = 0) {
+    fun playFile(url: String, startPositionSec: Long = 0, headers: Map<String, String>? = null) {
         if (!isInitialized) {
             logcat(LogPriority.ERROR) { "playFile called but MPV not initialized" }
             return
         }
         logcat(LogPriority.DEBUG, tag = "Player") { "MPV loadfile: $url start=$startPositionSec" }
+        applyHeaders(headers)
         if (startPositionSec > 0) {
             MPVLib.setOptionString("start", "+$startPositionSec")
         } else {
@@ -106,6 +107,33 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
         MPVLib.command(arrayOf("loadfile", url))
     }
 
+    private fun applyHeaders(headers: Map<String, String>?) {
+        val ua = headers?.entries?.firstOrNull { it.key.equals("User-Agent", ignoreCase = true) }?.value ?: ""
+        val ref = headers?.entries?.firstOrNull { it.key.equals("Referer", ignoreCase = true) }?.value ?: ""
+
+        MPVLib.setOptionString("user-agent", ua)
+        MPVLib.setOptionString("referrer", ref)
+
+        val extraHeaders = headers?.filterKeys { key ->
+            !key.equals("User-Agent", ignoreCase = true) && !key.equals("Referer", ignoreCase = true)
+        }.orEmpty()
+
+        if (extraHeaders.isEmpty()) {
+            MPVLib.setOptionString("http-header-fields", "")
+            MPVLib.setOptionString("demuxer-lavf-o", "")
+        } else {
+            val headerFields = extraHeaders.entries.joinToString(",") { "${it.key}: ${it.value}" }
+            MPVLib.setOptionString("http-header-fields", headerFields)
+            val ffmpegHeaders = extraHeaders.entries.joinToString("\r\n") { "${it.key}: ${it.value}" } + "\r\n"
+            MPVLib.setOptionString("demuxer-lavf-o", "headers=$ffmpegHeaders")
+        }
+    }
+
+    fun addSubtitleTrack(url: String, lang: String) {
+        if (!isInitialized) return
+        MPVLib.command(arrayOf("sub-add", url, "auto", lang, lang))
+    }
+
     val timePos: Int?
         get() = MPVLib.getPropertyInt(PROP_TIME_POS)
 
diff --git a/data/src/main/java/mihon/data/repository/AnimeExtensionRepoRepositoryImpl.kt b/data/src/main/java/mihon/data/repository/AnimeExtensionRepoRepositoryImpl.kt
new file mode 100644
index 0000000000..872838c406
--- /dev/null
+++ b/data/src/main/java/mihon/data/repository/AnimeExtensionRepoRepositoryImpl.kt
@@ -0,0 +1,93 @@
+package mihon.data.repository
+
+import android.database.sqlite.SQLiteException
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import mihon.domain.animeextensionrepo.repository.AnimeExtensionRepoRepository
+import mihon.domain.extensionrepo.exception.SaveExtensionRepoException
+import mihon.domain.extensionrepo.model.ExtensionRepo
+import tachiyomi.data.DatabaseHandler
+
+class AnimeExtensionRepoRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : AnimeExtensionRepoRepository {
+    override fun subscribeAll(): Flow<List<ExtensionRepo>> {
+        return handler.subscribeToList { anime_extension_reposQueries.findAll(::mapExtensionRepo) }
+    }
+
+    override suspend fun getAll(): List<ExtensionRepo> {
+        return handler.awaitList { anime_extension_reposQueries.findAll(::mapExtensionRepo) }
+    }
+
+    override suspend fun getRepo(baseUrl: String): ExtensionRepo? {
+        return handler.awaitOneOrNull { anime_extension_reposQueries.findOne(baseUrl, ::mapExtensionRepo) }
+    }
+
+    override suspend fun getRepoBySigningKeyFingerprint(fingerprint: String): ExtensionRepo? {
+        return handler.awaitOneOrNull {
+            anime_extension_reposQueries.findOneBySigningKeyFingerprint(fingerprint, ::mapExtensionRepo)
+        }
+    }
+
+    override fun getCount(): Flow<Int> {
+        return handler.subscribeToOne { anime_extension_reposQueries.count() }.map { it.toInt() }
+    }
+
+    override suspend fun insertRepo(
+        baseUrl: String,
+        name: String,
+        shortName: String?,
+        website: String,
+        signingKeyFingerprint: String,
+    ) {
+        try {
+            handler.await { anime_extension_reposQueries.insert(baseUrl, name, shortName, website, signingKeyFingerprint) }
+        } catch (ex: SQLiteException) {
+            throw SaveExtensionRepoException(ex)
+        }
+    }
+
+    override suspend fun upsertRepo(
+        baseUrl: String,
+        name: String,
+        shortName: String?,
+        website: String,
+        signingKeyFingerprint: String,
+    ) {
+        try {
+            handler.await { anime_extension_reposQueries.upsert(baseUrl, name, shortName, website, signingKeyFingerprint) }
+        } catch (ex: SQLiteException) {
+            throw SaveExtensionRepoException(ex)
+        }
+    }
+
+    override suspend fun replaceRepo(newRepo: ExtensionRepo) {
+        handler.await {
+            anime_extension_reposQueries.replace(
+                newRepo.baseUrl,
+                newRepo.name,
+                newRepo.shortName,
+                newRepo.website,
+                newRepo.signingKeyFingerprint,
+            )
+        }
+    }
+
+    override suspend fun deleteRepo(baseUrl: String) {
+        return handler.await { anime_extension_reposQueries.delete(baseUrl) }
+    }
+
+    private fun mapExtensionRepo(
+        baseUrl: String,
+        name: String,
+        shortName: String?,
+        website: String,
+        signingKeyFingerprint: String,
+    ): ExtensionRepo = ExtensionRepo(
+        baseUrl = baseUrl,
+        name = name,
+        shortName = shortName,
+        website = website,
+        signingKeyFingerprint = signingKeyFingerprint,
+    )
+}
diff --git a/data/src/main/java/tachiyomi/data/animesource/StubAnimeSourceRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/animesource/StubAnimeSourceRepositoryImpl.kt
new file mode 100644
index 0000000000..517ca4f5d9
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/animesource/StubAnimeSourceRepositoryImpl.kt
@@ -0,0 +1,29 @@
+package tachiyomi.data.animesource
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.animesource.model.StubAnimeSource
+import tachiyomi.domain.animesource.repository.StubAnimeSourceRepository
+
+class StubAnimeSourceRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : StubAnimeSourceRepository {
+
+    override fun subscribeAll(): Flow<List<StubAnimeSource>> {
+        return handler.subscribeToList { anime_sourcesQueries.findAll(::mapStubAnimeSource) }
+    }
+
+    override suspend fun getStubSource(id: Long): StubAnimeSource? {
+        return handler.awaitOneOrNull { anime_sourcesQueries.findOne(id, ::mapStubAnimeSource) }
+    }
+
+    override suspend fun upsertStubSource(id: Long, lang: String, name: String) {
+        handler.await { anime_sourcesQueries.upsert(id, lang, name) }
+    }
+
+    private fun mapStubAnimeSource(
+        id: Long,
+        lang: String,
+        name: String,
+    ): StubAnimeSource = StubAnimeSource(id = id, lang = lang, name = name)
+}
diff --git a/data/src/main/sqldelight/tachiyomi/data/anime_extension_repos.sq b/data/src/main/sqldelight/tachiyomi/data/anime_extension_repos.sq
new file mode 100644
index 0000000000..92d5e625f7
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/data/anime_extension_repos.sq
@@ -0,0 +1,57 @@
+CREATE TABLE anime_extension_repos (
+    base_url TEXT NOT NULL PRIMARY KEY,
+    name TEXT NOT NULL,
+    short_name TEXT,
+    website TEXT NOT NULL,
+    signing_key_fingerprint TEXT UNIQUE NOT NULL
+);
+
+findOne:
+SELECT *
+FROM anime_extension_repos
+WHERE base_url = :base_url;
+
+findOneBySigningKeyFingerprint:
+SELECT *
+FROM anime_extension_repos
+WHERE signing_key_fingerprint = :fingerprint;
+
+findAll:
+SELECT *
+FROM anime_extension_repos;
+
+count:
+SELECT COUNT(*)
+FROM anime_extension_repos;
+
+insert:
+INSERT INTO anime_extension_repos(base_url, name, short_name, website, signing_key_fingerprint)
+VALUES (:base_url, :name, :short_name, :website, :fingerprint);
+
+upsert:
+INSERT INTO anime_extension_repos(base_url, name, short_name, website, signing_key_fingerprint)
+VALUES (:base_url, :name, :short_name, :website, :fingerprint)
+ON CONFLICT(base_url)
+DO UPDATE
+SET
+    name = :name,
+    short_name = :short_name,
+    website = :website,
+    signing_key_fingerprint = :fingerprint
+WHERE base_url = base_url;
+
+replace:
+INSERT INTO anime_extension_repos(base_url, name, short_name, website, signing_key_fingerprint)
+VALUES (:base_url, :name, :short_name, :website, :fingerprint)
+ON CONFLICT(signing_key_fingerprint)
+DO UPDATE
+SET
+    base_url = :base_url,
+    name = :name,
+    short_name = :short_name,
+    website = :website
+WHERE signing_key_fingerprint = signing_key_fingerprint;
+
+delete:
+DELETE FROM anime_extension_repos
+WHERE base_url = :base_url;
diff --git a/data/src/main/sqldelight/tachiyomi/data/anime_sources.sq b/data/src/main/sqldelight/tachiyomi/data/anime_sources.sq
new file mode 100644
index 0000000000..93809825ae
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/data/anime_sources.sq
@@ -0,0 +1,24 @@
+CREATE TABLE anime_sources(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    lang TEXT NOT NULL,
+    name TEXT NOT NULL
+);
+
+findAll:
+SELECT *
+FROM anime_sources;
+
+findOne:
+SELECT *
+FROM anime_sources
+WHERE _id = :id;
+
+upsert:
+INSERT INTO anime_sources(_id, lang, name)
+VALUES (:id, :lang, :name)
+ON CONFLICT(_id)
+DO UPDATE
+SET
+    lang = :lang,
+    name = :name
+WHERE _id = :id;
diff --git a/data/src/main/sqldelight/tachiyomi/migrations/46.sqm b/data/src/main/sqldelight/tachiyomi/migrations/46.sqm
new file mode 100644
index 0000000000..9e0bd262ad
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/migrations/46.sqm
@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS anime_extension_repos (
+    base_url TEXT NOT NULL PRIMARY KEY,
+    name TEXT NOT NULL,
+    short_name TEXT,
+    website TEXT NOT NULL,
+    signing_key_fingerprint TEXT UNIQUE NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS anime_sources(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    lang TEXT NOT NULL,
+    name TEXT NOT NULL
+);
diff --git a/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/CreateAnimeExtensionRepo.kt b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/CreateAnimeExtensionRepo.kt
new file mode 100644
index 0000000000..72f20b58ef
--- /dev/null
+++ b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/CreateAnimeExtensionRepo.kt
@@ -0,0 +1,62 @@
+package mihon.domain.animeextensionrepo.interactor
+
+import logcat.LogPriority
+import mihon.domain.animeextensionrepo.repository.AnimeExtensionRepoRepository
+import mihon.domain.extensionrepo.exception.SaveExtensionRepoException
+import mihon.domain.extensionrepo.model.ExtensionRepo
+import mihon.domain.extensionrepo.service.ExtensionRepoService
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import tachiyomi.core.common.util.system.logcat
+
+class CreateAnimeExtensionRepo(
+    private val repository: AnimeExtensionRepoRepository,
+    private val service: ExtensionRepoService,
+) {
+    private val repoRegex = """^https://.*/index\.min\.json$""".toRegex()
+
+    suspend fun await(indexUrl: String): Result {
+        val formattedIndexUrl = indexUrl.toHttpUrlOrNull()
+            ?.toString()
+            ?.takeIf { it.matches(repoRegex) }
+            ?: return Result.InvalidUrl
+
+        val baseUrl = formattedIndexUrl.removeSuffix("/index.min.json")
+        return service.fetchRepoDetails(baseUrl)?.let { insert(it) } ?: Result.InvalidUrl
+    }
+
+    private suspend fun insert(repo: ExtensionRepo): Result {
+        return try {
+            repository.insertRepo(
+                repo.baseUrl,
+                repo.name,
+                repo.shortName,
+                repo.website,
+                repo.signingKeyFingerprint,
+            )
+            Result.Success
+        } catch (e: SaveExtensionRepoException) {
+            logcat(LogPriority.WARN, e) { "SQL Conflict attempting to add new anime repository ${repo.baseUrl}" }
+            return handleInsertionError(repo)
+        }
+    }
+
+    private suspend fun handleInsertionError(repo: ExtensionRepo): Result {
+        val repoExists = repository.getRepo(repo.baseUrl)
+        if (repoExists != null) {
+            return Result.RepoAlreadyExists
+        }
+        val matchingFingerprintRepo = repository.getRepoBySigningKeyFingerprint(repo.signingKeyFingerprint)
+        if (matchingFingerprintRepo != null) {
+            return Result.DuplicateFingerprint(matchingFingerprintRepo, repo)
+        }
+        return Result.Error
+    }
+
+    sealed interface Result {
+        data class DuplicateFingerprint(val oldRepo: ExtensionRepo, val newRepo: ExtensionRepo) : Result
+        data object InvalidUrl : Result
+        data object RepoAlreadyExists : Result
+        data object Success : Result
+        data object Error : Result
+    }
+}
diff --git a/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/DeleteAnimeExtensionRepo.kt b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/DeleteAnimeExtensionRepo.kt
new file mode 100644
index 0000000000..d8d1be8df2
--- /dev/null
+++ b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/DeleteAnimeExtensionRepo.kt
@@ -0,0 +1,11 @@
+package mihon.domain.animeextensionrepo.interactor
+
+import mihon.domain.animeextensionrepo.repository.AnimeExtensionRepoRepository
+
+class DeleteAnimeExtensionRepo(
+    private val repository: AnimeExtensionRepoRepository,
+) {
+    suspend fun await(baseUrl: String) {
+        repository.deleteRepo(baseUrl)
+    }
+}
diff --git a/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/GetAnimeExtensionRepo.kt b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/GetAnimeExtensionRepo.kt
new file mode 100644
index 0000000000..9f689fb2ba
--- /dev/null
+++ b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/GetAnimeExtensionRepo.kt
@@ -0,0 +1,13 @@
+package mihon.domain.animeextensionrepo.interactor
+
+import kotlinx.coroutines.flow.Flow
+import mihon.domain.animeextensionrepo.repository.AnimeExtensionRepoRepository
+import mihon.domain.extensionrepo.model.ExtensionRepo
+
+class GetAnimeExtensionRepo(
+    private val repository: AnimeExtensionRepoRepository,
+) {
+    fun subscribeAll(): Flow<List<ExtensionRepo>> = repository.subscribeAll()
+
+    suspend fun getAll(): List<ExtensionRepo> = repository.getAll()
+}
diff --git a/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/GetAnimeExtensionRepoCount.kt b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/GetAnimeExtensionRepoCount.kt
new file mode 100644
index 0000000000..c8bcaee700
--- /dev/null
+++ b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/GetAnimeExtensionRepoCount.kt
@@ -0,0 +1,9 @@
+package mihon.domain.animeextensionrepo.interactor
+
+import mihon.domain.animeextensionrepo.repository.AnimeExtensionRepoRepository
+
+class GetAnimeExtensionRepoCount(
+    private val repository: AnimeExtensionRepoRepository,
+) {
+    fun subscribe() = repository.getCount()
+}
diff --git a/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/ReplaceAnimeExtensionRepo.kt b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/ReplaceAnimeExtensionRepo.kt
new file mode 100644
index 0000000000..e64b7cf8dd
--- /dev/null
+++ b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/ReplaceAnimeExtensionRepo.kt
@@ -0,0 +1,12 @@
+package mihon.domain.animeextensionrepo.interactor
+
+import mihon.domain.animeextensionrepo.repository.AnimeExtensionRepoRepository
+import mihon.domain.extensionrepo.model.ExtensionRepo
+
+class ReplaceAnimeExtensionRepo(
+    private val repository: AnimeExtensionRepoRepository,
+) {
+    suspend fun await(repo: ExtensionRepo) {
+        repository.replaceRepo(repo)
+    }
+}
diff --git a/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/UpdateAnimeExtensionRepo.kt b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/UpdateAnimeExtensionRepo.kt
new file mode 100644
index 0000000000..fb97c870f2
--- /dev/null
+++ b/domain/src/main/java/mihon/domain/animeextensionrepo/interactor/UpdateAnimeExtensionRepo.kt
@@ -0,0 +1,30 @@
+package mihon.domain.animeextensionrepo.interactor
+
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import mihon.domain.animeextensionrepo.repository.AnimeExtensionRepoRepository
+import mihon.domain.extensionrepo.model.ExtensionRepo
+import mihon.domain.extensionrepo.service.ExtensionRepoService
+
+class UpdateAnimeExtensionRepo(
+    private val repository: AnimeExtensionRepoRepository,
+    private val service: ExtensionRepoService,
+) {
+
+    suspend fun awaitAll() = coroutineScope {
+        repository.getAll()
+            .map { async { await(it) } }
+            .awaitAll()
+    }
+
+    suspend fun await(repo: ExtensionRepo) {
+        val newRepo = service.fetchRepoDetails(repo.baseUrl) ?: return
+        if (
+            repo.signingKeyFingerprint.startsWith("NOFINGERPRINT") ||
+            repo.signingKeyFingerprint == newRepo.signingKeyFingerprint
+        ) {
+            repository.upsertRepo(newRepo)
+        }
+    }
+}
diff --git a/domain/src/main/java/mihon/domain/animeextensionrepo/repository/AnimeExtensionRepoRepository.kt b/domain/src/main/java/mihon/domain/animeextensionrepo/repository/AnimeExtensionRepoRepository.kt
new file mode 100644
index 0000000000..3ff4c6925e
--- /dev/null
+++ b/domain/src/main/java/mihon/domain/animeextensionrepo/repository/AnimeExtensionRepoRepository.kt
@@ -0,0 +1,47 @@
+package mihon.domain.animeextensionrepo.repository
+
+import kotlinx.coroutines.flow.Flow
+import mihon.domain.extensionrepo.model.ExtensionRepo
+
+interface AnimeExtensionRepoRepository {
+
+    fun subscribeAll(): Flow<List<ExtensionRepo>>
+
+    suspend fun getAll(): List<ExtensionRepo>
+
+    suspend fun getRepo(baseUrl: String): ExtensionRepo?
+
+    suspend fun getRepoBySigningKeyFingerprint(fingerprint: String): ExtensionRepo?
+
+    fun getCount(): Flow<Int>
+
+    suspend fun insertRepo(
+        baseUrl: String,
+        name: String,
+        shortName: String?,
+        website: String,
+        signingKeyFingerprint: String,
+    )
+
+    suspend fun upsertRepo(
+        baseUrl: String,
+        name: String,
+        shortName: String?,
+        website: String,
+        signingKeyFingerprint: String,
+    )
+
+    suspend fun upsertRepo(repo: ExtensionRepo) {
+        upsertRepo(
+            baseUrl = repo.baseUrl,
+            name = repo.name,
+            shortName = repo.shortName,
+            website = repo.website,
+            signingKeyFingerprint = repo.signingKeyFingerprint,
+        )
+    }
+
+    suspend fun replaceRepo(newRepo: ExtensionRepo)
+
+    suspend fun deleteRepo(baseUrl: String)
+}
diff --git a/domain/src/main/java/tachiyomi/domain/animesource/model/StubAnimeSource.kt b/domain/src/main/java/tachiyomi/domain/animesource/model/StubAnimeSource.kt
new file mode 100644
index 0000000000..5b2f24c818
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/animesource/model/StubAnimeSource.kt
@@ -0,0 +1,35 @@
+package tachiyomi.domain.animesource.model
+
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+
+class StubAnimeSource(
+    override val id: Long,
+    override val lang: String,
+    override val name: String,
+) : AnimeSource {
+
+    private val isInvalid: Boolean = name.isBlank() || lang.isBlank()
+
+    override suspend fun getAnimeDetails(anime: SAnime): SAnime =
+        throw AnimeSourceNotInstalledException()
+
+    override suspend fun getEpisodeList(anime: SAnime): List<SEpisode> =
+        throw AnimeSourceNotInstalledException()
+
+    override suspend fun getVideoList(episode: SEpisode): List<Video> =
+        throw AnimeSourceNotInstalledException()
+
+    override fun toString(): String =
+        if (!isInvalid) "$name (${lang.uppercase()})" else id.toString()
+
+    companion object {
+        fun from(source: AnimeSource): StubAnimeSource {
+            return StubAnimeSource(id = source.id, lang = source.lang, name = source.name)
+        }
+    }
+}
+
+class AnimeSourceNotInstalledException : Exception()
diff --git a/domain/src/main/java/tachiyomi/domain/animesource/repository/StubAnimeSourceRepository.kt b/domain/src/main/java/tachiyomi/domain/animesource/repository/StubAnimeSourceRepository.kt
new file mode 100644
index 0000000000..935bbf7e67
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/animesource/repository/StubAnimeSourceRepository.kt
@@ -0,0 +1,12 @@
+package tachiyomi.domain.animesource.repository
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.animesource.model.StubAnimeSource
+
+interface StubAnimeSourceRepository {
+    fun subscribeAll(): Flow<List<StubAnimeSource>>
+
+    suspend fun getStubSource(id: Long): StubAnimeSource?
+
+    suspend fun upsertStubSource(id: Long, lang: String, name: String)
+}
diff --git a/domain/src/main/java/tachiyomi/domain/animesource/service/AnimeSourceManager.kt b/domain/src/main/java/tachiyomi/domain/animesource/service/AnimeSourceManager.kt
new file mode 100644
index 0000000000..9bb66cc153
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/animesource/service/AnimeSourceManager.kt
@@ -0,0 +1,25 @@
+package tachiyomi.domain.animesource.service
+
+import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+import tachiyomi.domain.animesource.model.StubAnimeSource
+
+interface AnimeSourceManager {
+
+    val catalogueSources: Flow<List<AnimeCatalogueSource>>
+
+    val isInitialized: StateFlow<Boolean>
+
+    fun get(sourceKey: Long): AnimeSource?
+
+    fun getOrStub(sourceKey: Long): AnimeSource
+
+    fun getOnlineSources(): List<AnimeHttpSource>
+
+    fun getCatalogueSources(): List<AnimeCatalogueSource>
+
+    fun getStubSources(): List<StubAnimeSource>
+}
diff --git a/i18n/src/commonMain/moko-resources/base/strings.xml b/i18n/src/commonMain/moko-resources/base/strings.xml
index 0fe7b71cf1..13a31255e8 100644
--- a/i18n/src/commonMain/moko-resources/base/strings.xml
+++ b/i18n/src/commonMain/moko-resources/base/strings.xml
@@ -51,6 +51,8 @@
     <string name="label_stats">Statistics</string>
     <string name="label_migration">Migrate</string>
     <string name="label_extensions">Extensions</string>
+    <string name="label_anime_extensions">Anime Extensions</string>
+    <string name="label_anime_sources">Anime Sources</string>
     <string name="label_extension_info">Extension info</string>
     <string name="label_help">Help</string>
     <string name="label_default">Default</string>
@@ -1102,6 +1104,7 @@
     <string name="channel_new_chapters">Chapter updates</string>
     <string name="channel_app_updates">App updates</string>
     <string name="channel_ext_updates">Extension updates</string>
+    <string name="channel_anime_ext_updates">Anime extension updates</string>
 
     <!-- S Pen actions -->
     <string name="spen_previous_page">Previous page</string>

From 17ca36a3aa7729a233321d6f59be0eec369ff897 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sat, 9 May 2026 21:59:43 +0200
Subject: [PATCH 07/13] Anime extension details & filtering

---
 .../java/eu/kanade/core/util/SourceUtil.kt    |   6 +
 .../browse/AnimeExtensionDetailsScreen.kt     | 486 ++++++++++++++++++
 .../browse/AnimeExtensionFilterScreen.kt      |  99 ++++
 .../browse/components/BrowseIcons.kt          |  64 +++
 .../kanade/tachiyomi/ui/browse/BrowseTab.kt   |   2 +-
 .../AnimeExtensionFilterScreen.kt             |  50 ++
 .../AnimeExtensionFilterScreenModel.kt        |  80 +++
 .../animeextension/AnimeExtensionsTab.kt      |   7 +-
 .../details/AnimeExtensionDetailsScreen.kt    |  69 +++
 .../AnimeExtensionDetailsScreenModel.kt       | 158 ++++++
 .../details/AnimeSourcePreferencesScreen.kt   | 169 ++++++
 11 files changed, 1188 insertions(+), 2 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionDetailsScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionFilterScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionFilterScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionFilterScreenModel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeExtensionDetailsScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeExtensionDetailsScreenModel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeSourcePreferencesScreen.kt

diff --git a/app/src/main/java/eu/kanade/core/util/SourceUtil.kt b/app/src/main/java/eu/kanade/core/util/SourceUtil.kt
index c976e1e6ac..c63743d9ae 100644
--- a/app/src/main/java/eu/kanade/core/util/SourceUtil.kt
+++ b/app/src/main/java/eu/kanade/core/util/SourceUtil.kt
@@ -3,6 +3,7 @@ package eu.kanade.core.util
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.remember
+import tachiyomi.domain.animesource.service.AnimeSourceManager
 import tachiyomi.domain.source.service.SourceManager
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
@@ -11,3 +12,8 @@ import uy.kohesive.injekt.api.get
 fun ifSourcesLoaded(): Boolean {
     return remember { Injekt.get<SourceManager>().isInitialized }.collectAsState().value
 }
+
+@Composable
+fun ifAnimeSourcesLoaded(): Boolean {
+    return remember { Injekt.get<AnimeSourceManager>().isInitialized }.collectAsState().value
+}
diff --git a/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionDetailsScreen.kt b/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionDetailsScreen.kt
new file mode 100644
index 0000000000..96f5cc532b
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionDetailsScreen.kt
@@ -0,0 +1,486 @@
+package eu.kanade.presentation.browse
+
+import android.content.Intent
+import android.net.Uri
+import android.provider.Settings
+import android.util.DisplayMetrics
+import androidx.compose.animation.graphics.res.animatedVectorResource
+import androidx.compose.animation.graphics.res.rememberAnimatedVectorPainter
+import androidx.compose.animation.graphics.vector.AnimatedImageVector
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.Launch
+import androidx.compose.material.icons.outlined.Public
+import androidx.compose.material.icons.outlined.Settings
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.VerticalDivider
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import eu.kanade.domain.animeextension.interactor.AnimeExtensionSourceItem
+import eu.kanade.presentation.browse.components.AnimeExtensionIcon
+import eu.kanade.presentation.components.AppBar
+import eu.kanade.presentation.components.AppBarActions
+import eu.kanade.presentation.components.WarningBanner
+import eu.kanade.presentation.more.settings.widget.TextPreferenceWidget
+import eu.kanade.presentation.more.settings.widget.TrailingWidgetBuffer
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.ui.browse.animeextension.details.AnimeExtensionDetailsScreenModel
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import eu.kanade.tachiyomi.util.system.copyToClipboard
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.ScrollbarLazyColumn
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.components.material.padding
+import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.screens.EmptyScreen
+
+@Composable
+fun AnimeExtensionDetailsScreen(
+    navigateUp: () -> Unit,
+    state: AnimeExtensionDetailsScreenModel.State,
+    onClickSourcePreferences: (sourceId: Long) -> Unit,
+    onOpenWebView: (() -> Unit)?,
+    onClickEnableAll: () -> Unit,
+    onClickDisableAll: () -> Unit,
+    onClickClearCookies: () -> Unit,
+    onClickUninstall: () -> Unit,
+    onClickSource: (sourceId: Long) -> Unit,
+    onClickIncognito: (Boolean) -> Unit,
+) {
+    val uriHandler = LocalUriHandler.current
+    val url = remember(state.extension) {
+        val regex = """https://raw.githubusercontent.com/(.+?)/(.+?)/.+""".toRegex()
+        regex.find(state.extension?.repoUrl.orEmpty())
+            ?.let {
+                val (user, repo) = it.destructured
+                "https://github.com/$user/$repo"
+            }
+            ?: state.extension?.repoUrl
+    }
+
+    Scaffold(
+        topBar = { scrollBehavior ->
+            AppBar(
+                title = stringResource(MR.strings.label_extension_info),
+                navigateUp = navigateUp,
+                actions = {
+                    AppBarActions(
+                        actions = persistentListOf<AppBar.AppBarAction>().builder()
+                            .apply {
+                                if (onOpenWebView != null) {
+                                    add(
+                                        AppBar.Action(
+                                            title = stringResource(MR.strings.action_open_in_web_view),
+                                            icon = Icons.Outlined.Public,
+                                            onClick = onOpenWebView,
+                                        ),
+                                    )
+                                }
+                                if (url != null) {
+                                    add(
+                                        AppBar.Action(
+                                            title = stringResource(MR.strings.action_open_repo),
+                                            icon = Icons.AutoMirrored.Outlined.Launch,
+                                            onClick = {
+                                                uriHandler.openUri(url)
+                                            },
+                                        ),
+                                    )
+                                }
+                                addAll(
+                                    listOf(
+                                        AppBar.OverflowAction(
+                                            title = stringResource(MR.strings.action_enable_all),
+                                            onClick = onClickEnableAll,
+                                        ),
+                                        AppBar.OverflowAction(
+                                            title = stringResource(MR.strings.action_disable_all),
+                                            onClick = onClickDisableAll,
+                                        ),
+                                        AppBar.OverflowAction(
+                                            title = stringResource(MR.strings.pref_clear_cookies),
+                                            onClick = onClickClearCookies,
+                                        ),
+                                    ),
+                                )
+                            }
+                            .build(),
+                    )
+                },
+                scrollBehavior = scrollBehavior,
+            )
+        },
+    ) { paddingValues ->
+        if (state.extension == null) {
+            EmptyScreen(
+                MR.strings.empty_screen,
+                modifier = Modifier.padding(paddingValues),
+            )
+            return@Scaffold
+        }
+
+        AnimeExtensionDetails(
+            contentPadding = paddingValues,
+            extension = state.extension,
+            sources = state.sources,
+            incognitoMode = state.isIncognito,
+            onClickSourcePreferences = onClickSourcePreferences,
+            onClickUninstall = onClickUninstall,
+            onClickSource = onClickSource,
+            onClickIncognito = onClickIncognito,
+        )
+    }
+}
+
+@Composable
+private fun AnimeExtensionDetails(
+    contentPadding: PaddingValues,
+    extension: AnimeExtension.Installed,
+    sources: ImmutableList<AnimeExtensionSourceItem>,
+    incognitoMode: Boolean,
+    onClickSourcePreferences: (sourceId: Long) -> Unit,
+    onClickUninstall: () -> Unit,
+    onClickSource: (sourceId: Long) -> Unit,
+    onClickIncognito: (Boolean) -> Unit,
+) {
+    val context = LocalContext.current
+    var showNsfwWarning by remember { mutableStateOf(false) }
+
+    ScrollbarLazyColumn(
+        contentPadding = contentPadding,
+    ) {
+        if (extension.isObsolete) {
+            item {
+                WarningBanner(MR.strings.obsolete_extension_message)
+            }
+        }
+
+        item {
+            AnimeDetailsHeader(
+                extension = extension,
+                extIncognitoMode = incognitoMode,
+                onClickUninstall = onClickUninstall,
+                onClickAppInfo = {
+                    Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+                        data = Uri.fromParts("package", extension.pkgName, null)
+                        context.startActivity(this)
+                    }
+                    Unit
+                }.takeIf { extension.isShared },
+                onClickAgeRating = {
+                    showNsfwWarning = true
+                },
+                onExtIncognitoChange = onClickIncognito,
+            )
+        }
+
+        items(
+            items = sources,
+            key = { "anime-extension-details-${it.source.id}" },
+        ) { source ->
+            AnimeSourceSwitchPreference(
+                modifier = Modifier.animateItem(),
+                source = source,
+                onClickSourcePreferences = onClickSourcePreferences,
+                onClickSource = onClickSource,
+            )
+        }
+    }
+    if (showNsfwWarning) {
+        AnimeNsfwWarningDialog(
+            onClickConfirm = {
+                showNsfwWarning = false
+            },
+        )
+    }
+}
+
+@Composable
+private fun AnimeDetailsHeader(
+    extension: AnimeExtension,
+    extIncognitoMode: Boolean,
+    onClickAgeRating: () -> Unit,
+    onClickUninstall: () -> Unit,
+    onClickAppInfo: (() -> Unit)?,
+    onExtIncognitoChange: (Boolean) -> Unit,
+) {
+    val context = LocalContext.current
+
+    Column {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = MaterialTheme.padding.medium)
+                .padding(
+                    top = MaterialTheme.padding.medium,
+                    bottom = MaterialTheme.padding.small,
+                )
+                .clickable {
+                    val extDebugInfo = buildString {
+                        append(
+                            """
+                            Extension name: ${extension.name} (lang: ${extension.lang}; package: ${extension.pkgName})
+                            Extension version: ${extension.versionName} (lib: ${extension.libVersion}; version code: ${extension.versionCode})
+                            NSFW: ${extension.isNsfw}
+                            """.trimIndent(),
+                        )
+
+                        if (extension is AnimeExtension.Installed) {
+                            append("\n\n")
+                            append(
+                                """
+                                Update available: ${extension.hasUpdate}
+                                Obsolete: ${extension.isObsolete}
+                                Shared: ${extension.isShared}
+                                Repository: ${extension.repoUrl}
+                                """.trimIndent(),
+                            )
+                        }
+                    }
+                    context.copyToClipboard("Extension Debug information", extDebugInfo)
+                },
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            AnimeExtensionIcon(
+                modifier = Modifier
+                    .size(112.dp),
+                extension = extension,
+                density = DisplayMetrics.DENSITY_XXXHIGH,
+            )
+
+            Text(
+                text = extension.name,
+                style = MaterialTheme.typography.headlineSmall,
+                textAlign = TextAlign.Center,
+            )
+
+            val strippedPkgName = extension.pkgName.substringAfter("eu.kanade.tachiyomi.animeextension.")
+
+            Text(
+                text = strippedPkgName,
+                style = MaterialTheme.typography.bodySmall,
+            )
+        }
+
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    horizontal = MaterialTheme.padding.extraLarge,
+                    vertical = MaterialTheme.padding.small,
+                ),
+            horizontalArrangement = Arrangement.SpaceEvenly,
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            AnimeInfoText(
+                modifier = Modifier.weight(1f),
+                primaryText = extension.versionName,
+                secondaryText = stringResource(MR.strings.ext_info_version),
+            )
+
+            AnimeInfoDivider()
+
+            AnimeInfoText(
+                modifier = Modifier.weight(if (extension.isNsfw) 1.5f else 1f),
+                primaryText = LocaleHelper.getSourceDisplayName(extension.lang, context),
+                secondaryText = stringResource(MR.strings.ext_info_language),
+            )
+
+            if (extension.isNsfw) {
+                AnimeInfoDivider()
+
+                AnimeInfoText(
+                    modifier = Modifier.weight(1f),
+                    primaryText = stringResource(MR.strings.ext_nsfw_short),
+                    primaryTextStyle = MaterialTheme.typography.bodyLarge.copy(
+                        color = MaterialTheme.colorScheme.error,
+                        fontWeight = FontWeight.Medium,
+                    ),
+                    secondaryText = stringResource(MR.strings.ext_info_age_rating),
+                    onClick = onClickAgeRating,
+                )
+            }
+        }
+
+        Row(
+            modifier = Modifier
+                .padding(horizontal = MaterialTheme.padding.medium)
+                .padding(top = MaterialTheme.padding.small),
+            horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.medium),
+        ) {
+            OutlinedButton(
+                modifier = Modifier.weight(1f),
+                onClick = onClickUninstall,
+            ) {
+                Text(stringResource(MR.strings.ext_uninstall))
+            }
+
+            if (onClickAppInfo != null) {
+                Button(
+                    modifier = Modifier.weight(1f),
+                    onClick = onClickAppInfo,
+                ) {
+                    Text(
+                        text = stringResource(MR.strings.ext_app_info),
+                        color = MaterialTheme.colorScheme.onPrimary,
+                    )
+                }
+            }
+        }
+
+        TextPreferenceWidget(
+            modifier = Modifier.padding(horizontal = MaterialTheme.padding.small),
+            title = stringResource(MR.strings.pref_incognito_mode),
+            subtitle = stringResource(MR.strings.pref_incognito_mode_extension_summary),
+            icon = rememberAnimatedVectorPainter(
+                AnimatedImageVector.animatedVectorResource(R.drawable.anim_incognito),
+                extIncognitoMode,
+            ),
+            widget = {
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Switch(
+                        checked = extIncognitoMode,
+                        onCheckedChange = onExtIncognitoChange,
+                        modifier = Modifier.padding(start = TrailingWidgetBuffer),
+                    )
+                }
+            },
+        )
+
+        HorizontalDivider()
+    }
+}
+
+@Composable
+private fun AnimeInfoText(
+    primaryText: String,
+    secondaryText: String,
+    modifier: Modifier = Modifier,
+    primaryTextStyle: TextStyle = MaterialTheme.typography.bodyLarge,
+    onClick: (() -> Unit)? = null,
+) {
+    val clickableModifier = if (onClick != null) {
+        Modifier.clickable(interactionSource = null, indication = null, onClick = onClick)
+    } else {
+        Modifier
+    }
+
+    Column(
+        modifier = modifier.then(clickableModifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center,
+    ) {
+        Text(
+            text = primaryText,
+            textAlign = TextAlign.Center,
+            style = primaryTextStyle,
+        )
+
+        Text(
+            text = secondaryText + if (onClick != null) " ⓘ" else "",
+            textAlign = TextAlign.Center,
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.5f),
+        )
+    }
+}
+
+@Composable
+private fun AnimeInfoDivider() {
+    VerticalDivider(
+        modifier = Modifier.height(20.dp),
+    )
+}
+
+@Composable
+private fun AnimeSourceSwitchPreference(
+    source: AnimeExtensionSourceItem,
+    onClickSourcePreferences: (sourceId: Long) -> Unit,
+    onClickSource: (sourceId: Long) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val context = LocalContext.current
+
+    TextPreferenceWidget(
+        modifier = modifier,
+        title = if (source.labelAsName) {
+            source.source.toString()
+        } else {
+            LocaleHelper.getSourceDisplayName(source.source.lang, context)
+        },
+        widget = {
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                if (source.source is ConfigurableAnimeSource) {
+                    IconButton(onClick = { onClickSourcePreferences(source.source.id) }) {
+                        Icon(
+                            imageVector = Icons.Outlined.Settings,
+                            contentDescription = stringResource(MR.strings.label_settings),
+                            tint = MaterialTheme.colorScheme.onSurface,
+                        )
+                    }
+                }
+
+                Switch(
+                    checked = source.enabled,
+                    onCheckedChange = null,
+                    modifier = Modifier.padding(start = TrailingWidgetBuffer),
+                )
+            }
+        },
+        onPreferenceClick = { onClickSource(source.source.id) },
+    )
+}
+
+@Composable
+private fun AnimeNsfwWarningDialog(
+    onClickConfirm: () -> Unit,
+) {
+    AlertDialog(
+        text = {
+            Text(text = stringResource(MR.strings.ext_nsfw_warning))
+        },
+        confirmButton = {
+            TextButton(onClick = onClickConfirm) {
+                Text(text = stringResource(MR.strings.action_ok))
+            }
+        },
+        onDismissRequest = onClickConfirm,
+    )
+}
diff --git a/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionFilterScreen.kt b/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionFilterScreen.kt
new file mode 100644
index 0000000000..783bdaf854
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/browse/AnimeExtensionFilterScreen.kt
@@ -0,0 +1,99 @@
+package eu.kanade.presentation.browse
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+import eu.kanade.domain.extension.interactor.GetExtensionLanguages.Companion.getLanguageIconID
+import eu.kanade.presentation.components.AppBar
+import eu.kanade.presentation.more.settings.widget.SwitchPreferenceWidget
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.ui.browse.animeextension.AnimeExtensionFilterState
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.components.material.padding
+import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.screens.EmptyScreen
+
+@Composable
+fun AnimeExtensionFilterScreen(
+    navigateUp: () -> Unit,
+    state: AnimeExtensionFilterState.Success,
+    onClickToggle: (String) -> Unit,
+) {
+    Scaffold(
+        topBar = { scrollBehavior ->
+            AppBar(
+                title = stringResource(MR.strings.label_anime_extensions),
+                navigateUp = navigateUp,
+                scrollBehavior = scrollBehavior,
+            )
+        },
+    ) { contentPadding ->
+        if (state.isEmpty) {
+            EmptyScreen(
+                stringRes = MR.strings.empty_screen,
+                modifier = Modifier.padding(contentPadding),
+            )
+            return@Scaffold
+        }
+        AnimeExtensionFilterContent(
+            contentPadding = contentPadding,
+            state = state,
+            onClickLang = onClickToggle,
+        )
+    }
+}
+
+@Composable
+private fun AnimeExtensionFilterContent(
+    contentPadding: PaddingValues,
+    state: AnimeExtensionFilterState.Success,
+    onClickLang: (String) -> Unit,
+) {
+    val context = LocalContext.current
+    LazyColumn(
+        contentPadding = contentPadding,
+        modifier = Modifier
+            .padding(start = MaterialTheme.padding.small),
+    ) {
+        items(state.languages) { language ->
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                val iconResId = getLanguageIconID(language) ?: R.drawable.globe
+                Icon(
+                    painter = painterResource(id = iconResId),
+                    tint = Color.Unspecified,
+                    contentDescription = language,
+                    modifier = Modifier
+                        .width(48.dp)
+                        .height(32.dp),
+                )
+                SwitchPreferenceWidget(
+                    modifier = Modifier.animateItem(),
+                    title = LocaleHelper.getSourceDisplayName(language, context) +
+                        (
+                            " (${LocaleHelper.getDisplayName(language)})"
+                                .takeIf { language !in listOf("all", "other") } ?: ""
+                            ),
+                    checked = language in state.enabledLanguages,
+                    onCheckedChanged = { onClickLang(language) },
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/browse/components/BrowseIcons.kt b/app/src/main/java/eu/kanade/presentation/browse/components/BrowseIcons.kt
index a010a9d4ac..543ad778bb 100644
--- a/app/src/main/java/eu/kanade/presentation/browse/components/BrowseIcons.kt
+++ b/app/src/main/java/eu/kanade/presentation/browse/components/BrowseIcons.kt
@@ -29,6 +29,8 @@ import coil3.compose.AsyncImage
 import eu.kanade.domain.source.model.icon
 import eu.kanade.presentation.util.rememberResourceBitmapPainter
 import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animeextension.util.AnimeExtensionLoader
 import eu.kanade.tachiyomi.extension.model.Extension
 import eu.kanade.tachiyomi.extension.util.ExtensionLoader
 import tachiyomi.core.common.util.lang.withIOContext
@@ -141,6 +143,68 @@ private fun Extension.getIcon(density: Int = DisplayMetrics.DENSITY_DEFAULT): St
     }
 }
 
+@Composable
+fun AnimeExtensionIcon(
+    extension: AnimeExtension,
+    modifier: Modifier = Modifier,
+    density: Int = DisplayMetrics.DENSITY_DEFAULT,
+) {
+    when (extension) {
+        is AnimeExtension.Available -> {
+            AsyncImage(
+                model = extension.iconUrl,
+                contentDescription = null,
+                placeholder = ColorPainter(Color(0x1F888888)),
+                error = rememberResourceBitmapPainter(id = R.drawable.cover_error),
+                modifier = modifier
+                    .clip(MaterialTheme.shapes.extraSmall),
+            )
+        }
+        is AnimeExtension.Installed -> {
+            val icon by extension.getIcon(density)
+            when (icon) {
+                is Result.Loading -> Box(modifier = modifier)
+                is Result.Success -> Image(
+                    bitmap = (icon as Result.Success<ImageBitmap>).value,
+                    contentDescription = null,
+                    modifier = modifier,
+                )
+                is Result.Error -> Image(
+                    bitmap = ImageBitmap.imageResource(id = R.mipmap.ic_default_source),
+                    contentDescription = null,
+                    modifier = modifier,
+                )
+            }
+        }
+        is AnimeExtension.Untrusted -> Image(
+            imageVector = Icons.Filled.Dangerous,
+            contentDescription = null,
+            colorFilter = ColorFilter.tint(MaterialTheme.colorScheme.error),
+            modifier = modifier.then(defaultModifier),
+        )
+    }
+}
+
+@Composable
+private fun AnimeExtension.getIcon(density: Int = DisplayMetrics.DENSITY_DEFAULT): State<Result<ImageBitmap>> {
+    val context = LocalContext.current
+    return produceState<Result<ImageBitmap>>(initialValue = Result.Loading, this) {
+        withIOContext {
+            value = try {
+                val appInfo = AnimeExtensionLoader.getExtensionPackageInfoFromPkgName(context, pkgName)!!.applicationInfo!!
+                val appResources = context.packageManager.getResourcesForApplication(appInfo)
+                Result.Success(
+                    appResources.getDrawableForDensity(appInfo.icon, density, null)!!
+                        .toBitmap()
+                        .asImageBitmap(),
+                )
+            } catch (e: Exception) {
+                Result.Error
+            }
+        }
+    }
+}
+
 sealed class Result<out T> {
     data object Loading : Result<Nothing>()
     data object Error : Result<Nothing>()
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
index 0dfe06e4a3..a8b1949e2d 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
@@ -144,7 +144,7 @@ data object BrowseTab : Tab {
         val onChangeSearchQuery: (String?) -> Unit = when (currentTabTitleRes) {
             MR.strings.label_anime_extensions -> animeExtensionsScreenModel::search
             MR.strings.label_extensions -> extensionsScreenModel::search
-            else -> {}
+            else -> { _ -> }
         }
         TabbedScreen(
             titleRes = MR.strings.browse,
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionFilterScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionFilterScreen.kt
new file mode 100644
index 0000000000..767d1ddb47
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionFilterScreen.kt
@@ -0,0 +1,50 @@
+package eu.kanade.tachiyomi.ui.browse.animeextension
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.platform.LocalContext
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.browse.AnimeExtensionFilterScreen
+import eu.kanade.presentation.util.Screen
+import kotlinx.coroutines.flow.collectLatest
+import tachiyomi.core.common.i18n.stringResource
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.screens.LoadingScreen
+
+class AnimeExtensionFilterScreen : Screen() {
+
+    @Composable
+    override fun Content() {
+        val context = LocalContext.current
+        val navigator = LocalNavigator.currentOrThrow
+        val screenModel = rememberScreenModel { AnimeExtensionFilterScreenModel() }
+        val state by screenModel.state.collectAsState()
+
+        if (state is AnimeExtensionFilterState.Loading) {
+            LoadingScreen()
+            return
+        }
+
+        val successState = state as AnimeExtensionFilterState.Success
+
+        AnimeExtensionFilterScreen(
+            navigateUp = navigator::pop,
+            state = successState,
+            onClickToggle = screenModel::toggle,
+        )
+
+        LaunchedEffect(Unit) {
+            screenModel.events.collectLatest {
+                when (it) {
+                    AnimeExtensionFilterEvent.FailedFetchingLanguages -> {
+                        context.stringResource(MR.strings.internal_error)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionFilterScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionFilterScreenModel.kt
new file mode 100644
index 0000000000..a0a4b69fb8
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionFilterScreenModel.kt
@@ -0,0 +1,80 @@
+package eu.kanade.tachiyomi.ui.browse.animeextension
+
+import androidx.compose.runtime.Immutable
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import eu.kanade.domain.animeextension.interactor.GetAnimeExtensionLanguages
+import eu.kanade.domain.source.interactor.ToggleLanguage
+import eu.kanade.domain.source.service.SourcePreferences
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.ImmutableSet
+import kotlinx.collections.immutable.persistentSetOf
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.collections.immutable.toImmutableSet
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeExtensionFilterScreenModel(
+    private val preferences: SourcePreferences = Injekt.get(),
+    private val getAnimeExtensionLanguages: GetAnimeExtensionLanguages = Injekt.get(),
+    private val toggleLanguage: ToggleLanguage = Injekt.get(),
+) : StateScreenModel<AnimeExtensionFilterState>(AnimeExtensionFilterState.Loading) {
+
+    private val _events: Channel<AnimeExtensionFilterEvent> = Channel()
+    val events: Flow<AnimeExtensionFilterEvent> = _events.receiveAsFlow()
+
+    init {
+        screenModelScope.launch {
+            combine(
+                getAnimeExtensionLanguages.subscribe(),
+                preferences.enabledLanguages().changes(),
+            ) { a, b -> a to b }
+                .catch { throwable ->
+                    logcat(LogPriority.ERROR, throwable)
+                    _events.send(AnimeExtensionFilterEvent.FailedFetchingLanguages)
+                }
+                .collectLatest { (extensionLanguages, enabledLanguages) ->
+                    mutableState.update {
+                        AnimeExtensionFilterState.Success(
+                            languages = extensionLanguages.toImmutableList(),
+                            enabledLanguages = enabledLanguages.toImmutableSet(),
+                        )
+                    }
+                }
+        }
+    }
+
+    fun toggle(language: String) {
+        toggleLanguage.await(language)
+    }
+}
+
+sealed interface AnimeExtensionFilterEvent {
+    data object FailedFetchingLanguages : AnimeExtensionFilterEvent
+}
+
+sealed interface AnimeExtensionFilterState {
+
+    @Immutable
+    data object Loading : AnimeExtensionFilterState
+
+    @Immutable
+    data class Success(
+        val languages: ImmutableList<String>,
+        val enabledLanguages: ImmutableSet<String> = persistentSetOf(),
+    ) : AnimeExtensionFilterState {
+
+        val isEmpty: Boolean
+            get() = languages.isEmpty()
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsTab.kt
index e109f581d4..047f0e9571 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/AnimeExtensionsTab.kt
@@ -18,6 +18,7 @@ import eu.kanade.presentation.components.AppBar
 import eu.kanade.presentation.components.TabContent
 import eu.kanade.presentation.more.settings.screen.browse.AnimeExtensionReposScreen
 import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.ui.browse.animeextension.details.AnimeExtensionDetailsScreen
 import eu.kanade.tachiyomi.ui.webview.WebViewScreen
 import eu.kanade.tachiyomi.util.system.isPackageInstalled
 import kotlinx.collections.immutable.persistentListOf
@@ -39,6 +40,10 @@ fun animeExtensionsTab(
         badgeNumber = state.updates.takeIf { it > 0 },
         searchEnabled = true,
         actions = persistentListOf(
+            AppBar.OverflowAction(
+                title = stringResource(MR.strings.action_filter),
+                onClick = { navigator.push(AnimeExtensionFilterScreen()) },
+            ),
             AppBar.OverflowAction(
                 title = stringResource(MR.strings.action_webview_refresh),
                 onClick = animeExtensionsScreenModel::findAvailableExtensions,
@@ -82,7 +87,7 @@ fun animeExtensionsTab(
                     }
                 },
                 onInstallExtension = animeExtensionsScreenModel::installExtension,
-                onOpenExtension = { /* TODO: AnimeExtensionDetailsScreen */ },
+                onOpenExtension = { navigator.push(AnimeExtensionDetailsScreen(it.pkgName)) },
                 onTrustExtension = { animeExtensionsScreenModel.trustExtension(it) },
                 onUninstallExtension = { animeExtensionsScreenModel.uninstallExtension(it) },
                 onUpdateExtension = animeExtensionsScreenModel::updateExtension,
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeExtensionDetailsScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeExtensionDetailsScreen.kt
new file mode 100644
index 0000000000..1976508de0
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeExtensionDetailsScreen.kt
@@ -0,0 +1,69 @@
+package eu.kanade.tachiyomi.ui.browse.animeextension.details
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.platform.LocalContext
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.presentation.browse.AnimeExtensionDetailsScreen
+import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.ui.webview.WebViewScreen
+import kotlinx.coroutines.flow.collectLatest
+import tachiyomi.presentation.core.screens.LoadingScreen
+
+data class AnimeExtensionDetailsScreen(
+    private val pkgName: String,
+) : Screen() {
+
+    @Composable
+    override fun Content() {
+        val context = LocalContext.current
+        val screenModel = rememberScreenModel { AnimeExtensionDetailsScreenModel(pkgName = pkgName, context = context) }
+        val state by screenModel.state.collectAsState()
+
+        if (state.isLoading) {
+            LoadingScreen()
+            return
+        }
+
+        val navigator = LocalNavigator.currentOrThrow
+        val source = state.extension?.sources?.getOrNull(0)
+
+        AnimeExtensionDetailsScreen(
+            navigateUp = navigator::pop,
+            state = state,
+            onClickSourcePreferences = { navigator.push(AnimeSourcePreferencesScreen(it)) },
+            onOpenWebView = if (source != null && source is AnimeHttpSource) {
+                {
+                    navigator.push(
+                        WebViewScreen(
+                            url = source.baseUrl,
+                            initialTitle = source.name,
+                            sourceId = source.id,
+                        ),
+                    )
+                }
+            } else {
+                null
+            },
+            onClickEnableAll = { screenModel.toggleSources(true) },
+            onClickDisableAll = { screenModel.toggleSources(false) },
+            onClickClearCookies = screenModel::clearCookies,
+            onClickUninstall = screenModel::uninstallExtension,
+            onClickSource = screenModel::toggleSource,
+            onClickIncognito = screenModel::toggleIncognito,
+        )
+
+        LaunchedEffect(Unit) {
+            screenModel.events.collectLatest { event ->
+                if (event is AnimeExtensionDetailsEvent.Uninstalled) {
+                    navigator.pop()
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeExtensionDetailsScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeExtensionDetailsScreenModel.kt
new file mode 100644
index 0000000000..bf1a782ab3
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeExtensionDetailsScreenModel.kt
@@ -0,0 +1,158 @@
+package eu.kanade.tachiyomi.ui.browse.animeextension.details
+
+import android.content.Context
+import androidx.compose.runtime.Immutable
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import eu.kanade.domain.animeextension.interactor.AnimeExtensionSourceItem
+import eu.kanade.domain.animeextension.interactor.GetAnimeExtensionSources
+import eu.kanade.domain.source.interactor.ToggleIncognito
+import eu.kanade.domain.source.interactor.ToggleSource
+import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.animeextension.model.AnimeExtension
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.util.system.LocaleHelper
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.catch
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import logcat.LogPriority
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeExtensionDetailsScreenModel(
+    pkgName: String,
+    context: Context,
+    private val network: NetworkHelper = Injekt.get(),
+    private val animeExtensionManager: AnimeExtensionManager = Injekt.get(),
+    private val getAnimeExtensionSources: GetAnimeExtensionSources = Injekt.get(),
+    private val toggleSource: ToggleSource = Injekt.get(),
+    private val toggleIncognito: ToggleIncognito = Injekt.get(),
+    private val preferences: SourcePreferences = Injekt.get(),
+) : StateScreenModel<AnimeExtensionDetailsScreenModel.State>(State()) {
+
+    private val _events: Channel<AnimeExtensionDetailsEvent> = Channel()
+    val events: Flow<AnimeExtensionDetailsEvent> = _events.receiveAsFlow()
+
+    init {
+        screenModelScope.launch {
+            launch {
+                animeExtensionManager.installedExtensionsFlow
+                    .map { it.firstOrNull { extension -> extension.pkgName == pkgName } }
+                    .collectLatest { extension ->
+                        if (extension == null) {
+                            _events.send(AnimeExtensionDetailsEvent.Uninstalled)
+                            return@collectLatest
+                        }
+                        mutableState.update { state ->
+                            state.copy(extension = extension)
+                        }
+                    }
+            }
+            launch {
+                state.collectLatest { state ->
+                    if (state.extension == null) return@collectLatest
+                    getAnimeExtensionSources.subscribe(state.extension)
+                        .map {
+                            it.sortedWith(
+                                compareBy(
+                                    { !it.enabled },
+                                    { item ->
+                                        item.source.name.takeIf { item.labelAsName }
+                                            ?: LocaleHelper.getSourceDisplayName(item.source.lang, context).lowercase()
+                                    },
+                                ),
+                            )
+                        }
+                        .catch { throwable ->
+                            logcat(LogPriority.ERROR, throwable)
+                            mutableState.update { it.copy(_sources = persistentListOf()) }
+                        }
+                        .collectLatest { sources ->
+                            mutableState.update { it.copy(_sources = sources.toImmutableList()) }
+                        }
+                }
+            }
+            launch {
+                preferences.incognitoExtensions()
+                    .changes()
+                    .map { pkgName in it }
+                    .distinctUntilChanged()
+                    .collectLatest { isIncognito ->
+                        mutableState.update { it.copy(isIncognito = isIncognito) }
+                    }
+            }
+        }
+    }
+
+    fun clearCookies() {
+        val extension = state.value.extension ?: return
+
+        val urls = extension.sources
+            .filterIsInstance<AnimeHttpSource>()
+            .mapNotNull { it.baseUrl.takeUnless { url -> url.isEmpty() } }
+            .distinct()
+
+        val cleared = urls.sumOf {
+            try {
+                network.cookieJar.remove(it.toHttpUrl())
+            } catch (e: Exception) {
+                logcat(LogPriority.ERROR, e) { "Failed to clear cookies for $it" }
+                0
+            }
+        }
+
+        logcat { "Cleared $cleared cookies for: ${urls.joinToString()}" }
+    }
+
+    fun uninstallExtension() {
+        val extension = state.value.extension ?: return
+        animeExtensionManager.uninstallExtension(extension)
+    }
+
+    fun toggleSource(sourceId: Long) {
+        toggleSource.await(sourceId)
+    }
+
+    fun toggleSources(enable: Boolean) {
+        state.value.extension?.sources
+            ?.map { it.id }
+            ?.let { toggleSource.await(it, enable) }
+    }
+
+    fun toggleIncognito(enable: Boolean) {
+        state.value.extension?.pkgName?.let { packageName ->
+            toggleIncognito.await(packageName, enable)
+        }
+    }
+
+    @Immutable
+    data class State(
+        val extension: AnimeExtension.Installed? = null,
+        val isIncognito: Boolean = false,
+        private val _sources: ImmutableList<AnimeExtensionSourceItem>? = null,
+    ) {
+
+        val sources: ImmutableList<AnimeExtensionSourceItem>
+            get() = _sources ?: persistentListOf()
+
+        val isLoading: Boolean
+            get() = extension == null || _sources == null
+    }
+}
+
+sealed interface AnimeExtensionDetailsEvent {
+    data object Uninstalled : AnimeExtensionDetailsEvent
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeSourcePreferencesScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeSourcePreferencesScreen.kt
new file mode 100644
index 0000000000..fe5bca8ebd
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animeextension/details/AnimeSourcePreferencesScreen.kt
@@ -0,0 +1,169 @@
+package eu.kanade.tachiyomi.ui.browse.animeextension.details
+
+import android.content.Context
+import android.os.Bundle
+import android.util.TypedValue
+import android.view.View
+import androidx.appcompat.view.ContextThemeWrapper
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.os.bundleOf
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentContainerView
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.FragmentTransaction
+import androidx.fragment.app.commit
+import androidx.lifecycle.lifecycleScope
+import androidx.preference.DialogPreference
+import androidx.preference.EditTextPreference
+import androidx.preference.PreferenceFragmentCompat
+import androidx.preference.PreferenceScreen
+import androidx.preference.forEach
+import androidx.preference.getOnBindEditTextListener
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import eu.kanade.core.util.ifAnimeSourcesLoaded
+import eu.kanade.presentation.components.AppBar
+import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.animesource.sourcePreferences
+import eu.kanade.tachiyomi.data.preference.SharedPreferencesDataStore
+import eu.kanade.tachiyomi.widget.TachiyomiTextInputEditText.Companion.setIncognito
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.screens.LoadingScreen
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeSourcePreferencesScreen(val sourceId: Long) : Screen() {
+
+    @Composable
+    override fun Content() {
+        if (!ifAnimeSourcesLoaded()) {
+            LoadingScreen()
+            return
+        }
+
+        val context = LocalContext.current
+        val navigator = LocalNavigator.currentOrThrow
+
+        Scaffold(
+            topBar = {
+                AppBar(
+                    title = Injekt.get<AnimeSourceManager>().getOrStub(sourceId).toString(),
+                    navigateUp = navigator::pop,
+                    scrollBehavior = it,
+                )
+            },
+        ) { contentPadding ->
+            FragmentContainer(
+                fragmentManager = (context as FragmentActivity).supportFragmentManager,
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(contentPadding),
+            ) {
+                add(it, AnimeSourcePreferencesFragment.getInstance(sourceId), null)
+            }
+        }
+    }
+
+    @Composable
+    private fun FragmentContainer(
+        fragmentManager: FragmentManager,
+        modifier: Modifier = Modifier,
+        commit: FragmentTransaction.(containerId: Int) -> Unit,
+    ) {
+        val containerId by rememberSaveable {
+            mutableIntStateOf(View.generateViewId())
+        }
+        var initialized by rememberSaveable { mutableStateOf(false) }
+        AndroidView(
+            modifier = modifier,
+            factory = { context ->
+                FragmentContainerView(context)
+                    .apply { id = containerId }
+            },
+            update = { view ->
+                if (!initialized) {
+                    fragmentManager.commit { commit(view.id) }
+                    initialized = true
+                } else {
+                    fragmentManager.onContainerAvailable(view)
+                }
+            },
+        )
+    }
+
+    private fun FragmentManager.onContainerAvailable(view: FragmentContainerView) {
+        val method = FragmentManager::class.java.getDeclaredMethod(
+            "onContainerAvailable",
+            FragmentContainerView::class.java,
+        )
+        method.isAccessible = true
+        method.invoke(this, view)
+    }
+}
+
+class AnimeSourcePreferencesFragment : PreferenceFragmentCompat() {
+
+    override fun getContext(): Context? {
+        val superCtx = super.getContext() ?: return null
+        val tv = TypedValue()
+        superCtx.theme.resolveAttribute(R.attr.preferenceTheme, tv, true)
+        return ContextThemeWrapper(superCtx, tv.resourceId)
+    }
+
+    override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
+        preferenceScreen = populateScreen()
+    }
+
+    private fun populateScreen(): PreferenceScreen {
+        val sourceId = requireArguments().getLong(SOURCE_ID)
+        val source = Injekt.get<AnimeSourceManager>().getOrStub(sourceId)
+        val sourceScreen = preferenceManager.createPreferenceScreen(requireContext())
+
+        if (source is ConfigurableAnimeSource) {
+            val dataStore = SharedPreferencesDataStore(source.sourcePreferences())
+            preferenceManager.preferenceDataStore = dataStore
+
+            source.setupPreferenceScreen(sourceScreen)
+            sourceScreen.forEach { pref ->
+                pref.isIconSpaceReserved = false
+                pref.isSingleLineTitle = false
+                if (pref is DialogPreference && pref.dialogTitle.isNullOrEmpty()) {
+                    pref.dialogTitle = pref.title
+                }
+
+                if (pref is EditTextPreference) {
+                    val setListener = pref.getOnBindEditTextListener()
+                    pref.setOnBindEditTextListener {
+                        setListener?.onBindEditText(it)
+                        it.setIncognito(lifecycleScope)
+                    }
+                }
+            }
+        }
+
+        return sourceScreen
+    }
+
+    companion object {
+        private const val SOURCE_ID = "source_id"
+
+        fun getInstance(sourceId: Long): AnimeSourcePreferencesFragment {
+            return AnimeSourcePreferencesFragment().apply {
+                arguments = bundleOf(SOURCE_ID to sourceId)
+            }
+        }
+    }
+}

From f885d8fd849e18212c826ec1600c4d964ec7aa9a Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sun, 10 May 2026 00:05:23 +0200
Subject: [PATCH 08/13] Anime offline download

---
 .../java/eu/kanade/domain/DomainModule.kt     |   2 +
 .../interactor/DeleteAnimeDownload.kt         |  19 +
 .../kanade/presentation/anime/AnimeScreen.kt  |  59 ++-
 .../anime/components/AnimeEpisodeListItem.kt  |  83 ++++
 .../data/animedownload/AnimeDownloadCache.kt  | 307 ++++++++++++
 .../data/animedownload/AnimeDownloadJob.kt    | 138 ++++++
 .../animedownload/AnimeDownloadManager.kt     | 139 ++++++
 .../animedownload/AnimeDownloadNotifier.kt    | 121 +++++
 .../AnimeDownloadPendingDeleter.kt            |  75 +++
 .../animedownload/AnimeDownloadProvider.kt    | 124 +++++
 .../data/animedownload/AnimeDownloadStore.kt  |  96 ++++
 .../data/animedownload/AnimeDownloader.kt     | 437 ++++++++++++++++++
 .../data/animedownload/model/AnimeDownload.kt |  49 ++
 .../tachiyomi/data/download/DownloadCache.kt  |  27 --
 .../data/download/UniFileSerializer.kt        |  33 ++
 .../data/notification/Notifications.kt        |  20 +
 .../java/eu/kanade/tachiyomi/di/AppModule.kt  |   7 +
 .../kanade/tachiyomi/ui/anime/AnimeScreen.kt  |   3 +
 .../tachiyomi/ui/anime/AnimeScreenModel.kt    | 136 +++++-
 .../tachiyomi/ui/player/PlayerViewModel.kt    |  13 +-
 .../domain/storage/service/StorageManager.kt  |   5 +
 21 files changed, 1863 insertions(+), 30 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/domain/animedownload/interactor/DeleteAnimeDownload.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadCache.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadJob.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadManager.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadNotifier.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadPendingDeleter.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadProvider.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadStore.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/animedownload/model/AnimeDownload.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/download/UniFileSerializer.kt

diff --git a/app/src/main/java/eu/kanade/domain/DomainModule.kt b/app/src/main/java/eu/kanade/domain/DomainModule.kt
index d1a2e04a2c..3dd354f534 100644
--- a/app/src/main/java/eu/kanade/domain/DomainModule.kt
+++ b/app/src/main/java/eu/kanade/domain/DomainModule.kt
@@ -6,6 +6,7 @@ import eu.kanade.domain.animeextension.interactor.GetAnimeExtensionsByType
 import eu.kanade.domain.chapter.interactor.GetAvailableScanlators
 import eu.kanade.domain.chapter.interactor.SetReadStatus
 import eu.kanade.domain.chapter.interactor.SyncChaptersWithSource
+import eu.kanade.domain.animedownload.interactor.DeleteAnimeDownload
 import eu.kanade.domain.download.interactor.DeleteDownload
 import eu.kanade.domain.extension.interactor.GetExtensionLanguages
 import eu.kanade.domain.extension.interactor.GetExtensionSources
@@ -189,6 +190,7 @@ class DomainModule : InjektModule {
         addFactory { GetTotalReadDuration(get()) }
 
         addFactory { DeleteDownload(get(), get()) }
+        addFactory { DeleteAnimeDownload(get(), get()) }
 
         addFactory { GetExtensionsByType(get(), get()) }
         addFactory { GetExtensionSources(get()) }
diff --git a/app/src/main/java/eu/kanade/domain/animedownload/interactor/DeleteAnimeDownload.kt b/app/src/main/java/eu/kanade/domain/animedownload/interactor/DeleteAnimeDownload.kt
new file mode 100644
index 0000000000..e057003b0e
--- /dev/null
+++ b/app/src/main/java/eu/kanade/domain/animedownload/interactor/DeleteAnimeDownload.kt
@@ -0,0 +1,19 @@
+package eu.kanade.domain.animedownload.interactor
+
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
+import tachiyomi.core.common.util.lang.withNonCancellableContext
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.domain.episode.model.Episode
+
+class DeleteAnimeDownload(
+    private val animeSourceManager: AnimeSourceManager,
+    private val animeDownloadManager: AnimeDownloadManager,
+) {
+
+    suspend fun awaitAll(anime: Anime, vararg episodes: Episode) = withNonCancellableContext {
+        animeSourceManager.get(anime.source)?.let { source ->
+            animeDownloadManager.deleteEpisodes(episodes.toList(), anime, source)
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt b/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
index 2c553098c8..45b9f26456 100644
--- a/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
@@ -1,5 +1,6 @@
 package eu.kanade.presentation.anime
 
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
@@ -9,10 +10,12 @@ import androidx.compose.material.icons.automirrored.outlined.ArrowBack
 import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.PlayArrow
 import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.CircularProgressIndicator
 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
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SmallExtendedFloatingActionButton
 import androidx.compose.material3.Text
@@ -26,6 +29,8 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import eu.kanade.presentation.anime.components.AnimeEpisodeListItem
 import eu.kanade.presentation.anime.components.AnimeInfoHeader
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
 import eu.kanade.tachiyomi.ui.anime.AnimeScreenModel
 import tachiyomi.domain.episode.model.Episode
 import tachiyomi.i18n.MR
@@ -43,6 +48,9 @@ fun AnimeScreenContent(
     onDeleteClicked: () -> Unit,
     onDismissDialog: () -> Unit,
     onConfirmDelete: () -> Unit,
+    onDownloadEpisode: (Episode) -> Unit = {},
+    onDeleteEpisodeDownload: (Episode) -> Unit = {},
+    onConfirmDownloadQuality: (Episode, Video) -> Unit = { _, _ -> },
 ) {
     val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
 
@@ -119,16 +127,21 @@ fun AnimeScreenContent(
                 items = state.episodes,
                 key = { it.id },
             ) { episode ->
+                val dlState = state.episodeDownloadState[episode.id]
                 AnimeEpisodeListItem(
                     episode = episode,
+                    downloadState = dlState?.status ?: AnimeDownload.State.NOT_DOWNLOADED,
+                    downloadProgress = dlState?.progress ?: 0,
                     onClick = { onEpisodeClicked(episode) },
+                    onDownloadClick = { onDownloadEpisode(episode) },
+                    onDeleteDownloadClick = { onDeleteEpisodeDownload(episode) },
                 )
                 HorizontalDivider()
             }
         }
     }
 
-    when (state.dialog) {
+    when (val dialog = state.dialog) {
         is AnimeScreenModel.Dialog.ConfirmDelete -> {
             AlertDialog(
                 onDismissRequest = onDismissDialog,
@@ -146,6 +159,50 @@ fun AnimeScreenContent(
                 },
             )
         }
+        is AnimeScreenModel.Dialog.DownloadLoading -> {
+            AlertDialog(
+                onDismissRequest = onDismissDialog,
+                title = { Text("Resolving videos...") },
+                text = { CircularProgressIndicator() },
+                confirmButton = {
+                    TextButton(onClick = onDismissDialog) {
+                        Text(stringResource(MR.strings.action_cancel))
+                    }
+                },
+            )
+        }
+        is AnimeScreenModel.Dialog.QualitySelection -> {
+            AlertDialog(
+                onDismissRequest = onDismissDialog,
+                title = { Text("Select quality") },
+                text = {
+                    LazyColumn {
+                        items(
+                            items = dialog.videos,
+                            key = { it.videoUrl },
+                        ) { video ->
+                            ListItem(
+                                headlineContent = {
+                                    Text(
+                                        text = video.videoTitle.ifBlank {
+                                            video.resolution?.let { "${it}p" } ?: "Unknown"
+                                        },
+                                    )
+                                },
+                                modifier = Modifier.clickable {
+                                    onConfirmDownloadQuality(dialog.episode, video)
+                                },
+                            )
+                        }
+                    }
+                },
+                confirmButton = {
+                    TextButton(onClick = onDismissDialog) {
+                        Text(stringResource(MR.strings.action_cancel))
+                    }
+                },
+            )
+        }
         null -> {}
     }
 }
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
index d1778a71a5..db4f551dee 100644
--- a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
@@ -1,13 +1,19 @@
 package eu.kanade.presentation.anime.components
 
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Bookmark
+import androidx.compose.material.icons.filled.CheckCircle
+import androidx.compose.material.icons.outlined.Download
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.LocalContentColor
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -17,6 +23,7 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
 import eu.kanade.tachiyomi.ui.player.buildProgressString
 import tachiyomi.domain.episode.model.Episode
 import tachiyomi.presentation.core.components.material.DISABLED_ALPHA
@@ -24,7 +31,11 @@ import tachiyomi.presentation.core.components.material.DISABLED_ALPHA
 @Composable
 fun AnimeEpisodeListItem(
     episode: Episode,
+    downloadState: AnimeDownload.State,
+    downloadProgress: Int,
     onClick: () -> Unit,
+    onDownloadClick: () -> Unit,
+    onDeleteDownloadClick: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
     val textColor = if (episode.seen) {
@@ -71,5 +82,77 @@ fun AnimeEpisodeListItem(
                 }
             }
         }
+
+        EpisodeDownloadIndicator(
+            state = downloadState,
+            progress = downloadProgress,
+            onDownloadClick = onDownloadClick,
+            onDeleteClick = onDeleteDownloadClick,
+        )
+    }
+}
+
+@Composable
+private fun EpisodeDownloadIndicator(
+    state: AnimeDownload.State,
+    progress: Int,
+    onDownloadClick: () -> Unit,
+    onDeleteClick: () -> Unit,
+) {
+    when (state) {
+        AnimeDownload.State.NOT_DOWNLOADED -> {
+            IconButton(onClick = onDownloadClick) {
+                Icon(
+                    imageVector = Icons.Outlined.Download,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.size(24.dp),
+                )
+            }
+        }
+        AnimeDownload.State.QUEUE -> {
+            Box(
+                modifier = Modifier.size(48.dp),
+                contentAlignment = Alignment.Center,
+            ) {
+                CircularProgressIndicator(
+                    modifier = Modifier.size(24.dp),
+                    strokeWidth = 2.dp,
+                )
+            }
+        }
+        AnimeDownload.State.DOWNLOADING -> {
+            Box(
+                modifier = Modifier.size(48.dp),
+                contentAlignment = Alignment.Center,
+            ) {
+                CircularProgressIndicator(
+                    progress = { progress / 100f },
+                    modifier = Modifier.size(24.dp),
+                    strokeWidth = 2.dp,
+                    color = MaterialTheme.colorScheme.primary,
+                )
+            }
+        }
+        AnimeDownload.State.DOWNLOADED -> {
+            IconButton(onClick = onDeleteClick) {
+                Icon(
+                    imageVector = Icons.Filled.CheckCircle,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.size(24.dp),
+                )
+            }
+        }
+        AnimeDownload.State.ERROR -> {
+            IconButton(onClick = onDownloadClick) {
+                Icon(
+                    imageVector = Icons.Outlined.Download,
+                    contentDescription = null,
+                    tint = MaterialTheme.colorScheme.error,
+                    modifier = Modifier.size(24.dp),
+                )
+            }
+        }
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadCache.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadCache.kt
new file mode 100644
index 0000000000..756de67d2b
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadCache.kt
@@ -0,0 +1,307 @@
+package eu.kanade.tachiyomi.data.animedownload
+
+import android.content.Context
+import com.hippo.unifile.UniFile
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadProvider.Companion.TMP_DIR_SUFFIX
+import eu.kanade.tachiyomi.data.download.UniFileAsStringSerializer
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.onStart
+import kotlinx.coroutines.flow.receiveAsFlow
+import kotlinx.coroutines.flow.shareIn
+import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromByteArray
+import kotlinx.serialization.encodeToByteArray
+import kotlinx.serialization.protobuf.ProtoBuf
+import logcat.LogPriority
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.lang.launchNonCancellable
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.storage.service.StorageManager
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.io.File
+import kotlin.time.Duration.Companion.hours
+
+class AnimeDownloadCache(
+    private val context: Context,
+    private val provider: AnimeDownloadProvider = Injekt.get(),
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+    private val storageManager: StorageManager = Injekt.get(),
+) {
+
+    private val scope = CoroutineScope(Dispatchers.IO)
+
+    private val _changes: Channel<Unit> = Channel(Channel.UNLIMITED)
+    val changes = _changes.receiveAsFlow()
+        .onStart { emit(Unit) }
+        .shareIn(scope, SharingStarted.Lazily, 1)
+
+    private val renewInterval = 1.hours.inWholeMilliseconds
+
+    private var lastRenew = 0L
+    private var renewalJob: Job? = null
+
+    private val _isInitializing = MutableStateFlow(false)
+    val isInitializing = _isInitializing
+        .debounce(1000L)
+        .stateIn(scope, SharingStarted.WhileSubscribed(), false)
+
+    private val diskCacheFile: File
+        get() = File(context.cacheDir, "anime_dl_index_cache_v1")
+
+    private val rootDirMutex = Mutex()
+    private var rootDir = RootDirectory(storageManager.getAnimeDownloadsDirectory())
+
+    init {
+        scope.launch {
+            rootDirMutex.withLock {
+                try {
+                    if (diskCacheFile.exists()) {
+                        val diskCache = diskCacheFile.inputStream().use {
+                            ProtoBuf.decodeFromByteArray<RootDirectory>(it.readBytes())
+                        }
+                        rootDir = diskCache
+                        lastRenew = System.currentTimeMillis()
+                    }
+                } catch (e: Throwable) {
+                    logcat(LogPriority.ERROR, e) { "Failed to initialize anime download cache from disk" }
+                    diskCacheFile.delete()
+                }
+            }
+        }
+
+        storageManager.changes
+            .onEach { invalidateCache() }
+            .launchIn(scope)
+    }
+
+    fun isEpisodeDownloaded(
+        episodeName: String,
+        episodeScanlator: String?,
+        animeTitle: String,
+        sourceId: Long,
+        skipCache: Boolean = false,
+    ): Boolean {
+        if (skipCache) {
+            val source = animeSourceManager.getOrStub(sourceId)
+            return provider.findEpisodeDir(episodeName, episodeScanlator, animeTitle, source) != null
+        }
+
+        renewCache()
+
+        val sourceDir = rootDir.sourceDirs[sourceId]
+        if (sourceDir != null) {
+            val animeDir = sourceDir.animeDirs[provider.getAnimeDirName(animeTitle)]
+            if (animeDir != null) {
+                val episodeDirName = provider.getEpisodeDirName(episodeName, episodeScanlator)
+                return episodeDirName in animeDir.episodeDirs
+            }
+        }
+        return false
+    }
+
+    fun getDownloadCount(anime: Anime): Int {
+        renewCache()
+
+        val sourceDir = rootDir.sourceDirs[anime.source]
+        if (sourceDir != null) {
+            val animeDir = sourceDir.animeDirs[provider.getAnimeDirName(anime.title)]
+            if (animeDir != null) {
+                return animeDir.episodeDirs.size
+            }
+        }
+        return 0
+    }
+
+    suspend fun addEpisode(episodeDirName: String, animeUniFile: UniFile, anime: Anime) {
+        rootDirMutex.withLock {
+            var sourceDir = rootDir.sourceDirs[anime.source]
+            if (sourceDir == null) {
+                val source = animeSourceManager.get(anime.source) ?: return
+                val sourceUniFile = provider.findSourceDir(source) ?: return
+                sourceDir = SourceDirectory(sourceUniFile)
+                rootDir.sourceDirs += anime.source to sourceDir
+            }
+
+            val animeDirName = provider.getAnimeDirName(anime.title)
+            var animeDir = sourceDir.animeDirs[animeDirName]
+            if (animeDir == null) {
+                animeDir = AnimeDirectory(animeUniFile)
+                sourceDir.animeDirs += animeDirName to animeDir
+            }
+
+            animeDir.episodeDirs += episodeDirName
+        }
+
+        notifyChanges()
+    }
+
+    suspend fun removeEpisode(episode: Episode, anime: Anime) {
+        rootDirMutex.withLock {
+            val sourceDir = rootDir.sourceDirs[anime.source] ?: return
+            val animeDir = sourceDir.animeDirs[provider.getAnimeDirName(anime.title)] ?: return
+            val episodeDirName = provider.getEpisodeDirName(episode.name, episode.scanlator)
+            animeDir.episodeDirs -= episodeDirName
+        }
+
+        notifyChanges()
+    }
+
+    suspend fun removeEpisodes(episodes: List<Episode>, anime: Anime) {
+        rootDirMutex.withLock {
+            val sourceDir = rootDir.sourceDirs[anime.source] ?: return
+            val animeDir = sourceDir.animeDirs[provider.getAnimeDirName(anime.title)] ?: return
+            episodes.forEach { episode ->
+                val episodeDirName = provider.getEpisodeDirName(episode.name, episode.scanlator)
+                animeDir.episodeDirs -= episodeDirName
+            }
+        }
+
+        notifyChanges()
+    }
+
+    suspend fun removeAnime(anime: Anime) {
+        rootDirMutex.withLock {
+            val sourceDir = rootDir.sourceDirs[anime.source] ?: return
+            val animeDirName = provider.getAnimeDirName(anime.title)
+            if (sourceDir.animeDirs.containsKey(animeDirName)) {
+                sourceDir.animeDirs -= animeDirName
+            }
+        }
+
+        notifyChanges()
+    }
+
+    fun invalidateCache() {
+        lastRenew = 0L
+        renewalJob?.cancel()
+        diskCacheFile.delete()
+        renewCache()
+    }
+
+    private fun renewCache() {
+        if (lastRenew + renewInterval >= System.currentTimeMillis() || renewalJob?.isActive == true) {
+            return
+        }
+
+        renewalJob = scope.launchIO {
+            if (lastRenew == 0L) {
+                _isInitializing.emit(true)
+            }
+
+            val sources = animeSourceManager.getOnlineSources() + animeSourceManager.getStubSources()
+            val sourceMap = sources.associate { provider.getSourceDirName(it).lowercase() to it.id }
+
+            val updatedRootDir = RootDirectory(storageManager.getAnimeDownloadsDirectory())
+
+            updatedRootDir.sourceDirs = updatedRootDir.dir?.listFiles().orEmpty()
+                .filter { it.isDirectory && !it.name.isNullOrBlank() }
+                .mapNotNull { dir ->
+                    val sourceId = sourceMap[dir.name!!.lowercase()]
+                    sourceId?.let { it to SourceDirectory(dir) }
+                }
+                .toMap()
+
+            updatedRootDir.sourceDirs.values.map { sourceDir ->
+                async {
+                    sourceDir.animeDirs = sourceDir.dir?.listFiles().orEmpty()
+                        .filter { it.isDirectory && !it.name.isNullOrBlank() }
+                        .associate { it.name!! to AnimeDirectory(it) }
+
+                    sourceDir.animeDirs.values.forEach { animeDir ->
+                        val episodeDirs = animeDir.dir?.listFiles().orEmpty()
+                            .mapNotNull {
+                                when {
+                                    it.name?.endsWith(TMP_DIR_SUFFIX) == true -> null
+                                    it.isDirectory -> it.name
+                                    else -> null
+                                }
+                            }
+                            .toMutableSet()
+
+                        animeDir.episodeDirs = episodeDirs
+                    }
+                }
+            }.awaitAll()
+
+            rootDirMutex.withLock {
+                rootDir = updatedRootDir
+            }
+
+            _isInitializing.emit(false)
+        }.also {
+            it.invokeOnCompletion(onCancelling = true) { exception ->
+                if (exception != null && exception !is CancellationException) {
+                    logcat(LogPriority.ERROR, exception) { "AnimeDownloadCache: failed to create cache" }
+                }
+                lastRenew = System.currentTimeMillis()
+                notifyChanges()
+            }
+        }
+
+    }
+
+    private fun notifyChanges() {
+        scope.launchNonCancellable {
+            _changes.send(Unit)
+        }
+        updateDiskCache()
+    }
+
+    private var updateDiskCacheJob: Job? = null
+    private fun updateDiskCache() {
+        updateDiskCacheJob?.cancel()
+        updateDiskCacheJob = scope.launchIO {
+            delay(1000)
+            ensureActive()
+            val bytes = ProtoBuf.encodeToByteArray(rootDir)
+            ensureActive()
+            try {
+                diskCacheFile.writeBytes(bytes)
+            } catch (e: Throwable) {
+                logcat(LogPriority.ERROR, e) { "Failed to write anime download disk cache" }
+            }
+        }
+    }
+}
+
+@Serializable
+private class RootDirectory(
+    @Serializable(with = UniFileAsStringSerializer::class)
+    val dir: UniFile?,
+    var sourceDirs: Map<Long, SourceDirectory> = mapOf(),
+)
+
+@Serializable
+private class SourceDirectory(
+    @Serializable(with = UniFileAsStringSerializer::class)
+    val dir: UniFile?,
+    var animeDirs: Map<String, AnimeDirectory> = mapOf(),
+)
+
+@Serializable
+private class AnimeDirectory(
+    @Serializable(with = UniFileAsStringSerializer::class)
+    val dir: UniFile?,
+    var episodeDirs: MutableSet<String> = mutableSetOf(),
+)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadJob.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadJob.kt
new file mode 100644
index 0000000000..4ef8393c9d
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadJob.kt
@@ -0,0 +1,138 @@
+package eu.kanade.tachiyomi.data.animedownload
+
+import android.content.Context
+import android.content.pm.ServiceInfo
+import android.os.Build
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.asFlow
+import androidx.work.CoroutineWorker
+import androidx.work.ExistingWorkPolicy
+import androidx.work.ForegroundInfo
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import androidx.work.WorkerParameters
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.data.notification.Notifications
+import eu.kanade.tachiyomi.util.system.NetworkState
+import eu.kanade.tachiyomi.util.system.activeNetworkState
+import eu.kanade.tachiyomi.util.system.networkStateFlow
+import eu.kanade.tachiyomi.util.system.notificationBuilder
+import eu.kanade.tachiyomi.util.system.setForegroundSafely
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.combineTransform
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.download.service.DownloadPreferences
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeDownloadJob(
+    private val context: Context,
+    workerParams: WorkerParameters,
+) : CoroutineWorker(context, workerParams) {
+
+    private val animeDownloadManager: AnimeDownloadManager = Injekt.get()
+    private val downloadPreferences: DownloadPreferences = Injekt.get()
+
+    override suspend fun getForegroundInfo(): ForegroundInfo {
+        val notification = applicationContext.notificationBuilder(Notifications.CHANNEL_ANIME_DOWNLOADER_PROGRESS) {
+            setContentTitle(applicationContext.getString(R.string.download_notifier_downloader_title))
+            setSmallIcon(android.R.drawable.stat_sys_download)
+            setColor(ContextCompat.getColor(applicationContext, R.color.ic_launcher))
+        }.build()
+        return ForegroundInfo(
+            Notifications.ID_ANIME_DOWNLOAD_PROGRESS,
+            notification,
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            } else {
+                0
+            },
+        )
+    }
+
+    override suspend fun doWork(): Result {
+        var networkCheck = checkNetworkState(
+            applicationContext.activeNetworkState(),
+            downloadPreferences.downloadOnlyOverWifi().get(),
+        )
+        var active = networkCheck && animeDownloadManager.downloaderStart()
+
+        if (!active) {
+            logcat(LogPriority.WARN) { "AnimeDownloadJob: not active (networkCheck=$networkCheck)" }
+            return Result.failure()
+        }
+        logcat(LogPriority.INFO) { "AnimeDownloadJob: started successfully" }
+
+        setForegroundSafely()
+
+        coroutineScope {
+            combineTransform(
+                applicationContext.networkStateFlow(),
+                downloadPreferences.downloadOnlyOverWifi().changes(),
+                transform = { a, b -> emit(checkNetworkState(a, b)) },
+            )
+                .onEach { networkCheck = it }
+                .launchIn(this)
+        }
+
+        while (active) {
+            active = !isStopped && animeDownloadManager.isRunning && networkCheck
+        }
+
+        return Result.success()
+    }
+
+    private fun checkNetworkState(state: NetworkState, requireWifi: Boolean): Boolean {
+        return if (state.isOnline) {
+            val noWifi = requireWifi && !state.isWifi
+            if (noWifi) {
+                animeDownloadManager.downloaderStop(
+                    applicationContext.getString(R.string.download_notifier_text_only_wifi),
+                )
+            }
+            !noWifi
+        } else {
+            animeDownloadManager.downloaderStop(
+                applicationContext.getString(R.string.download_notifier_no_network),
+            )
+            false
+        }
+    }
+
+    companion object {
+        private const val TAG = "AnimeDownloader"
+
+        fun start(context: Context) {
+            val request = OneTimeWorkRequestBuilder<AnimeDownloadJob>()
+                .addTag(TAG)
+                .build()
+            WorkManager.getInstance(context)
+                .enqueueUniqueWork(TAG, ExistingWorkPolicy.REPLACE, request)
+        }
+
+        fun stop(context: Context) {
+            WorkManager.getInstance(context)
+                .cancelUniqueWork(TAG)
+        }
+
+        fun isRunning(context: Context): Boolean {
+            return WorkManager.getInstance(context)
+                .getWorkInfosForUniqueWork(TAG)
+                .get()
+                .let { list -> list.count { it.state == WorkInfo.State.RUNNING } == 1 }
+        }
+
+        fun isRunningFlow(context: Context): Flow<Boolean> {
+            return WorkManager.getInstance(context)
+                .getWorkInfosForUniqueWorkLiveData(TAG)
+                .asFlow()
+                .map { list -> list.count { it.state == WorkInfo.State.RUNNING } == 1 }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadManager.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadManager.kt
new file mode 100644
index 0000000000..7bf41de714
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadManager.kt
@@ -0,0 +1,139 @@
+package eu.kanade.tachiyomi.data.animedownload
+
+import android.content.Context
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.animesource.model.SerializableVideo.Companion.toVideoList
+import eu.kanade.tachiyomi.animesource.model.Track
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.domain.episode.model.Episode
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeDownloadManager(
+    private val context: Context,
+    private val provider: AnimeDownloadProvider = Injekt.get(),
+    private val cache: AnimeDownloadCache = Injekt.get(),
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+) {
+
+    private val downloader = AnimeDownloader(context, provider, cache)
+    private val pendingDeleter = AnimeDownloadPendingDeleter(context)
+
+    val isRunning: Boolean
+        get() = downloader.isRunning
+
+    val queueState
+        get() = downloader.queueState
+
+    val stateVersion
+        get() = downloader.stateVersion
+
+    fun downloaderStart() = downloader.start()
+    fun downloaderStop(reason: String? = null) = downloader.stop(reason)
+
+    fun startDownloads() {
+        if (downloader.isRunning) return
+        if (AnimeDownloadJob.isRunning(context)) {
+            downloader.start()
+        } else {
+            AnimeDownloadJob.start(context)
+        }
+    }
+
+    fun pauseDownloads() {
+        downloader.pause()
+        AnimeDownloadJob.stop(context)
+    }
+
+    fun clearQueue() {
+        downloader.clearQueue()
+        AnimeDownloadJob.stop(context)
+    }
+
+    fun downloadEpisodes(anime: Anime, episodes: List<Episode>, videos: List<Video?>, autoStart: Boolean = true) {
+        downloader.queueEpisodes(anime, episodes, videos, autoStart)
+    }
+
+    fun isEpisodeDownloaded(episodeName: String, scanlator: String?, animeTitle: String, sourceId: Long): Boolean {
+        return cache.isEpisodeDownloaded(episodeName, scanlator, animeTitle, sourceId)
+    }
+
+    fun getDownloadCount(anime: Anime): Int {
+        return cache.getDownloadCount(anime)
+    }
+
+    suspend fun deleteEpisodes(episodes: List<Episode>, anime: Anime, source: AnimeSource) {
+        val (_, episodeDirs) = provider.findEpisodeDirs(episodes, anime, source)
+        episodeDirs.forEach { it.delete() }
+        cache.removeEpisodes(episodes, anime)
+        downloader.removeFromQueue(episodes)
+    }
+
+    suspend fun deleteAnime(anime: Anime, source: AnimeSource) {
+        val animeDir = provider.findAnimeDir(anime.title, source)
+        animeDir?.delete()
+        cache.removeAnime(anime)
+        downloader.removeFromQueue(anime)
+    }
+
+    fun buildVideoForPlayer(anime: Anime, episode: Episode, source: AnimeSource): Video? {
+        val episodeDir = provider.findEpisodeDir(
+            episode.name,
+            episode.scanlator,
+            anime.title,
+            source,
+        ) ?: return null
+
+        val videoFile = episodeDir.listFiles()?.firstOrNull { file ->
+            val name = file.name ?: return@firstOrNull false
+            !file.isDirectory &&
+                name != "metadata.json" &&
+                name != ".nomedia" &&
+                !name.startsWith(".")
+        } ?: return null
+
+        val metadataFile = episodeDir.findFile("metadata.json")
+        var subtitleTracks = emptyList<Track>()
+        var timestamps = emptyList<eu.kanade.tachiyomi.animesource.model.TimeStamp>()
+        var videoTitle = ""
+
+        if (metadataFile != null) {
+            try {
+                val json = metadataFile.openInputStream().use { it.bufferedReader().readText() }
+                val videos = json.toVideoList()
+                videos.firstOrNull()?.let { v ->
+                    videoTitle = v.videoTitle
+                    timestamps = v.timestamps
+                    // Remap subtitle tracks to local paths
+                    val subtitleDir = episodeDir.findFile("subtitles")
+                    subtitleTracks = v.subtitleTracks.map { track ->
+                        val localFile = subtitleDir?.findFile("${track.lang}.${subtitleExtensionFromUrl(track.url)}")
+                        Track(
+                            url = localFile?.uri?.toString() ?: track.url,
+                            lang = track.lang,
+                        )
+                    }
+                }
+            } catch (_: Exception) {}
+        }
+
+        return Video(
+            videoUrl = videoFile.uri.toString(),
+            videoTitle = videoTitle,
+            subtitleTracks = subtitleTracks,
+            timestamps = timestamps,
+        )
+    }
+
+    fun statusFlow(): Flow<AnimeDownload?> {
+        return queueState.map { queue ->
+            queue.firstOrNull { it.status == AnimeDownload.State.DOWNLOADING }
+                ?: queue.firstOrNull()
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadNotifier.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadNotifier.kt
new file mode 100644
index 0000000000..3907391dba
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadNotifier.kt
@@ -0,0 +1,121 @@
+package eu.kanade.tachiyomi.data.animedownload
+
+import android.content.Context
+import androidx.core.app.NotificationCompat
+import androidx.core.content.ContextCompat
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.core.security.SecurityPreferences
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
+import eu.kanade.tachiyomi.data.notification.NotificationHandler
+import eu.kanade.tachiyomi.data.notification.Notifications
+import eu.kanade.tachiyomi.util.lang.chop
+import eu.kanade.tachiyomi.util.system.cancelNotification
+import eu.kanade.tachiyomi.util.system.notificationBuilder
+import eu.kanade.tachiyomi.util.system.notify
+import tachiyomi.core.common.i18n.stringResource
+import tachiyomi.i18n.MR
+import uy.kohesive.injekt.injectLazy
+import java.util.regex.Pattern
+
+internal class AnimeDownloadNotifier(private val context: Context) {
+
+    private val preferences: SecurityPreferences by injectLazy()
+
+    private val progressNotificationBuilder by lazy {
+        context.notificationBuilder(Notifications.CHANNEL_ANIME_DOWNLOADER_PROGRESS) {
+            setColor(ContextCompat.getColor(context, R.color.ic_launcher))
+            setAutoCancel(false)
+            setOnlyAlertOnce(true)
+        }
+    }
+
+    private val errorNotificationBuilder by lazy {
+        context.notificationBuilder(Notifications.CHANNEL_ANIME_DOWNLOADER_ERROR) {
+            setColor(ContextCompat.getColor(context, R.color.ic_launcher))
+            setAutoCancel(false)
+        }
+    }
+
+    private var isDownloading = false
+
+    private fun NotificationCompat.Builder.show(id: Int) {
+        context.notify(id, build())
+    }
+
+    fun dismissProgress() {
+        context.cancelNotification(Notifications.ID_ANIME_DOWNLOAD_PROGRESS)
+        context.cancelNotification(Notifications.ID_ANIME_DOWNLOAD_PAUSED)
+    }
+
+    fun dismissPaused() {
+        context.cancelNotification(Notifications.ID_ANIME_DOWNLOAD_PAUSED)
+    }
+
+    fun onProgressChange(download: AnimeDownload) {
+        with(progressNotificationBuilder) {
+            if (!isDownloading) {
+                setSmallIcon(android.R.drawable.stat_sys_download)
+                clearActions()
+                setContentIntent(NotificationHandler.openDownloadManagerPendingActivity(context))
+                isDownloading = true
+            }
+
+            val title = if (preferences.hideNotificationContent().get()) {
+                context.stringResource(MR.strings.download_notifier_downloader_title)
+            } else {
+                val animeTitle = download.anime.title.chop(15)
+                val quotedTitle = Pattern.quote(animeTitle)
+                val episode = download.episode.name.replaceFirst(
+                    "$quotedTitle[\\s]*[-]*[\\s]*".toRegex(RegexOption.IGNORE_CASE),
+                    "",
+                )
+                "$animeTitle - $episode".chop(30)
+            }
+            setContentTitle(title)
+            setContentText("${download.progress}%")
+            setProgress(100, download.progress, false)
+            setOngoing(true)
+
+            show(Notifications.ID_ANIME_DOWNLOAD_PROGRESS)
+        }
+    }
+
+    fun onPaused() {
+        with(progressNotificationBuilder) {
+            setContentTitle(context.stringResource(MR.strings.chapter_paused))
+            setContentText(context.stringResource(MR.strings.download_notifier_download_paused))
+            setSmallIcon(R.drawable.ic_pause_24dp)
+            setProgress(0, 0, false)
+            setOngoing(false)
+            clearActions()
+            setContentIntent(NotificationHandler.openDownloadManagerPendingActivity(context))
+
+            show(Notifications.ID_ANIME_DOWNLOAD_PAUSED)
+        }
+
+        isDownloading = false
+    }
+
+    fun onComplete() {
+        dismissProgress()
+        isDownloading = false
+    }
+
+    fun onError(error: String? = null, episodeName: String? = null, animeTitle: String? = null) {
+        with(errorNotificationBuilder) {
+            setContentTitle(
+                animeTitle?.plus(": $episodeName")
+                    ?: context.stringResource(MR.strings.download_notifier_downloader_title),
+            )
+            setContentText(error ?: context.stringResource(MR.strings.download_notifier_unknown_error))
+            setSmallIcon(R.drawable.ic_warning_white_24dp)
+            clearActions()
+            setContentIntent(NotificationHandler.openDownloadManagerPendingActivity(context))
+            setProgress(0, 0, false)
+
+            show(Notifications.ID_ANIME_DOWNLOAD_ERROR)
+        }
+
+        isDownloading = false
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadPendingDeleter.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadPendingDeleter.kt
new file mode 100644
index 0000000000..fda28066a4
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadPendingDeleter.kt
@@ -0,0 +1,75 @@
+package eu.kanade.tachiyomi.data.animedownload
+
+import android.content.Context
+import androidx.core.content.edit
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.episode.model.Episode
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeDownloadPendingDeleter(
+    context: Context,
+    private val json: Json = Injekt.get(),
+) {
+
+    private val preferences = context.getSharedPreferences("anime_episodes_to_delete", Context.MODE_PRIVATE)
+
+    fun enqueueEpisodesToDelete(episodes: List<Episode>, anime: Anime) {
+        val existingEntry = preferences.getString(anime.id.toString(), null)
+        val existingEpisodes = existingEntry?.let { decodeEntry(it)?.episodes } ?: emptyList()
+        val existingIds = existingEpisodes.map { it.id }.toSet()
+
+        val merged = existingEpisodes + episodes
+            .filter { it.id !in existingIds }
+            .map { EpisodeEntry(it.id, it.name, it.scanlator) }
+        val entry = Entry(merged, AnimeEntry(anime.id, anime.title, anime.source))
+        preferences.edit {
+            putString(anime.id.toString(), json.encodeToString(entry))
+        }
+    }
+
+    fun getPendingEpisodes(anime: Anime): List<Episode> {
+        val entry = preferences.getString(anime.id.toString(), null)?.let { decodeEntry(it) }
+            ?: return emptyList()
+        return entry.episodes.map { ep ->
+            Episode.create().copy(id = ep.id, name = ep.name, scanlator = ep.scanlator)
+        }
+    }
+
+    fun removePendingDelete(anime: Anime) {
+        preferences.edit {
+            remove(anime.id.toString())
+        }
+    }
+
+    private fun decodeEntry(string: String): Entry? {
+        return try {
+            json.decodeFromString<Entry>(string)
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    @Serializable
+    private data class Entry(
+        val episodes: List<EpisodeEntry>,
+        val anime: AnimeEntry,
+    )
+
+    @Serializable
+    private data class EpisodeEntry(
+        val id: Long,
+        val name: String,
+        val scanlator: String?,
+    )
+
+    @Serializable
+    private data class AnimeEntry(
+        val id: Long,
+        val title: String,
+        val source: Long,
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadProvider.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadProvider.kt
new file mode 100644
index 0000000000..846f446e2a
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadProvider.kt
@@ -0,0 +1,124 @@
+package eu.kanade.tachiyomi.data.animedownload
+
+import android.content.Context
+import com.hippo.unifile.UniFile
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.util.storage.DiskUtil
+import logcat.LogPriority
+import tachiyomi.core.common.i18n.stringResource
+import tachiyomi.core.common.storage.displayablePath
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.library.service.LibraryPreferences
+import tachiyomi.domain.storage.service.StorageManager
+import tachiyomi.i18n.MR
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.io.IOException
+
+class AnimeDownloadProvider(
+    private val context: Context,
+    private val storageManager: StorageManager = Injekt.get(),
+    private val libraryPreferences: LibraryPreferences = Injekt.get(),
+) {
+
+    private val downloadsDir: UniFile?
+        get() = storageManager.getAnimeDownloadsDirectory()
+
+    internal fun getAnimeDir(animeTitle: String, source: AnimeSource): Result<UniFile> {
+        val downloadsDir = downloadsDir
+        if (downloadsDir == null) {
+            logcat(LogPriority.ERROR) { "Failed to create anime download directory" }
+            return Result.failure(
+                IOException(context.stringResource(MR.strings.storage_failed_to_create_download_directory)),
+            )
+        }
+
+        val sourceDirName = getSourceDirName(source)
+        val sourceDir = downloadsDir.createDirectory(sourceDirName)
+        if (sourceDir == null) {
+            val displayablePath = downloadsDir.displayablePath + "/$sourceDirName"
+            logcat(LogPriority.ERROR) { "Failed to create source download directory: $displayablePath" }
+            return Result.failure(
+                IOException(context.stringResource(MR.strings.storage_failed_to_create_directory, displayablePath)),
+            )
+        }
+
+        val animeDirName = getAnimeDirName(animeTitle)
+        val animeDir = sourceDir.createDirectory(animeDirName)
+        if (animeDir == null) {
+            val displayablePath = sourceDir.displayablePath + "/$animeDirName"
+            logcat(LogPriority.ERROR) { "Failed to create anime download directory: $displayablePath" }
+            return Result.failure(
+                IOException(context.stringResource(MR.strings.storage_failed_to_create_directory, displayablePath)),
+            )
+        }
+
+        return Result.success(animeDir)
+    }
+
+    fun findSourceDir(source: AnimeSource): UniFile? {
+        return downloadsDir?.findFile(getSourceDirName(source))
+    }
+
+    fun findAnimeDir(animeTitle: String, source: AnimeSource): UniFile? {
+        val sourceDir = findSourceDir(source)
+        return sourceDir?.findFile(getAnimeDirName(animeTitle))
+    }
+
+    fun findEpisodeDir(
+        episodeName: String,
+        episodeScanlator: String?,
+        animeTitle: String,
+        source: AnimeSource,
+    ): UniFile? {
+        val animeDir = findAnimeDir(animeTitle, source)
+        return getValidEpisodeDirNames(episodeName, episodeScanlator).asSequence()
+            .mapNotNull { animeDir?.findFile(it) }
+            .firstOrNull()
+    }
+
+    fun findEpisodeDirs(episodes: List<Episode>, anime: Anime, source: AnimeSource): Pair<UniFile?, List<UniFile>> {
+        val animeDir = findAnimeDir(anime.title, source) ?: return null to emptyList()
+        return animeDir to episodes.mapNotNull { episode ->
+            getValidEpisodeDirNames(episode.name, episode.scanlator).asSequence()
+                .mapNotNull { animeDir.findFile(it) }
+                .firstOrNull()
+        }
+    }
+
+    fun getSourceDirName(source: AnimeSource): String {
+        return DiskUtil.buildValidFilename(
+            source.toString(),
+            disallowNonAscii = libraryPreferences.disallowNonAsciiFilenames().get(),
+        )
+    }
+
+    fun getAnimeDirName(animeTitle: String): String {
+        return DiskUtil.buildValidFilename(
+            animeTitle,
+            disallowNonAscii = libraryPreferences.disallowNonAsciiFilenames().get(),
+        )
+    }
+
+    fun getEpisodeDirName(episodeName: String, episodeScanlator: String?): String {
+        var dirName = episodeName.ifBlank { "Episode" }
+        if (!episodeScanlator.isNullOrBlank()) {
+            dirName = "${episodeScanlator}_$dirName"
+        }
+        return DiskUtil.buildValidFilename(
+            dirName,
+            disallowNonAscii = libraryPreferences.disallowNonAsciiFilenames().get(),
+        )
+    }
+
+    private fun getValidEpisodeDirNames(episodeName: String, episodeScanlator: String?): List<String> {
+        val episodeDirName = getEpisodeDirName(episodeName, episodeScanlator)
+        return listOf(episodeDirName)
+    }
+
+    companion object {
+        const val TMP_DIR_SUFFIX = "_tmp"
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadStore.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadStore.kt
new file mode 100644
index 0000000000..6e11d1455a
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadStore.kt
@@ -0,0 +1,96 @@
+package eu.kanade.tachiyomi.data.animedownload
+
+import android.content.Context
+import androidx.core.content.edit
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.domain.episode.interactor.GetEpisode
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class AnimeDownloadStore(
+    context: Context,
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+    private val json: Json = Injekt.get(),
+    private val getAnime: GetAnime = Injekt.get(),
+    private val getEpisode: GetEpisode = Injekt.get(),
+) {
+
+    private val preferences = context.getSharedPreferences("active_anime_downloads", Context.MODE_PRIVATE)
+
+    private var counter = 0
+
+    fun addAll(downloads: List<AnimeDownload>) {
+        preferences.edit {
+            downloads.forEach { putString(getKey(it), serialize(it)) }
+        }
+    }
+
+    fun remove(download: AnimeDownload) {
+        preferences.edit {
+            remove(getKey(download))
+        }
+    }
+
+    fun removeAll(downloads: List<AnimeDownload>) {
+        preferences.edit {
+            downloads.forEach { remove(getKey(it)) }
+        }
+    }
+
+    fun clear() {
+        preferences.edit {
+            clear()
+        }
+    }
+
+    private fun getKey(download: AnimeDownload): String {
+        return download.episode.id.toString()
+    }
+
+    fun restore(): List<AnimeDownload> {
+        val objs = preferences.all
+            .mapNotNull { it.value as? String }
+            .mapNotNull { deserialize(it) }
+            .sortedBy { it.order }
+
+        val downloads = mutableListOf<AnimeDownload>()
+        if (objs.isNotEmpty()) {
+            val cachedAnime = mutableMapOf<Long, Anime?>()
+            for ((animeId, episodeId) in objs) {
+                val anime = cachedAnime.getOrPut(animeId) {
+                    runBlocking { getAnime.await(animeId) }
+                } ?: continue
+                val source = animeSourceManager.get(anime.source) as? AnimeHttpSource ?: continue
+                val episode = runBlocking { getEpisode.await(episodeId) } ?: continue
+                downloads.add(AnimeDownload(source, anime, episode))
+            }
+        }
+
+        clear()
+        return downloads
+    }
+
+    private fun serialize(download: AnimeDownload): String {
+        val obj = AnimeDownloadObject(download.anime.id, download.episode.id, counter++)
+        return json.encodeToString(obj)
+    }
+
+    private fun deserialize(string: String): AnimeDownloadObject? {
+        return try {
+            json.decodeFromString<AnimeDownloadObject>(string)
+        } catch (e: Exception) {
+            null
+        }
+    }
+}
+
+@Serializable
+private data class AnimeDownloadObject(val animeId: Long, val episodeId: Long, val order: Int)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
new file mode 100644
index 0000000000..0f72832020
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
@@ -0,0 +1,437 @@
+package eu.kanade.tachiyomi.data.animedownload
+
+import android.content.Context
+import com.hippo.unifile.UniFile
+import eu.kanade.tachiyomi.animesource.model.SerializableVideo.Companion.serialize
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
+import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.network.ProgressListener
+import eu.kanade.tachiyomi.util.storage.DiskUtil
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.supervisorScope
+import kotlinx.coroutines.withContext
+import logcat.LogPriority
+import okhttp3.Headers
+import okhttp3.Request
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.domain.episode.model.Episode
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.io.File
+import java.io.RandomAccessFile
+
+class AnimeDownloader(
+    private val context: Context,
+    private val provider: AnimeDownloadProvider,
+    private val cache: AnimeDownloadCache,
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+    private val networkHelper: NetworkHelper = Injekt.get(),
+) {
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    private val store = AnimeDownloadStore(context)
+    private val notifier by lazy { AnimeDownloadNotifier(context) }
+    private val downloadClient by lazy {
+        networkHelper.client.newBuilder()
+            .callTimeout(java.time.Duration.ofMinutes(10))
+            .readTimeout(java.time.Duration.ofMinutes(5))
+            .build()
+    }
+
+    private val _queueState = MutableStateFlow<List<AnimeDownload>>(emptyList())
+    private val _stateVersion = MutableStateFlow(0L)
+
+    val queueState = _queueState.asStateFlow()
+    val stateVersion = _stateVersion.asStateFlow()
+
+    private fun notifyQueueChanged() {
+        _stateVersion.update { it + 1 }
+    }
+
+    private var downloaderJob: Job? = null
+
+    val isRunning: Boolean
+        get() = downloaderJob?.isActive == true
+
+    fun start(): Boolean {
+        if (downloaderJob?.isActive == true) {
+            logcat(LogPriority.INFO) { "AnimeDownloader: already running" }
+            return true
+        }
+
+        val queuedDownloads = _queueState.value.filter { it.status == AnimeDownload.State.QUEUE }
+        if (queuedDownloads.isEmpty()) {
+            val restored = store.restore()
+            if (restored.isEmpty()) {
+                logcat(LogPriority.INFO) { "AnimeDownloader: nothing to start (queue empty, no restore)" }
+                return false
+            }
+            restored.forEach { it.status = AnimeDownload.State.QUEUE }
+            addAllToQueue(restored)
+        }
+
+        logcat(LogPriority.INFO) { "AnimeDownloader: starting processQueue with ${_queueState.value.size} items" }
+        downloaderJob = scope.launchIO {
+            processQueue()
+        }
+        return true
+    }
+
+    fun stop(reason: String? = null) {
+        downloaderJob?.cancel()
+        downloaderJob = null
+
+        if (_queueState.value.isEmpty()) {
+            notifier.onComplete()
+            return
+        }
+
+        if (reason != null) {
+            notifier.onPaused()
+        } else {
+            notifier.onComplete()
+        }
+
+        _queueState.value
+            .filter { it.status == AnimeDownload.State.DOWNLOADING }
+            .forEach { it.status = AnimeDownload.State.QUEUE }
+        notifyQueueChanged()
+    }
+
+    fun pause() {
+        downloaderJob?.cancel()
+        downloaderJob = null
+        _queueState.value
+            .filter { it.status == AnimeDownload.State.DOWNLOADING }
+            .forEach { it.status = AnimeDownload.State.QUEUE }
+        notifyQueueChanged()
+        notifier.onPaused()
+    }
+
+    fun clearQueue() {
+        store.clear()
+        _queueState.update { emptyList() }
+        notifier.dismissProgress()
+    }
+
+    fun queueEpisodes(anime: Anime, episodes: List<Episode>, videos: List<Video?>, autoStart: Boolean) {
+        val source = animeSourceManager.get(anime.source) as? AnimeHttpSource
+        if (source == null) {
+            logcat(LogPriority.ERROR) { "AnimeDownloader: source ${anime.source} not found or not AnimeHttpSource" }
+            return
+        }
+
+        val episodesToQueue = episodes.zip(videos).filter { (episode, _) ->
+            val isDuplicate = _queueState.value.any { it.episode.id == episode.id }
+            val isDownloaded = provider.findEpisodeDir(
+                episode.name,
+                episode.scanlator,
+                anime.title,
+                source,
+            ) != null
+            !isDuplicate && !isDownloaded
+        }
+
+        if (episodesToQueue.isEmpty()) {
+            logcat(LogPriority.WARN) { "AnimeDownloader: nothing to queue (duplicate or already downloaded)" }
+            return
+        }
+
+        val downloads = episodesToQueue.map { (episode, video) ->
+            AnimeDownload(source, anime, episode, video)
+        }
+
+        downloads.forEach { it.status = AnimeDownload.State.QUEUE }
+        addAllToQueue(downloads)
+        store.addAll(downloads)
+        logcat(LogPriority.INFO) { "AnimeDownloader: queued ${downloads.size} episode(s)" }
+
+        if (autoStart) {
+            AnimeDownloadJob.start(context)
+        }
+    }
+
+    fun removeFromQueue(episodes: List<Episode>) {
+        val episodeIds = episodes.map { it.id }.toSet()
+        val removed = _queueState.value.filter { it.episode.id in episodeIds }
+        store.removeAll(removed)
+        _queueState.update { queue -> queue.filter { it.episode.id !in episodeIds } }
+    }
+
+    fun removeFromQueue(anime: Anime) {
+        val removed = _queueState.value.filter { it.anime.id == anime.id }
+        store.removeAll(removed)
+        _queueState.update { queue -> queue.filter { it.anime.id != anime.id } }
+    }
+
+    private fun addAllToQueue(downloads: List<AnimeDownload>) {
+        _queueState.update { it + downloads }
+    }
+
+    private fun removeFromQueueState(download: AnimeDownload) {
+        _queueState.update { queue -> queue.filter { it.episode.id != download.episode.id } }
+    }
+
+    private suspend fun processQueue() {
+        logcat(LogPriority.INFO) { "AnimeDownloader: processQueue started" }
+        supervisorScope {
+            while (true) {
+                val download = _queueState.value.firstOrNull { it.status == AnimeDownload.State.QUEUE }
+                    ?: break
+
+                logcat(LogPriority.INFO) { "AnimeDownloader: downloading ${download.episode.name}" }
+                try {
+                    downloadEpisode(download)
+                    store.remove(download)
+                    removeFromQueueState(download)
+                    logcat(LogPriority.INFO) { "AnimeDownloader: completed ${download.episode.name}" }
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Exception) {
+                    logcat(LogPriority.ERROR, e) { "Failed to download ${download.episode.name}" }
+                    download.status = AnimeDownload.State.ERROR
+                    notifyQueueChanged()
+                    notifier.onError(e.message, download.episode.name, download.anime.title)
+                    store.remove(download)
+                }
+            }
+        }
+
+        notifier.onComplete()
+        stop()
+    }
+
+    private suspend fun downloadEpisode(download: AnimeDownload) {
+        val video = download.video
+            ?: throw IllegalStateException("Video not resolved for episode ${download.episode.name}")
+
+        val videoUrl = video.videoUrl
+        if (videoUrl.isBlank()) {
+            throw IllegalStateException("Video URL is blank for episode ${download.episode.name}")
+        }
+
+        if (isStreamingUrl(videoUrl)) {
+            throw IllegalStateException(
+                "Cannot download streaming content (DASH/HLS). URL: ${videoUrl.take(80)}",
+            )
+        }
+
+        download.status = AnimeDownload.State.DOWNLOADING
+        notifyQueueChanged()
+        notifier.onProgressChange(download)
+
+        val animeDir = provider.getAnimeDir(download.anime.title, download.source).getOrThrow()
+        val episodeDirName = provider.getEpisodeDirName(download.episode.name, download.episode.scanlator)
+        val tmpDirName = episodeDirName + AnimeDownloadProvider.TMP_DIR_SUFFIX
+        val tmpDir = animeDir.createDirectory(tmpDirName)
+            ?: throw IllegalStateException("Failed to create temp directory")
+
+        try {
+            DiskUtil.createNoMediaFile(tmpDir, context)
+
+            downloadVideoFile(video, tmpDir, download)
+
+            downloadSubtitles(video, tmpDir)
+
+            writeMetadata(video, tmpDir)
+
+            // Rename tmp → final
+            val finalDir = animeDir.findFile(episodeDirName)
+            finalDir?.delete()
+            tmpDir.renameTo(episodeDirName)
+
+            download.status = AnimeDownload.State.DOWNLOADED
+            download.progress = 100
+            cache.addEpisode(episodeDirName, animeDir, download.anime)
+        } catch (e: Exception) {
+            tmpDir.delete()
+            throw e
+        }
+    }
+
+    private suspend fun downloadVideoFile(video: Video, tmpDir: UniFile, download: AnimeDownload) {
+        withContext(Dispatchers.IO) {
+            val extension = guessVideoExtension(video.videoUrl)
+            val videoFileName = "video.$extension"
+            val tmpFile = File(context.cacheDir, "anime_dl_${download.episode.id}.$extension")
+
+            try {
+                val headers = video.headers
+                    ?: download.source.headers
+                    ?: Headers.Builder().build()
+
+                val progressListener = object : ProgressListener {
+                    private var lastNotify = 0L
+                    override fun update(bytesRead: Long, contentLength: Long, done: Boolean) {
+                        download.downloadedBytes = bytesRead
+                        if (download.totalBytes <= 0 && contentLength > 0) {
+                            download.totalBytes = contentLength
+                        }
+                        val total = if (contentLength > 0) contentLength else download.totalBytes
+                        if (total > 0) {
+                            download.progress = ((bytesRead * 100) / total).toInt().coerceIn(0, 99)
+                            val now = System.currentTimeMillis()
+                            if (now - lastNotify > 1000) {
+                                lastNotify = now
+                                notifier.onProgressChange(download)
+                                notifyQueueChanged()
+                            }
+                        }
+                    }
+                }
+
+                downloadWithResume(video.videoUrl, headers, tmpFile, progressListener)
+
+                val videoFile = tmpDir.createFile(videoFileName)
+                    ?: throw IllegalStateException("Failed to create video file in episode dir")
+                videoFile.openOutputStream().use { output ->
+                    tmpFile.inputStream().use { input ->
+                        input.copyTo(output, bufferSize = 256 * 1024)
+                    }
+                }
+            } finally {
+                tmpFile.delete()
+            }
+        }
+    }
+
+    private suspend fun downloadWithResume(url: String, headers: Headers, outputFile: File, progressListener: ProgressListener) {
+        var attempt = 0
+        val maxRetries = 3
+
+        while (attempt < maxRetries) {
+            try {
+                val downloadedBytes = outputFile.length()
+
+                val requestHeaders = headers.newBuilder()
+                    .set("Range", "bytes=$downloadedBytes-")
+                    .build()
+
+                val request = Request.Builder()
+                    .url(url)
+                    .headers(requestHeaders)
+                    .build()
+
+                downloadClient.newCall(request).execute().use { response ->
+                    if (response.isSuccessful || response.code == 206) {
+                        if (response.code == 200 && downloadedBytes > 0) {
+                            outputFile.delete()
+                        }
+
+                        val body = response.body
+                        val contentLength = body.contentLength() + (if (response.code == 206) downloadedBytes else 0)
+
+                        RandomAccessFile(outputFile, "rw").use { raf ->
+                            val startPos = if (response.code == 206) downloadedBytes else 0
+                            raf.seek(startPos)
+
+                            val buffer = ByteArray(8192)
+                            var totalRead = startPos
+                            body.byteStream().use { stream ->
+                                var read: Int
+                                while (stream.read(buffer).also { read = it } != -1) {
+                                    raf.write(buffer, 0, read)
+                                    totalRead += read
+                                    progressListener.update(totalRead, contentLength, false)
+                                }
+                            }
+                        }
+
+                        progressListener.update(contentLength, contentLength, true)
+                        return
+                    } else if (response.code == 416) {
+                        outputFile.delete()
+                        attempt++
+                    } else {
+                        attempt++
+                    }
+                }
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: Exception) {
+                logcat(LogPriority.WARN, e) { "Download attempt $attempt failed" }
+                attempt++
+                if (attempt < maxRetries) {
+                    delay((1000L * (1 shl attempt)).coerceAtMost(8000))
+                }
+            }
+        }
+
+        throw java.io.IOException("Failed to download video after $maxRetries attempts")
+    }
+
+    private suspend fun downloadSubtitles(video: Video, tmpDir: UniFile) {
+        if (video.subtitleTracks.isEmpty()) return
+
+        val subtitleDir = tmpDir.createDirectory("subtitles") ?: return
+
+        withContext(Dispatchers.IO) {
+            supervisorScope {
+                video.subtitleTracks.map { track ->
+                    async {
+                        try {
+                            val fileName = "${track.lang}.${subtitleExtensionFromUrl(track.url)}"
+                            val request = Request.Builder()
+                                .url(track.url)
+                                .build()
+
+                            networkHelper.client.newCall(request).execute().use { response ->
+                                if (response.isSuccessful) {
+                                    val subFile = subtitleDir.createFile(fileName) ?: return@use
+                                    subFile.openOutputStream().use { output ->
+                                        response.body.byteStream().copyTo(output)
+                                    }
+                                }
+                            }
+                        } catch (e: Exception) {
+                            logcat(LogPriority.WARN, e) { "Failed to download subtitle: ${track.lang}" }
+                        }
+                    }
+                }.awaitAll()
+            }
+        }
+    }
+
+    private fun writeMetadata(video: Video, tmpDir: UniFile) {
+        val metadata = listOf(video).serialize()
+        val metadataFile = tmpDir.createFile("metadata.json") ?: return
+        metadataFile.openOutputStream().use { output ->
+            output.write(metadata.toByteArray(Charsets.UTF_8))
+        }
+    }
+
+    private fun guessVideoExtension(url: String): String {
+        val path = url.substringBefore('?').substringAfterLast('/')
+        val ext = path.substringAfterLast('.', "").lowercase().take(5)
+        return when {
+            ext in setOf("mp4", "mkv", "webm", "avi", "m4v", "ts") -> ext
+            else -> "mp4"
+        }
+    }
+
+    private fun isStreamingUrl(url: String): Boolean {
+        val path = url.substringBefore('?').lowercase()
+        return path.endsWith(".mpd") ||
+            path.endsWith(".m3u8") ||
+            path.endsWith(".m3u") ||
+            path.contains("/manifest") && (path.endsWith(".mpd") || path.contains("dash"))
+    }
+}
+
+internal fun subtitleExtensionFromUrl(url: String): String =
+    url.substringAfterLast('.').substringBefore('?').take(5).ifBlank { "srt" }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/model/AnimeDownload.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/model/AnimeDownload.kt
new file mode 100644
index 0000000000..a2841768ae
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/model/AnimeDownload.kt
@@ -0,0 +1,49 @@
+package eu.kanade.tachiyomi.data.animedownload.model
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.episode.model.Episode
+
+data class AnimeDownload(
+    val source: AnimeHttpSource,
+    val anime: Anime,
+    val episode: Episode,
+    val video: Video? = null,
+) {
+    var totalBytes: Long = -1L
+    var downloadedBytes: Long = 0L
+
+    @Transient
+    private val _statusFlow = MutableStateFlow(State.NOT_DOWNLOADED)
+
+    @Transient
+    val statusFlow = _statusFlow.asStateFlow()
+    var status: State
+        get() = _statusFlow.value
+        set(status) {
+            _statusFlow.value = status
+        }
+
+    @Transient
+    private val _progressFlow = MutableStateFlow(0)
+
+    @Transient
+    val progressFlow = _progressFlow.asStateFlow()
+    var progress: Int
+        get() = _progressFlow.value
+        set(value) {
+            _progressFlow.value = value
+        }
+
+    enum class State(val value: Int) {
+        NOT_DOWNLOADED(0),
+        QUEUE(1),
+        DOWNLOADING(2),
+        DOWNLOADED(3),
+        ERROR(4),
+    }
+
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadCache.kt b/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadCache.kt
index 962132052b..3865a16523 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadCache.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/download/DownloadCache.kt
@@ -1,8 +1,6 @@
 package eu.kanade.tachiyomi.data.download
 
-import android.app.Application
 import android.content.Context
-import androidx.core.net.toUri
 import com.hippo.unifile.UniFile
 import eu.kanade.tachiyomi.extension.ExtensionManager
 import eu.kanade.tachiyomi.source.Source
@@ -29,15 +27,9 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withTimeoutOrNull
-import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.decodeFromByteArray
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
-import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encodeToByteArray
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
 import kotlinx.serialization.protobuf.ProtoBuf
 import logcat.LogPriority
 import tachiyomi.core.common.storage.extension
@@ -545,22 +537,3 @@ private class MangaDirectory(
     var chapterDirs: MutableSet<String> = mutableSetOf(),
 )
 
-private object UniFileAsStringSerializer : KSerializer<UniFile?> {
-    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("UniFile", PrimitiveKind.STRING)
-
-    override fun serialize(encoder: Encoder, value: UniFile?) {
-        return if (value == null) {
-            encoder.encodeNull()
-        } else {
-            encoder.encodeString(value.uri.toString())
-        }
-    }
-
-    override fun deserialize(decoder: Decoder): UniFile? {
-        return if (decoder.decodeNotNullMark()) {
-            UniFile.fromUri(Injekt.get<Application>(), decoder.decodeString().toUri())
-        } else {
-            decoder.decodeNull()
-        }
-    }
-}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/download/UniFileSerializer.kt b/app/src/main/java/eu/kanade/tachiyomi/data/download/UniFileSerializer.kt
new file mode 100644
index 0000000000..8dff2f999a
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/download/UniFileSerializer.kt
@@ -0,0 +1,33 @@
+package eu.kanade.tachiyomi.data.download
+
+import android.app.Application
+import androidx.core.net.toUri
+import com.hippo.unifile.UniFile
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+internal object UniFileAsStringSerializer : KSerializer<UniFile?> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("UniFile", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: UniFile?) {
+        return if (value == null) {
+            encoder.encodeNull()
+        } else {
+            encoder.encodeString(value.uri.toString())
+        }
+    }
+
+    override fun deserialize(decoder: Decoder): UniFile? {
+        return if (decoder.decodeNotNullMark()) {
+            UniFile.fromUri(Injekt.get<Application>(), decoder.decodeString().toUri())
+        } else {
+            decoder.decodeNull()
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt b/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
index 9e96e10a30..3385c28700 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
@@ -105,6 +105,13 @@ object Notifications {
     const val CHANNEL_ANIME_EXTENSIONS_UPDATE = "anime_ext_apk_update_channel"
     const val ID_UPDATES_TO_ANIME_EXTS = -904
 
+    private const val GROUP_ANIME_DOWNLOADER = "group_anime_downloader"
+    const val CHANNEL_ANIME_DOWNLOADER_PROGRESS = "anime_downloader_progress_channel"
+    const val CHANNEL_ANIME_DOWNLOADER_ERROR = "anime_downloader_error_channel"
+    const val ID_ANIME_DOWNLOAD_PROGRESS = -901
+    const val ID_ANIME_DOWNLOAD_PAUSED = -902
+    const val ID_ANIME_DOWNLOAD_ERROR = -903
+
     private val deprecatedChannels = listOf(
         "downloader_channel",
         "downloader_complete_channel",
@@ -143,6 +150,9 @@ object Notifications {
                 buildNotificationChannelGroup(GROUP_APK_UPDATES) {
                     setName(context.stringResource(MR.strings.label_recent_updates))
                 },
+                buildNotificationChannelGroup(GROUP_ANIME_DOWNLOADER) {
+                    setName(context.stringResource(MR.strings.download_notifier_downloader_title))
+                },
             ),
         )
 
@@ -205,6 +215,16 @@ object Notifications {
                     setGroup(GROUP_APK_UPDATES)
                     setName(context.stringResource(MR.strings.channel_anime_ext_updates))
                 },
+                buildNotificationChannel(CHANNEL_ANIME_DOWNLOADER_PROGRESS, IMPORTANCE_LOW) {
+                    setName(context.stringResource(MR.strings.channel_progress))
+                    setGroup(GROUP_ANIME_DOWNLOADER)
+                    setShowBadge(false)
+                },
+                buildNotificationChannel(CHANNEL_ANIME_DOWNLOADER_ERROR, IMPORTANCE_LOW) {
+                    setName(context.stringResource(MR.strings.channel_errors))
+                    setGroup(GROUP_ANIME_DOWNLOADER)
+                    setShowBadge(false)
+                },
                 // AM (DISCORD) -->
                 buildNotificationChannel(CHANNEL_DISCORD_RPC, IMPORTANCE_LOW) {
                     setName(context.getString(R.string.pref_discord_rpc))
diff --git a/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt b/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
index f35bd3cf65..a27fcf6bfc 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
@@ -22,6 +22,9 @@ import eu.kanade.tachiyomi.data.cache.ChapterCache
 import eu.kanade.tachiyomi.data.cache.CoverCache
 import eu.kanade.tachiyomi.data.cache.PagePreviewCache
 import eu.kanade.tachiyomi.data.connections.ConnectionsManager
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadCache
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadProvider
 import eu.kanade.tachiyomi.data.download.DownloadCache
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.download.DownloadProvider
@@ -185,6 +188,10 @@ class AppModule(val app: Application) : InjektModule {
         addSingletonFactory { DownloadCache(app) }
         addSingletonFactory { MokuroSidecarCopier(get<NetworkHelper>().client) }
 
+        addSingletonFactory { AnimeDownloadProvider(app) }
+        addSingletonFactory { AnimeDownloadManager(app) }
+        addSingletonFactory { AnimeDownloadCache(app) }
+
         addSingletonFactory { OcrCacheManager(app, get(), get()) }
         addSingletonFactory { OcrStore(app) }
         addSingletonFactory { OcrManager(app) }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
index de0b24c185..53609229b2 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
@@ -51,6 +51,9 @@ class AnimeScreen(
                         screenModel.deleteAnime()
                         navigator.pop()
                     },
+                    onDownloadEpisode = screenModel::startDownload,
+                    onDeleteEpisodeDownload = screenModel::deleteEpisodeDownload,
+                    onConfirmDownloadQuality = screenModel::confirmDownload,
                 )
             }
         }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
index 1faa0c262a..958eebe11e 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
@@ -5,12 +5,17 @@ import cafe.adriel.voyager.core.model.StateScreenModel
 import cafe.adriel.voyager.core.model.screenModelScope
 import eu.kanade.tachiyomi.animesource.model.SAnime
 import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.update
 import logcat.LogPriority
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.core.common.util.lang.launchNonCancellable
+import tachiyomi.core.common.util.lang.withIOContext
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.anime.interactor.GetAnime
 import tachiyomi.domain.anime.interactor.SetAnimeEpisodeFlags
@@ -40,6 +45,7 @@ class AnimeScreenModel(
     private val animeRepository: AnimeRepository = Injekt.get(),
     private val episodeRepository: EpisodeRepository = Injekt.get(),
     private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+    private val animeDownloadManager: AnimeDownloadManager = Injekt.get(),
 ) : StateScreenModel<AnimeScreenModel.State>(State.Loading) {
 
     init {
@@ -51,14 +57,28 @@ class AnimeScreenModel(
             combine(
                 getAnime.subscribe(animeId),
                 getEpisodesByAnimeId.subscribe(animeId),
-            ) { anime, episodes ->
+                animeDownloadManager.queueState,
+                animeDownloadManager.stateVersion,
+            ) { anime, episodes, downloadQueue, _ ->
                 val sortedEpisodes = applySort(anime, episodes)
                 val filteredEpisodes = applyFilters(anime, sortedEpisodes)
+                val queueById = downloadQueue.associateBy { it.episode.id }
+                val episodeDownloadState = buildMap {
+                    for (ep in episodes) {
+                        val dl = queueById[ep.id]
+                        if (dl != null) {
+                            put(ep.id, EpisodeDownloadState(dl.status, dl.progress))
+                        } else if (animeDownloadManager.isEpisodeDownloaded(ep.name, ep.scanlator, anime.title, anime.source)) {
+                            put(ep.id, EpisodeDownloadState(AnimeDownload.State.DOWNLOADED, 100))
+                        }
+                    }
+                }
                 State.Success(
                     anime = anime,
                     episodes = filteredEpisodes,
                     allEpisodeCount = episodes.size,
                     nextUnseenEpisode = episodes.asSequence().filter { !it.seen }.minByOrNull { it.sourceOrder },
+                    episodeDownloadState = episodeDownloadState,
                 )
             }.collectLatest { newState ->
                 mutableState.update { old ->
@@ -199,6 +219,111 @@ class AnimeScreenModel(
         }
     }
 
+    fun startDownload(episode: Episode) {
+        screenModelScope.launchIO {
+            val successState = state.value as? State.Success ?: return@launchIO
+            val anime = successState.anime
+            val source = animeSourceManager.get(anime.source) ?: return@launchIO
+
+            val httpSource = source as? AnimeHttpSource
+            if (httpSource == null) {
+                logcat(LogPriority.ERROR) { "Source is not AnimeHttpSource, cannot download" }
+                return@launchIO
+            }
+
+            mutableState.update { s ->
+                if (s is State.Success) s.copy(dialog = Dialog.DownloadLoading(episode)) else s
+            }
+
+            try {
+                val videos = resolveVideosForEpisode(httpSource, episode)
+                if (videos.isEmpty()) {
+                    mutableState.update { s ->
+                        if (s is State.Success) s.copy(dialog = null) else s
+                    }
+                    return@launchIO
+                }
+                mutableState.update { s ->
+                    if (s is State.Success) s.copy(dialog = Dialog.QualitySelection(episode, videos)) else s
+                }
+            } catch (e: Exception) {
+                logcat(LogPriority.ERROR, e) { "Failed to resolve videos for download" }
+                mutableState.update { s ->
+                    if (s is State.Success) s.copy(dialog = null) else s
+                }
+            }
+        }
+    }
+
+    fun confirmDownload(episode: Episode, video: Video) {
+        logcat(LogPriority.INFO) { "AnimeScreenModel: confirmDownload for ${episode.name}, video=${video.videoTitle}" }
+        screenModelScope.launchNonCancellable {
+            val successState = state.value as? State.Success ?: return@launchNonCancellable
+            val anime = successState.anime
+            logcat(LogPriority.INFO) { "AnimeScreenModel: calling downloadEpisodes for anime=${anime.title}" }
+            animeDownloadManager.downloadEpisodes(anime, listOf(episode), listOf(video))
+        }
+        dismissDialog()
+    }
+
+    fun deleteEpisodeDownload(episode: Episode) {
+        screenModelScope.launchNonCancellable {
+            val successState = state.value as? State.Success ?: return@launchNonCancellable
+            val anime = successState.anime
+            val source = animeSourceManager.get(anime.source) ?: return@launchNonCancellable
+            animeDownloadManager.deleteEpisodes(listOf(episode), anime, source)
+        }
+    }
+
+    private suspend fun resolveVideosForEpisode(source: AnimeHttpSource, episode: Episode): List<Video> {
+        return withIOContext {
+            val sEpisode = SEpisode.create().apply {
+                url = episode.url
+                name = episode.name
+            }
+
+            val videos = mutableListOf<Video>()
+
+            try {
+                videos.addAll(source.getVideoList(sEpisode))
+            } catch (_: Throwable) {}
+
+            if (videos.isEmpty()) {
+                try {
+                    val hosters = source.getHosterList(sEpisode)
+                    for (hoster in hosters) {
+                        val hosterVideos = hoster.videoList ?: try {
+                            source.getVideoList(hoster)
+                        } catch (_: Throwable) {
+                            emptyList()
+                        }
+                        videos.addAll(hosterVideos)
+                    }
+                } catch (_: Throwable) {}
+            }
+
+            // Resolve URLs
+            videos.mapNotNull { video ->
+                var resolved = video
+                try {
+                    resolved = source.resolveVideo(video) ?: return@mapNotNull null
+                } catch (_: Throwable) {}
+
+                if (resolved.videoUrl.isBlank() && resolved.videoPageUrl.isNotBlank()) {
+                    val url = try { source.getVideoUrl(resolved) } catch (_: Throwable) { null }
+                    if (!url.isNullOrBlank()) {
+                        resolved = resolved.copy(videoUrl = url)
+                    }
+                }
+
+                val headers = resolved.headers ?: source.headers
+                resolved = resolved.copy(headers = headers)
+
+                if (resolved.videoUrl.isNotBlank()) resolved else null
+            }
+        }
+    }
+
     fun showDialog(dialog: Dialog) {
         mutableState.update { state ->
             when (state) {
@@ -217,6 +342,12 @@ class AnimeScreenModel(
         }
     }
 
+    @Immutable
+    data class EpisodeDownloadState(
+        val status: AnimeDownload.State,
+        val progress: Int,
+    )
+
     sealed interface State {
         @Immutable
         data object Loading : State
@@ -227,11 +358,14 @@ class AnimeScreenModel(
             val episodes: List<Episode>,
             val allEpisodeCount: Int = 0,
             val nextUnseenEpisode: Episode? = null,
+            val episodeDownloadState: Map<Long, EpisodeDownloadState> = emptyMap(),
             val dialog: Dialog? = null,
         ) : State
     }
 
     sealed interface Dialog {
         data object ConfirmDelete : Dialog
+        data class DownloadLoading(val episode: Episode) : Dialog
+        data class QualitySelection(val episode: Episode, val videos: List<Video>) : Dialog
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
index 51077a9efa..af3d51aeff 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
@@ -12,6 +12,7 @@ import eu.kanade.tachiyomi.animesource.AnimeSource
 import eu.kanade.tachiyomi.animesource.model.SEpisode
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
 import tachiyomi.domain.animesource.service.AnimeSourceManager
@@ -58,6 +59,7 @@ class PlayerViewModel @JvmOverloads constructor(
     private val dictionaryRepository: DictionaryRepository = Injekt.get(),
     private val application: Application = Injekt.get(),
     private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+    private val animeDownloadManager: AnimeDownloadManager = Injekt.get(),
 ) : ViewModel() {
 
     private val mutableState = MutableStateFlow(
@@ -119,7 +121,16 @@ class PlayerViewModel @JvmOverloads constructor(
 
             var resolvedVideo: Video? = null
             if (anime.source != LOCAL_ANIME_SOURCE_ID) {
-                resolvedVideo = resolveVideoFromSource(anime.source, episode)
+                val source = animeSourceManager.get(anime.source)
+                if (source != null && animeDownloadManager.isEpisodeDownloaded(
+                        episode.name, episode.scanlator, anime.title, anime.source,
+                    )
+                ) {
+                    resolvedVideo = animeDownloadManager.buildVideoForPlayer(anime, episode, source)
+                }
+                if (resolvedVideo == null) {
+                    resolvedVideo = resolveVideoFromSource(anime.source, episode)
+                }
             }
 
             mutableState.update {
diff --git a/domain/src/main/java/tachiyomi/domain/storage/service/StorageManager.kt b/domain/src/main/java/tachiyomi/domain/storage/service/StorageManager.kt
index 78718ac874..4a3098a560 100644
--- a/domain/src/main/java/tachiyomi/domain/storage/service/StorageManager.kt
+++ b/domain/src/main/java/tachiyomi/domain/storage/service/StorageManager.kt
@@ -82,6 +82,10 @@ class StorageManager(
         return baseDir?.createDirectory(LOCAL_SOURCE_PATH)
     }
 
+    fun getAnimeDownloadsDirectory(): UniFile? {
+        return baseDir?.createDirectory(ANIME_DOWNLOADS_PATH)
+    }
+
     // SY -->
     fun getLogsDirectory(): UniFile? {
         return baseDir?.createDirectory(LOGS_PATH)
@@ -221,6 +225,7 @@ class StorageManager(
 
 private const val AUTOMATIC_BACKUPS_PATH = "autobackup"
 private const val DOWNLOADS_PATH = "downloads"
+private const val ANIME_DOWNLOADS_PATH = "animedownloads"
 private const val LOCAL_SOURCE_PATH = "local"
 
 // SY -->

From 1222e569807a49dff56a76f9916ef4fa4e32fae0 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sun, 10 May 2026 01:16:19 +0200
Subject: [PATCH 09/13] Extended library UI

---
 .../eu/kanade/domain/AnimeDomainModule.kt     |  17 +
 .../anime/library/AnimeLibraryContent.kt      | 106 +++++
 .../anime/library/AnimeLibraryGrid.kt         | 239 +++++++++++
 .../library/AnimeLibrarySettingsDialog.kt     | 120 ++++++
 .../anime/library/AnimeLibraryTabs.kt         |  49 +++
 .../eu/kanade/tachiyomi/ui/anime/AnimeTab.kt  | 144 ++++++-
 .../ui/anime/library/AnimeLibraryItem.kt      |  42 ++
 .../anime/library/AnimeLibraryScreenModel.kt  | 404 ++++++++++++++++++
 .../browse/BrowseAnimeSourceScreenModel.kt    |  36 +-
 .../data/anime/AnimeLibraryMapper.kt          |  78 ++++
 .../data/anime/AnimeRepositoryImpl.kt         |  18 +
 .../data/category/AnimeCategoryMapper.kt      |  21 +
 .../category/AnimeCategoryRepositoryImpl.kt   |  76 ++++
 .../tachiyomi/data/anime_categories.sq        |  69 +++
 .../tachiyomi/data/animes_categories.sq       |  24 ++
 .../sqldelight/tachiyomi/migrations/48.sqm    |  67 +++
 .../tachiyomi/view/animeLibraryView.sq        |  42 ++
 .../anime/interactor/GetLibraryAnime.kt       |  18 +
 .../domain/anime/model/AnimeCover.kt          |  19 +
 .../anime/repository/AnimeRepository.kt       |   7 +
 .../interactor/CreateAnimeCategory.kt         |  30 ++
 .../interactor/DeleteAnimeCategory.kt         |  12 +
 .../category/interactor/GetAnimeCategories.kt |  26 ++
 .../category/interactor/SetAnimeCategories.kt |  12 +
 .../domain/category/model/AnimeCategory.kt    |  18 +
 .../category/model/AnimeCategoryUpdate.kt     |   9 +
 .../repository/AnimeCategoryRepository.kt     |  24 ++
 .../domain/library/model/LibraryAnime.kt      |  28 ++
 .../service/AnimeLibraryPreferences.kt        | 122 ++++++
 .../tachiyomi/animesource/PreferenceScreen.kt |   3 +
 .../animesource/ConfigurableAnimeSource.kt    |   4 +-
 .../tachiyomi/animesource/PreferenceScreen.kt |   3 +
 .../tachiyomi/animesource/model/FilterList.kt |   3 +
 33 files changed, 1869 insertions(+), 21 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryContent.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryGrid.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibrarySettingsDialog.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryTabs.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/anime/library/AnimeLibraryItem.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/anime/library/AnimeLibraryScreenModel.kt
 create mode 100644 data/src/main/java/tachiyomi/data/anime/AnimeLibraryMapper.kt
 create mode 100644 data/src/main/java/tachiyomi/data/category/AnimeCategoryMapper.kt
 create mode 100644 data/src/main/java/tachiyomi/data/category/AnimeCategoryRepositoryImpl.kt
 create mode 100644 data/src/main/sqldelight/tachiyomi/data/anime_categories.sq
 create mode 100644 data/src/main/sqldelight/tachiyomi/data/animes_categories.sq
 create mode 100644 data/src/main/sqldelight/tachiyomi/migrations/48.sqm
 create mode 100644 data/src/main/sqldelight/tachiyomi/view/animeLibraryView.sq
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/interactor/GetLibraryAnime.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/model/AnimeCover.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/category/interactor/CreateAnimeCategory.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/category/interactor/DeleteAnimeCategory.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/category/interactor/GetAnimeCategories.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/category/interactor/SetAnimeCategories.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/category/model/AnimeCategory.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/category/model/AnimeCategoryUpdate.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/category/repository/AnimeCategoryRepository.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/library/model/LibraryAnime.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/library/service/AnimeLibraryPreferences.kt
 create mode 100644 source-api/src/androidMain/kotlin/eu/kanade/tachiyomi/animesource/PreferenceScreen.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/PreferenceScreen.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/FilterList.kt

diff --git a/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt b/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
index 38a6d5e9f5..cae9693b09 100644
--- a/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
+++ b/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
@@ -1,17 +1,25 @@
 package eu.kanade.domain
 
 import tachiyomi.data.anime.AnimeRepositoryImpl
+import tachiyomi.data.category.AnimeCategoryRepositoryImpl
 import tachiyomi.data.episode.EpisodeRepositoryImpl
 import tachiyomi.domain.anime.interactor.GetAnime
 import tachiyomi.domain.anime.interactor.GetFavoriteAnime
+import tachiyomi.domain.anime.interactor.GetLibraryAnime
 import tachiyomi.domain.anime.interactor.SetAnimeEpisodeFlags
 import tachiyomi.domain.anime.interactor.UpdateAnime
 import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.category.interactor.CreateAnimeCategory
+import tachiyomi.domain.category.interactor.DeleteAnimeCategory
+import tachiyomi.domain.category.interactor.GetAnimeCategories
+import tachiyomi.domain.category.interactor.SetAnimeCategories
+import tachiyomi.domain.category.repository.AnimeCategoryRepository
 import tachiyomi.domain.episode.interactor.GetEpisode
 import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
 import tachiyomi.domain.episode.interactor.SetSeenStatus
 import tachiyomi.domain.episode.interactor.UpdateEpisode
 import tachiyomi.domain.episode.repository.EpisodeRepository
+import tachiyomi.domain.library.service.AnimeLibraryPreferences
 import uy.kohesive.injekt.api.InjektModule
 import uy.kohesive.injekt.api.InjektRegistrar
 import uy.kohesive.injekt.api.addFactory
@@ -25,6 +33,7 @@ class AnimeDomainModule : InjektModule {
         addFactory { GetAnime(get()) }
         addFactory { UpdateAnime(get()) }
         addFactory { GetFavoriteAnime(get()) }
+        addFactory { GetLibraryAnime(get()) }
         addFactory { SetAnimeEpisodeFlags(get()) }
 
         addSingletonFactory<EpisodeRepository> { EpisodeRepositoryImpl(get()) }
@@ -32,5 +41,13 @@ class AnimeDomainModule : InjektModule {
         addFactory { GetEpisodesByAnimeId(get()) }
         addFactory { UpdateEpisode(get()) }
         addFactory { SetSeenStatus(get()) }
+
+        addSingletonFactory<AnimeCategoryRepository> { AnimeCategoryRepositoryImpl(get()) }
+        addFactory { GetAnimeCategories(get()) }
+        addFactory { CreateAnimeCategory(get()) }
+        addFactory { DeleteAnimeCategory(get()) }
+        addFactory { SetAnimeCategories(get()) }
+
+        addSingletonFactory { AnimeLibraryPreferences(get()) }
     }
 }
diff --git a/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryContent.kt b/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryContent.kt
new file mode 100644
index 0000000000..eabba1b0e7
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryContent.kt
@@ -0,0 +1,106 @@
+package eu.kanade.presentation.anime.library
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.calculateEndPadding
+import androidx.compose.foundation.layout.calculateStartPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.pager.HorizontalPager
+import androidx.compose.foundation.pager.rememberPagerState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalLayoutDirection
+import eu.kanade.tachiyomi.ui.anime.library.AnimeLibraryItem
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import tachiyomi.domain.category.model.AnimeCategory
+import tachiyomi.domain.library.model.LibraryAnime
+import tachiyomi.domain.library.model.LibraryDisplayMode
+import tachiyomi.presentation.core.components.material.PullRefresh
+import kotlin.time.Duration.Companion.seconds
+
+@Composable
+fun AnimeLibraryContent(
+    categories: List<AnimeCategory>,
+    currentPage: Int,
+    contentPadding: PaddingValues,
+    selection: Set<Long>,
+    hasActiveFilters: Boolean,
+    showPageTabs: Boolean,
+    showAnimeCount: Boolean,
+    displayMode: LibraryDisplayMode,
+    onChangeCurrentPage: (Int) -> Unit,
+    onAnimeClicked: (Long) -> Unit,
+    onContinueWatchingClicked: ((LibraryAnime) -> Unit)?,
+    onToggleSelection: (LibraryAnime) -> Unit,
+    onRefresh: () -> Boolean,
+    getItemsForCategory: (AnimeCategory) -> List<AnimeLibraryItem>,
+) {
+    Column(
+        modifier = Modifier.padding(
+            top = contentPadding.calculateTopPadding(),
+            start = contentPadding.calculateStartPadding(LocalLayoutDirection.current),
+            end = contentPadding.calculateEndPadding(LocalLayoutDirection.current),
+        ),
+    ) {
+        val pagerState = rememberPagerState(currentPage) { categories.size }
+
+        val scope = rememberCoroutineScope()
+        var isRefreshing by remember(pagerState.currentPage) { mutableStateOf(false) }
+
+        if (showPageTabs && categories.size > 1) {
+            AnimeLibraryTabs(
+                categories = categories,
+                pagerState = pagerState,
+                showAnimeCount = showAnimeCount,
+                getItemCount = { category -> getItemsForCategory(category).size },
+            )
+        }
+
+        LaunchedEffect(pagerState.currentPage) {
+            onChangeCurrentPage(pagerState.currentPage)
+        }
+
+        PullRefresh(
+            refreshing = isRefreshing,
+            onRefresh = {
+                val shouldRefresh = onRefresh()
+                if (shouldRefresh) {
+                    isRefreshing = true
+                    scope.launch {
+                        delay(1.5.seconds)
+                        isRefreshing = false
+                    }
+                }
+            },
+            enabled = selection.isEmpty(),
+        ) {
+            HorizontalPager(
+                state = pagerState,
+                beyondViewportPageCount = 1,
+            ) { page ->
+                val category = categories.getOrNull(page) ?: return@HorizontalPager
+                val items = getItemsForCategory(category)
+
+                AnimeLibraryGrid(
+                    items = items,
+                    displayMode = displayMode,
+                    selection = selection,
+                    contentPadding = PaddingValues(
+                        bottom = contentPadding.calculateBottomPadding(),
+                    ),
+                    onAnimeClicked = onAnimeClicked,
+                    onContinueWatchingClicked = onContinueWatchingClicked,
+                    onToggleSelection = onToggleSelection,
+                    hasActiveFilters = hasActiveFilters,
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryGrid.kt b/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryGrid.kt
new file mode 100644
index 0000000000..897a588011
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryGrid.kt
@@ -0,0 +1,239 @@
+package eu.kanade.presentation.anime.library
+
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.grid.items
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import coil3.compose.AsyncImage
+import eu.kanade.tachiyomi.ui.anime.library.AnimeLibraryItem
+import tachiyomi.domain.library.model.LibraryAnime
+import tachiyomi.domain.library.model.LibraryDisplayMode
+import tachiyomi.presentation.core.components.Badge
+import tachiyomi.presentation.core.components.BadgeGroup
+import tachiyomi.presentation.core.components.ScrollbarLazyColumn
+import tachiyomi.presentation.core.screens.EmptyScreen
+import tachiyomi.presentation.core.util.selectedBackground
+
+@Composable
+fun AnimeLibraryGrid(
+    items: List<AnimeLibraryItem>,
+    displayMode: LibraryDisplayMode,
+    selection: Set<Long>,
+    contentPadding: PaddingValues,
+    hasActiveFilters: Boolean,
+    onAnimeClicked: (Long) -> Unit,
+    onContinueWatchingClicked: ((LibraryAnime) -> Unit)?,
+    onToggleSelection: (LibraryAnime) -> Unit,
+) {
+    if (items.isEmpty()) {
+        EmptyScreen(
+            modifier = Modifier.padding(contentPadding),
+            message = if (hasActiveFilters) "No anime matching filters" else "Your anime library is empty",
+        )
+        return
+    }
+
+    when (displayMode) {
+        LibraryDisplayMode.List -> {
+            AnimeLibraryList(
+                items = items,
+                selection = selection,
+                contentPadding = contentPadding,
+                onAnimeClicked = onAnimeClicked,
+                onToggleSelection = onToggleSelection,
+            )
+        }
+        else -> {
+            val columns = when (displayMode) {
+                LibraryDisplayMode.CompactGrid -> GridCells.Adaptive(96.dp)
+                LibraryDisplayMode.ComfortableGrid,
+                LibraryDisplayMode.ComfortableGridPanorama,
+                -> GridCells.Adaptive(128.dp)
+                LibraryDisplayMode.CoverOnlyGrid -> GridCells.Adaptive(80.dp)
+                LibraryDisplayMode.List -> GridCells.Adaptive(96.dp)
+            }
+
+            LazyVerticalGrid(
+                columns = columns,
+                contentPadding = contentPadding,
+                horizontalArrangement = Arrangement.spacedBy(4.dp),
+                verticalArrangement = Arrangement.spacedBy(4.dp),
+                modifier = Modifier.fillMaxSize(),
+            ) {
+                items(
+                    items = items,
+                    key = { it.libraryAnime.id },
+                ) { item ->
+                    val isSelected = item.libraryAnime.id in selection
+                    AnimeGridItem(
+                        item = item,
+                        isSelected = isSelected,
+                        showTitle = displayMode != LibraryDisplayMode.CoverOnlyGrid,
+                        onClick = {
+                            if (selection.isNotEmpty()) {
+                                onToggleSelection(item.libraryAnime)
+                            } else {
+                                onAnimeClicked(item.libraryAnime.id)
+                            }
+                        },
+                        onLongClick = { onToggleSelection(item.libraryAnime) },
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeGridItem(
+    item: AnimeLibraryItem,
+    isSelected: Boolean,
+    showTitle: Boolean,
+    onClick: () -> Unit,
+    onLongClick: () -> Unit,
+) {
+    Box(
+        modifier = Modifier
+            .selectedBackground(isSelected)
+            .combinedClickable(
+                onClick = onClick,
+                onLongClick = onLongClick,
+            )
+            .clip(RoundedCornerShape(4.dp)),
+    ) {
+        AsyncImage(
+            model = item.libraryAnime.anime.thumbnailUrl,
+            contentDescription = null,
+            contentScale = ContentScale.Crop,
+            modifier = Modifier
+                .fillMaxWidth()
+                .aspectRatio(2f / 3f)
+                .alpha(if (isSelected) 0.76f else 1f),
+        )
+
+        if (item.unseenCount > 0 || item.downloadCount > 0) {
+            BadgeGroup(
+                modifier = Modifier
+                    .padding(4.dp)
+                    .align(Alignment.TopStart),
+            ) {
+                if (item.downloadCount > 0) {
+                    Badge(
+                        text = item.downloadCount.toString(),
+                        color = MaterialTheme.colorScheme.tertiary,
+                        textColor = MaterialTheme.colorScheme.onTertiary,
+                    )
+                }
+                if (item.unseenCount > 0) {
+                    Badge(text = item.unseenCount.toString())
+                }
+            }
+        }
+
+        if (showTitle) {
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .align(Alignment.BottomStart)
+                    .padding(4.dp),
+            ) {
+                Text(
+                    text = item.libraryAnime.anime.title,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurface,
+                    maxLines = 2,
+                    overflow = TextOverflow.Ellipsis,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeLibraryList(
+    items: List<AnimeLibraryItem>,
+    selection: Set<Long>,
+    contentPadding: PaddingValues,
+    onAnimeClicked: (Long) -> Unit,
+    onToggleSelection: (LibraryAnime) -> Unit,
+) {
+    ScrollbarLazyColumn(
+        contentPadding = contentPadding,
+        modifier = Modifier.fillMaxSize(),
+    ) {
+        items(
+            items = items,
+            key = { it.libraryAnime.id },
+        ) { item ->
+            val isSelected = item.libraryAnime.id in selection
+            Row(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .selectedBackground(isSelected)
+                    .combinedClickable(
+                        onClick = {
+                            if (selection.isNotEmpty()) {
+                                onToggleSelection(item.libraryAnime)
+                            } else {
+                                onAnimeClicked(item.libraryAnime.id)
+                            }
+                        },
+                        onLongClick = { onToggleSelection(item.libraryAnime) },
+                    )
+                    .height(56.dp)
+                    .padding(horizontal = 16.dp),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                AsyncImage(
+                    model = item.libraryAnime.anime.thumbnailUrl,
+                    contentDescription = null,
+                    contentScale = ContentScale.Crop,
+                    modifier = Modifier
+                        .height(48.dp)
+                        .aspectRatio(2f / 3f)
+                        .clip(RoundedCornerShape(4.dp)),
+                )
+                Column(
+                    modifier = Modifier
+                        .weight(1f)
+                        .padding(start = 12.dp),
+                ) {
+                    Text(
+                        text = item.libraryAnime.anime.title,
+                        style = MaterialTheme.typography.bodyMedium,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                    )
+                }
+                if (item.unseenCount > 0) {
+                    BadgeGroup {
+                        Badge(text = item.unseenCount.toString())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibrarySettingsDialog.kt b/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibrarySettingsDialog.kt
new file mode 100644
index 0000000000..e493f146b9
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibrarySettingsDialog.kt
@@ -0,0 +1,120 @@
+package eu.kanade.presentation.anime.library
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import eu.kanade.presentation.components.TabbedDialog
+import eu.kanade.presentation.components.TabbedDialogPaddings
+import kotlinx.collections.immutable.persistentListOf
+import tachiyomi.core.common.preference.TriState
+import tachiyomi.domain.library.model.LibraryDisplayMode
+import tachiyomi.domain.library.model.LibrarySort
+import tachiyomi.domain.library.service.AnimeLibraryPreferences
+import tachiyomi.presentation.core.components.SortItem
+import tachiyomi.presentation.core.components.TriStateItem
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+@Composable
+fun AnimeLibrarySettingsDialog(
+    onDismissRequest: () -> Unit,
+    preferences: AnimeLibraryPreferences = Injekt.get(),
+) {
+    TabbedDialog(
+        onDismissRequest = onDismissRequest,
+        tabTitles = persistentListOf("Filter", "Sort", "Display"),
+    ) { page ->
+        Column(
+            modifier = Modifier
+                .padding(vertical = TabbedDialogPaddings.Vertical)
+                .verticalScroll(rememberScrollState()),
+        ) {
+            when (page) {
+                0 -> FilterTab(preferences)
+                1 -> SortTab(preferences)
+                2 -> DisplayTab(preferences)
+            }
+        }
+    }
+}
+
+@Composable
+private fun ColumnScope.FilterTab(preferences: AnimeLibraryPreferences) {
+    val filterUnseen by remember { preferences.filterUnseen().changes() }.collectAsState(preferences.filterUnseen().get())
+    val filterStarted by remember { preferences.filterStarted().changes() }.collectAsState(preferences.filterStarted().get())
+    val filterBookmarked by remember { preferences.filterBookmarked().changes() }.collectAsState(preferences.filterBookmarked().get())
+    val filterCompleted by remember { preferences.filterCompleted().changes() }.collectAsState(preferences.filterCompleted().get())
+    val filterDownloaded by remember { preferences.filterDownloaded().changes() }.collectAsState(preferences.filterDownloaded().get())
+    val filterFillermarked by remember { preferences.filterFillermarked().changes() }.collectAsState(preferences.filterFillermarked().get())
+
+    TriStateItem(label = "Unseen", state = filterUnseen, onClick = { preferences.filterUnseen().set(it) })
+    TriStateItem(label = "Started", state = filterStarted, onClick = { preferences.filterStarted().set(it) })
+    TriStateItem(label = "Bookmarked", state = filterBookmarked, onClick = { preferences.filterBookmarked().set(it) })
+    TriStateItem(label = "Completed", state = filterCompleted, onClick = { preferences.filterCompleted().set(it) })
+    TriStateItem(label = "Downloaded", state = filterDownloaded, onClick = { preferences.filterDownloaded().set(it) })
+    TriStateItem(label = "Fillermarked", state = filterFillermarked, onClick = { preferences.filterFillermarked().set(it) })
+}
+
+@Composable
+private fun ColumnScope.SortTab(preferences: AnimeLibraryPreferences) {
+    val sortMode by remember { preferences.sortingMode().changes() }.collectAsState(preferences.sortingMode().get())
+
+    val sortTypes = listOf(
+        LibrarySort.Type.Alphabetical to "Alphabetical",
+        LibrarySort.Type.LastRead to "Last watched",
+        LibrarySort.Type.LastUpdate to "Last update",
+        LibrarySort.Type.UnreadCount to "Unseen count",
+        LibrarySort.Type.TotalChapters to "Total episodes",
+        LibrarySort.Type.LatestChapter to "Latest episode",
+        LibrarySort.Type.ChapterFetchDate to "Episode fetch date",
+        LibrarySort.Type.DateAdded to "Date added",
+    )
+
+    sortTypes.forEach { (type, label) ->
+        val sortDescending = if (sortMode.type == type) !sortMode.isAscending else null
+        SortItem(
+            label = label,
+            sortDescending = sortDescending,
+            onClick = {
+                val newDirection = if (sortMode.type == type) {
+                    if (sortMode.isAscending) LibrarySort.Direction.Descending
+                    else LibrarySort.Direction.Ascending
+                } else {
+                    LibrarySort.Direction.Ascending
+                }
+                preferences.sortingMode().set(LibrarySort(type, newDirection))
+            },
+        )
+    }
+}
+
+@Composable
+private fun ColumnScope.DisplayTab(preferences: AnimeLibraryPreferences) {
+    val displayMode by remember { preferences.displayMode().changes() }.collectAsState(preferences.displayMode().get())
+
+    val modes = listOf(
+        LibraryDisplayMode.CompactGrid to "Compact grid",
+        LibraryDisplayMode.ComfortableGrid to "Comfortable grid",
+        LibraryDisplayMode.List to "List",
+        LibraryDisplayMode.CoverOnlyGrid to "Cover only",
+    )
+
+    modes.forEach { (mode, label) ->
+        FilterChip(
+            selected = displayMode == mode,
+            onClick = { preferences.displayMode().set(mode) },
+            label = { Text(label) },
+            modifier = Modifier.padding(horizontal = 4.dp),
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryTabs.kt b/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryTabs.kt
new file mode 100644
index 0000000000..b7d4168431
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/library/AnimeLibraryTabs.kt
@@ -0,0 +1,49 @@
+package eu.kanade.presentation.anime.library
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.pager.PagerState
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.PrimaryScrollableTabRow
+import androidx.compose.material3.Tab
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+import tachiyomi.domain.category.model.AnimeCategory
+
+@Composable
+fun AnimeLibraryTabs(
+    categories: List<AnimeCategory>,
+    pagerState: PagerState,
+    showAnimeCount: Boolean,
+    getItemCount: (AnimeCategory) -> Int,
+) {
+    val scope = rememberCoroutineScope()
+
+    PrimaryScrollableTabRow(
+        selectedTabIndex = pagerState.currentPage,
+        edgePadding = 0.dp,
+    ) {
+        categories.forEachIndexed { index, category ->
+            Tab(
+                selected = pagerState.currentPage == index,
+                onClick = { scope.launch { pagerState.animateScrollToPage(index) } },
+                text = {
+                    Column {
+                        Text(
+                            text = if (category.isSystemCategory) "Default" else category.name,
+                            style = MaterialTheme.typography.bodyMedium,
+                        )
+                        if (showAnimeCount) {
+                            Text(
+                                text = "${getItemCount(category)}",
+                                style = MaterialTheme.typography.bodySmall,
+                            )
+                        }
+                    }
+                },
+            )
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
index 4e3438d572..4aae7a89dc 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
@@ -1,17 +1,48 @@
 package eu.kanade.tachiyomi.ui.anime
 
+import android.content.Intent
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.layout.padding
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.FilterList
 import androidx.compose.material.icons.outlined.PlayCircle
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+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.Modifier
 import androidx.compose.ui.graphics.vector.rememberVectorPainter
-import androidx.lifecycle.compose.LifecycleResumeEffect
+import androidx.compose.ui.platform.LocalContext
 import cafe.adriel.voyager.core.model.rememberScreenModel
 import cafe.adriel.voyager.navigator.LocalNavigator
 import cafe.adriel.voyager.navigator.currentOrThrow
 import cafe.adriel.voyager.navigator.tab.TabOptions
+import eu.kanade.presentation.anime.library.AnimeLibraryContent
+import eu.kanade.presentation.anime.library.AnimeLibrarySettingsDialog
 import eu.kanade.presentation.util.Tab
+import eu.kanade.tachiyomi.ui.anime.library.AnimeLibraryScreenModel
+import eu.kanade.tachiyomi.ui.player.PlayerActivity
+import tachiyomi.domain.library.model.LibraryDisplayMode
+import tachiyomi.domain.library.service.AnimeLibraryPreferences
 import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.material.Scaffold
 import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.screens.LoadingScreen
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
 
 data object AnimeTab : Tab {
 
@@ -28,14 +59,109 @@ data object AnimeTab : Tab {
     @Composable
     override fun Content() {
         val navigator = LocalNavigator.currentOrThrow
-        val screenModel = rememberScreenModel { AnimeListScreenModel() }
-        LifecycleResumeEffect(Unit) {
-            screenModel.loadAnime()
-            onPauseOrDispose { }
+        val context = LocalContext.current
+        val screenModel = rememberScreenModel { AnimeLibraryScreenModel() }
+        val state by screenModel.state.collectAsState()
+        val preferences: AnimeLibraryPreferences = remember { Injekt.get() }
+
+        var showSettingsDialog by remember { mutableStateOf(false) }
+        var showOpenVideoDialog by remember { mutableStateOf(false) }
+        var showOverflowMenu by remember { mutableStateOf(false) }
+        var currentPage by rememberSaveable { mutableIntStateOf(0) }
+
+        val displayMode by remember { preferences.displayMode().changes() }
+            .collectAsState(initial = preferences.displayMode().get())
+
+        val snackbarHostState = remember { SnackbarHostState() }
+
+        val filePickerLauncher = rememberLauncherForActivityResult(
+            contract = ActivityResultContracts.OpenDocument(),
+        ) { uri ->
+            if (uri != null) {
+                context.contentResolver.takePersistableUriPermission(
+                    uri,
+                    Intent.FLAG_GRANT_READ_URI_PERMISSION,
+                )
+                context.startActivity(PlayerActivity.newIntent(context, uri.toString()))
+            }
+        }
+
+        Scaffold(
+            topBar = {
+                TopAppBar(
+                    title = { Text(stringResource(MR.strings.label_anime)) },
+                    actions = {
+                        IconButton(onClick = { showSettingsDialog = true }) {
+                            Icon(
+                                imageVector = Icons.Default.FilterList,
+                                contentDescription = "Filter",
+                            )
+                        }
+                        IconButton(onClick = { showOverflowMenu = true }) {
+                            Icon(
+                                imageVector = Icons.Outlined.PlayCircle,
+                                contentDescription = "More",
+                            )
+                        }
+                        DropdownMenu(
+                            expanded = showOverflowMenu,
+                            onDismissRequest = { showOverflowMenu = false },
+                        ) {
+                            DropdownMenuItem(
+                                text = { Text(stringResource(MR.strings.action_open_video)) },
+                                onClick = {
+                                    showOverflowMenu = false
+                                    showOpenVideoDialog = true
+                                },
+                            )
+                        }
+                    },
+                )
+            },
+            snackbarHost = { SnackbarHost(hostState = snackbarHostState) },
+        ) { contentPadding ->
+            if (state.isLoading) {
+                LoadingScreen(modifier = Modifier.padding(contentPadding))
+            } else {
+                AnimeLibraryContent(
+                    categories = state.displayCategories,
+                    currentPage = currentPage,
+                    contentPadding = contentPadding,
+                    selection = state.selection.map { it.id }.toSet(),
+                    hasActiveFilters = state.hasActiveFilters,
+                    showPageTabs = state.showCategoryTabs,
+                    showAnimeCount = state.showAnimeCount,
+                    displayMode = displayMode,
+                    onChangeCurrentPage = { currentPage = it },
+                    onAnimeClicked = { animeId -> navigator.push(AnimeScreen(animeId)) },
+                    onContinueWatchingClicked = null,
+                    onToggleSelection = { anime -> screenModel.toggleSelection(anime) },
+                    onRefresh = { false },
+                    getItemsForCategory = { category ->
+                        state.library[category].orEmpty()
+                    },
+                )
+            }
+        }
+
+        if (showSettingsDialog) {
+            AnimeLibrarySettingsDialog(
+                onDismissRequest = { showSettingsDialog = false },
+            )
+        }
+
+        if (showOpenVideoDialog) {
+            OpenVideoDialog(
+                onDismiss = { showOpenVideoDialog = false },
+                onOpenUrl = { url ->
+                    showOpenVideoDialog = false
+                    context.startActivity(PlayerActivity.newIntent(context, url))
+                },
+                onPickFile = {
+                    showOpenVideoDialog = false
+                    filePickerLauncher.launch(arrayOf("video/*"))
+                },
+            )
         }
-        AnimeListScreen(
-            screenModel = screenModel,
-            onAnimeClick = { animeId -> navigator.push(AnimeScreen(animeId)) },
-        )
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/library/AnimeLibraryItem.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/library/AnimeLibraryItem.kt
new file mode 100644
index 0000000000..eeeff2431c
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/library/AnimeLibraryItem.kt
@@ -0,0 +1,42 @@
+package eu.kanade.tachiyomi.ui.anime.library
+
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.domain.library.model.LibraryAnime
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+data class AnimeLibraryItem(
+    val libraryAnime: LibraryAnime,
+    var downloadCount: Long = -1,
+    var unseenCount: Long = -1,
+    var isLocal: Boolean = false,
+    var sourceLanguage: String = "",
+    private val sourceManager: AnimeSourceManager = Injekt.get(),
+) {
+    fun matches(constraint: String): Boolean {
+        val sourceName by lazy {
+            sourceManager.getOrStub(libraryAnime.anime.source).name
+        }
+        return libraryAnime.anime.title.contains(constraint, true) ||
+            (libraryAnime.anime.author?.contains(constraint, true) ?: false) ||
+            (libraryAnime.anime.artist?.contains(constraint, true) ?: false) ||
+            (libraryAnime.anime.description?.contains(constraint, true) ?: false) ||
+            constraint.split(",").map { it.trim() }.all { subconstraint ->
+                checkNegatableConstraint(subconstraint) {
+                    sourceName.contains(it, true) ||
+                        (libraryAnime.anime.genre?.any { genre -> genre.equals(it, true) } ?: false)
+                }
+            }
+    }
+
+    private fun checkNegatableConstraint(
+        constraint: String,
+        predicate: (String) -> Boolean,
+    ): Boolean {
+        return if (constraint.startsWith("-")) {
+            !predicate(constraint.substringAfter("-").trimStart())
+        } else {
+            predicate(constraint)
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/library/AnimeLibraryScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/library/AnimeLibraryScreenModel.kt
new file mode 100644
index 0000000000..7ec88ae91d
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/library/AnimeLibraryScreenModel.kt
@@ -0,0 +1,404 @@
+package eu.kanade.tachiyomi.ui.anime.library
+
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadCache
+import kotlinx.collections.immutable.PersistentList
+import kotlinx.collections.immutable.mutate
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.update
+import tachiyomi.core.common.preference.TriState
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.lang.launchNonCancellable
+import tachiyomi.domain.anime.interactor.GetLibraryAnime
+import tachiyomi.domain.anime.interactor.UpdateAnime
+import tachiyomi.domain.anime.model.AnimeUpdate
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.domain.category.interactor.GetAnimeCategories
+import tachiyomi.domain.category.interactor.SetAnimeCategories
+import tachiyomi.domain.category.model.AnimeCategory
+import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
+import tachiyomi.domain.episode.interactor.SetSeenStatus
+import tachiyomi.domain.library.model.LibraryAnime
+import tachiyomi.domain.library.model.LibraryGroup
+import tachiyomi.domain.library.model.LibrarySort
+import tachiyomi.domain.library.service.AnimeLibraryPreferences
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.text.Collator
+import java.util.Locale
+
+class AnimeLibraryScreenModel(
+    private val getLibraryAnime: GetLibraryAnime = Injekt.get(),
+    private val getAnimeCategories: GetAnimeCategories = Injekt.get(),
+    private val setAnimeCategories: SetAnimeCategories = Injekt.get(),
+    private val updateAnime: UpdateAnime = Injekt.get(),
+    private val setSeenStatus: SetSeenStatus = Injekt.get(),
+    private val getEpisodesByAnimeId: GetEpisodesByAnimeId = Injekt.get(),
+    private val preferences: AnimeLibraryPreferences = Injekt.get(),
+    private val sourceManager: AnimeSourceManager = Injekt.get(),
+    private val downloadCache: AnimeDownloadCache = Injekt.get(),
+) : StateScreenModel<AnimeLibraryScreenModel.State>(State()) {
+
+    private val searchQueryFlow = MutableStateFlow<String?>(null)
+
+    init {
+        screenModelScope.launchIO {
+            combine(
+                getLibraryAnime.subscribe(),
+                getAnimeCategories.subscribe(),
+                searchQueryFlow.debounce(SEARCH_DEBOUNCE_MILLIS).distinctUntilChanged(),
+                preferences.sortingMode().changes(),
+                preferences.filterUnseen().changes(),
+                preferences.filterStarted().changes(),
+                preferences.filterBookmarked().changes(),
+                preferences.filterCompleted().changes(),
+                preferences.filterDownloaded().changes(),
+                preferences.filterFillermarked().changes(),
+                preferences.groupLibraryBy().changes(),
+            ) { values ->
+                @Suppress("UNCHECKED_CAST")
+                val libraryAnime = values[0] as List<LibraryAnime>
+                @Suppress("UNCHECKED_CAST")
+                val categories = values[1] as List<AnimeCategory>
+                val searchQuery = values[2] as String?
+                val sortMode = values[3] as LibrarySort
+                val filterUnseen = values[4] as TriState
+                val filterStarted = values[5] as TriState
+                val filterBookmarked = values[6] as TriState
+                val filterCompleted = values[7] as TriState
+                val filterDownloaded = values[8] as TriState
+                val filterFillermarked = values[9] as TriState
+                val groupType = values[10] as Int
+
+                val items = libraryAnime.map { anime ->
+                    AnimeLibraryItem(
+                        libraryAnime = anime,
+                        downloadCount = downloadCache.getDownloadCount(anime.anime).toLong(),
+                        unseenCount = anime.unseenCount,
+                        isLocal = anime.anime.source == LOCAL_SOURCE_ID,
+                        sourceLanguage = sourceManager.getOrStub(anime.anime.source).lang,
+                    )
+                }
+
+                val filtered = applyFilters(
+                    items,
+                    searchQuery,
+                    filterUnseen,
+                    filterStarted,
+                    filterBookmarked,
+                    filterCompleted,
+                    filterDownloaded,
+                    filterFillermarked,
+                )
+
+                val grouped = applyGrouping(filtered, categories, groupType)
+                val collator = Collator.getInstance(Locale.getDefault())
+                val sorted = grouped.mapValues { (_, list) ->
+                    applySort(list, sortMode, collator)
+                }
+
+                val hasActiveFilters = filterUnseen != TriState.DISABLED ||
+                    filterStarted != TriState.DISABLED ||
+                    filterBookmarked != TriState.DISABLED ||
+                    filterCompleted != TriState.DISABLED ||
+                    filterDownloaded != TriState.DISABLED ||
+                    filterFillermarked != TriState.DISABLED
+
+                State(
+                    isLoading = false,
+                    library = sorted,
+                    categories = categories,
+                    searchQuery = searchQuery,
+                    hasActiveFilters = hasActiveFilters,
+                )
+            }.collectLatest { newState ->
+                mutableState.update { oldState ->
+                    newState.copy(selection = oldState.selection)
+                }
+            }
+        }
+
+        preferences.categoryTabs().changes()
+            .onEach { showTabs ->
+                mutableState.update { it.copy(showCategoryTabs = showTabs) }
+            }
+            .launchIn(screenModelScope)
+
+        preferences.categoryNumberOfItems().changes()
+            .onEach { show ->
+                mutableState.update { it.copy(showAnimeCount = show) }
+            }
+            .launchIn(screenModelScope)
+
+        preferences.showContinueWatchingButton().changes()
+            .onEach { show ->
+                mutableState.update { it.copy(showContinueWatchingButton = show) }
+            }
+            .launchIn(screenModelScope)
+
+    }
+
+    fun search(query: String?) {
+        searchQueryFlow.value = query
+    }
+
+    fun toggleSelection(anime: LibraryAnime) {
+        mutableState.update { state ->
+            val newSelection = state.selection.mutate { list ->
+                if (list.any { it.id == anime.id }) {
+                    list.removeAll { it.id == anime.id }
+                } else {
+                    list.add(anime)
+                }
+            }
+            state.copy(selection = newSelection)
+        }
+    }
+
+    fun selectAll(categoryIndex: Int) {
+        mutableState.update { state ->
+            val items = state.library.values.toList().getOrNull(categoryIndex) ?: return@update state
+            val newSelection = state.selection.mutate { list ->
+                items.forEach { item ->
+                    if (list.none { it.id == item.libraryAnime.id }) {
+                        list.add(item.libraryAnime)
+                    }
+                }
+            }
+            state.copy(selection = newSelection)
+        }
+    }
+
+    fun invertSelection(categoryIndex: Int) {
+        mutableState.update { state ->
+            val items = state.library.values.toList().getOrNull(categoryIndex) ?: return@update state
+            val newSelection = state.selection.mutate { list ->
+                items.forEach { item ->
+                    if (list.any { it.id == item.libraryAnime.id }) {
+                        list.removeAll { it.id == item.libraryAnime.id }
+                    } else {
+                        list.add(item.libraryAnime)
+                    }
+                }
+            }
+            state.copy(selection = newSelection)
+        }
+    }
+
+    fun clearSelection() {
+        mutableState.update { it.copy(selection = persistentListOf()) }
+    }
+
+    fun markSeenSelection(seen: Boolean) {
+        val animes = state.value.selection.toList()
+        screenModelScope.launchNonCancellable {
+            animes.forEach { anime ->
+                setSeenStatus.await(
+                    animeId = anime.id,
+                    seen = seen,
+                )
+            }
+        }
+        clearSelection()
+    }
+
+    fun setAnimeCategories(animeIds: List<Long>, categoryIds: List<Long>) {
+        screenModelScope.launchNonCancellable {
+            animeIds.forEach { animeId ->
+                setAnimeCategories.await(animeId, categoryIds)
+            }
+        }
+    }
+
+    fun removeAnime(animeIds: List<Long>) {
+        screenModelScope.launchNonCancellable {
+            animeIds.forEach { animeId ->
+                updateAnime.await(AnimeUpdate(id = animeId, favorite = false))
+            }
+        }
+        clearSelection()
+    }
+
+    private fun applyFilters(
+        items: List<AnimeLibraryItem>,
+        searchQuery: String?,
+        filterUnseen: TriState,
+        filterStarted: TriState,
+        filterBookmarked: TriState,
+        filterCompleted: TriState,
+        filterDownloaded: TriState,
+        filterFillermarked: TriState,
+    ): List<AnimeLibraryItem> {
+        var result = items
+
+        if (!searchQuery.isNullOrBlank()) {
+            result = result.filter { it.matches(searchQuery) }
+        }
+
+        result = applyTriStateFilter(result, filterUnseen) { it.libraryAnime.unseenCount > 0 }
+        result = applyTriStateFilter(result, filterStarted) { it.libraryAnime.hasStarted }
+        result = applyTriStateFilter(result, filterBookmarked) { it.libraryAnime.hasBookmarks }
+        result = applyTriStateFilter(result, filterCompleted) { it.libraryAnime.anime.status == SAnime.COMPLETED.toLong() }
+        result = applyTriStateFilter(result, filterFillermarked) { it.libraryAnime.hasFillermarks }
+        result = applyTriStateFilter(result, filterDownloaded) { it.downloadCount > 0 || it.isLocal }
+
+        return result
+    }
+
+    private fun applyTriStateFilter(
+        items: List<AnimeLibraryItem>,
+        state: TriState,
+        predicate: (AnimeLibraryItem) -> Boolean,
+    ): List<AnimeLibraryItem> {
+        return when (state) {
+            TriState.DISABLED -> items
+            TriState.ENABLED_IS -> items.filter(predicate)
+            TriState.ENABLED_NOT -> items.filterNot(predicate)
+        }
+    }
+
+    private fun applyGrouping(
+        items: List<AnimeLibraryItem>,
+        categories: List<AnimeCategory>,
+        groupType: Int,
+    ): Map<AnimeCategory, List<AnimeLibraryItem>> {
+        return when (groupType) {
+            LibraryGroup.BY_SOURCE -> {
+                items.groupBy { sourceManager.getOrStub(it.libraryAnime.anime.source) }
+                    .toSortedMap(compareBy { it.name })
+                    .entries.mapIndexed { index, (source, animeList) ->
+                        AnimeCategory(
+                            id = source.id,
+                            name = source.name,
+                            order = index.toLong(),
+                            flags = 0L,
+                            hidden = false,
+                        ) to animeList
+                    }.toMap()
+            }
+            LibraryGroup.BY_STATUS -> {
+                val statusOrder = listOf(
+                    SAnime.ONGOING.toLong(),
+                    SAnime.COMPLETED.toLong(),
+                    SAnime.LICENSED.toLong(),
+                    SAnime.ON_HIATUS.toLong(),
+                    SAnime.CANCELLED.toLong(),
+                )
+                items.groupBy { it.libraryAnime.anime.status }
+                    .toSortedMap(compareBy { statusOrder.indexOf(it) })
+                    .entries.mapIndexed { index, (status, animeList) ->
+                        AnimeCategory(
+                            id = status,
+                            name = statusToString(status),
+                            order = index.toLong(),
+                            flags = 0L,
+                            hidden = false,
+                        ) to animeList
+                    }.toMap()
+            }
+            else -> {
+                if (categories.isEmpty()) {
+                    val defaultCategory = AnimeCategory(
+                        id = AnimeCategory.UNCATEGORIZED_ID,
+                        name = "Default",
+                        order = 0,
+                        flags = 0L,
+                        hidden = false,
+                    )
+                    mapOf(defaultCategory to items)
+                } else {
+                    val uncategorized = items.filter { item ->
+                        item.libraryAnime.categories.isEmpty() ||
+                            item.libraryAnime.categories == listOf(AnimeCategory.UNCATEGORIZED_ID)
+                    }
+                    val categorized = categories.filter { !it.isSystemCategory }.associateWith { category ->
+                        items.filter { item -> category.id in item.libraryAnime.categories }
+                    }
+                    val result = mutableMapOf<AnimeCategory, List<AnimeLibraryItem>>()
+                    if (uncategorized.isNotEmpty() || categorized.isEmpty()) {
+                        val systemCategory = categories.find { it.isSystemCategory } ?: AnimeCategory(
+                            id = AnimeCategory.UNCATEGORIZED_ID,
+                            name = "Default",
+                            order = -1,
+                            flags = 0L,
+                            hidden = false,
+                        )
+                        result[systemCategory] = uncategorized
+                    }
+                    result.putAll(categorized)
+                    result
+                }
+            }
+        }
+    }
+
+    private fun applySort(
+        items: List<AnimeLibraryItem>,
+        sort: LibrarySort,
+        collator: Collator,
+    ): List<AnimeLibraryItem> {
+        val comparator: Comparator<AnimeLibraryItem> = when (sort.type) {
+            LibrarySort.Type.Alphabetical -> Comparator { a, b ->
+                collator.compare(a.libraryAnime.anime.title, b.libraryAnime.anime.title)
+            }
+            LibrarySort.Type.LastRead -> compareByDescending { it.libraryAnime.lastSeen }
+            LibrarySort.Type.LastUpdate -> compareByDescending { it.libraryAnime.anime.lastUpdate }
+            LibrarySort.Type.UnreadCount -> compareByDescending { it.libraryAnime.unseenCount }
+            LibrarySort.Type.TotalChapters -> compareByDescending { it.libraryAnime.totalEpisodes }
+            LibrarySort.Type.LatestChapter -> compareByDescending { it.libraryAnime.latestUpload }
+            LibrarySort.Type.ChapterFetchDate -> compareByDescending { it.libraryAnime.episodeFetchedAt }
+            LibrarySort.Type.DateAdded -> compareByDescending { it.libraryAnime.anime.dateAdded }
+            LibrarySort.Type.Random -> {
+                val seed = preferences.randomSortSeed().get()
+                val random = java.util.Random(seed.toLong())
+                val shuffled = items.shuffled(random)
+                return shuffled
+            }
+            else -> compareBy { it.libraryAnime.anime.title }
+        }
+
+        val sorted = items.sortedWith(comparator)
+        return if (sort.direction == LibrarySort.Direction.Descending) sorted.reversed() else sorted
+    }
+
+    private fun statusToString(status: Long): String {
+        return when (status.toInt()) {
+            SAnime.ONGOING -> "Ongoing"
+            SAnime.COMPLETED -> "Completed"
+            SAnime.LICENSED -> "Licensed"
+            SAnime.ON_HIATUS -> "On Hiatus"
+            SAnime.CANCELLED -> "Cancelled"
+            else -> "Unknown"
+        }
+    }
+
+    data class State(
+        val isLoading: Boolean = true,
+        val library: Map<AnimeCategory, List<AnimeLibraryItem>> = emptyMap(),
+        val categories: List<AnimeCategory> = emptyList(),
+        val searchQuery: String? = null,
+        val selection: PersistentList<LibraryAnime> = persistentListOf(),
+        val hasActiveFilters: Boolean = false,
+        val showCategoryTabs: Boolean = true,
+        val showAnimeCount: Boolean = false,
+        val showContinueWatchingButton: Boolean = false,
+    ) {
+        val selectionMode = selection.isNotEmpty()
+
+        val displayCategories: List<AnimeCategory> = library.keys.toList()
+    }
+
+    companion object {
+        private const val SEARCH_DEBOUNCE_MILLIS = 250L
+        private const val LOCAL_SOURCE_ID = 0L
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
index ff58cb82aa..2bfa3826a3 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
@@ -6,6 +6,8 @@ import cafe.adriel.voyager.core.model.screenModelScope
 import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
 import eu.kanade.tachiyomi.animesource.model.SAnime
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.update
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.domain.anime.interactor.GetAnime
 import tachiyomi.domain.anime.model.Anime
@@ -24,12 +26,18 @@ class BrowseAnimeSourceScreenModel(
     private val source: AnimeCatalogueSource?
         get() = animeSourceManager.get(sourceId) as? AnimeCatalogueSource
 
+    @Volatile
     private var currentPage = 1
     @Volatile
+    private var currentQuery: String? = null
+    @Volatile
     private var isLoadingMore = false
 
+    private var browseJob: Job? = null
+
     fun loadPopular() {
-        screenModelScope.launchIO {
+        browseJob?.cancel()
+        browseJob = screenModelScope.launchIO {
             mutableState.value = State(isLoading = true)
             try {
                 val source = source ?: run {
@@ -38,6 +46,7 @@ class BrowseAnimeSourceScreenModel(
                 }
                 val result = source.getPopularAnime(1)
                 currentPage = 1
+                currentQuery = null
                 mutableState.value = State(
                     items = result.animes,
                     hasNextPage = result.hasNextPage,
@@ -53,7 +62,8 @@ class BrowseAnimeSourceScreenModel(
             loadPopular()
             return
         }
-        screenModelScope.launchIO {
+        browseJob?.cancel()
+        browseJob = screenModelScope.launchIO {
             mutableState.value = State(isLoading = true)
             try {
                 val source = source ?: run {
@@ -62,6 +72,7 @@ class BrowseAnimeSourceScreenModel(
                 }
                 val result = source.getSearchAnime(1, query, AnimeFilterList())
                 currentPage = 1
+                currentQuery = query
                 mutableState.value = State(
                     items = result.animes,
                     hasNextPage = result.hasNextPage,
@@ -74,22 +85,27 @@ class BrowseAnimeSourceScreenModel(
 
     fun loadNextPage() {
         if (isLoadingMore) return
-        val currentState = state.value
-        if (!currentState.hasNextPage) return
+        if (!state.value.hasNextPage) return
 
         isLoadingMore = true
         screenModelScope.launchIO {
             try {
                 val source = source ?: return@launchIO
                 val nextPage = currentPage + 1
-                val result = source.getPopularAnime(nextPage)
+                val query = currentQuery
+                val result = if (query != null) {
+                    source.getSearchAnime(nextPage, query, AnimeFilterList())
+                } else {
+                    source.getPopularAnime(nextPage)
+                }
                 currentPage = nextPage
-                mutableState.value = currentState.copy(
-                    items = currentState.items + result.animes,
-                    hasNextPage = result.hasNextPage,
-                )
+                mutableState.update {
+                    it.copy(
+                        items = it.items + result.animes,
+                        hasNextPage = result.hasNextPage,
+                    )
+                }
             } catch (_: Exception) {
-                // Silently fail for pagination
             } finally {
                 isLoadingMore = false
             }
diff --git a/data/src/main/java/tachiyomi/data/anime/AnimeLibraryMapper.kt b/data/src/main/java/tachiyomi/data/anime/AnimeLibraryMapper.kt
new file mode 100644
index 0000000000..fbcc907022
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/anime/AnimeLibraryMapper.kt
@@ -0,0 +1,78 @@
+package tachiyomi.data.anime
+
+import eu.kanade.tachiyomi.animesource.model.AnimeUpdateStrategy
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.library.model.LibraryAnime
+
+object AnimeLibraryMapper {
+
+    fun mapLibraryAnime(
+        id: Long,
+        source: Long,
+        url: String,
+        artist: String?,
+        author: String?,
+        description: String?,
+        genre: List<String>?,
+        title: String,
+        status: Long,
+        thumbnailUrl: String?,
+        favorite: Boolean,
+        lastUpdate: Long?,
+        nextUpdate: Long?,
+        initialized: Boolean,
+        viewerFlags: Long,
+        episodeFlags: Long,
+        coverLastModified: Long,
+        dateAdded: Long,
+        updateStrategy: AnimeUpdateStrategy,
+        calculateInterval: Long,
+        lastModifiedAt: Long,
+        favoriteModifiedAt: Long?,
+        version: Long,
+        @Suppress("UNUSED_PARAMETER")
+        isSyncing: Long,
+        totalCount: Long,
+        seenCount: Double,
+        latestUpload: Long,
+        episodeFetchedAt: Long,
+        lastSeen: Long,
+        bookmarkCount: Double,
+        fillermarkCount: Double,
+        categories: String,
+    ): LibraryAnime = LibraryAnime(
+        anime = Anime(
+            id = id,
+            source = source,
+            favorite = favorite,
+            lastUpdate = lastUpdate ?: 0,
+            nextUpdate = nextUpdate ?: 0,
+            fetchInterval = calculateInterval.toInt(),
+            dateAdded = dateAdded,
+            viewerFlags = viewerFlags,
+            episodeFlags = episodeFlags,
+            coverLastModified = coverLastModified,
+            url = url,
+            title = title,
+            artist = artist,
+            author = author,
+            thumbnailUrl = thumbnailUrl,
+            description = description,
+            genre = genre,
+            status = status,
+            updateStrategy = updateStrategy,
+            initialized = initialized,
+            lastModifiedAt = lastModifiedAt,
+            favoriteModifiedAt = favoriteModifiedAt,
+            version = version,
+        ),
+        categories = categories.split(",").mapNotNull { it.trim().toLongOrNull() },
+        totalEpisodes = totalCount,
+        seenCount = seenCount.toLong(),
+        bookmarkCount = bookmarkCount.toLong(),
+        fillermarkCount = fillermarkCount.toLong(),
+        latestUpload = latestUpload,
+        episodeFetchedAt = episodeFetchedAt,
+        lastSeen = lastSeen,
+    )
+}
diff --git a/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
index aacadcb29e..373002195e 100644
--- a/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
+++ b/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
@@ -9,6 +9,7 @@ import tachiyomi.data.StringListColumnAdapter
 import tachiyomi.domain.anime.model.Anime
 import tachiyomi.domain.anime.model.AnimeUpdate
 import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.library.model.LibraryAnime
 
 class AnimeRepositoryImpl(
     private val handler: DatabaseHandler,
@@ -50,6 +51,23 @@ class AnimeRepositoryImpl(
         return handler.subscribeToList { animesQueries.getFavoriteBySourceId(sourceId, AnimeMapper::mapAnime) }
     }
 
+    override suspend fun getLibraryAnime(): List<LibraryAnime> {
+        return handler.awaitList { animeLibraryViewQueries.library(AnimeLibraryMapper::mapLibraryAnime) }
+    }
+
+    override fun getLibraryAnimeAsFlow(): Flow<List<LibraryAnime>> {
+        return handler.subscribeToList { animeLibraryViewQueries.library(AnimeLibraryMapper::mapLibraryAnime) }
+    }
+
+    override suspend fun setAnimeCategories(animeId: Long, categoryIds: List<Long>) {
+        handler.await(inTransaction = true) {
+            animes_categoriesQueries.deleteAnimeCategoryByAnimeId(animeId)
+            categoryIds.forEach { categoryId ->
+                animes_categoriesQueries.insert(animeId, categoryId)
+            }
+        }
+    }
+
     override suspend fun update(update: AnimeUpdate): Boolean {
         return try {
             partialUpdate(update)
diff --git a/data/src/main/java/tachiyomi/data/category/AnimeCategoryMapper.kt b/data/src/main/java/tachiyomi/data/category/AnimeCategoryMapper.kt
new file mode 100644
index 0000000000..bcb24c829a
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/category/AnimeCategoryMapper.kt
@@ -0,0 +1,21 @@
+package tachiyomi.data.category
+
+import tachiyomi.domain.category.model.AnimeCategory
+
+object AnimeCategoryMapper {
+    fun mapAnimeCategory(
+        id: Long,
+        name: String,
+        order: Long,
+        flags: Long,
+        hidden: Long,
+    ): AnimeCategory {
+        return AnimeCategory(
+            id = id,
+            name = name,
+            order = order,
+            flags = flags,
+            hidden = hidden == 1L,
+        )
+    }
+}
diff --git a/data/src/main/java/tachiyomi/data/category/AnimeCategoryRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/category/AnimeCategoryRepositoryImpl.kt
new file mode 100644
index 0000000000..be7939e571
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/category/AnimeCategoryRepositoryImpl.kt
@@ -0,0 +1,76 @@
+package tachiyomi.data.category
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.data.Database
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.category.model.AnimeCategory
+import tachiyomi.domain.category.model.AnimeCategoryUpdate
+import tachiyomi.domain.category.repository.AnimeCategoryRepository
+
+class AnimeCategoryRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : AnimeCategoryRepository {
+
+    override suspend fun getAll(): List<AnimeCategory> {
+        return handler.awaitList {
+            anime_categoriesQueries.getCategories(AnimeCategoryMapper::mapAnimeCategory)
+        }
+    }
+
+    override fun getAllAsFlow(): Flow<List<AnimeCategory>> {
+        return handler.subscribeToList {
+            anime_categoriesQueries.getCategories(AnimeCategoryMapper::mapAnimeCategory)
+        }
+    }
+
+    override suspend fun getCategoriesByAnimeId(animeId: Long): List<AnimeCategory> {
+        return handler.awaitList {
+            anime_categoriesQueries.getCategoriesByAnimeId(animeId, AnimeCategoryMapper::mapAnimeCategory)
+        }
+    }
+
+    override fun getCategoriesByAnimeIdAsFlow(animeId: Long): Flow<List<AnimeCategory>> {
+        return handler.subscribeToList {
+            anime_categoriesQueries.getCategoriesByAnimeId(animeId, AnimeCategoryMapper::mapAnimeCategory)
+        }
+    }
+
+    override suspend fun insert(name: String, order: Long, flags: Long) {
+        handler.await {
+            anime_categoriesQueries.insert(
+                name = name,
+                order = order,
+                flags = flags,
+                hidden = 0L,
+            )
+        }
+    }
+
+    override suspend fun delete(categoryId: Long) {
+        handler.await {
+            anime_categoriesQueries.delete(categoryId = categoryId)
+        }
+    }
+
+    override suspend fun update(update: AnimeCategoryUpdate) {
+        handler.await {
+            updatePartialBlocking(update)
+        }
+    }
+
+    override suspend fun updateAllFlags(flags: Long?) {
+        handler.await {
+            anime_categoriesQueries.updateAllFlags(flags)
+        }
+    }
+
+    private fun Database.updatePartialBlocking(update: AnimeCategoryUpdate) {
+        anime_categoriesQueries.update(
+            name = update.name,
+            order = update.order,
+            flags = update.flags,
+            hidden = update.hidden?.let { if (it) 1L else 0L },
+            categoryId = update.id,
+        )
+    }
+}
diff --git a/data/src/main/sqldelight/tachiyomi/data/anime_categories.sq b/data/src/main/sqldelight/tachiyomi/data/anime_categories.sq
new file mode 100644
index 0000000000..db71520aa1
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/data/anime_categories.sq
@@ -0,0 +1,69 @@
+CREATE TABLE anime_categories(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    name TEXT NOT NULL,
+    sort INTEGER NOT NULL,
+    flags INTEGER NOT NULL,
+    hidden INTEGER NOT NULL DEFAULT 0
+);
+
+-- Insert system category
+INSERT OR IGNORE INTO anime_categories(_id, name, sort, flags, hidden) VALUES (0, "", -1, 0, 0);
+-- Disallow deletion of default category
+CREATE TRIGGER IF NOT EXISTS system_anime_category_delete_trigger BEFORE DELETE
+ON anime_categories
+BEGIN SELECT CASE
+    WHEN old._id <= 0 THEN
+        RAISE(ABORT, "System category can't be deleted")
+    END;
+END;
+
+getCategory:
+SELECT _id, name, sort, flags, hidden
+FROM anime_categories
+WHERE _id = :id
+LIMIT 1;
+
+getCategories:
+SELECT
+_id AS id,
+name,
+sort AS `order`,
+flags,
+hidden
+FROM anime_categories
+ORDER BY sort;
+
+getCategoriesByAnimeId:
+SELECT
+C._id AS id,
+C.name,
+C.sort AS `order`,
+C.flags,
+C.hidden
+FROM anime_categories C
+JOIN animes_categories AC
+ON C._id = AC.category_id
+WHERE AC.anime_id = :animeId;
+
+insert:
+INSERT INTO anime_categories(name, sort, flags, hidden)
+VALUES (:name, :order, :flags, :hidden);
+
+delete:
+DELETE FROM anime_categories
+WHERE _id = :categoryId;
+
+update:
+UPDATE anime_categories
+SET name = coalesce(:name, name),
+    sort = coalesce(:order, sort),
+    flags = coalesce(:flags, flags),
+    hidden = coalesce(:hidden, hidden)
+WHERE _id = :categoryId;
+
+updateAllFlags:
+UPDATE anime_categories SET
+flags = coalesce(?, flags);
+
+selectLastInsertedRowId:
+SELECT last_insert_rowid();
diff --git a/data/src/main/sqldelight/tachiyomi/data/animes_categories.sq b/data/src/main/sqldelight/tachiyomi/data/animes_categories.sq
new file mode 100644
index 0000000000..a61049bf9e
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/data/animes_categories.sq
@@ -0,0 +1,24 @@
+CREATE TABLE animes_categories(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    anime_id INTEGER NOT NULL,
+    category_id INTEGER NOT NULL,
+    FOREIGN KEY(category_id) REFERENCES anime_categories (_id)
+    ON DELETE CASCADE,
+    FOREIGN KEY(anime_id) REFERENCES animes (_id)
+    ON DELETE CASCADE
+);
+
+CREATE TRIGGER insert_anime_category_update_version AFTER INSERT ON animes_categories
+BEGIN
+    UPDATE animes
+    SET version = version + 1
+    WHERE _id = new.anime_id AND (SELECT is_syncing FROM animes WHERE _id = new.anime_id) = 0;
+END;
+
+insert:
+INSERT INTO animes_categories(anime_id, category_id)
+VALUES (:animeId, :categoryId);
+
+deleteAnimeCategoryByAnimeId:
+DELETE FROM animes_categories
+WHERE anime_id = :animeId;
diff --git a/data/src/main/sqldelight/tachiyomi/migrations/48.sqm b/data/src/main/sqldelight/tachiyomi/migrations/48.sqm
new file mode 100644
index 0000000000..61c6654a6e
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/migrations/48.sqm
@@ -0,0 +1,67 @@
+CREATE TABLE IF NOT EXISTS anime_categories(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    name TEXT NOT NULL,
+    sort INTEGER NOT NULL,
+    flags INTEGER NOT NULL,
+    hidden INTEGER NOT NULL DEFAULT 0
+);
+
+INSERT OR IGNORE INTO anime_categories(_id, name, sort, flags, hidden) VALUES (0, "", -1, 0, 0);
+
+CREATE TRIGGER IF NOT EXISTS system_anime_category_delete_trigger BEFORE DELETE
+ON anime_categories
+BEGIN SELECT CASE
+    WHEN old._id <= 0 THEN
+        RAISE(ABORT, "System category can't be deleted")
+    END;
+END;
+
+CREATE TABLE IF NOT EXISTS animes_categories(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    anime_id INTEGER NOT NULL,
+    category_id INTEGER NOT NULL,
+    FOREIGN KEY(category_id) REFERENCES anime_categories (_id)
+    ON DELETE CASCADE,
+    FOREIGN KEY(anime_id) REFERENCES animes (_id)
+    ON DELETE CASCADE
+);
+
+CREATE TRIGGER IF NOT EXISTS insert_anime_category_update_version AFTER INSERT ON animes_categories
+BEGIN
+    UPDATE animes
+    SET version = version + 1
+    WHERE _id = new.anime_id AND (SELECT is_syncing FROM animes WHERE _id = new.anime_id) = 0;
+END;
+
+CREATE VIEW IF NOT EXISTS animeLibraryView AS
+SELECT
+    A.*,
+    coalesce(EP.total, 0) AS totalCount,
+    coalesce(EP.seenCount, 0) AS seenCount,
+    coalesce(EP.latestUpload, 0) AS latestUpload,
+    coalesce(EP.fetchedAt, 0) AS episodeFetchedAt,
+    coalesce(EP.lastSeen, 0) AS lastSeen,
+    coalesce(EP.bookmarkCount, 0) AS bookmarkCount,
+    coalesce(EP.fillermarkCount, 0) AS fillermarkCount,
+    coalesce(AC.categories, '0') AS categories
+FROM animes A
+LEFT JOIN(
+    SELECT
+        episodes.anime_id,
+        count(*) AS total,
+        sum(seen) AS seenCount,
+        coalesce(max(episodes.date_upload), 0) AS latestUpload,
+        coalesce(max(episodes.last_modified_at), 0) AS lastSeen,
+        coalesce(max(episodes.date_fetch), 0) AS fetchedAt,
+        sum(episodes.bookmark) AS bookmarkCount,
+        sum(episodes.fillermark) AS fillermarkCount
+    FROM episodes
+    GROUP BY episodes.anime_id
+) AS EP
+ON A._id = EP.anime_id
+LEFT JOIN (
+    SELECT anime_id, group_concat(category_id) AS categories
+    FROM animes_categories
+    GROUP BY anime_id
+) AS AC
+ON AC.anime_id = A._id;
diff --git a/data/src/main/sqldelight/tachiyomi/view/animeLibraryView.sq b/data/src/main/sqldelight/tachiyomi/view/animeLibraryView.sq
new file mode 100644
index 0000000000..e402212751
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/view/animeLibraryView.sq
@@ -0,0 +1,42 @@
+CREATE VIEW animeLibraryView AS
+SELECT
+    A.*,
+    coalesce(EP.total, 0) AS totalCount,
+    coalesce(EP.seenCount, 0) AS seenCount,
+    coalesce(EP.latestUpload, 0) AS latestUpload,
+    coalesce(EP.fetchedAt, 0) AS episodeFetchedAt,
+    coalesce(EP.lastSeen, 0) AS lastSeen,
+    coalesce(EP.bookmarkCount, 0) AS bookmarkCount,
+    coalesce(EP.fillermarkCount, 0) AS fillermarkCount,
+    coalesce(AC.categories, '0') AS categories
+FROM animes A
+LEFT JOIN(
+    SELECT
+        episodes.anime_id,
+        count(*) AS total,
+        sum(seen) AS seenCount,
+        coalesce(max(episodes.date_upload), 0) AS latestUpload,
+        coalesce(max(episodes.last_modified_at), 0) AS lastSeen,
+        coalesce(max(episodes.date_fetch), 0) AS fetchedAt,
+        sum(episodes.bookmark) AS bookmarkCount,
+        sum(episodes.fillermark) AS fillermarkCount
+    FROM episodes
+    GROUP BY episodes.anime_id
+) AS EP
+ON A._id = EP.anime_id
+LEFT JOIN (
+    SELECT anime_id, group_concat(category_id) AS categories
+    FROM animes_categories
+    GROUP BY anime_id
+) AS AC
+ON AC.anime_id = A._id;
+
+library:
+SELECT *
+FROM animeLibraryView
+WHERE animeLibraryView.favorite = 1;
+
+seenAnimeNonLibrary:
+SELECT *
+FROM animeLibraryView
+WHERE animeLibraryView.favorite = 0 AND animeLibraryView.seenCount != 0;
diff --git a/domain/src/main/java/tachiyomi/domain/anime/interactor/GetLibraryAnime.kt b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetLibraryAnime.kt
new file mode 100644
index 0000000000..8c2783bcbd
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetLibraryAnime.kt
@@ -0,0 +1,18 @@
+package tachiyomi.domain.anime.interactor
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.library.model.LibraryAnime
+
+class GetLibraryAnime(
+    private val animeRepository: AnimeRepository,
+) {
+
+    suspend fun await(): List<LibraryAnime> {
+        return animeRepository.getLibraryAnime()
+    }
+
+    fun subscribe(): Flow<List<LibraryAnime>> {
+        return animeRepository.getLibraryAnimeAsFlow()
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/model/AnimeCover.kt b/domain/src/main/java/tachiyomi/domain/anime/model/AnimeCover.kt
new file mode 100644
index 0000000000..9352828628
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/model/AnimeCover.kt
@@ -0,0 +1,19 @@
+package tachiyomi.domain.anime.model
+
+data class AnimeCover(
+    val animeId: Long,
+    val sourceId: Long,
+    val isAnimeFavorite: Boolean,
+    val url: String?,
+    val lastModified: Long,
+)
+
+fun Anime.asAnimeCover(): AnimeCover {
+    return AnimeCover(
+        animeId = id,
+        sourceId = source,
+        isAnimeFavorite = favorite,
+        url = thumbnailUrl,
+        lastModified = coverLastModified,
+    )
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt b/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
index 3eeff062db..ff34ccd524 100644
--- a/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
+++ b/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
@@ -3,6 +3,7 @@ package tachiyomi.domain.anime.repository
 import kotlinx.coroutines.flow.Flow
 import tachiyomi.domain.anime.model.Anime
 import tachiyomi.domain.anime.model.AnimeUpdate
+import tachiyomi.domain.library.model.LibraryAnime
 
 interface AnimeRepository {
 
@@ -18,6 +19,12 @@ interface AnimeRepository {
 
     fun getFavoritesBySourceId(sourceId: Long): Flow<List<Anime>>
 
+    suspend fun getLibraryAnime(): List<LibraryAnime>
+
+    fun getLibraryAnimeAsFlow(): Flow<List<LibraryAnime>>
+
+    suspend fun setAnimeCategories(animeId: Long, categoryIds: List<Long>)
+
     suspend fun update(update: AnimeUpdate): Boolean
 
     suspend fun updateAll(animeUpdates: List<AnimeUpdate>): Boolean
diff --git a/domain/src/main/java/tachiyomi/domain/category/interactor/CreateAnimeCategory.kt b/domain/src/main/java/tachiyomi/domain/category/interactor/CreateAnimeCategory.kt
new file mode 100644
index 0000000000..2eee293879
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/category/interactor/CreateAnimeCategory.kt
@@ -0,0 +1,30 @@
+package tachiyomi.domain.category.interactor
+
+import tachiyomi.domain.category.repository.AnimeCategoryRepository
+
+class CreateAnimeCategory(
+    private val animeCategoryRepository: AnimeCategoryRepository,
+) {
+
+    suspend fun await(name: String): Result {
+        val trimmedName = name.trim()
+        if (trimmedName.isBlank()) {
+            return Result.NameEmpty
+        }
+
+        val categories = animeCategoryRepository.getAll()
+        if (categories.any { it.name == trimmedName }) {
+            return Result.NameAlreadyExists
+        }
+
+        val nextOrder = categories.maxOfOrNull { it.order }?.plus(1) ?: 0
+        animeCategoryRepository.insert(trimmedName, nextOrder, 0)
+        return Result.Success
+    }
+
+    sealed interface Result {
+        data object Success : Result
+        data object NameEmpty : Result
+        data object NameAlreadyExists : Result
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/category/interactor/DeleteAnimeCategory.kt b/domain/src/main/java/tachiyomi/domain/category/interactor/DeleteAnimeCategory.kt
new file mode 100644
index 0000000000..1da690eead
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/category/interactor/DeleteAnimeCategory.kt
@@ -0,0 +1,12 @@
+package tachiyomi.domain.category.interactor
+
+import tachiyomi.domain.category.repository.AnimeCategoryRepository
+
+class DeleteAnimeCategory(
+    private val animeCategoryRepository: AnimeCategoryRepository,
+) {
+
+    suspend fun await(categoryId: Long) {
+        animeCategoryRepository.delete(categoryId)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/category/interactor/GetAnimeCategories.kt b/domain/src/main/java/tachiyomi/domain/category/interactor/GetAnimeCategories.kt
new file mode 100644
index 0000000000..26c2cb8bc1
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/category/interactor/GetAnimeCategories.kt
@@ -0,0 +1,26 @@
+package tachiyomi.domain.category.interactor
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.category.model.AnimeCategory
+import tachiyomi.domain.category.repository.AnimeCategoryRepository
+
+class GetAnimeCategories(
+    private val animeCategoryRepository: AnimeCategoryRepository,
+) {
+
+    fun subscribe(): Flow<List<AnimeCategory>> {
+        return animeCategoryRepository.getAllAsFlow()
+    }
+
+    fun subscribe(animeId: Long): Flow<List<AnimeCategory>> {
+        return animeCategoryRepository.getCategoriesByAnimeIdAsFlow(animeId)
+    }
+
+    suspend fun await(): List<AnimeCategory> {
+        return animeCategoryRepository.getAll()
+    }
+
+    suspend fun await(animeId: Long): List<AnimeCategory> {
+        return animeCategoryRepository.getCategoriesByAnimeId(animeId)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/category/interactor/SetAnimeCategories.kt b/domain/src/main/java/tachiyomi/domain/category/interactor/SetAnimeCategories.kt
new file mode 100644
index 0000000000..8d76a19319
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/category/interactor/SetAnimeCategories.kt
@@ -0,0 +1,12 @@
+package tachiyomi.domain.category.interactor
+
+import tachiyomi.domain.anime.repository.AnimeRepository
+
+class SetAnimeCategories(
+    private val animeRepository: AnimeRepository,
+) {
+
+    suspend fun await(animeId: Long, categoryIds: List<Long>) {
+        animeRepository.setAnimeCategories(animeId, categoryIds)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/category/model/AnimeCategory.kt b/domain/src/main/java/tachiyomi/domain/category/model/AnimeCategory.kt
new file mode 100644
index 0000000000..b48bf35692
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/category/model/AnimeCategory.kt
@@ -0,0 +1,18 @@
+package tachiyomi.domain.category.model
+
+import java.io.Serializable
+
+data class AnimeCategory(
+    val id: Long,
+    val name: String,
+    val order: Long,
+    val flags: Long,
+    val hidden: Boolean,
+) : Serializable {
+
+    val isSystemCategory: Boolean = id == UNCATEGORIZED_ID
+
+    companion object {
+        const val UNCATEGORIZED_ID = 0L
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/category/model/AnimeCategoryUpdate.kt b/domain/src/main/java/tachiyomi/domain/category/model/AnimeCategoryUpdate.kt
new file mode 100644
index 0000000000..b47a6ff139
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/category/model/AnimeCategoryUpdate.kt
@@ -0,0 +1,9 @@
+package tachiyomi.domain.category.model
+
+data class AnimeCategoryUpdate(
+    val id: Long,
+    val name: String? = null,
+    val order: Long? = null,
+    val flags: Long? = null,
+    val hidden: Boolean? = null,
+)
diff --git a/domain/src/main/java/tachiyomi/domain/category/repository/AnimeCategoryRepository.kt b/domain/src/main/java/tachiyomi/domain/category/repository/AnimeCategoryRepository.kt
new file mode 100644
index 0000000000..beff185032
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/category/repository/AnimeCategoryRepository.kt
@@ -0,0 +1,24 @@
+package tachiyomi.domain.category.repository
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.category.model.AnimeCategory
+import tachiyomi.domain.category.model.AnimeCategoryUpdate
+
+interface AnimeCategoryRepository {
+
+    suspend fun getAll(): List<AnimeCategory>
+
+    fun getAllAsFlow(): Flow<List<AnimeCategory>>
+
+    suspend fun getCategoriesByAnimeId(animeId: Long): List<AnimeCategory>
+
+    fun getCategoriesByAnimeIdAsFlow(animeId: Long): Flow<List<AnimeCategory>>
+
+    suspend fun insert(name: String, order: Long, flags: Long)
+
+    suspend fun delete(categoryId: Long)
+
+    suspend fun update(update: AnimeCategoryUpdate)
+
+    suspend fun updateAllFlags(flags: Long?)
+}
diff --git a/domain/src/main/java/tachiyomi/domain/library/model/LibraryAnime.kt b/domain/src/main/java/tachiyomi/domain/library/model/LibraryAnime.kt
new file mode 100644
index 0000000000..9fe644355e
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/library/model/LibraryAnime.kt
@@ -0,0 +1,28 @@
+package tachiyomi.domain.library.model
+
+import tachiyomi.domain.anime.model.Anime
+
+data class LibraryAnime(
+    val anime: Anime,
+    val categories: List<Long>,
+    val totalEpisodes: Long,
+    val seenCount: Long,
+    val bookmarkCount: Long,
+    val fillermarkCount: Long,
+    val latestUpload: Long,
+    val episodeFetchedAt: Long,
+    val lastSeen: Long,
+) {
+    val id: Long = anime.id
+
+    val unseenCount: Long
+        get() = totalEpisodes - seenCount
+
+    val hasBookmarks: Boolean
+        get() = bookmarkCount > 0
+
+    val hasFillermarks: Boolean
+        get() = fillermarkCount > 0
+
+    val hasStarted: Boolean = seenCount > 0
+}
diff --git a/domain/src/main/java/tachiyomi/domain/library/service/AnimeLibraryPreferences.kt b/domain/src/main/java/tachiyomi/domain/library/service/AnimeLibraryPreferences.kt
new file mode 100644
index 0000000000..871c322f0c
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/library/service/AnimeLibraryPreferences.kt
@@ -0,0 +1,122 @@
+package tachiyomi.domain.library.service
+
+import tachiyomi.core.common.preference.Preference
+import tachiyomi.core.common.preference.PreferenceStore
+import tachiyomi.core.common.preference.TriState
+import tachiyomi.core.common.preference.getEnum
+import tachiyomi.domain.library.model.LibraryDisplayMode
+import tachiyomi.domain.library.model.LibraryGroup
+import tachiyomi.domain.library.model.LibrarySort
+
+class AnimeLibraryPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+
+    fun displayMode() = preferenceStore.getObjectFromString(
+        "pref_display_mode_animelib",
+        LibraryDisplayMode.default,
+        LibraryDisplayMode.Serializer::serialize,
+        LibraryDisplayMode.Serializer::deserialize,
+    )
+
+    fun sortingMode() = preferenceStore.getObjectFromString(
+        "animelib_sorting_mode",
+        LibrarySort.default,
+        LibrarySort.Serializer::serialize,
+        LibrarySort.Serializer::deserialize,
+    )
+
+    fun randomSortSeed() = preferenceStore.getInt("library_random_anime_sort_seed", 0)
+
+    fun portraitColumns() = preferenceStore.getInt("pref_animelib_columns_portrait_key", 0)
+
+    fun landscapeColumns() = preferenceStore.getInt("pref_animelib_columns_landscape_key", 0)
+
+    fun showContinueWatchingButton() = preferenceStore.getBoolean(
+        "display_continue_watching_button",
+        false,
+    )
+
+    // region Filter
+
+    fun filterDownloaded() = preferenceStore.getEnum(
+        "pref_filter_animelib_downloaded_v2",
+        TriState.DISABLED,
+    )
+
+    fun filterUnseen() = preferenceStore.getEnum(
+        "pref_filter_animelib_unseen_v2",
+        TriState.DISABLED,
+    )
+
+    fun filterStarted() = preferenceStore.getEnum(
+        "pref_filter_animelib_started_v2",
+        TriState.DISABLED,
+    )
+
+    fun filterBookmarked() = preferenceStore.getEnum(
+        "pref_filter_animelib_bookmarked_v2",
+        TriState.DISABLED,
+    )
+
+    fun filterFillermarked() = preferenceStore.getEnum(
+        "pref_filter_animelib_fillermarked_v2",
+        TriState.DISABLED,
+    )
+
+    fun filterCompleted() = preferenceStore.getEnum(
+        "pref_filter_animelib_completed_v2",
+        TriState.DISABLED,
+    )
+
+    fun filterTracking(id: Int) = preferenceStore.getEnum(
+        "pref_filter_animelib_tracked_${id}_v2",
+        TriState.DISABLED,
+    )
+
+    // endregion
+
+    // region Badges
+
+    fun downloadBadge() = preferenceStore.getBoolean("display_animelib_download_badge", false)
+
+    fun unseenBadge() = preferenceStore.getBoolean("display_animelib_unseen_badge", true)
+
+    fun localBadge() = preferenceStore.getBoolean("display_animelib_local_badge", true)
+
+    fun languageBadge() = preferenceStore.getBoolean("display_animelib_language_badge", false)
+
+    // endregion
+
+    // region Category
+
+    fun defaultCategory() = preferenceStore.getInt("default_anime_category", -1)
+
+    fun lastUsedCategory() = preferenceStore.getInt(
+        Preference.appStateKey("last_used_anime_category"),
+        0,
+    )
+
+    fun categoryTabs() = preferenceStore.getBoolean("display_anime_category_tabs", true)
+
+    fun categoryNumberOfItems() = preferenceStore.getBoolean(
+        "display_anime_number_of_items",
+        false,
+    )
+
+    fun categorizedDisplaySettings() = preferenceStore.getBoolean(
+        "anime_categorized_display",
+        false,
+    )
+
+    // endregion
+
+    // region Grouping
+
+    fun groupLibraryBy() = preferenceStore.getInt(
+        "group_anime_library_by",
+        LibraryGroup.BY_DEFAULT,
+    )
+
+    // endregion
+}
diff --git a/source-api/src/androidMain/kotlin/eu/kanade/tachiyomi/animesource/PreferenceScreen.kt b/source-api/src/androidMain/kotlin/eu/kanade/tachiyomi/animesource/PreferenceScreen.kt
new file mode 100644
index 0000000000..8b5a770187
--- /dev/null
+++ b/source-api/src/androidMain/kotlin/eu/kanade/tachiyomi/animesource/PreferenceScreen.kt
@@ -0,0 +1,3 @@
+package eu.kanade.tachiyomi.animesource
+
+actual typealias PreferenceScreen = androidx.preference.PreferenceScreen
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/ConfigurableAnimeSource.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/ConfigurableAnimeSource.kt
index 7172da9982..21413fe128 100644
--- a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/ConfigurableAnimeSource.kt
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/ConfigurableAnimeSource.kt
@@ -3,7 +3,6 @@ package eu.kanade.tachiyomi.animesource
 import android.app.Application
 import android.content.Context
 import android.content.SharedPreferences
-import eu.kanade.tachiyomi.source.PreferenceScreen
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 
@@ -17,4 +16,5 @@ interface ConfigurableAnimeSource : AnimeSource {
 
 fun ConfigurableAnimeSource.preferenceKey(): String = "source_$id"
 
-fun ConfigurableAnimeSource.sourcePreferences(): SharedPreferences = getSourcePreferences()
+fun ConfigurableAnimeSource.sourcePreferences(): SharedPreferences =
+    Injekt.get<Application>().getSharedPreferences(preferenceKey(), Context.MODE_PRIVATE)
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/PreferenceScreen.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/PreferenceScreen.kt
new file mode 100644
index 0000000000..041ae83b60
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/PreferenceScreen.kt
@@ -0,0 +1,3 @@
+package eu.kanade.tachiyomi.animesource
+
+expect class PreferenceScreen
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/FilterList.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/FilterList.kt
new file mode 100644
index 0000000000..4b721ccd00
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/FilterList.kt
@@ -0,0 +1,3 @@
+package eu.kanade.tachiyomi.animesource.model
+
+typealias FilterList = AnimeFilterList

From 60b53b2ec926a9edf2812b64c918e47d227cf813 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sun, 10 May 2026 03:58:16 +0200
Subject: [PATCH 10/13] Add a few (lol) features to the video player

---
 app/build.gradle.kts                          |   6 +
 app/src/main/AndroidManifest.xml              |  11 +-
 .../player/components/PlayerSheet.kt          | 233 +++++++++
 .../player/components/SwitchPreference.kt     |  33 ++
 .../data/notification/Notifications.kt        |   3 +
 .../service/TorrentServerService.kt           | 126 +++++
 .../kanade/tachiyomi/di/PreferenceModule.kt   |  24 +
 .../torrentServer/TorrentServerApi.kt         |  80 +++
 .../torrentServer/TorrentServerPreferences.kt |  26 +
 .../torrentServer/TorrentServerUtils.kt       |  55 ++
 .../tachiyomi/torrentServer/model/Torrent.kt  |  33 ++
 .../torrentServer/model/TorrentRequest.kt     |  20 +
 .../kanade/tachiyomi/ui/browse/BrowseTab.kt   |   9 +-
 .../browse/BrowseAnimeSourceScreenModel.kt    |   5 +-
 .../kanade/tachiyomi/ui/player/CastManager.kt | 109 ++++
 .../tachiyomi/ui/player/ExternalIntents.kt    | 273 ++++++++++
 .../kanade/tachiyomi/ui/player/PipActions.kt  |  56 ++
 .../tachiyomi/ui/player/PlayerActivity.kt     | 448 +++++++++++++++-
 .../kanade/tachiyomi/ui/player/PlayerEnums.kt |  59 +++
 .../tachiyomi/ui/player/PlayerScreen.kt       |  77 ++-
 .../tachiyomi/ui/player/PlayerViewModel.kt    | 373 ++++++++++++-
 .../ui/player/cast/CastOptionsProvider.kt     |  23 +
 .../ui/player/controls/GestureHandler.kt      | 224 ++++++++
 .../player/controls/PlayerControlsOverlay.kt  | 495 +++++++++++++-----
 .../ui/player/controls/SubtitleTapOverlay.kt  |  55 +-
 .../tachiyomi/ui/player/controls/TimeBar.kt   |  72 ++-
 .../components/BrightnessVolumeIndicator.kt   |  95 ++++
 .../controls/components/CurrentChapter.kt     | 104 ++++
 .../components/DoubleTapSeekTriangles.kt      |  60 +++
 .../controls/components/IndexedSegment.kt     |  21 +
 .../controls/components/StatsOverlay.kt       |  81 +++
 .../components/dialogs/PlayerDialog.kt        |  46 ++
 .../controls/components/panels/DelayPanel.kt  | 104 ++++
 .../panels/SubtitleSettingsPanel.kt           | 356 +++++++++++++
 .../components/panels/VideoFiltersPanel.kt    | 128 +++++
 .../components/sheets/ChaptersSheet.kt        |  81 +++
 .../components/sheets/GenericTracksSheet.kt   |  73 +++
 .../controls/components/sheets/MoreSheet.kt   | 210 ++++++++
 .../components/sheets/ScreenshotSheet.kt      | 110 ++++
 .../controls/components/sheets/SpeedSheet.kt  |  77 +++
 .../kanade/tachiyomi/ui/player/mpv/MPVView.kt | 106 +++-
 .../tachiyomi/ui/player/mpv/PlayerObserver.kt |   6 +
 .../setting/AdvancedPlayerPreferences.kt      |  11 +
 .../ui/player/setting/AudioPreferences.kt     |  23 +
 .../ui/player/setting/DecoderPreferences.kt   |  20 +
 .../ui/player/setting/GesturePreferences.kt   |  23 +
 .../ui/player/setting/PlayerPreferences.kt    |  59 ++-
 .../ui/player/setting/SubtitlePreferences.kt  |  46 ++
 .../tachiyomi/ui/player/utils/AniSkipApi.kt   | 121 +++++
 .../tachiyomi/ui/player/utils/ChapterUtils.kt |  94 ++++
 .../tachiyomi/ui/player/utils/TrackSelect.kt  |  52 ++
 .../res/drawable/ic_play_seek_triangle.xml    |  11 +
 .../main/res/drawable/ic_skip_next_24dp.xml   |  10 +
 .../res/drawable/ic_skip_previous_24dp.xml    |  10 +
 gradle/libs.versions.toml                     |   9 +
 .../moko-resources/base/strings.xml           |  51 ++
 .../tachiyomi/animesource/model/Video.kt      |   1 +
 57 files changed, 4923 insertions(+), 204 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/presentation/player/components/PlayerSheet.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/player/components/SwitchPreference.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/data/torrentServer/service/TorrentServerService.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/CastManager.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/ExternalIntents.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/PipActions.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerEnums.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/cast/CastOptionsProvider.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/GestureHandler.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/BrightnessVolumeIndicator.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/CurrentChapter.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/DoubleTapSeekTriangles.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/IndexedSegment.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/StatsOverlay.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/dialogs/PlayerDialog.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/DelayPanel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/SubtitleSettingsPanel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/VideoFiltersPanel.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ChaptersSheet.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/GenericTracksSheet.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/MoreSheet.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ScreenshotSheet.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/SpeedSheet.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/AdvancedPlayerPreferences.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/AudioPreferences.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/DecoderPreferences.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/GesturePreferences.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/SubtitlePreferences.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/AniSkipApi.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/ChapterUtils.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/TrackSelect.kt
 create mode 100644 app/src/main/res/drawable/ic_play_seek_triangle.xml
 create mode 100644 app/src/main/res/drawable/ic_skip_next_24dp.xml
 create mode 100644 app/src/main/res/drawable/ic_skip_previous_24dp.xml

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index a1a685d0c3..2c497442dc 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -357,8 +357,14 @@ dependencies {
 
     // MPV player
     implementation(libs.aniyomi.mpv)
+    implementation(libs.seeker)
     implementation(libs.ffmpeg.kit)
     implementation(libs.smart.exception.java)
+    implementation(libs.mediasession)
+    implementation(libs.truetypeparser)
+    implementation(libs.torrentserver)
+    implementation(libs.media.router)
+    implementation(libs.cast.play.services)
 
     // SY -->
     // Better logging (EH)
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 075a452fd6..a2cd4e836d 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -181,7 +181,7 @@
             android:launchMode="singleTask"
             android:configChanges="orientation|screenSize|screenLayout|smallestScreenSize|uiMode"
             android:theme="@style/Theme.Tachiyomi"
-            android:supportsPictureInPicture="false">
+            android:supportsPictureInPicture="true">
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
                 <category android:name="android.intent.category.DEFAULT" />
@@ -189,6 +189,15 @@
             </intent-filter>
         </activity>
 
+        <service
+            android:name=".data.torrentServer.service.TorrentServerService"
+            android:exported="false"
+            android:foregroundServiceType="dataSync" />
+
+        <meta-data
+            android:name="com.google.android.gms.cast.framework.OPTIONS_PROVIDER_CLASS_NAME"
+            android:value="eu.kanade.tachiyomi.ui.player.cast.CastOptionsProvider" />
+
         <activity
             android:name=".ui.security.UnlockActivity"
             android:exported="false"
diff --git a/app/src/main/java/eu/kanade/presentation/player/components/PlayerSheet.kt b/app/src/main/java/eu/kanade/presentation/player/components/PlayerSheet.kt
new file mode 100644
index 0000000000..a95f1df5ef
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/player/components/PlayerSheet.kt
@@ -0,0 +1,233 @@
+package eu.kanade.presentation.player.components
+
+import android.content.res.Configuration.ORIENTATION_LANDSCAPE
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.animation.rememberSplineBasedDecay
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.AnchoredDraggableState
+import androidx.compose.foundation.gestures.DraggableAnchors
+import androidx.compose.foundation.gestures.Orientation
+import androidx.compose.foundation.gestures.anchoredDraggable
+import androidx.compose.foundation.gestures.animateTo
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.only
+import androidx.compose.foundation.layout.sizeIn
+import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.windowInsetsPadding
+import androidx.compose.foundation.shape.ZeroCornerSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import androidx.compose.runtime.snapshotFlow
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.nestedscroll.NestedScrollConnection
+import androidx.compose.ui.input.nestedscroll.NestedScrollSource
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.Velocity
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.launch
+import kotlin.math.roundToInt
+
+private val sheetAnimationSpec = tween<Float>(350)
+
+@Composable
+fun PlayerSheet(
+    onDismissRequest: () -> Unit,
+    modifier: Modifier = Modifier,
+    tonalElevation: Dp = 1.dp,
+    dismissEvent: Boolean = false,
+    content: @Composable () -> Unit,
+) {
+    val scope = rememberCoroutineScope()
+    val density = LocalDensity.current
+    val latestOnDismissRequest by rememberUpdatedState(onDismissRequest)
+    val maxWidth = if (LocalConfiguration.current.orientation == ORIENTATION_LANDSCAPE) {
+        640.dp
+    } else {
+        420.dp
+    }
+    val maxHeight = LocalConfiguration.current.screenHeightDp.dp * .95f
+
+    var backgroundAlpha by remember { mutableFloatStateOf(0f) }
+    val alpha by animateFloatAsState(
+        backgroundAlpha,
+        animationSpec = sheetAnimationSpec,
+        label = "alpha",
+    )
+
+    val decayAnimationSpec = rememberSplineBasedDecay<Float>()
+    val anchoredDraggableState = remember {
+        AnchoredDraggableState(
+            initialValue = 1,
+            snapAnimationSpec = sheetAnimationSpec,
+            decayAnimationSpec = decayAnimationSpec,
+            positionalThreshold = { with(density) { 56.dp.toPx() } },
+            velocityThreshold = { with(density) { 125.dp.toPx() } },
+        )
+    }
+
+    LaunchedEffect(dismissEvent) {
+        if (dismissEvent) {
+            backgroundAlpha = 0f
+            anchoredDraggableState.animateTo(1)
+            onDismissRequest()
+        }
+    }
+
+    val internalOnDismissRequest = {
+        if (anchoredDraggableState.currentValue == 0) {
+            scope.launch {
+                backgroundAlpha = 0f
+                anchoredDraggableState.animateTo(1)
+            }
+        }
+    }
+    Box(
+        modifier = Modifier
+            .clickable(
+                interactionSource = remember { MutableInteractionSource() },
+                indication = null,
+                onClick = internalOnDismissRequest,
+            )
+            .fillMaxSize()
+            .background(Color.Black.copy(alpha))
+            .onSizeChanged {
+                val anchors = DraggableAnchors {
+                    0 at 0f
+                    1 at it.height.toFloat()
+                }
+                anchoredDraggableState.updateAnchors(anchors)
+            },
+        contentAlignment = Alignment.BottomCenter,
+    ) {
+        Surface(
+            modifier = Modifier
+                .sizeIn(maxWidth = maxWidth, maxHeight = maxHeight)
+                .clickable(
+                    interactionSource = remember { MutableInteractionSource() },
+                    indication = null,
+                    onClick = {},
+                )
+                .nestedScroll(
+                    remember(anchoredDraggableState) {
+                        anchoredDraggableState.preUpPostDownNestedScrollConnection()
+                    },
+                )
+                .then(modifier)
+                .offset {
+                    IntOffset(
+                        0,
+                        anchoredDraggableState.offset
+                            .takeIf { it.isFinite() }
+                            ?.roundToInt()
+                            ?: 0,
+                    )
+                }
+                .anchoredDraggable(
+                    state = anchoredDraggableState,
+                    orientation = Orientation.Vertical,
+                )
+                .windowInsetsPadding(
+                    WindowInsets.systemBars
+                        .only(WindowInsetsSides.Top + WindowInsetsSides.Horizontal),
+                ),
+            shape = MaterialTheme.shapes.extraLarge.copy(bottomEnd = ZeroCornerSize, bottomStart = ZeroCornerSize),
+            tonalElevation = tonalElevation,
+            content = {
+                BackHandler(
+                    enabled = anchoredDraggableState.targetValue == 0,
+                    onBack = internalOnDismissRequest,
+                )
+                content()
+            },
+        )
+
+        LaunchedEffect(true) {
+            backgroundAlpha = 0.5f
+        }
+
+        LaunchedEffect(anchoredDraggableState) {
+            scope.launch { anchoredDraggableState.animateTo(0) }
+            snapshotFlow { anchoredDraggableState.currentValue }
+                .drop(1)
+                .filter { it == 1 }
+                .collectLatest { latestOnDismissRequest() }
+        }
+    }
+}
+
+private fun <T> AnchoredDraggableState<T>.preUpPostDownNestedScrollConnection() = object : NestedScrollConnection {
+    override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
+        val delta = available.toFloat()
+        return if (delta < 0 && source == NestedScrollSource.UserInput) {
+            dispatchRawDelta(delta).toOffset()
+        } else {
+            Offset.Zero
+        }
+    }
+
+    override fun onPostScroll(
+        consumed: Offset,
+        available: Offset,
+        source: NestedScrollSource,
+    ): Offset {
+        return if (source == NestedScrollSource.UserInput) {
+            dispatchRawDelta(available.toFloat()).toOffset()
+        } else {
+            Offset.Zero
+        }
+    }
+
+    override suspend fun onPreFling(available: Velocity): Velocity {
+        val toFling = available.toFloat()
+        return if (toFling < 0 && offset > anchors.minPosition()) {
+            settle(toFling)
+            available
+        } else {
+            Velocity.Zero
+        }
+    }
+
+    override suspend fun onPostFling(consumed: Velocity, available: Velocity): Velocity {
+        val toFling = available.toFloat()
+        return if (toFling > 0) {
+            settle(toFling)
+            available
+        } else {
+            Velocity.Zero
+        }
+    }
+
+    private fun Float.toOffset(): Offset = Offset(0f, this)
+
+    @JvmName("velocityToFloat")
+    private fun Velocity.toFloat() = y
+
+    private fun Offset.toFloat(): Float = y
+}
diff --git a/app/src/main/java/eu/kanade/presentation/player/components/SwitchPreference.kt b/app/src/main/java/eu/kanade/presentation/player/components/SwitchPreference.kt
new file mode 100644
index 0000000000..4e9001030f
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/player/components/SwitchPreference.kt
@@ -0,0 +1,33 @@
+package eu.kanade.presentation.player.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.selection.toggleable
+import androidx.compose.material3.Switch
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.Role
+
+@Composable
+fun SwitchPreference(
+    value: Boolean,
+    onValueChange: (Boolean) -> Unit,
+    content: @Composable () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = modifier
+            .toggleable(value, true, Role.Switch, null, onValueChange)
+            .fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        content()
+        Switch(
+            checked = value,
+            onCheckedChange = null,
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt b/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
index 3385c28700..080e0ff6f4 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
@@ -23,6 +23,9 @@ object Notifications {
     const val CHANNEL_COMMON = "common_channel"
     const val ID_DOWNLOAD_IMAGE = 2
 
+    const val CHANNEL_TORRENT_SERVER = "torrent_server_channel"
+    const val ID_TORRENT_SERVER = -601
+
     /**
      * Notification channel and ids used by the library updater.
      */
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/torrentServer/service/TorrentServerService.kt b/app/src/main/java/eu/kanade/tachiyomi/data/torrentServer/service/TorrentServerService.kt
new file mode 100644
index 0000000000..29727834b0
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/torrentServer/service/TorrentServerService.kt
@@ -0,0 +1,126 @@
+package eu.kanade.tachiyomi.data.torrentServer.service
+
+import android.app.Application
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.os.IBinder
+import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.data.notification.Notifications
+import eu.kanade.tachiyomi.torrentServer.TorrentServerApi
+import eu.kanade.tachiyomi.torrentServer.TorrentServerUtils
+import eu.kanade.tachiyomi.util.system.cancelNotification
+import eu.kanade.tachiyomi.util.system.notificationBuilder
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import kotlin.coroutines.EmptyCoroutineContext
+
+class TorrentServerService : Service() {
+    private val serviceScope = CoroutineScope(EmptyCoroutineContext)
+    private val applicationContext = Injekt.get<Application>()
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.action) {
+            ACTION_START -> {
+                startServer()
+                notification(applicationContext)
+                return START_STICKY
+            }
+            ACTION_STOP -> {
+                stopServer()
+                return START_NOT_STICKY
+            }
+        }
+        return START_NOT_STICKY
+    }
+
+    private fun startServer() {
+        serviceScope.launch {
+            if (TorrentServerApi.echo() == "") {
+                torrServer.TorrServer.startTorrentServer(filesDir.absolutePath)
+                wait(10)
+                TorrentServerUtils.setTrackersList()
+            }
+        }
+    }
+
+    private fun stopServer() {
+        serviceScope.launch {
+            torrServer.TorrServer.stopTorrentServer()
+            TorrentServerApi.shutdown()
+            applicationContext.cancelNotification(Notifications.ID_TORRENT_SERVER)
+            stopSelf()
+        }
+    }
+
+    private fun notification(context: Context) {
+        val exitPendingIntent = PendingIntent.getService(
+            applicationContext,
+            0,
+            Intent(applicationContext, TorrentServerService::class.java).apply {
+                action = ACTION_STOP
+            },
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+        val builder = context.notificationBuilder(Notifications.CHANNEL_TORRENT_SERVER) {
+            setSmallIcon(R.mipmap.ic_launcher)
+            setContentText("Torrent server is running")
+            setContentTitle("Chimahon")
+            setAutoCancel(false)
+            setOngoing(true)
+            setUsesChronometer(true)
+            addAction(R.drawable.ic_close_24dp, "Stop", exitPendingIntent)
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            startForeground(
+                Notifications.ID_TORRENT_SERVER,
+                builder.build(),
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+            )
+        } else {
+            startForeground(Notifications.ID_TORRENT_SERVER, builder.build())
+        }
+    }
+
+    companion object {
+        const val ACTION_START = "start_torrent_server"
+        const val ACTION_STOP = "stop_torrent_server"
+        private val applicationContext = Injekt.get<Application>()
+
+        fun start() {
+            try {
+                val intent = Intent(applicationContext, TorrentServerService::class.java).apply {
+                    action = ACTION_START
+                }
+                applicationContext.startService(intent)
+            } catch (_: Exception) {}
+        }
+
+        fun stop() {
+            try {
+                val intent = Intent(applicationContext, TorrentServerService::class.java).apply {
+                    action = ACTION_STOP
+                }
+                applicationContext.startService(intent)
+            } catch (_: Exception) {}
+        }
+
+        fun wait(timeout: Int = -1): Boolean {
+            var count = if (timeout < 0) -20 else 0
+            while (TorrentServerApi.echo() == "") {
+                Thread.sleep(1000)
+                count++
+                if (count > timeout) return false
+            }
+            return true
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/di/PreferenceModule.kt b/app/src/main/java/eu/kanade/tachiyomi/di/PreferenceModule.kt
index 61ec90e05b..92ec0bcef7 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/di/PreferenceModule.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/di/PreferenceModule.kt
@@ -11,7 +11,13 @@ import eu.kanade.tachiyomi.core.security.PrivacyPreferences
 import eu.kanade.tachiyomi.core.security.SecurityPreferences
 import eu.kanade.tachiyomi.network.NetworkPreferences
 import eu.kanade.tachiyomi.ui.dictionary.DictionaryPreferences
+import eu.kanade.tachiyomi.torrentServer.TorrentServerPreferences
+import eu.kanade.tachiyomi.ui.player.setting.AdvancedPlayerPreferences
+import eu.kanade.tachiyomi.ui.player.setting.AudioPreferences
+import eu.kanade.tachiyomi.ui.player.setting.DecoderPreferences
+import eu.kanade.tachiyomi.ui.player.setting.GesturePreferences
 import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
 import eu.kanade.tachiyomi.ui.reader.setting.ReaderPreferences
 import com.canopus.chimareader.data.NovelReaderSettings
 import eu.kanade.tachiyomi.util.system.isDebugBuildType
@@ -67,6 +73,24 @@ class PreferenceModule(val app: Application) : InjektModule {
         addSingletonFactory {
             PlayerPreferences(get())
         }
+        addSingletonFactory {
+            GesturePreferences(get())
+        }
+        addSingletonFactory {
+            SubtitlePreferences(get())
+        }
+        addSingletonFactory {
+            AudioPreferences(get())
+        }
+        addSingletonFactory {
+            DecoderPreferences(get())
+        }
+        addSingletonFactory {
+            AdvancedPlayerPreferences(get())
+        }
+        addSingletonFactory {
+            TorrentServerPreferences(get())
+        }
         addSingletonFactory {
             DictionaryPreferences(get())
         }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
new file mode 100644
index 0000000000..b490cb1034
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
@@ -0,0 +1,80 @@
+package eu.kanade.tachiyomi.torrentServer
+
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.torrentServer.model.Torrent
+import eu.kanade.tachiyomi.torrentServer.model.TorrentRequest
+import kotlinx.serialization.json.Json
+import logcat.LogPriority
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.RequestBody.Companion.toRequestBody
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.injectLazy
+
+object TorrentServerApi {
+    private val network: NetworkHelper by injectLazy()
+    private val hostUrl get() = TorrentServerUtils.hostUrl
+
+    fun echo(): String {
+        return try {
+            network.client.newCall(GET("$hostUrl/echo")).execute().body.string()
+        } catch (e: Exception) {
+            logcat(LogPriority.DEBUG) { e.toString() }
+            ""
+        }
+    }
+
+    fun shutdown(): String {
+        return try {
+            network.client.newCall(GET("$hostUrl/shutdown")).execute().body.string()
+        } catch (e: Exception) {
+            logcat(LogPriority.DEBUG) { e.toString() }
+            ""
+        }
+    }
+
+    fun addTorrent(
+        link: String,
+        title: String,
+        poster: String = "",
+        data: String = "",
+        save: Boolean = false,
+    ): Torrent {
+        val req = TorrentRequest(
+            "add",
+            link = link,
+            title = title,
+            poster = poster,
+            data = data,
+            saveToDb = save,
+        ).toString()
+        val resp = network.client.newCall(
+            POST("$hostUrl/torrents", body = req.toRequestBody("application/json".toMediaTypeOrNull())),
+        ).execute()
+        return Json.decodeFromString(Torrent.serializer(), resp.body.string())
+    }
+
+    fun getTorrent(hash: String): Torrent {
+        val req = TorrentRequest("get", hash).toString()
+        val resp = network.client.newCall(
+            POST("$hostUrl/torrents", body = req.toRequestBody("application/json".toMediaTypeOrNull())),
+        ).execute()
+        return Json.decodeFromString(Torrent.serializer(), resp.body.string())
+    }
+
+    fun remTorrent(hash: String) {
+        val req = TorrentRequest("rem", hash).toString()
+        network.client.newCall(
+            POST("$hostUrl/torrents", body = req.toRequestBody("application/json".toMediaTypeOrNull())),
+        ).execute()
+    }
+
+    fun listTorrent(): List<Torrent> {
+        val req = TorrentRequest("list").toString()
+        val resp = network.client.newCall(
+            POST("$hostUrl/torrents", body = req.toRequestBody("application/json".toMediaTypeOrNull())),
+        ).execute()
+        return Json.decodeFromString<List<Torrent>>(resp.body.string())
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt
new file mode 100644
index 0000000000..0f2601c23d
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt
@@ -0,0 +1,26 @@
+package eu.kanade.tachiyomi.torrentServer
+
+import tachiyomi.core.common.preference.PreferenceStore
+
+class TorrentServerPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+    fun port() = preferenceStore.getString("pref_torrent_port", "8090")
+
+    fun trackers() = preferenceStore.getString(
+        "pref_torrent_trackers",
+        """http://nyaa.tracker.wf:7777/announce
+http://anidex.moe:6969/announce
+http://tracker.anirena.com:80/announce
+udp://tracker.uw0.xyz:6969/announce
+udp://exodus.desync.com:6969/announce
+udp://explodie.org:6969/announce
+udp://open.stealth.si:80/announce
+udp://opentracker.i2p.rocks:6969/announce
+udp://tracker.cyberia.is:6969/announce
+udp://tracker.dler.org:6969/announce
+udp://tracker.openbittorrent.com:6969/announce
+udp://tracker.opentrackr.org:1337/announce
+udp://tracker.torrent.eu.org:451/announce""",
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt
new file mode 100644
index 0000000000..2b0e29befc
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt
@@ -0,0 +1,55 @@
+package eu.kanade.tachiyomi.torrentServer
+
+import eu.kanade.tachiyomi.torrentServer.model.FileStat
+import eu.kanade.tachiyomi.torrentServer.model.Torrent
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import uy.kohesive.injekt.injectLazy
+import java.io.File
+import java.net.Inet4Address
+import java.net.NetworkInterface
+import java.net.URLEncoder
+
+object TorrentServerUtils {
+    private val preferences: TorrentServerPreferences by injectLazy()
+
+    val hostUrl: String get() = "http://${getLocalIpAddress()}:${preferences.port().get()}"
+
+    private val animeTrackers: String
+        get() = preferences.trackers().get().split("\n").joinToString(",\n")
+
+    fun setTrackersList() {
+        torrServer.TorrServer.addTrackers(animeTrackers)
+    }
+
+    fun getTorrentPlayLink(torr: Torrent, index: Int): String {
+        val file = findFile(torr, index)
+        val name = file?.let { File(it.path).name } ?: torr.title
+        return "$hostUrl/stream/${name.urlEncode()}?link=${torr.hash}&index=$index&play"
+    }
+
+    private fun findFile(torrent: Torrent, index: Int): FileStat? {
+        return torrent.file_stats?.firstOrNull { it.id == index }
+    }
+
+    private fun getLocalIpAddress(): String {
+        try {
+            val interfaces = NetworkInterface.getNetworkInterfaces()
+            while (interfaces.hasMoreElements()) {
+                val intf = interfaces.nextElement()
+                val addresses = intf.inetAddresses
+                while (addresses.hasMoreElements()) {
+                    val addr = addresses.nextElement()
+                    if (!addr.isLoopbackAddress && addr is Inet4Address) {
+                        return addr.hostAddress ?: "127.0.0.1"
+                    }
+                }
+            }
+        } catch (ex: Exception) {
+            logcat(LogPriority.DEBUG) { "Error getting local IP address" }
+        }
+        return "127.0.0.1"
+    }
+
+    private fun String.urlEncode(): String = URLEncoder.encode(this, "utf8")
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt
new file mode 100644
index 0000000000..97811005a5
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt
@@ -0,0 +1,33 @@
+package eu.kanade.tachiyomi.torrentServer.model
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+@Suppress("ConstructorParameterNaming")
+data class Torrent(
+    var title: String,
+    var poster: String? = null,
+    var data: String? = null,
+    var timestamp: Long? = null,
+    var name: String? = null,
+    var hash: String? = null,
+    var stat: Int? = null,
+    var stat_string: String? = null,
+    var loaded_size: Long? = null,
+    var torrent_size: Long? = null,
+    var preloaded_bytes: Long? = null,
+    var preload_size: Long? = null,
+    var download_speed: Double? = null,
+    var upload_speed: Double? = null,
+    var total_peers: Int? = null,
+    var active_peers: Int? = null,
+    var connected_seeders: Int? = null,
+    var file_stats: List<FileStat>? = null,
+)
+
+@Serializable
+data class FileStat(
+    var id: Int? = null,
+    var path: String,
+    var length: Long,
+)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt
new file mode 100644
index 0000000000..1f760a48e6
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt
@@ -0,0 +1,20 @@
+package eu.kanade.tachiyomi.torrentServer.model
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.serializer
+
+@Serializable
+data class TorrentRequest(
+    val action: String,
+    val hash: String = "",
+    val link: String = "",
+    val title: String = "",
+    val poster: String = "",
+    val data: String = "",
+    val saveToDb: Boolean = false,
+) {
+    override fun toString(): String {
+        return Json.encodeToString(serializer(), this)
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
index a8b1949e2d..0ff911fcfd 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/BrowseTab.kt
@@ -159,7 +159,14 @@ data object BrowseTab : Tab {
         )
         LaunchedEffect(Unit) {
             switchToExtensionTabChannel.receiveAsFlow()
-                .collectLatest { state.scrollToPage(/* SY --> */2/* SY <-- */) }
+                .collectLatest {
+                    val extensionsIndex = tabs.indexOfFirst { tab ->
+                        tab.titleRes == MR.strings.label_extensions
+                    }
+                    if (extensionsIndex >= 0) {
+                        state.scrollToPage(extensionsIndex)
+                    }
+                }
         }
 
         LaunchedEffect(Unit) {
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
index 2bfa3826a3..40132a8d00 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/browse/BrowseAnimeSourceScreenModel.kt
@@ -9,6 +9,7 @@ import eu.kanade.tachiyomi.animesource.model.SAnime
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.update
 import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.lang.withUIContext
 import tachiyomi.domain.anime.interactor.GetAnime
 import tachiyomi.domain.anime.model.Anime
 import tachiyomi.domain.anime.repository.AnimeRepository
@@ -116,7 +117,7 @@ class BrowseAnimeSourceScreenModel(
         screenModelScope.launchIO {
             val existingAnime = getAnime.await(sAnime.url, sourceId)
             if (existingAnime != null) {
-                onAdded(existingAnime.id)
+                withUIContext { onAdded(existingAnime.id) }
                 return@launchIO
             }
 
@@ -133,7 +134,7 @@ class BrowseAnimeSourceScreenModel(
                 initialized = true,
             )
             val id = animeRepository.insert(anime)
-            onAdded(id)
+            withUIContext { onAdded(id) }
         }
     }
 
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/CastManager.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/CastManager.kt
new file mode 100644
index 0000000000..f485c894ec
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/CastManager.kt
@@ -0,0 +1,109 @@
+package eu.kanade.tachiyomi.ui.player
+
+import android.content.Context
+import android.net.Uri
+import com.google.android.gms.cast.MediaInfo
+import com.google.android.gms.cast.MediaLoadRequestData
+import com.google.android.gms.cast.MediaMetadata
+import com.google.android.gms.cast.framework.CastContext
+import com.google.android.gms.cast.framework.CastSession
+import com.google.android.gms.cast.framework.SessionManager
+import com.google.android.gms.cast.framework.SessionManagerListener
+import com.google.android.gms.common.images.WebImage
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+
+class CastManager(private val context: Context) {
+
+    private var castContext: CastContext? = null
+    private var sessionManager: SessionManager? = null
+    private var currentSession: CastSession? = null
+
+    private val sessionListener = object : SessionManagerListener<CastSession> {
+        override fun onSessionStarting(session: CastSession) {}
+        override fun onSessionStarted(session: CastSession, sessionId: String) {
+            currentSession = session
+            logcat(LogPriority.DEBUG, tag = "Cast") { "Cast session started" }
+        }
+        override fun onSessionStartFailed(session: CastSession, error: Int) {
+            logcat(LogPriority.ERROR, tag = "Cast") { "Cast session start failed: $error" }
+        }
+        override fun onSessionEnding(session: CastSession) {}
+        override fun onSessionEnded(session: CastSession, error: Int) {
+            currentSession = null
+            logcat(LogPriority.DEBUG, tag = "Cast") { "Cast session ended" }
+        }
+        override fun onSessionResuming(session: CastSession, sessionId: String) {}
+        override fun onSessionResumed(session: CastSession, wasSuspended: Boolean) {
+            currentSession = session
+        }
+        override fun onSessionResumeFailed(session: CastSession, error: Int) {}
+        override fun onSessionSuspended(session: CastSession, reason: Int) {}
+    }
+
+    fun initialize() {
+        try {
+            castContext = CastContext.getSharedInstance(context)
+            sessionManager = castContext?.sessionManager
+            sessionManager?.addSessionManagerListener(sessionListener, CastSession::class.java)
+            currentSession = sessionManager?.currentCastSession
+        } catch (e: Exception) {
+            logcat(LogPriority.WARN, tag = "Cast") { "Cast not available: ${e.message}" }
+        }
+    }
+
+    fun release() {
+        sessionManager?.removeSessionManagerListener(sessionListener, CastSession::class.java)
+        currentSession = null
+    }
+
+    val isConnected: Boolean
+        get() = currentSession?.isConnected == true
+
+    fun loadMedia(
+        url: String,
+        title: String,
+        episodeName: String,
+        thumbnailUrl: String? = null,
+        startPositionMs: Long = 0,
+    ) {
+        val session = currentSession ?: return
+        val remoteClient = session.remoteMediaClient ?: return
+
+        val metadata = MediaMetadata(MediaMetadata.MEDIA_TYPE_MOVIE).apply {
+            putString(MediaMetadata.KEY_TITLE, title)
+            putString(MediaMetadata.KEY_SUBTITLE, episodeName)
+            if (!thumbnailUrl.isNullOrBlank()) {
+                addImage(WebImage(Uri.parse(thumbnailUrl)))
+            }
+        }
+
+        val mediaInfo = MediaInfo.Builder(url)
+            .setMetadata(metadata)
+            .build()
+
+        val requestData = MediaLoadRequestData.Builder()
+            .setMediaInfo(mediaInfo)
+            .setAutoplay(true)
+            .setCurrentTime(startPositionMs)
+            .build()
+
+        remoteClient.load(requestData)
+    }
+
+    fun pause() {
+        currentSession?.remoteMediaClient?.pause()
+    }
+
+    fun play() {
+        currentSession?.remoteMediaClient?.play()
+    }
+
+    fun seek(positionMs: Long) {
+        currentSession?.remoteMediaClient?.seek(positionMs)
+    }
+
+    fun stop() {
+        currentSession?.remoteMediaClient?.stop()
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/ExternalIntents.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/ExternalIntents.kt
new file mode 100644
index 0000000000..b0230a2669
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/ExternalIntents.kt
@@ -0,0 +1,273 @@
+package eu.kanade.tachiyomi.ui.player
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import androidx.core.content.FileProvider
+import androidx.core.net.toUri
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import kotlinx.coroutines.DelicateCoroutinesApi
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
+import tachiyomi.domain.episode.interactor.UpdateEpisode
+import tachiyomi.domain.episode.model.Episode
+import tachiyomi.domain.episode.model.EpisodeUpdate
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import uy.kohesive.injekt.injectLazy
+import java.io.File
+
+class ExternalIntents {
+
+    lateinit var anime: Anime
+    lateinit var episode: Episode
+
+    var animeId: Long? = null
+    var episodeId: Long? = null
+
+    suspend fun getExternalIntent(
+        context: Context,
+        animeId: Long,
+        episodeId: Long,
+        videoUrl: String,
+        video: Video?,
+    ): Intent? {
+        if (!initAnime(animeId, episodeId)) return null
+
+        val uri = videoUrl.toUri()
+        val pkgName = playerPreferences.externalPlayerPreference().get()
+
+        return if (pkgName.isEmpty()) {
+            Intent(Intent.ACTION_VIEW).apply {
+                setDataAndTypeAndNormalize(uri, getMime(uri))
+                addExtrasAndFlags(false, this)
+                addVideoHeaders(false, video, this)
+            }
+        } else {
+            getIntentForPackage(pkgName, context, uri, video)
+        }
+    }
+
+    private suspend fun initAnime(animeId: Long, episodeId: Long): Boolean {
+        anime = getAnime.await(animeId) ?: return false
+        episode = getEpisodesByAnimeId.await(anime.id).find { it.id == episodeId } ?: return false
+        this.animeId = animeId
+        this.episodeId = episodeId
+        return true
+    }
+
+    private fun getLastSecondSeen(): Long {
+        val preserveWatchPos = playerPreferences.preserveWatchingPosition().get()
+        val isEpisodeWatched = episode.lastSecondSeen == episode.totalSeconds
+        return if (episode.seen && (!preserveWatchPos || (preserveWatchPos && isEpisodeWatched))) {
+            1L
+        } else {
+            episode.lastSecondSeen
+        }
+    }
+
+    private fun getIntentForPackage(pkgName: String, context: Context, uri: Uri, video: Video?): Intent {
+        return when (pkgName) {
+            WEB_VIDEO_CASTER -> webVideoCasterIntent(pkgName, context, uri, video)
+            else -> standardIntentForPackage(pkgName, context, uri, video)
+        }
+    }
+
+    private fun webVideoCasterIntent(pkgName: String, context: Context, uri: Uri, video: Video?): Intent {
+        return Intent(Intent.ACTION_VIEW).apply {
+            setDataAndType(uri, "video/*")
+            if (isPackageInstalled(pkgName, context.packageManager)) setPackage(WEB_VIDEO_CASTER)
+            addExtrasAndFlags(true, this)
+
+            val headers = Bundle()
+            video?.headers?.forEach {
+                headers.putString(it.first, it.second)
+            }
+
+            video?.subtitleTracks?.firstOrNull()?.let {
+                putExtra("subtitle", it.url)
+            }
+
+            putExtra("android.media.intent.extra.HTTP_HEADERS", headers)
+            putExtra("secure_uri", true)
+        }
+    }
+
+    private fun standardIntentForPackage(pkgName: String, context: Context, uri: Uri, video: Video?): Intent {
+        return Intent(Intent.ACTION_VIEW).apply {
+            if (isPackageInstalled(pkgName, context.packageManager)) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && pkgName.contains("vlc")) {
+                    setPackage(pkgName)
+                } else {
+                    component = getComponent(pkgName)
+                }
+            }
+            setDataAndType(uri, "video/*")
+            addExtrasAndFlags(true, this)
+            addVideoHeaders(true, video, this)
+
+            video?.let { v ->
+                putExtra("subs", v.subtitleTracks.map { Uri.parse(it.url) }.toTypedArray())
+                putExtra("subs.name", v.subtitleTracks.map { it.lang }.toTypedArray())
+                v.subtitleTracks.firstOrNull()?.let { sub ->
+                    putExtra("subs.enable", arrayOf(Uri.parse(sub.url)))
+                    putExtra("subtitles_location", sub.url)
+                }
+            }
+        }
+    }
+
+    private fun addExtrasAndFlags(isSupportedPlayer: Boolean, intent: Intent): Intent {
+        return intent.apply {
+            putExtra("title", anime.title + " - " + episode.name)
+            putExtra("position", getLastSecondSeen().toInt())
+            putExtra("return_result", true)
+            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            if (isSupportedPlayer) putExtra("secure_uri", true)
+        }
+    }
+
+    private fun addVideoHeaders(isSupportedPlayer: Boolean, video: Video?, intent: Intent): Intent {
+        return intent.apply {
+            val headers = video?.headers ?: return@apply
+            var headersArray = arrayOf<String>()
+            for (header in headers) {
+                headersArray += arrayOf(header.first, header.second)
+            }
+            putExtra("headers", headersArray)
+            if (!isSupportedPlayer) {
+                val headersString = headersArray.toList()
+                    .chunked(2) { "${it[0]}: ${it.getOrElse(1) { "" }}" }
+                    .joinToString("\r\n")
+                putExtra("http-header-fields", headersString)
+            }
+        }
+    }
+
+    private fun getMime(uri: Uri): String {
+        return when (uri.path?.substringAfterLast(".")) {
+            "mp4" -> "video/mp4"
+            "mkv" -> "video/x-matroska"
+            "m3u8" -> "application/x-mpegURL"
+            else -> "video/any"
+        }
+    }
+
+    private fun getComponent(packageName: String): ComponentName? {
+        return when (packageName) {
+            MPV_PLAYER -> ComponentName(packageName, "$packageName.MPVActivity")
+            MX_PLAYER, MX_PLAYER_FREE, MX_PLAYER_PRO -> ComponentName(
+                packageName,
+                "$packageName.ActivityScreen",
+            )
+            VLC_PLAYER -> ComponentName(packageName, "$packageName.gui.video.VideoPlayerActivity")
+            MPV_KT, MPV_KT_PREVIEW -> ComponentName(packageName, "live.mehiz.mpvkt.ui.player.PlayerActivity")
+            MPV_REMOTE -> ComponentName(packageName, "$packageName.MainActivity")
+            JUST_PLAYER -> ComponentName(packageName, "$packageName.PlayerActivity")
+            NEXT_PLAYER -> ComponentName(packageName, "$packageName.feature.player.PlayerActivity")
+            X_PLAYER -> ComponentName(packageName, "com.inshot.xplayer.activities.PlayerActivity")
+            else -> null
+        }
+    }
+
+    private fun isPackageInstalled(packageName: String, packageManager: PackageManager): Boolean {
+        return try {
+            packageManager.getPackageInfo(packageName, 0)
+            true
+        } catch (_: PackageManager.NameNotFoundException) {
+            false
+        }
+    }
+
+    @OptIn(DelicateCoroutinesApi::class)
+    @Suppress("DEPRECATION")
+    fun onActivityResult(intent: Intent?) {
+        val data = intent ?: return
+        if (animeId == null || episodeId == null) return
+
+        val currentPosition: Long
+        val duration: Long
+        val cause = data.getStringExtra("end_by") ?: ""
+
+        if (cause.isNotEmpty()) {
+            val positionExtra = data.extras?.get("position")
+            currentPosition = if (positionExtra is Int) {
+                positionExtra.toLong()
+            } else {
+                positionExtra as? Long ?: 0L
+            }
+            val durationExtra = data.extras?.get("duration")
+            duration = if (durationExtra is Int) {
+                durationExtra.toLong()
+            } else {
+                durationExtra as? Long ?: 0L
+            }
+        } else {
+            if (data.extras?.get("extra_position") != null) {
+                currentPosition = data.getLongExtra("extra_position", 0L)
+                duration = data.getLongExtra("extra_duration", 0L)
+            } else {
+                currentPosition = data.getIntExtra("position", 0).toLong()
+                duration = data.getIntExtra("duration", 0).toLong()
+            }
+        }
+
+        launchIO {
+            if (cause == "playback_completion" || (currentPosition == duration && duration == 0L)) {
+                saveEpisodeProgress(episode.totalSeconds, episode.totalSeconds)
+            } else {
+                saveEpisodeProgress(currentPosition, duration)
+            }
+        }
+    }
+
+    private suspend fun saveEpisodeProgress(lastSecondSeen: Long, totalSeconds: Long) {
+        if (totalSeconds > 0L) {
+            val progress = playerPreferences.progressPreference().get()
+            val seen = if (!episode.seen) lastSecondSeen >= totalSeconds * progress else true
+            updateEpisode.await(
+                EpisodeUpdate(
+                    id = episode.id,
+                    seen = seen,
+                    lastSecondSeen = lastSecondSeen,
+                    totalSeconds = totalSeconds,
+                ),
+            )
+        }
+    }
+
+    private val updateEpisode: UpdateEpisode = Injekt.get()
+    private val getAnime: GetAnime = Injekt.get()
+    private val getEpisodesByAnimeId: GetEpisodesByAnimeId = Injekt.get()
+    private val playerPreferences: PlayerPreferences = Injekt.get()
+
+    companion object {
+        val externalIntents: ExternalIntents by injectLazy()
+
+        suspend fun newIntent(context: Context, animeId: Long, episodeId: Long, videoUrl: String, video: Video?): Intent? {
+            return externalIntents.getExternalIntent(context, animeId, episodeId, videoUrl, video)
+        }
+    }
+}
+
+const val MPV_PLAYER = "is.xyz.mpv"
+const val MX_PLAYER = "com.mxtech.videoplayer"
+const val MX_PLAYER_FREE = "com.mxtech.videoplayer.ad"
+const val MX_PLAYER_PRO = "com.mxtech.videoplayer.pro"
+const val VLC_PLAYER = "org.videolan.vlc"
+const val MPV_KT = "live.mehiz.mpvkt"
+const val MPV_KT_PREVIEW = "live.mehiz.mpvkt.preview"
+const val MPV_REMOTE = "com.husudosu.mpvremote"
+const val JUST_PLAYER = "com.brouken.player"
+const val NEXT_PLAYER = "dev.anilbeesetti.nextplayer"
+const val X_PLAYER = "video.player.videoplayer"
+const val WEB_VIDEO_CASTER = "com.instantbits.cast.webvideo"
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PipActions.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PipActions.kt
new file mode 100644
index 0000000000..76ca167da5
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PipActions.kt
@@ -0,0 +1,56 @@
+package eu.kanade.tachiyomi.ui.player
+
+import android.app.PendingIntent
+import android.app.RemoteAction
+import android.content.Context
+import android.content.Intent
+import android.graphics.drawable.Icon
+import eu.kanade.tachiyomi.R
+import tachiyomi.core.common.i18n.stringResource
+import tachiyomi.i18n.MR
+
+const val PIP_INTENTS_FILTER = "pip_control"
+const val PIP_INTENT_ACTION = "media_control"
+const val PIP_PAUSE = 1
+const val PIP_PLAY = 2
+const val PIP_PREVIOUS = 3
+const val PIP_NEXT = 4
+
+fun createPipActions(
+    context: Context,
+    isPaused: Boolean,
+    hasPrevious: Boolean,
+    hasNext: Boolean,
+): ArrayList<RemoteAction> = arrayListOf(
+    createPipAction(context, R.drawable.ic_skip_previous_24dp, context.stringResource(MR.strings.player_previous), PIP_PREVIOUS, hasPrevious),
+    if (isPaused) {
+        createPipAction(context, R.drawable.ic_play_arrow_24dp, context.stringResource(MR.strings.action_play), PIP_PLAY)
+    } else {
+        createPipAction(context, R.drawable.ic_pause_24dp, context.stringResource(MR.strings.action_pause), PIP_PAUSE)
+    },
+    createPipAction(context, R.drawable.ic_skip_next_24dp, context.stringResource(MR.strings.player_next), PIP_NEXT, hasNext),
+)
+
+private fun createPipAction(
+    context: Context,
+    iconRes: Int,
+    title: String,
+    requestCode: Int,
+    isEnabled: Boolean = true,
+): RemoteAction {
+    val action = RemoteAction(
+        Icon.createWithResource(context, iconRes),
+        title,
+        title,
+        PendingIntent.getBroadcast(
+            context,
+            requestCode,
+            Intent(PIP_INTENTS_FILTER)
+                .putExtra(PIP_INTENT_ACTION, requestCode)
+                .setPackage(context.packageName),
+            PendingIntent.FLAG_IMMUTABLE,
+        ),
+    )
+    action.isEnabled = isEnabled
+    return action
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
index 61c5b70e79..82f862069f 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
@@ -1,11 +1,23 @@
 package eu.kanade.tachiyomi.ui.player
 
 import android.annotation.SuppressLint
+import android.app.PictureInPictureParams
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
+import android.content.pm.ActivityInfo
+import android.content.pm.PackageManager
+import android.content.res.Configuration
+import android.media.AudioManager
+import android.media.session.MediaSession
+import androidx.media.AudioFocusRequestCompat
+import androidx.media.AudioManagerCompat
+import android.media.session.PlaybackState
 import android.net.Uri
 import android.os.Build
 import android.os.Bundle
+import android.util.Rational
 import android.view.KeyEvent
 import android.view.WindowManager
 import android.webkit.WebView
@@ -13,6 +25,7 @@ import androidx.activity.ComponentActivity
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.activity.viewModels
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
@@ -37,12 +50,20 @@ import eu.kanade.tachiyomi.ui.dictionary.getDictionaryBootstrapHtml
 import eu.kanade.tachiyomi.ui.dictionary.getDictionaryPaths
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 import eu.kanade.tachiyomi.ui.player.mpv.PlayerObserver
+import eu.kanade.tachiyomi.ui.player.setting.AudioPreferences
+import eu.kanade.tachiyomi.ui.player.setting.DecoderPreferences
 import eu.kanade.tachiyomi.ui.player.setting.PlayerOrientation
 import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
+import eu.kanade.tachiyomi.ui.player.utils.TrackSelect
 import eu.kanade.tachiyomi.ui.reader.viewer.OcrLookupPopup
 import `is`.xyz.mpv.MPVLib
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -60,11 +81,58 @@ class PlayerActivity : ComponentActivity() {
     private var mpvView: MPVView? = null
     private var playerObserver: PlayerObserver? = null
 
+    private val audioManager by lazy { getSystemService(Context.AUDIO_SERVICE) as AudioManager }
+
     private var popupWebView: WebView? = null
 
     private val dictionaryPreferences: DictionaryPreferences by lazy { Injekt.get() }
     private val dictionaryRepository: chimahon.DictionaryRepository by lazy { Injekt.get() }
 
+    private val subtitlePreferences: SubtitlePreferences by lazy { Injekt.get() }
+    private val audioPreferences: AudioPreferences by lazy { Injekt.get() }
+    private val decoderPreferences: DecoderPreferences by lazy { Injekt.get() }
+    private val trackSelect by lazy { TrackSelect() }
+    private var mediaSession: MediaSession? = null
+    private var audioFocusRequest: AudioFocusRequestCompat? = null
+    private var restoreAudioFocus: () -> Unit = {}
+    private var hideSliderJob: Job? = null
+    private var aniSkipFetched = false
+
+    private val subtitleFilePicker = registerForActivityResult(
+        ActivityResultContracts.OpenDocument(),
+    ) { uri ->
+        if (uri != null) {
+            try {
+                contentResolver.takePersistableUriPermission(uri, Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            } catch (_: SecurityException) {}
+            val name = uri.lastPathSegment ?: "External"
+            val fd = contentResolver.openFileDescriptor(uri, "r")?.detachFd() ?: return@registerForActivityResult
+            val path = "fdclose://$fd"
+            mpvView?.addSubtitleTrack(path, name)
+            viewModel.saveCustomSubtitle(uri.toString(), name)
+        }
+    }
+
+    private val pipReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            when (intent.getIntExtra(PIP_INTENT_ACTION, 0)) {
+                PIP_PLAY -> mpvView?.resume()
+                PIP_PAUSE -> mpvView?.pause()
+                PIP_PREVIOUS -> viewModel.loadPreviousEpisode()
+                PIP_NEXT -> viewModel.loadNextEpisode()
+            }
+        }
+    }
+
+    private val noisyReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (intent?.action == AudioManager.ACTION_AUDIO_BECOMING_NOISY) {
+                mpvView?.pause()
+                window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+            }
+        }
+    }
+
     @Volatile private var cachedActiveProfile: chimahon.anki.AnkiProfile? = null
     @Volatile private var cachedTermPaths: List<String>? = null
 
@@ -92,6 +160,16 @@ class PlayerActivity : ComponentActivity() {
             }
         }
 
+        initBrightnessVolume()
+        setupPlayerAudio()
+        setupMediaSession()
+        registerReceiver(pipReceiver, IntentFilter(PIP_INTENTS_FILTER), RECEIVER_NOT_EXPORTED)
+        registerReceiver(
+            noisyReceiver,
+            IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY),
+            RECEIVER_NOT_EXPORTED,
+        )
+
         setContent {
             PlayerScreen(
                 viewModel = viewModel,
@@ -99,10 +177,21 @@ class PlayerActivity : ComponentActivity() {
                 onPlayPause = ::togglePlayPause,
                 onSeek = ::seekToPercent,
                 onSeekRelative = ::seekRelative,
-                onBack = { finish() },
+                onSeekTo = ::seekToSeconds,
+                onBack = ::handleBack,
                 onSelectSubtitle = ::selectSubtitleTrack,
                 onSelectAudio = ::selectAudioTrack,
                 onSubtitleWordTapped = ::onSubtitleWordTapped,
+                onBrightnessChange = ::adjustBrightness,
+                onVolumeChange = ::adjustVolume,
+                onSeekStart = { mpvView?.pause() },
+                onSeekEnd = { mpvView?.resume() },
+                onSetSpeed = ::setSpeed,
+                onSetAspectRatio = { setAspectRatio(it) },
+                onRotateScreen = ::rotateScreen,
+                onNavigatePrevious = { viewModel.loadPreviousEpisode() },
+                onNavigateNext = { viewModel.loadNextEpisode() },
+                onAddSubtitleFile = { subtitleFilePicker.launch(arrayOf("*/*")) },
                 lookupContent = {
                     val state by viewModel.state.collectAsState()
                     val ls = state.lookupState
@@ -166,6 +255,17 @@ class PlayerActivity : ComponentActivity() {
                     is PlayerViewModel.Event.PlaybackCompleted -> {}
                     is PlayerViewModel.Event.PauseForLookup -> mpvView?.pause()
                     is PlayerViewModel.Event.ResumeFromLookup -> mpvView?.resume()
+                    is PlayerViewModel.Event.EpisodeChanged -> playCurrentEpisode()
+                    is PlayerViewModel.Event.ShowToast -> {
+                        android.widget.Toast.makeText(this@PlayerActivity, event.message, android.widget.Toast.LENGTH_SHORT).show()
+                    }
+                    is PlayerViewModel.Event.SeekTo -> {
+                        mpvView?.seekTo(event.positionSec)
+                    }
+                    is PlayerViewModel.Event.PauseForTimer -> {
+                        mpvView?.pause()
+                        window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+                    }
                 }
             }
             .launchIn(lifecycleScope)
@@ -177,20 +277,48 @@ class PlayerActivity : ComponentActivity() {
         val configDir = filesDir.resolve("mpv").absolutePath
         val cacheDir = cacheDir.resolve("mpv").absolutePath
         logcat(LogPriority.DEBUG, tag = "Player") { "Initializing MPV" }
-        view.initialize(configDir, cacheDir)
+        view.initialize(configDir, cacheDir, decoderPreferences, audioPreferences, subtitlePreferences)
         logcat(LogPriority.DEBUG, tag = "Player") { "MPV initialized" }
 
+        val advancedPrefs: eu.kanade.tachiyomi.ui.player.setting.AdvancedPlayerPreferences = Injekt.get()
+        val mpvConf = advancedPrefs.mpvConf().get()
+        if (mpvConf.isNotBlank()) {
+            mpvConf.lines().filter { it.isNotBlank() && !it.startsWith("#") }.forEach { line ->
+                val parts = line.split("=", limit = 2)
+                if (parts.size == 2) {
+                    MPVLib.setOptionString(parts[0].trim(), parts[1].trim())
+                } else {
+                    MPVLib.setOptionString(parts[0].trim(), "")
+                }
+            }
+        }
+
         val observer = PlayerObserver(
             onPositionChanged = { pos -> viewModel.updatePosition(pos) },
-            onDurationChanged = { dur -> viewModel.updateDuration(dur) },
+            onDurationChanged = { dur ->
+                viewModel.updateDuration(dur)
+                if (dur > 0 && !aniSkipFetched) {
+                    aniSkipFetched = true
+                    lifecycleScope.launchIO {
+                        viewModel.fetchAniSkipTimestamps(dur.toInt())
+                    }
+                }
+            },
             onPauseChanged = { paused -> viewModel.updatePlaybackState(!paused) },
             onEofReached = { viewModel.onPlaybackCompleted() },
             onSubTextChanged = { text -> viewModel.updateSubText(text) },
             onTrackListChanged = ::onTrackListChanged,
+            onChapterListChanged = { viewModel.loadChapters() },
         )
         playerObserver = observer
         MPVLib.addObserver(observer)
 
+        val screenshotDir = android.os.Environment.getExternalStoragePublicDirectory(
+            android.os.Environment.DIRECTORY_PICTURES,
+        )
+        screenshotDir.mkdirs()
+        MPVLib.setOptionString("screenshot-directory", screenshotDir.path)
+
         val animeId = intent.getLongExtra(PlayerViewModel.KEY_ANIME_ID, -1L)
         val episodeId = intent.getLongExtra(PlayerViewModel.KEY_EPISODE_ID, -1L)
         val videoUrl = resolveVideoUrl(intent)
@@ -224,6 +352,7 @@ class PlayerActivity : ComponentActivity() {
                 resolvedVideo?.subtitleTracks?.forEach { track ->
                     view.addSubtitleTrack(track.url, track.lang)
                 }
+                loadCustomSubtitles(view)
                 logcat(LogPriority.DEBUG, tag = "Player") { "playFile called, ${resolvedVideo?.subtitleTracks?.size ?: 0} subtitle tracks added" }
             }
         }
@@ -291,15 +420,24 @@ class PlayerActivity : ComponentActivity() {
         return super.dispatchKeyEvent(event)
     }
 
+    private var userSelectedSubId: Int? = null
+    private var userSelectedAudioId: Int? = null
+
     private fun onTrackListChanged() {
         val view = mpvView ?: return
         val (subs, audio) = view.loadTracks()
 
-        val preferred = playerPreferences.preferredSubLanguage().get()
-        if (preferred.isNotBlank() && subs.isNotEmpty()) {
-            val match = subs.firstOrNull { it.language.equals(preferred, ignoreCase = true) }
-            if (match != null && view.sid != match.id) {
-                view.sid = match.id
+        if (userSelectedSubId == null) {
+            val preferredSub = trackSelect.getPreferredSubTrack(subs)
+            if (preferredSub != null && view.sid != preferredSub.id) {
+                view.sid = preferredSub.id
+            }
+        }
+
+        if (userSelectedAudioId == null) {
+            val preferredAudio = trackSelect.getPreferredAudioTrack(audio)
+            if (preferredAudio != null && view.aid != preferredAudio.id) {
+                view.aid = preferredAudio.id
             }
         }
 
@@ -308,19 +446,128 @@ class PlayerActivity : ComponentActivity() {
 
     private fun selectSubtitleTrack(id: Int) {
         val view = mpvView ?: return
+        userSelectedSubId = id
         view.sid = id
         viewModel.updateSelectedSubId(id)
 
         val track = viewModel.state.value.subtitleTracks.firstOrNull { it.id == id }
-        playerPreferences.preferredSubLanguage().set(track?.language ?: "")
+        subtitlePreferences.preferredSubLanguages().set(track?.language ?: "")
+    }
+
+    private fun loadCustomSubtitles(view: MPVView) {
+        for (sub in viewModel.getCustomSubtitles()) {
+            try {
+                val uri = Uri.parse(sub.uri)
+                val fd = contentResolver.openFileDescriptor(uri, "r")?.detachFd() ?: continue
+                view.addSubtitleTrack("fdclose://$fd", sub.name)
+            } catch (_: Exception) {}
+        }
     }
 
     private fun selectAudioTrack(id: Int) {
         val view = mpvView ?: return
+        userSelectedAudioId = id
         view.aid = id
         viewModel.updateSelectedAudioId(id)
     }
 
+    private fun setupPlayerAudio() {
+        audioPreferences.audioChannels().get().let { MPVLib.setPropertyString(it.property, it.value) }
+
+        val request = AudioFocusRequestCompat.Builder(AudioManagerCompat.AUDIOFOCUS_GAIN)
+            .setAudioAttributes(
+                androidx.media.AudioAttributesCompat.Builder()
+                    .setUsage(androidx.media.AudioAttributesCompat.USAGE_MEDIA)
+                    .setContentType(androidx.media.AudioAttributesCompat.CONTENT_TYPE_MUSIC)
+                    .build(),
+            )
+            .setOnAudioFocusChangeListener(audioFocusChangeListener)
+            .build()
+        AudioManagerCompat.requestAudioFocus(audioManager, request).let {
+            if (it == AudioManager.AUDIOFOCUS_REQUEST_FAILED) return@let
+            audioFocusRequest = request
+        }
+    }
+
+    private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener {
+        when (it) {
+            AudioManager.AUDIOFOCUS_LOSS,
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT,
+            -> {
+                val oldRestore = restoreAudioFocus
+                val wasPlayerPaused = mpvView?.paused ?: true
+                mpvView?.pause()
+                restoreAudioFocus = {
+                    oldRestore()
+                    if (!wasPlayerPaused) mpvView?.resume()
+                }
+            }
+
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                MPVLib.command(arrayOf("multiply", "volume", "0.5"))
+                restoreAudioFocus = {
+                    MPVLib.command(arrayOf("multiply", "volume", "2"))
+                }
+            }
+
+            AudioManager.AUDIOFOCUS_GAIN -> {
+                restoreAudioFocus()
+                restoreAudioFocus = {}
+            }
+        }
+    }
+
+    private fun setupMediaSession() {
+        mediaSession = MediaSession(this, "ChimahonPlayer").apply {
+            setCallback(object : MediaSession.Callback() {
+                override fun onPlay() { mpvView?.resume() }
+                override fun onPause() { mpvView?.pause() }
+                override fun onSkipToNext() { viewModel.loadNextEpisode() }
+                override fun onSkipToPrevious() { viewModel.loadPreviousEpisode() }
+                override fun onStop() {
+                    mpvView?.pause()
+                    isActive = false
+                }
+                override fun onSeekTo(pos: Long) { mpvView?.seekTo((pos / 1000).toInt()) }
+            })
+            isActive = true
+        }
+        lifecycleScope.launch {
+            viewModel.state
+                .map { it.isPlaying }
+                .distinctUntilChanged()
+                .collect { isPlaying ->
+                    updateMediaSessionState(isPlaying, viewModel.state.value.currentPositionSec)
+                }
+        }
+    }
+
+    private fun updateMediaSessionState(isPlaying: Boolean, positionSec: Long) {
+        val session = mediaSession ?: return
+        val pbState = if (isPlaying) PlaybackState.STATE_PLAYING else PlaybackState.STATE_PAUSED
+        session.setPlaybackState(
+            PlaybackState.Builder()
+                .setState(pbState, positionSec * 1000, 1f)
+                .setActions(
+                    PlaybackState.ACTION_PLAY or
+                        PlaybackState.ACTION_PAUSE or
+                        PlaybackState.ACTION_STOP or
+                        PlaybackState.ACTION_SEEK_TO or
+                        PlaybackState.ACTION_SKIP_TO_PREVIOUS or
+                        PlaybackState.ACTION_SKIP_TO_NEXT,
+                )
+                .build(),
+        )
+    }
+
+    private fun handleBack() {
+        if (playerPreferences.enablePip().get() && !isInPictureInPictureMode) {
+            enterPipMode()
+        } else {
+            finish()
+        }
+    }
+
     private fun togglePlayPause() {
         mpvView?.cyclePause()
     }
@@ -334,12 +581,193 @@ class PlayerActivity : ComponentActivity() {
         mpvView?.seekRelative(deltaSec)
     }
 
+    private fun seekToSeconds(positionSec: Int) {
+        mpvView?.seekTo(positionSec)
+    }
+
+    private fun initBrightnessVolume() {
+        val maxVol = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC).toFloat()
+        val currentVol = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC).toFloat()
+        var currentBrightness = window.attributes.screenBrightness.let {
+            if (it < 0) 0.5f else it
+        }
+
+        if (playerPreferences.rememberPlayerBrightness().get()) {
+            val saved = playerPreferences.playerBrightnessValue().get()
+            if (saved >= 0f) {
+                currentBrightness = saved.coerceIn(0.01f, 1f)
+                val params = window.attributes
+                params.screenBrightness = currentBrightness
+                window.attributes = params
+            }
+        }
+
+        if (playerPreferences.rememberPlayerVolume().get()) {
+            val saved = playerPreferences.playerVolumeValue().get()
+            if (saved >= 0f) {
+                val restoredVol = saved.coerceIn(0f, maxVol).toInt()
+                audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, restoredVol, 0)
+                viewModel.updateVolumeState(restoredVol.toFloat(), maxVol, false)
+            } else {
+                viewModel.updateVolumeState(currentVol, maxVol, false)
+            }
+        } else {
+            viewModel.updateVolumeState(currentVol, maxVol, false)
+        }
+
+        viewModel.updateBrightnessState(currentBrightness, false)
+    }
+
+    private fun adjustBrightness(delta: Float) {
+        val params = window.attributes
+        val current = params.screenBrightness.let { if (it < 0) 0.5f else it }
+        val newBrightness = (current + delta * 1.5f).coerceIn(0.01f, 1f)
+        params.screenBrightness = newBrightness
+        window.attributes = params
+        viewModel.updateBrightnessState(newBrightness, true)
+        if (playerPreferences.rememberPlayerBrightness().get()) {
+            playerPreferences.playerBrightnessValue().set(newBrightness)
+        }
+        scheduleHideSliders()
+    }
+
+    private fun adjustVolume(delta: Float) {
+        val maxVol = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)
+        val currentVol = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)
+        val scaledDelta = delta * maxVol * 1.5f
+        val newVol = (currentVol + scaledDelta).toInt().coerceIn(0, maxVol)
+        if (newVol != currentVol) {
+            audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, newVol, 0)
+        }
+        viewModel.updateVolumeState(newVol.toFloat(), maxVol.toFloat(), true)
+        if (playerPreferences.rememberPlayerVolume().get()) {
+            playerPreferences.playerVolumeValue().set(newVol.toFloat())
+        }
+        scheduleHideSliders()
+    }
+
+    private fun scheduleHideSliders() {
+        hideSliderJob?.cancel()
+        hideSliderJob = lifecycleScope.launch {
+            delay(1500)
+            viewModel.hideBrightnessVolumeSliders()
+        }
+    }
+
+    private fun setSpeed(speed: Float) {
+        mpvView?.let {
+            MPVLib.setPropertyDouble("speed", speed.toDouble())
+        }
+        viewModel.setSpeed(speed)
+    }
+
+    private fun setAspectRatio(aspect: VideoAspect) {
+        mpvView?.let {
+            when (aspect) {
+                VideoAspect.Fit -> {
+                    MPVLib.setPropertyDouble("panscan", 0.0)
+                    MPVLib.setPropertyString("video-aspect-override", "-1")
+                }
+                VideoAspect.Crop -> {
+                    MPVLib.setPropertyDouble("panscan", 1.0)
+                    MPVLib.setPropertyString("video-aspect-override", "-1")
+                }
+                VideoAspect.Stretch -> {
+                    MPVLib.setPropertyDouble("panscan", 0.0)
+                    val w = it.width.toDouble()
+                    val h = it.height.toDouble()
+                    if (h > 0) MPVLib.setPropertyString("video-aspect-override", "${w / h}")
+                }
+            }
+        }
+    }
+
+    private fun rotateScreen() {
+        requestedOrientation = when (requestedOrientation) {
+            ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE,
+            ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE,
+            -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+            else -> ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
+        }
+    }
+
+    private fun playCurrentEpisode() {
+        val view = mpvView ?: return
+        val state = viewModel.state.value
+        val episode = state.episode ?: return
+        val resolvedVideo = state.resolvedVideo
+        val url = resolvedVideo?.videoUrl?.takeIf { it.isNotBlank() }
+            ?: episode.url.takeIf { PlayerViewModel.isPlayableScheme(it) }
+        if (url.isNullOrBlank()) return
+        val resumePos = episode.lastSecondSeen
+        val playUrl = resolvePlaybackUrl(url)
+        val headers = resolvedVideo?.headers?.let { h ->
+            (0 until h.size).associate { i -> h.name(i) to h.value(i) }
+        }
+        view.playFile(playUrl, resumePos, headers)
+        resolvedVideo?.subtitleTracks?.forEach { track ->
+            view.addSubtitleTrack(track.url, track.lang)
+        }
+        loadCustomSubtitles(view)
+    }
+
+    override fun onUserLeaveHint() {
+        super.onUserLeaveHint()
+        if (playerPreferences.pipOnExit().get() && !isInPictureInPictureMode) {
+            enterPipMode()
+        }
+    }
+
+    override fun onPictureInPictureModeChanged(isInPipMode: Boolean, newConfig: Configuration) {
+        super.onPictureInPictureModeChanged(isInPipMode, newConfig)
+        viewModel.updatePipMode(isInPipMode)
+        if (!isInPipMode) {
+            setupImmersiveMode()
+        }
+    }
+
+    private fun enterPipMode() {
+        if (!packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)) return
+        val state = viewModel.state.value
+        val params = PictureInPictureParams.Builder()
+            .setActions(
+                createPipActions(
+                    this,
+                    isPaused = !state.isPlaying,
+                    hasPrevious = state.currentEpisodeIndex > 0,
+                    hasNext = state.currentEpisodeIndex >= 0 &&
+                        state.currentEpisodeIndex < state.episodes.size - 1,
+                ),
+            )
+            .setAspectRatio(Rational(16, 9))
+            .build()
+        enterPictureInPictureMode(params)
+    }
+
+    override fun onResume() {
+        super.onResume()
+        setupImmersiveMode()
+    }
+
     override fun onStop() {
         super.onStop()
-        viewModel.saveProgress()
+        if (!isInPictureInPictureMode) {
+            viewModel.saveProgress()
+        }
     }
 
     override fun onDestroy() {
+        try {
+            unregisterReceiver(pipReceiver)
+        } catch (_: IllegalArgumentException) {}
+        try {
+            unregisterReceiver(noisyReceiver)
+        } catch (_: IllegalArgumentException) {}
+        audioFocusRequest?.let { AudioManagerCompat.abandonAudioFocusRequest(audioManager, it) }
+        audioFocusRequest = null
+        mediaSession?.isActive = false
+        mediaSession?.release()
+        mediaSession = null
         playerObserver?.let { MPVLib.removeObserver(it) }
         mpvView?.destroy()
         mpvView = null
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerEnums.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerEnums.kt
new file mode 100644
index 0000000000..efa7b4e201
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerEnums.kt
@@ -0,0 +1,59 @@
+package eu.kanade.tachiyomi.ui.player
+
+enum class VideoAspect {
+    Fit,
+    Crop,
+    Stretch,
+}
+
+enum class SingleActionGesture {
+    None,
+    Seek,
+    PlayPause,
+}
+
+enum class Decoder(val title: String, val value: String) {
+    AutoCopy("Auto", "auto-copy"),
+    Auto("Auto", "auto"),
+    SW("SW", "no"),
+    HW("HW", "mediacodec-copy"),
+    HWPlus("HW+", "mediacodec"),
+}
+
+enum class Debanding {
+    None,
+    CPU,
+    GPU,
+}
+
+enum class Sheets {
+    None,
+    PlaybackSpeed,
+    SubtitleTracks,
+    AudioTracks,
+    QualityTracks,
+    More,
+}
+
+enum class Panels {
+    None,
+    SubtitleSettings,
+    SubtitleDelay,
+    AudioDelay,
+    VideoFilters,
+}
+
+sealed class Dialogs {
+    data object None : Dialogs()
+    data object EpisodeList : Dialogs()
+}
+
+enum class VideoFilters(
+    val mpvProperty: String,
+) {
+    BRIGHTNESS("brightness"),
+    SATURATION("saturation"),
+    CONTRAST("contrast"),
+    GAMMA("gamma"),
+    HUE("hue"),
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
index 577d3d9f03..a02dbc0c8f 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
@@ -11,8 +11,11 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.viewinterop.AndroidView
+import eu.kanade.tachiyomi.ui.player.controls.GestureHandler
 import eu.kanade.tachiyomi.ui.player.controls.PlayerControlsOverlay
 import eu.kanade.tachiyomi.ui.player.controls.SubtitleTapOverlay
+import eu.kanade.tachiyomi.ui.player.controls.components.BrightnessVolumeIndicator
+import eu.kanade.tachiyomi.ui.player.controls.components.StatsOverlay
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 
 @Composable
@@ -22,10 +25,21 @@ fun PlayerScreen(
     onPlayPause: () -> Unit,
     onSeek: (Float) -> Unit,
     onSeekRelative: (Int) -> Unit,
+    onSeekTo: (Int) -> Unit,
     onBack: () -> Unit,
     onSelectSubtitle: (Int) -> Unit = {},
     onSelectAudio: (Int) -> Unit = {},
     onSubtitleWordTapped: (word: String, fullText: String, charOffset: Int, anchorX: Float, anchorY: Float) -> Unit = { _, _, _, _, _ -> },
+    onBrightnessChange: (Float) -> Unit = {},
+    onVolumeChange: (Float) -> Unit = {},
+    onSeekStart: () -> Unit = {},
+    onSeekEnd: () -> Unit = {},
+    onSetSpeed: (Float) -> Unit = {},
+    onSetAspectRatio: (VideoAspect) -> Unit = {},
+    onRotateScreen: () -> Unit = {},
+    onNavigatePrevious: () -> Unit = {},
+    onNavigateNext: () -> Unit = {},
+    onAddSubtitleFile: () -> Unit = {},
     lookupContent: @Composable () -> Unit = {},
 ) {
     val state by viewModel.state.collectAsState()
@@ -42,6 +56,23 @@ fun PlayerScreen(
             modifier = Modifier.fillMaxSize(),
         )
 
+        if (state.isInPipMode) return@Box
+
+        GestureHandler(
+            isLocked = state.isLocked,
+            subtitleActive = state.currentSubText.isNotBlank(),
+            currentPositionSec = state.currentPositionSec,
+            durationSec = state.durationSec,
+            onToggleControls = { viewModel.toggleControls() },
+            onSeekRelative = onSeekRelative,
+            onPlayPause = onPlayPause,
+            onBrightnessChange = onBrightnessChange,
+            onVolumeChange = onVolumeChange,
+            onSeekTo = onSeekTo,
+            onSeekStart = onSeekStart,
+            onSeekEnd = onSeekEnd,
+        )
+
         if (state.isLoading) {
             CircularProgressIndicator(
                 color = Color.White,
@@ -49,24 +80,48 @@ fun PlayerScreen(
             )
         }
 
+        BrightnessVolumeIndicator(
+            isBrightness = true,
+            value = state.currentBrightness,
+            maxValue = 1f,
+            visible = state.showBrightnessSlider,
+        )
+        BrightnessVolumeIndicator(
+            isBrightness = false,
+            value = state.currentVolume,
+            maxValue = state.maxVolume,
+            visible = state.showVolumeSlider,
+        )
+
+        if (state.showStats) {
+            StatsOverlay()
+        }
+
         if (state.lookupState == null) {
             PlayerControlsOverlay(
-                isPlaying = state.isPlaying,
-                animeTitle = state.anime?.title,
-                episodeName = state.episode?.name,
-                currentPositionSec = state.currentPositionSec,
-                durationSec = state.durationSec,
-                doubleTapSeekSec = state.doubleTapSeekSec,
+                state = state,
                 onPlayPause = onPlayPause,
                 onSeek = onSeek,
-                onSeekRelative = onSeekRelative,
                 onBack = onBack,
-                subtitleTracks = state.subtitleTracks,
-                audioTracks = state.audioTracks,
-                selectedSubId = state.selectedSubId,
-                selectedAudioId = state.selectedAudioId,
                 onSelectSubtitle = onSelectSubtitle,
                 onSelectAudio = onSelectAudio,
+                onToggleLock = { viewModel.toggleLock() },
+                onSetSpeed = onSetSpeed,
+                onCycleAspectRatio = {
+                    viewModel.cycleAspectRatio()
+                    onSetAspectRatio(viewModel.state.value.aspectRatio)
+                },
+                onRotateScreen = onRotateScreen,
+                onNavigatePrevious = onNavigatePrevious,
+                onNavigateNext = onNavigateNext,
+                onAddSubtitleFile = onAddSubtitleFile,
+                onHideControls = { viewModel.hideControls() },
+                onToggleStats = { viewModel.toggleStats() },
+                onLoadEpisodeAt = { viewModel.loadEpisodeAt(it) },
+                onSkipIntro = { viewModel.onSkipIntro() },
+                onSelectChapter = { viewModel.selectChapter(it) },
+                onStartTimer = { viewModel.startTimer(it) },
+                onCancelTimer = { viewModel.cancelTimer() },
             )
         }
 
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
index af3d51aeff..c995c2dde3 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
@@ -9,18 +9,28 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import chimahon.DictionaryRepository
 import eu.kanade.tachiyomi.animesource.AnimeSource
+import eu.kanade.tachiyomi.animesource.model.ChapterType
 import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.TimeStamp
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
+import eu.kanade.tachiyomi.data.track.TrackerManager
+import eu.kanade.tachiyomi.data.track.anilist.Anilist
+import eu.kanade.tachiyomi.data.track.myanimelist.MyAnimeList
+import eu.kanade.tachiyomi.ui.player.controls.components.IndexedSegment
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
-import tachiyomi.domain.animesource.service.AnimeSourceManager
+import eu.kanade.tachiyomi.ui.player.utils.AniSkipApi
+import eu.kanade.tachiyomi.ui.player.utils.ChapterUtils
+import `is`.xyz.mpv.MPVLib
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
@@ -29,6 +39,7 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.flow.sample
 import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
 import logcat.LogPriority
 import tachiyomi.core.common.util.lang.launchIO
 import tachiyomi.core.common.util.lang.launchNonCancellable
@@ -37,14 +48,18 @@ import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.anime.interactor.GetAnime
 import tachiyomi.domain.anime.model.Anime
 import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.animesource.service.AnimeSourceManager
 import tachiyomi.domain.episode.interactor.GetEpisode
 import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
 import tachiyomi.domain.episode.interactor.UpdateEpisode
 import tachiyomi.domain.episode.model.Episode
 import tachiyomi.domain.episode.model.EpisodeUpdate
 import tachiyomi.domain.episode.repository.EpisodeRepository
+import tachiyomi.domain.track.interactor.GetTracks
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
+import java.io.File
+import java.io.InputStream
 import kotlin.time.Duration.Companion.seconds
 
 class PlayerViewModel @JvmOverloads constructor(
@@ -60,10 +75,14 @@ class PlayerViewModel @JvmOverloads constructor(
     private val application: Application = Injekt.get(),
     private val animeSourceManager: AnimeSourceManager = Injekt.get(),
     private val animeDownloadManager: AnimeDownloadManager = Injekt.get(),
+    private val getTracks: GetTracks = Injekt.get(),
 ) : ViewModel() {
 
     private val mutableState = MutableStateFlow(
-        State(doubleTapSeekSec = playerPreferences.doubleTapSeekLength().get()),
+        State(
+            currentSpeed = playerPreferences.playerSpeed().get(),
+            aspectRatio = playerPreferences.aspectState().get(),
+        ),
     )
     val state = mutableState.asStateFlow()
 
@@ -78,6 +97,16 @@ class PlayerViewModel @JvmOverloads constructor(
     var lookupDeferred: Deferred<DictionaryRepository.LookupResult2>? = null
         private set
 
+    private var aniSkipStamps: List<TimeStamp> = emptyList()
+    private var mpvChapters: List<IndexedSegment> = emptyList()
+    private var timerJob: Job? = null
+
+    private val introSkipEnabled = playerPreferences.enableSkipIntro().get()
+    private val autoSkip = playerPreferences.autoSkipIntro().get()
+    private val netflixStyle = playerPreferences.enableNetflixStyleIntroSkip().get()
+    private val defaultWaitingTime = playerPreferences.waitingTimeIntroSkip().get()
+    private var waitingSkipIntro = defaultWaitingTime
+
     init {
         progressSaveFlow
             .sample(playerPreferences.progressSaveIntervalSec().get().seconds)
@@ -119,6 +148,12 @@ class PlayerViewModel @JvmOverloads constructor(
                 return
             }
 
+            val allEpisodes = withIOContext {
+                getEpisodesByAnimeId.await(animeId)
+            }.sortedBy { it.episodeNumber }
+
+            val currentIndex = allEpisodes.indexOfFirst { it.id == episodeId }
+
             var resolvedVideo: Video? = null
             if (anime.source != LOCAL_ANIME_SOURCE_ID) {
                 val source = animeSourceManager.get(anime.source)
@@ -133,12 +168,21 @@ class PlayerViewModel @JvmOverloads constructor(
                 }
             }
 
+            aniSkipStamps = emptyList()
+            mpvChapters = emptyList()
+            waitingSkipIntro = defaultWaitingTime
+
             mutableState.update {
                 it.copy(
                     anime = anime,
                     episode = episode,
                     resolvedVideo = resolvedVideo,
                     isLoading = false,
+                    episodes = allEpisodes,
+                    currentEpisodeIndex = currentIndex,
+                    chapters = emptyList(),
+                    currentChapter = null,
+                    skipIntroText = null,
                 )
             }
         } catch (e: Exception) {
@@ -223,15 +267,13 @@ class PlayerViewModel @JvmOverloads constructor(
             }
 
             val url = resolved.videoUrl
-            if (url.isNotBlank() && isStreamableUrl(url)) {
+            if (url.isNotBlank() && isPlayableScheme(url)) {
                 return resolved
             }
         }
         return null
     }
 
-    private fun isStreamableUrl(url: String): Boolean = isPlayableScheme(url)
-
     fun updatePlaybackState(isPlaying: Boolean) {
         if (isPlaying == mutableState.value.isPlaying) return
         mutableState.update { it.copy(isPlaying = isPlaying) }
@@ -242,6 +284,7 @@ class PlayerViewModel @JvmOverloads constructor(
         val duration = mutableState.value.durationSec
         mutableState.update { it.copy(currentPositionSec = positionSec) }
         progressSaveFlow.tryEmit(positionSec to duration)
+        setChapter(positionSec.toFloat())
     }
 
     fun updateDuration(durationSec: Long) {
@@ -307,13 +350,94 @@ class PlayerViewModel @JvmOverloads constructor(
         mutableState.update { it.copy(highlightRange = range) }
     }
 
+    fun toggleControls() {
+        mutableState.update { it.copy(controlsVisible = !it.controlsVisible) }
+    }
+
+    fun hideControls() {
+        mutableState.update { it.copy(controlsVisible = false) }
+    }
+
+    fun toggleLock() {
+        mutableState.update { it.copy(isLocked = !it.isLocked) }
+    }
+
+    fun setSpeed(speed: Float) {
+        mutableState.update { it.copy(currentSpeed = speed) }
+        playerPreferences.playerSpeed().set(speed)
+    }
+
+    fun cycleAspectRatio() {
+        val next = when (mutableState.value.aspectRatio) {
+            VideoAspect.Fit -> VideoAspect.Crop
+            VideoAspect.Crop -> VideoAspect.Stretch
+            VideoAspect.Stretch -> VideoAspect.Fit
+        }
+        mutableState.update { it.copy(aspectRatio = next) }
+        playerPreferences.aspectState().set(next)
+    }
+
+    fun updateBrightnessState(brightness: Float, visible: Boolean) {
+        mutableState.update { it.copy(currentBrightness = brightness, showBrightnessSlider = visible) }
+    }
+
+    fun updateVolumeState(volume: Float, maxVolume: Float, visible: Boolean) {
+        mutableState.update { it.copy(currentVolume = volume, maxVolume = maxVolume, showVolumeSlider = visible) }
+    }
+
+    fun toggleStats() {
+        mutableState.update { it.copy(showStats = !it.showStats) }
+    }
+
+    fun updatePipMode(isInPip: Boolean) {
+        mutableState.update { it.copy(isInPipMode = isInPip) }
+    }
+
+    fun hideBrightnessVolumeSliders() {
+        mutableState.update { it.copy(showBrightnessSlider = false, showVolumeSlider = false) }
+    }
+
+    fun loadNextEpisode() {
+        val state = mutableState.value
+        val idx = state.currentEpisodeIndex
+        if (idx < 0 || idx >= state.episodes.size - 1) return
+        val nextEpisode = state.episodes[idx + 1]
+        switchToEpisode(nextEpisode)
+    }
+
+    fun loadPreviousEpisode() {
+        val state = mutableState.value
+        val idx = state.currentEpisodeIndex
+        if (idx <= 0) return
+        val prevEpisode = state.episodes[idx - 1]
+        switchToEpisode(prevEpisode)
+    }
+
+    fun loadEpisodeAt(index: Int) {
+        val state = mutableState.value
+        if (index < 0 || index >= state.episodes.size) return
+        switchToEpisode(state.episodes[index])
+    }
+
+    private fun switchToEpisode(episode: Episode) {
+        saveProgress()
+        episodeId = episode.id
+        savedState[KEY_EPISODE_ID] = episodeId
+        mutableState.update { it.copy(isLoading = true, resolvedVideo = null) }
+        viewModelScope.launchIO {
+            loadFromDb()
+            eventChannel.send(Event.EpisodeChanged(episode.id))
+        }
+    }
+
     fun onPlaybackCompleted() {
         val state = mutableState.value
         val episode = state.episode ?: return
         val duration = state.durationSec
         val position = state.currentPositionSec
         viewModelScope.launchIO {
-            val seen = duration > 0 && position >= duration * 0.9
+            val threshold = playerPreferences.progressPreference().get()
+            val seen = duration > 0 && position >= duration * threshold
             updateEpisode.await(
                 EpisodeUpdate(
                     id = episode.id,
@@ -322,7 +446,15 @@ class PlayerViewModel @JvmOverloads constructor(
                     totalSeconds = duration,
                 ),
             )
-            eventChannel.send(Event.PlaybackCompleted)
+            if (playerPreferences.autoplayEnabled().get() &&
+                state.currentEpisodeIndex >= 0 &&
+                state.currentEpisodeIndex < state.episodes.size - 1
+            ) {
+                val nextEpisode = state.episodes[state.currentEpisodeIndex + 1]
+                switchToEpisode(nextEpisode)
+            } else {
+                eventChannel.send(Event.PlaybackCompleted)
+            }
         }
     }
 
@@ -352,6 +484,211 @@ class PlayerViewModel @JvmOverloads constructor(
         }
     }
 
+    data class CustomSubtitle(val uri: String, val name: String)
+
+    fun saveCustomSubtitle(uri: String, name: String) {
+        val epId = mutableState.value.episode?.id ?: return
+        val existing = getCustomSubtitles(epId)
+        if (existing.any { it.uri == uri }) return
+        val updated = existing + CustomSubtitle(uri, name)
+        playerPreferences.customSubtitlesForEpisode(epId).set(
+            updated.joinToString("|") { "${it.uri}\t${it.name}" },
+        )
+    }
+
+    fun getCustomSubtitles(episodeId: Long = mutableState.value.episode?.id ?: -1L): List<CustomSubtitle> {
+        if (episodeId <= 0) return emptyList()
+        val raw = playerPreferences.customSubtitlesForEpisode(episodeId).get()
+        if (raw.isBlank()) return emptyList()
+        return raw.split("|").mapNotNull { entry ->
+            val parts = entry.split("\t", limit = 2)
+            if (parts.size == 2) CustomSubtitle(parts[0], parts[1]) else null
+        }
+    }
+
+    // AniSkip
+
+    suspend fun fetchAniSkipTimestamps(playerDuration: Int?) {
+        if (!playerPreferences.aniSkipEnabled().get()) return
+        val animeId = mutableState.value.anime?.id ?: return
+        val trackerManager = Injekt.get<TrackerManager>()
+        val episodeNumber = mutableState.value.episode?.episodeNumber?.toInt() ?: return
+
+        val tracks = withIOContext { getTracks.await(animeId) }
+        if (tracks.isEmpty()) {
+            logcat { "AniSkip: No tracks found for anime $animeId" }
+            return
+        }
+
+        for (track in tracks) {
+            val tracker = trackerManager.get(track.trackerId)
+            val malId: Long? = when (tracker) {
+                is MyAnimeList -> track.remoteId
+                is Anilist -> withIOContext { AniSkipApi().getMalIdFromAL(track.remoteId) }
+                else -> null
+            }
+            val duration = playerDuration ?: continue
+            val stamps = malId?.let {
+                withIOContext { AniSkipApi().getResult(it.toInt(), episodeNumber, duration.toLong()) }
+            }
+            if (stamps != null) {
+                aniSkipStamps = stamps
+                rebuildChapters()
+                return
+            }
+        }
+    }
+
+    fun loadChapters() {
+        try {
+            val count = MPVLib.getPropertyInt("chapter-list/count") ?: 0
+            val chapters = mutableListOf<IndexedSegment>()
+            for (i in 0 until count) {
+                val title = MPVLib.getPropertyString("chapter-list/$i/title") ?: "Chapter ${i + 1}"
+                val time = MPVLib.getPropertyInt("chapter-list/$i/time") ?: 0
+                chapters.add(IndexedSegment(name = title, start = time.toFloat(), index = i))
+            }
+            mpvChapters = chapters
+            rebuildChapters()
+        } catch (e: Exception) {
+            logcat(LogPriority.WARN, e) { "Failed to load MPV chapters" }
+        }
+    }
+
+    private fun rebuildChapters() {
+        val duration = mutableState.value.durationSec.toInt().takeIf { it > 0 }
+        val merged = if (aniSkipStamps.isNotEmpty()) {
+            ChapterUtils.mergeChapters(mpvChapters, aniSkipStamps, duration)
+        } else {
+            mpvChapters
+        }
+        mutableState.update { it.copy(chapters = merged) }
+    }
+
+    private fun setChapter(position: Float) {
+        val chapters = mutableState.value.chapters
+        if (chapters.isEmpty()) return
+
+        getCurrentChapter(position)?.let { (chapterIndex, chapter) ->
+            if (mutableState.value.currentChapter != chapter) {
+                mutableState.update { it.copy(currentChapter = chapter) }
+            }
+
+            if (!introSkipEnabled) return
+
+            if (chapter.chapterType == ChapterType.Other) {
+                mutableState.update { it.copy(skipIntroText = null) }
+                waitingSkipIntro = defaultWaitingTime
+            } else {
+                val nextChapterPos = chapters.getOrNull(chapterIndex + 1)?.start ?: position
+
+                if (netflixStyle) {
+                    if (waitingSkipIntro == defaultWaitingTime) {
+                        viewModelScope.launchIO {
+                            eventChannel.send(Event.ShowToast("Skipping ${chapter.name} in $waitingSkipIntro seconds"))
+                        }
+                    }
+                    showSkipIntroButton(chapter, nextChapterPos, waitingSkipIntro)
+                    waitingSkipIntro--
+                } else if (autoSkip) {
+                    viewModelScope.launchIO {
+                        eventChannel.send(Event.SeekTo(nextChapterPos.toInt()))
+                        eventChannel.send(Event.ShowToast("${chapter.name} skipped"))
+                    }
+                } else {
+                    mutableState.update { it.copy(skipIntroText = "Skip ${chapter.name}") }
+                }
+            }
+        }
+    }
+
+    private fun showSkipIntroButton(chapter: IndexedSegment, nextChapterPos: Float, waitingTime: Int) {
+        if (waitingTime > -1) {
+            if (waitingTime > 0) {
+                mutableState.update { it.copy(skipIntroText = "Don't skip") }
+            } else {
+                viewModelScope.launchIO {
+                    eventChannel.send(Event.SeekTo(nextChapterPos.toInt()))
+                    eventChannel.send(Event.ShowToast("${chapter.name} skipped"))
+                }
+            }
+        } else {
+            mutableState.update { it.copy(skipIntroText = "Skip ${chapter.name}") }
+        }
+    }
+
+    fun onSkipIntro() {
+        val chapters = mutableState.value.chapters
+        getCurrentChapter()?.let { (chapterIndex, chapter) ->
+            if (waitingSkipIntro > 0 && netflixStyle) {
+                waitingSkipIntro = -1
+                return
+            }
+
+            val nextChapterPos = chapters.getOrNull(chapterIndex + 1)?.start
+                ?: mutableState.value.currentPositionSec.toFloat()
+
+            viewModelScope.launchIO {
+                eventChannel.send(Event.SeekTo(nextChapterPos.toInt()))
+                eventChannel.send(Event.ShowToast("${chapter.name} skipped"))
+            }
+        }
+    }
+
+    fun selectChapter(index: Int) {
+        val chapters = mutableState.value.chapters
+        val chapter = chapters.getOrNull(index) ?: return
+        viewModelScope.launchIO {
+            eventChannel.send(Event.SeekTo(chapter.start.toInt()))
+        }
+    }
+
+    private fun getCurrentChapter(position: Float? = null): IndexedValue<IndexedSegment>? {
+        val chapters = mutableState.value.chapters
+        if (chapters.isEmpty()) return null
+        val pos = position ?: mutableState.value.currentPositionSec.toFloat()
+        return chapters.withIndex().lastOrNull { it.value.start <= pos }
+    }
+
+    // Screenshot
+
+    fun takeScreenshot(cachePath: String, showSubtitles: Boolean): InputStream? {
+        val filename = "$cachePath/${System.currentTimeMillis()}_mpv_screenshot_tmp.png"
+        val subtitleFlag = if (showSubtitles) "subtitles" else "video"
+        MPVLib.command(arrayOf("screenshot-to-file", filename, subtitleFlag))
+        val newFile = File("$cachePath/mpv_screenshot.png")
+        File(filename).renameTo(newFile)
+        return newFile.takeIf { it.exists() }?.inputStream()
+    }
+
+    // Sleep timer
+
+    fun startTimer(seconds: Int) {
+        timerJob?.cancel()
+        if (seconds < 1) {
+            mutableState.update { it.copy(remainingTimerSeconds = null) }
+            return
+        }
+        mutableState.update { it.copy(remainingTimerSeconds = seconds) }
+        timerJob = viewModelScope.launch {
+            for (time in seconds downTo 0) {
+                mutableState.update { it.copy(remainingTimerSeconds = time) }
+                if (time == 0) {
+                    eventChannel.send(Event.PauseForTimer)
+                    mutableState.update { it.copy(remainingTimerSeconds = null) }
+                    break
+                }
+                delay(1000)
+            }
+        }
+    }
+
+    fun cancelTimer() {
+        timerJob?.cancel()
+        timerJob = null
+        mutableState.update { it.copy(remainingTimerSeconds = null) }
+    }
+
     private suspend fun createOrGetAnimeForUrl(videoUrl: String) {
         withIOContext {
             val existingAnime = animeRepository.getAnimeByUrlAndSourceId(videoUrl, LOCAL_ANIME_SOURCE_ID)
@@ -437,7 +774,6 @@ class PlayerViewModel @JvmOverloads constructor(
         val isPlaying: Boolean = false,
         val currentPositionSec: Long = 0,
         val durationSec: Long = 0,
-        val doubleTapSeekSec: Int = 10,
         val currentSubText: String = "",
         val subtitleTracks: List<MPVView.Track> = emptyList(),
         val audioTracks: List<MPVView.Track> = emptyList(),
@@ -445,6 +781,23 @@ class PlayerViewModel @JvmOverloads constructor(
         val selectedAudioId: Int = -1,
         val lookupState: SubtitleLookupState? = null,
         val highlightRange: IntRange? = null,
+        val isLocked: Boolean = false,
+        val currentSpeed: Float = 1f,
+        val aspectRatio: VideoAspect = VideoAspect.Fit,
+        val showBrightnessSlider: Boolean = false,
+        val showVolumeSlider: Boolean = false,
+        val currentBrightness: Float = 0f,
+        val currentVolume: Float = 0f,
+        val maxVolume: Float = 15f,
+        val episodes: List<Episode> = emptyList(),
+        val currentEpisodeIndex: Int = -1,
+        val isInPipMode: Boolean = false,
+        val showStats: Boolean = false,
+        val controlsVisible: Boolean = true,
+        val chapters: List<IndexedSegment> = emptyList(),
+        val currentChapter: IndexedSegment? = null,
+        val skipIntroText: String? = null,
+        val remainingTimerSeconds: Int? = null,
     )
 
     sealed interface Event {
@@ -452,6 +805,10 @@ class PlayerViewModel @JvmOverloads constructor(
         data object PlaybackCompleted : Event
         data object PauseForLookup : Event
         data object ResumeFromLookup : Event
+        data class EpisodeChanged(val episodeId: Long) : Event
+        data class ShowToast(val message: String) : Event
+        data class SeekTo(val positionSec: Int) : Event
+        data object PauseForTimer : Event
     }
 
     companion object {
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/cast/CastOptionsProvider.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/cast/CastOptionsProvider.kt
new file mode 100644
index 0000000000..1ebf4385f9
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/cast/CastOptionsProvider.kt
@@ -0,0 +1,23 @@
+package eu.kanade.tachiyomi.ui.player.cast
+
+import android.annotation.SuppressLint
+import android.content.Context
+import com.google.android.gms.cast.CastMediaControlIntent
+import com.google.android.gms.cast.framework.CastOptions
+import com.google.android.gms.cast.framework.OptionsProvider
+import com.google.android.gms.cast.framework.SessionProvider
+import com.google.android.gms.cast.framework.media.CastMediaOptions
+
+open class CastOptionsProvider : OptionsProvider {
+
+    @SuppressLint("VisibleForTests")
+    override fun getCastOptions(context: Context): CastOptions {
+        val mediaOptions = CastMediaOptions.Builder().build()
+        return CastOptions.Builder()
+            .setReceiverApplicationId(CastMediaControlIntent.DEFAULT_MEDIA_RECEIVER_APPLICATION_ID)
+            .setCastMediaOptions(mediaOptions)
+            .build()
+    }
+
+    override fun getAdditionalSessionProviders(context: Context): List<SessionProvider>? = null
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/GestureHandler.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/GestureHandler.kt
new file mode 100644
index 0000000000..c45e3ab726
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/GestureHandler.kt
@@ -0,0 +1,224 @@
+package eu.kanade.tachiyomi.ui.player.controls
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectHorizontalDragGestures
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.gestures.detectVerticalDragGestures
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import eu.kanade.tachiyomi.ui.player.controls.components.DoubleTapSeekTriangles
+import eu.kanade.tachiyomi.ui.player.setting.GesturePreferences
+import kotlinx.coroutines.delay
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+@Composable
+fun GestureHandler(
+    isLocked: Boolean,
+    subtitleActive: Boolean,
+    currentPositionSec: Long,
+    durationSec: Long,
+    onToggleControls: () -> Unit,
+    onSeekRelative: (Int) -> Unit,
+    onPlayPause: () -> Unit,
+    onBrightnessChange: (Float) -> Unit,
+    onVolumeChange: (Float) -> Unit,
+    onSeekTo: (Int) -> Unit,
+    onSeekStart: () -> Unit,
+    onSeekEnd: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val gesturePreferences = remember { Injekt.get<GesturePreferences>() }
+    val skipLength = remember { gesturePreferences.skipLengthPreference().get() }
+    val gestureVolumeBrightness = remember { gesturePreferences.gestureVolumeBrightness().get() }
+    val seekGesture = remember { gesturePreferences.gestureHorizontalSeek().get() }
+    val swapVolumeBrightness = remember { gesturePreferences.swapVolumeBrightness().get() }
+
+    var seekAmount by remember { mutableIntStateOf(0) }
+    var isSeekingForward by remember { mutableStateOf(true) }
+    var isDoubleTapSeeking by remember { mutableStateOf(false) }
+    var seekPreviewText by remember { mutableStateOf<String?>(null) }
+
+    LaunchedEffect(seekAmount) {
+        if (seekAmount != 0) {
+            delay(800)
+            isDoubleTapSeeking = false
+            seekAmount = 0
+            seekPreviewText = null
+        }
+    }
+
+    Box(modifier = modifier.fillMaxSize()) {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .pointerInput(isLocked) {
+                    detectTapGestures(
+                        onTap = {
+                            if (isLocked) return@detectTapGestures
+                            onToggleControls()
+                        },
+                        onDoubleTap = { offset ->
+                            if (isLocked) return@detectTapGestures
+                            when {
+                                offset.x > size.width * 3 / 5 -> {
+                                    if (!isSeekingForward) seekAmount = 0
+                                    isSeekingForward = true
+                                    seekAmount += skipLength
+                                    isDoubleTapSeeking = true
+                                    onSeekRelative(skipLength)
+                                }
+                                offset.x < size.width * 2 / 5 -> {
+                                    if (isSeekingForward) seekAmount = 0
+                                    isSeekingForward = false
+                                    seekAmount += skipLength
+                                    isDoubleTapSeeking = true
+                                    onSeekRelative(-skipLength)
+                                }
+                                else -> onPlayPause()
+                            }
+                        },
+                    )
+                }
+                .pointerInput(isLocked, seekGesture) {
+                    if (!seekGesture || isLocked) return@pointerInput
+                    var startingPosition = currentPositionSec.toInt()
+                    var startingX = 0f
+                    detectHorizontalDragGestures(
+                        onDragStart = {
+                            startingPosition = currentPositionSec.toInt()
+                            startingX = it.x
+                            onSeekStart()
+                        },
+                        onDragEnd = {
+                            seekPreviewText = null
+                            onSeekEnd()
+                        },
+                    ) { change, _ ->
+                        val newPos = calculateNewHorizontalGestureValue(
+                            startingPosition,
+                            startingX,
+                            change.position.x,
+                            0.15f,
+                        ).coerceIn(0, durationSec.toInt())
+                        val delta = newPos - startingPosition
+                        val sign = if (delta >= 0) "+" else ""
+                        seekPreviewText = "$sign${delta}s"
+                        onSeekTo(newPos)
+                    }
+                }
+                .pointerInput(isLocked, gestureVolumeBrightness, subtitleActive) {
+                    if (!gestureVolumeBrightness || isLocked) return@pointerInput
+                    var startingY: Float? = null
+                    var isBrightnessSide = true
+                    detectVerticalDragGestures(
+                        onDragEnd = { startingY = null },
+                        onDragStart = {
+                            if (subtitleActive && it.y > size.height * 0.8f) return@detectVerticalDragGestures
+                            startingY = it.y
+                            isBrightnessSide = if (swapVolumeBrightness) {
+                                it.x > size.width / 2
+                            } else {
+                                it.x < size.width / 2
+                            }
+                        },
+                    ) { change, _ ->
+                        val sy = startingY ?: return@detectVerticalDragGestures
+                        val totalDisplacement = sy - change.position.y
+                        val normalizedDelta = totalDisplacement / size.height
+                        if (isBrightnessSide) {
+                            onBrightnessChange(normalizedDelta)
+                        } else {
+                            onVolumeChange(normalizedDelta)
+                        }
+                        startingY = change.position.y
+                    }
+                },
+        )
+
+        // Double-tap seek overlay
+        AnimatedVisibility(
+            visible = isDoubleTapSeeking && seekAmount != 0,
+            enter = fadeIn(),
+            exit = fadeOut(),
+            modifier = Modifier.fillMaxSize(),
+        ) {
+            Box(
+                modifier = Modifier.fillMaxSize(),
+                contentAlignment = if (isSeekingForward) Alignment.CenterEnd else Alignment.CenterStart,
+            ) {
+                Box(
+                    modifier = Modifier
+                        .fillMaxHeight()
+                        .fillMaxWidth(0.4f)
+                        .background(Color.White.copy(alpha = 0.15f)),
+                    contentAlignment = Alignment.Center,
+                ) {
+                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                        DoubleTapSeekTriangles(isForward = isSeekingForward)
+                        Text(
+                            text = "${seekAmount}s",
+                            fontSize = 12.sp,
+                            textAlign = TextAlign.Center,
+                            color = Color.White,
+                        )
+                    }
+                }
+            }
+        }
+
+        // Horizontal seek preview text
+        if (seekPreviewText != null) {
+            Box(
+                modifier = Modifier.fillMaxSize(),
+                contentAlignment = Alignment.Center,
+            ) {
+                Text(
+                    text = seekPreviewText!!,
+                    fontSize = 28.sp,
+                    color = Color.White,
+                    textAlign = TextAlign.Center,
+                    modifier = Modifier
+                        .background(
+                            Color.Black.copy(alpha = 0.5f),
+                            shape = RoundedCornerShape(8.dp),
+                        )
+                        .padding(horizontal = 16.dp, vertical = 8.dp),
+                )
+            }
+        }
+    }
+}
+
+private fun calculateNewHorizontalGestureValue(
+    originalValue: Int,
+    startingX: Float,
+    newX: Float,
+    sensitivity: Float,
+): Int {
+    return originalValue + ((newX - startingX) * sensitivity).toInt()
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
index 712da557e5..3683b028cb 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
@@ -1,10 +1,12 @@
 package eu.kanade.tachiyomi.ui.player.controls
 
 import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.EnterTransition
+import androidx.compose.animation.ExitTransition
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -20,9 +22,19 @@ import androidx.compose.foundation.selection.selectable
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.AspectRatio
 import androidx.compose.material.icons.filled.ClosedCaption
+import androidx.compose.material.icons.filled.Lock
+import androidx.compose.material.icons.filled.LockOpen
+import androidx.compose.material.icons.filled.MoreVert
 import androidx.compose.material.icons.filled.Pause
 import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material.icons.filled.ScreenRotation
+import androidx.compose.material.icons.filled.SkipNext
+import androidx.compose.material.icons.filled.SkipPrevious
+import androidx.compose.material.icons.filled.Speed
+import androidx.compose.material3.FilledTonalButton
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
@@ -41,146 +53,290 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Brush
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import androidx.compose.ui.window.Dialog
+import eu.kanade.tachiyomi.ui.player.PlayerViewModel
+import eu.kanade.tachiyomi.ui.player.controls.components.CurrentChapter
+import eu.kanade.tachiyomi.ui.player.controls.components.IndexedSegment
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import eu.kanade.tachiyomi.ui.player.controls.components.sheets.ChaptersSheet
+import eu.kanade.tachiyomi.ui.player.controls.components.sheets.MoreSheet
+import eu.kanade.tachiyomi.ui.player.controls.components.sheets.SpeedSheet
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
+import kotlinx.collections.immutable.toImmutableList
 import kotlinx.coroutines.delay
 import tachiyomi.i18n.MR
 import tachiyomi.presentation.core.components.ScrollbarLazyColumn
 import tachiyomi.presentation.core.i18n.stringResource
-import kotlin.time.Duration.Companion.seconds
 
 @Composable
 fun PlayerControlsOverlay(
-    isPlaying: Boolean,
-    animeTitle: String?,
-    episodeName: String?,
-    currentPositionSec: Long,
-    durationSec: Long,
-    doubleTapSeekSec: Int,
+    state: PlayerViewModel.State,
     onPlayPause: () -> Unit,
     onSeek: (Float) -> Unit,
-    onSeekRelative: (Int) -> Unit,
     onBack: () -> Unit,
-    subtitleTracks: List<MPVView.Track> = emptyList(),
-    audioTracks: List<MPVView.Track> = emptyList(),
-    selectedSubId: Int = -1,
-    selectedAudioId: Int = -1,
     onSelectSubtitle: (Int) -> Unit = {},
     onSelectAudio: (Int) -> Unit = {},
+    onToggleLock: () -> Unit = {},
+    onSetSpeed: (Float) -> Unit = {},
+    onCycleAspectRatio: () -> Unit = {},
+    onRotateScreen: () -> Unit = {},
+    onNavigatePrevious: () -> Unit = {},
+    onNavigateNext: () -> Unit = {},
+    onAddSubtitleFile: () -> Unit = {},
+    onHideControls: () -> Unit = {},
+    onToggleStats: () -> Unit = {},
+    onLoadEpisodeAt: (Int) -> Unit = {},
+    onSkipIntro: () -> Unit = {},
+    onSelectChapter: (Int) -> Unit = {},
+    onStartTimer: (Int) -> Unit = {},
+    onCancelTimer: () -> Unit = {},
     modifier: Modifier = Modifier,
 ) {
-    var controlsVisible by remember { mutableStateOf(true) }
     var showTrackDialog by remember { mutableStateOf(false) }
+    var showSpeedDialog by remember { mutableStateOf(false) }
+    var showEpisodeDialog by remember { mutableStateOf(false) }
+    var showMoreSheet by remember { mutableStateOf(false) }
+    var showChaptersSheet by remember { mutableStateOf(false) }
 
-    LaunchedEffect(controlsVisible, isPlaying) {
-        if (controlsVisible && isPlaying) {
-            delay(3.seconds)
-            controlsVisible = false
+    val playerPreferences = remember { Injekt.get<PlayerPreferences>() }
+    val controlsTimeout = remember { playerPreferences.playerTimeToDisappear().get().toLong() }
+    val reduceMotion = remember { playerPreferences.reduceMotion().get() }
+    val enterAnim = if (reduceMotion) EnterTransition.None else fadeIn()
+    val exitAnim = if (reduceMotion) ExitTransition.None else fadeOut()
+    LaunchedEffect(state.controlsVisible, state.isPlaying, state.isLocked) {
+        if (state.controlsVisible && state.isPlaying && !state.isLocked) {
+            delay(controlsTimeout)
+            onHideControls()
         }
     }
 
-    Box(
-        modifier = modifier
-            .fillMaxSize()
-            .pointerInput(doubleTapSeekSec) {
-                detectTapGestures(
-                    onTap = { controlsVisible = !controlsVisible },
-                    onDoubleTap = { offset ->
-                        val isLeftSide = offset.x < size.width / 2
-                        onSeekRelative(if (isLeftSide) -doubleTapSeekSec else doubleTapSeekSec)
-                    },
-                )
-            },
-    ) {
+    if (state.isLocked) {
         AnimatedVisibility(
-            visible = controlsVisible,
-            enter = fadeIn(),
-            exit = fadeOut(),
+            visible = state.controlsVisible,
+            enter = enterAnim,
+            exit = exitAnim,
         ) {
-            Box(modifier = Modifier.fillMaxSize()) {
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(
-                            Brush.verticalGradient(
-                                colors = listOf(Color.Black.copy(alpha = 0.7f), Color.Transparent),
-                            ),
+            Box(
+                modifier = modifier
+                    .fillMaxSize()
+                    .statusBarsPadding()
+                    .padding(16.dp),
+                contentAlignment = Alignment.TopEnd,
+            ) {
+                IconButton(onClick = onToggleLock) {
+                    Icon(
+                        Icons.Default.Lock,
+                        contentDescription = stringResource(MR.strings.player_unlock),
+                        tint = Color.White,
+                    )
+                }
+            }
+        }
+        return
+    }
+
+    AnimatedVisibility(
+        visible = state.controlsVisible,
+        enter = enterAnim,
+        exit = exitAnim,
+        modifier = modifier,
+    ) {
+        Box(modifier = Modifier.fillMaxSize()) {
+            // Top bar
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .background(
+                        Brush.verticalGradient(
+                            colors = listOf(Color.Black.copy(alpha = 0.7f), Color.Transparent),
+                        ),
+                    )
+                    .statusBarsPadding()
+                    .padding(horizontal = 4.dp, vertical = 4.dp),
+            ) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    IconButton(onClick = onBack) {
+                        Icon(
+                            Icons.AutoMirrored.Filled.ArrowBack,
+                            contentDescription = null,
+                            tint = Color.White,
                         )
-                        .statusBarsPadding()
-                        .padding(horizontal = 4.dp, vertical = 4.dp),
-                ) {
-                    Row(verticalAlignment = Alignment.CenterVertically) {
-                        IconButton(onClick = onBack) {
-                            Icon(
-                                Icons.AutoMirrored.Filled.ArrowBack,
-                                contentDescription = null,
-                                tint = Color.White,
+                    }
+                    Column(modifier = Modifier.weight(1f)) {
+                        state.anime?.title?.let {
+                            Text(
+                                text = it,
+                                style = MaterialTheme.typography.titleMedium,
+                                color = Color.White,
+                                maxLines = 1,
                             )
                         }
-                        Column(modifier = Modifier.weight(1f)) {
-                            animeTitle?.let {
-                                Text(
-                                    text = it,
-                                    style = MaterialTheme.typography.titleMedium,
-                                    color = Color.White,
-                                    maxLines = 1,
-                                )
-                            }
-                            episodeName?.let {
-                                Text(
-                                    text = it,
-                                    style = MaterialTheme.typography.bodySmall,
-                                    color = Color.White.copy(alpha = 0.7f),
-                                    maxLines = 1,
-                                )
-                            }
+                        state.episode?.name?.let {
+                            Text(
+                                text = it,
+                                style = MaterialTheme.typography.bodySmall,
+                                color = Color.White.copy(alpha = 0.7f),
+                                maxLines = 1,
+                            )
                         }
-                        if (subtitleTracks.isNotEmpty() || audioTracks.isNotEmpty()) {
-                            IconButton(onClick = { showTrackDialog = true }) {
-                                Icon(
-                                    Icons.Default.ClosedCaption,
-                                    contentDescription = stringResource(MR.strings.player_tracks),
-                                    tint = Color.White,
-                                )
-                            }
+                    }
+
+                    if (state.episodes.size > 1) {
+                        IconButton(onClick = { showEpisodeDialog = true }) {
+                            Text(
+                                text = "${state.currentEpisodeIndex + 1}/${state.episodes.size}",
+                                color = Color.White,
+                                fontSize = 12.sp,
+                            )
+                        }
+                    }
+
+                    IconButton(onClick = onToggleLock) {
+                        Icon(
+                            Icons.Default.LockOpen,
+                            contentDescription = stringResource(MR.strings.player_lock),
+                            tint = Color.White,
+                        )
+                    }
+
+                    IconButton(onClick = { showSpeedDialog = true }) {
+                        Icon(
+                            Icons.Default.Speed,
+                            contentDescription = stringResource(MR.strings.player_speed),
+                            tint = Color.White,
+                        )
+                    }
+
+                    if (state.subtitleTracks.isNotEmpty() || state.audioTracks.isNotEmpty()) {
+                        IconButton(onClick = { showTrackDialog = true }) {
+                            Icon(
+                                Icons.Default.ClosedCaption,
+                                contentDescription = stringResource(MR.strings.player_tracks),
+                                tint = Color.White,
+                            )
                         }
                     }
+
+                    IconButton(onClick = { showMoreSheet = true }) {
+                        Icon(
+                            Icons.Default.MoreVert,
+                            contentDescription = stringResource(MR.strings.player_more),
+                            tint = Color.White,
+                        )
+                    }
                 }
+            }
 
-                IconButton(
-                    onClick = onPlayPause,
-                    modifier = Modifier.align(Alignment.Center),
-                ) {
+            // Center controls
+            Row(
+                modifier = Modifier.align(Alignment.Center),
+                horizontalArrangement = Arrangement.spacedBy(24.dp),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                if (state.currentEpisodeIndex > 0) {
+                    IconButton(onClick = onNavigatePrevious) {
+                        Icon(
+                            Icons.Default.SkipPrevious,
+                            contentDescription = stringResource(MR.strings.player_previous),
+                            tint = Color.White,
+                            modifier = Modifier.size(36.dp),
+                        )
+                    }
+                }
+
+                IconButton(onClick = onPlayPause) {
                     Icon(
-                        imageVector = if (isPlaying) Icons.Default.Pause else Icons.Default.PlayArrow,
+                        imageVector = if (state.isPlaying) Icons.Default.Pause else Icons.Default.PlayArrow,
                         contentDescription = stringResource(
-                            if (isPlaying) MR.strings.action_pause else MR.strings.action_play,
+                            if (state.isPlaying) MR.strings.action_pause else MR.strings.action_play,
                         ),
                         tint = Color.White,
                         modifier = Modifier.size(64.dp),
                     )
                 }
 
-                Column(
+                if (state.currentEpisodeIndex >= 0 && state.currentEpisodeIndex < state.episodes.size - 1) {
+                    IconButton(onClick = onNavigateNext) {
+                        Icon(
+                            Icons.Default.SkipNext,
+                            contentDescription = stringResource(MR.strings.player_next),
+                            tint = Color.White,
+                            modifier = Modifier.size(36.dp),
+                        )
+                    }
+                }
+            }
+
+            // Bottom bar
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .align(Alignment.BottomCenter)
+                    .background(
+                        Brush.verticalGradient(
+                            colors = listOf(Color.Transparent, Color.Black.copy(alpha = 0.7f)),
+                        ),
+                    )
+                    .navigationBarsPadding()
+                    .padding(bottom = 8.dp),
+            ) {
+                Row(
                     modifier = Modifier
                         .fillMaxWidth()
-                        .align(Alignment.BottomCenter)
-                        .background(
-                            Brush.verticalGradient(
-                                colors = listOf(Color.Transparent, Color.Black.copy(alpha = 0.7f)),
-                            ),
+                        .padding(horizontal = 16.dp),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    if (state.currentChapter != null && state.currentChapter.name.isNotEmpty()) {
+                        CurrentChapter(
+                            chapter = state.currentChapter,
+                            onClick = { showChaptersSheet = true },
                         )
-                        .navigationBarsPadding()
-                        .padding(bottom = 8.dp),
+                    } else {
+                        Spacer(Modifier)
+                    }
+
+                    state.skipIntroText?.let { text ->
+                        FilledTonalButton(onClick = onSkipIntro) {
+                            Text(text)
+                        }
+                    }
+                }
+
+                TimeBar(
+                    currentPositionSec = state.currentPositionSec,
+                    durationSec = state.durationSec,
+                    onSeek = onSeek,
+                    modifier = Modifier.fillMaxWidth(),
+                    chapters = state.chapters.map { it.toSegment() }.toImmutableList(),
+                )
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 8.dp),
+                    horizontalArrangement = Arrangement.End,
+                    verticalAlignment = Alignment.CenterVertically,
                 ) {
-                    TimeBar(
-                        currentPositionSec = currentPositionSec,
-                        durationSec = durationSec,
-                        onSeek = onSeek,
-                        modifier = Modifier.fillMaxWidth(),
-                    )
+                    IconButton(onClick = onCycleAspectRatio) {
+                        Icon(
+                            Icons.Default.AspectRatio,
+                            contentDescription = stringResource(MR.strings.player_aspect_ratio),
+                            tint = Color.White,
+                            modifier = Modifier.size(20.dp),
+                        )
+                    }
+                    IconButton(onClick = onRotateScreen) {
+                        Icon(
+                            Icons.Default.ScreenRotation,
+                            contentDescription = stringResource(MR.strings.player_rotate),
+                            tint = Color.White,
+                            modifier = Modifier.size(20.dp),
+                        )
+                    }
                 }
             }
         }
@@ -188,15 +344,67 @@ fun PlayerControlsOverlay(
 
     if (showTrackDialog) {
         TrackSelectionDialog(
-            subtitleTracks = subtitleTracks,
-            audioTracks = audioTracks,
-            selectedSubId = selectedSubId,
-            selectedAudioId = selectedAudioId,
+            subtitleTracks = state.subtitleTracks,
+            audioTracks = state.audioTracks,
+            selectedSubId = state.selectedSubId,
+            selectedAudioId = state.selectedAudioId,
             onSelectSubtitle = onSelectSubtitle,
             onSelectAudio = onSelectAudio,
+            onAddSubtitleFile = {
+                showTrackDialog = false
+                onAddSubtitleFile()
+            },
             onDismiss = { showTrackDialog = false },
         )
     }
+
+    if (showSpeedDialog) {
+        SpeedSheet(
+            currentSpeed = state.currentSpeed,
+            onSpeedSelected = { speed ->
+                onSetSpeed(speed)
+                showSpeedDialog = false
+            },
+            onDismiss = { showSpeedDialog = false },
+        )
+    }
+
+    if (showMoreSheet) {
+        MoreSheet(
+            currentSpeed = state.currentSpeed,
+            onSpeedSelected = onSetSpeed,
+            onToggleStats = { onToggleStats(); showMoreSheet = false },
+            onDismiss = { showMoreSheet = false },
+            remainingTimerSeconds = state.remainingTimerSeconds,
+            onStartTimer = onStartTimer,
+            onCancelTimer = onCancelTimer,
+        )
+    }
+
+    if (showChaptersSheet && state.chapters.isNotEmpty()) {
+        ChaptersSheet(
+            chapters = state.chapters.toImmutableList(),
+            currentChapter = state.currentChapter,
+            onClick = { chapter ->
+                val idx = state.chapters.indexOf(chapter)
+                if (idx >= 0) onSelectChapter(idx)
+                showChaptersSheet = false
+            },
+            onDismissRequest = { showChaptersSheet = false },
+        )
+    }
+
+    if (showEpisodeDialog) {
+        EpisodeListDialog(
+            episodes = state.episodes,
+            currentIndex = state.currentEpisodeIndex,
+            onEpisodeSelected = { index ->
+                onLoadEpisodeAt(index)
+                showEpisodeDialog = false
+            },
+            onDismiss = { showEpisodeDialog = false },
+        )
+    }
 }
 
 @Composable
@@ -207,6 +415,7 @@ private fun TrackSelectionDialog(
     selectedAudioId: Int,
     onSelectSubtitle: (Int) -> Unit,
     onSelectAudio: (Int) -> Unit,
+    onAddSubtitleFile: () -> Unit,
     onDismiss: () -> Unit,
 ) {
     Dialog(onDismissRequest = onDismiss) {
@@ -216,30 +425,41 @@ private fun TrackSelectionDialog(
             tonalElevation = 6.dp,
         ) {
             ScrollbarLazyColumn(modifier = Modifier.padding(vertical = 16.dp)) {
-                if (subtitleTracks.isNotEmpty()) {
-                    item {
+                item {
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(horizontal = 24.dp, vertical = 8.dp),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
                         Text(
                             text = stringResource(MR.strings.player_subtitles),
                             style = MaterialTheme.typography.titleMedium,
-                            modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
-                        )
-                    }
-                    item {
-                        TrackRow(
-                            name = stringResource(MR.strings.off),
-                            selected = selectedSubId == -1,
-                            onClick = { onSelectSubtitle(-1); onDismiss() },
-                        )
-                    }
-                    items(subtitleTracks.size) { index ->
-                        val track = subtitleTracks[index]
-                        TrackRow(
-                            name = track.name,
-                            selected = track.id == selectedSubId,
-                            onClick = { onSelectSubtitle(track.id); onDismiss() },
                         )
+                        IconButton(onClick = onAddSubtitleFile) {
+                            Icon(
+                                Icons.Default.Add,
+                                contentDescription = stringResource(MR.strings.player_add_subtitle_file),
+                            )
+                        }
                     }
                 }
+                item {
+                    TrackRow(
+                        name = stringResource(MR.strings.off),
+                        selected = selectedSubId == -1,
+                        onClick = { onSelectSubtitle(-1); onDismiss() },
+                    )
+                }
+                items(subtitleTracks.size) { index ->
+                    val track = subtitleTracks[index]
+                    TrackRow(
+                        name = track.name,
+                        selected = track.id == selectedSubId,
+                        onClick = { onSelectSubtitle(track.id); onDismiss() },
+                    )
+                }
 
                 if (audioTracks.size > 1) {
                     item {
@@ -264,6 +484,40 @@ private fun TrackSelectionDialog(
     }
 }
 
+@Composable
+private fun EpisodeListDialog(
+    episodes: List<tachiyomi.domain.episode.model.Episode>,
+    currentIndex: Int,
+    onEpisodeSelected: (Int) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    Dialog(onDismissRequest = onDismiss) {
+        Surface(
+            shape = MaterialTheme.shapes.extraLarge,
+            color = MaterialTheme.colorScheme.surface,
+            tonalElevation = 6.dp,
+        ) {
+            ScrollbarLazyColumn(modifier = Modifier.padding(vertical = 16.dp)) {
+                item {
+                    Text(
+                        text = stringResource(MR.strings.player_episodes),
+                        style = MaterialTheme.typography.titleMedium,
+                        modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
+                    )
+                }
+                items(episodes.size) { index ->
+                    val episode = episodes[index]
+                    TrackRow(
+                        name = episode.name,
+                        selected = index == currentIndex,
+                        onClick = { onEpisodeSelected(index) },
+                    )
+                }
+            }
+        }
+    }
+}
+
 @Composable
 private fun TrackRow(
     name: String,
@@ -273,6 +527,7 @@ private fun TrackRow(
     Row(
         verticalAlignment = Alignment.CenterVertically,
         modifier = Modifier
+            .padding(horizontal = 8.dp)
             .clip(RoundedCornerShape(8.dp))
             .selectable(selected = selected, onClick = onClick)
             .fillMaxWidth()
@@ -285,7 +540,7 @@ private fun TrackRow(
         Text(
             text = name,
             style = MaterialTheme.typography.bodyLarge,
-            modifier = Modifier.padding(start = 24.dp),
+            modifier = Modifier.padding(start = 16.dp),
         )
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/SubtitleTapOverlay.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/SubtitleTapOverlay.kt
index 943278055e..223671e7a2 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/SubtitleTapOverlay.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/SubtitleTapOverlay.kt
@@ -1,7 +1,6 @@
 package eu.kanade.tachiyomi.ui.player.controls
 
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
@@ -12,6 +11,7 @@ import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableFloatStateOf
 import androidx.compose.runtime.remember
@@ -23,9 +23,15 @@ import androidx.compose.ui.graphics.Shadow
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.positionInRoot
 import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
+import tachiyomi.presentation.core.util.collectAsState
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
 
 private val ASS_OVERRIDE_REGEX = Regex("""\{\\[^}]*\}""")
 
@@ -35,19 +41,6 @@ private fun stripAssOverrides(text: String): String {
 
 private val HIGHLIGHT_COLOR = Color(0xFF4FC3F7)
 
-private val subtitleStyle = TextStyle(
-    color = Color.White,
-    fontSize = 24.sp,
-    textAlign = TextAlign.Center,
-    shadow = Shadow(
-        color = Color.Black,
-        offset = Offset(1f, 1f),
-        blurRadius = 8f,
-    ),
-)
-
-private val highlightStyle = subtitleStyle.copy(color = HIGHLIGHT_COLOR)
-
 @OptIn(ExperimentalLayoutApi::class)
 @Composable
 fun SubtitleTapOverlay(
@@ -57,15 +50,43 @@ fun SubtitleTapOverlay(
     modifier: Modifier = Modifier,
 ) {
     val cleanText = remember(subText) { stripAssOverrides(subText) }
-
     if (cleanText.isBlank()) return
 
+    val prefs = remember { Injekt.get<SubtitlePreferences>() }
+    val textColorInt by prefs.textColorSubtitles().collectAsState()
+    val borderColorInt by prefs.borderColorSubtitles().collectAsState()
+    val fontSize by prefs.subtitleFontSize().collectAsState()
+    val scale by prefs.subtitleFontScale().collectAsState()
+    val isBold by prefs.boldSubtitles().collectAsState()
+    val isItalic by prefs.italicSubtitles().collectAsState()
+    val shadowOffset by prefs.shadowOffsetSubtitles().collectAsState()
+    val textColor = Color(textColorInt)
+    val borderColor = Color(borderColorInt)
+
+    val effectiveFontSize = (fontSize * scale * 0.45f).sp
+
+    val subtitleStyle = remember(textColor, borderColor, effectiveFontSize, isBold, isItalic, shadowOffset) {
+        TextStyle(
+            color = textColor,
+            fontSize = effectiveFontSize,
+            textAlign = TextAlign.Center,
+            fontWeight = if (isBold) FontWeight.Bold else FontWeight.Normal,
+            fontStyle = if (isItalic) FontStyle.Italic else FontStyle.Normal,
+            shadow = Shadow(
+                color = borderColor,
+                offset = Offset(shadowOffset.toFloat().coerceAtLeast(1f), shadowOffset.toFloat().coerceAtLeast(1f)),
+                blurRadius = 8f,
+            ),
+        )
+    }
+    val highlightStyle = remember(subtitleStyle) { subtitleStyle.copy(color = HIGHLIGHT_COLOR) }
+
     Box(modifier = modifier.fillMaxSize()) {
         Box(
             modifier = Modifier
                 .align(Alignment.BottomCenter)
                 .navigationBarsPadding()
-                .padding(horizontal = 24.dp, vertical = 72.dp),
+                .padding(horizontal = 24.dp, vertical = 120.dp),
         ) {
             FlowRow(
                 horizontalArrangement = Arrangement.Center,
@@ -92,7 +113,7 @@ fun SubtitleTapOverlay(
                                 anchorY.floatValue = pos.y
                             }
                             .clickable(
-                                interactionSource = remember { MutableInteractionSource() },
+                                interactionSource = null,
                                 indication = null,
                             ) {
                                 val lookupLen = minOf(10, cleanText.length - idx)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/TimeBar.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/TimeBar.kt
index fc6d346d64..c0374273cc 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/TimeBar.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/TimeBar.kt
@@ -1,10 +1,10 @@
 package eu.kanade.tachiyomi.ui.player.controls
 
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.width
 import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Slider
-import androidx.compose.material3.SliderDefaults
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
@@ -14,8 +14,14 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
+import dev.vivvvek.seeker.Seeker
+import dev.vivvvek.seeker.SeekerDefaults
+import dev.vivvvek.seeker.Segment
 import eu.kanade.tachiyomi.ui.player.formatTime
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
 
 @Composable
 fun TimeBar(
@@ -23,47 +29,61 @@ fun TimeBar(
     durationSec: Long,
     onSeek: (Float) -> Unit,
     modifier: Modifier = Modifier,
+    chapters: ImmutableList<Segment> = persistentListOf(),
 ) {
-    var seekingProgress by remember { mutableFloatStateOf(-1f) }
-    val progress = when {
-        seekingProgress >= 0f -> seekingProgress
-        durationSec > 0 -> currentPositionSec.toFloat() / durationSec
-        else -> 0f
-    }
+    var seekingPosition by remember { mutableFloatStateOf(-1f) }
+    val position = if (seekingPosition >= 0f) seekingPosition else currentPositionSec.toFloat()
+    val duration = durationSec.toFloat().coerceAtLeast(1f)
 
     Row(
-        modifier = modifier,
+        modifier = modifier.height(48.dp),
         verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(4.dp),
     ) {
         Text(
             text = formatTime(
-                if (seekingProgress >= 0f) (seekingProgress * durationSec).toLong() else currentPositionSec,
+                if (seekingPosition >= 0f) seekingPosition.toLong() else currentPositionSec,
             ),
-            style = MaterialTheme.typography.bodySmall,
             color = Color.White,
-            modifier = Modifier.padding(horizontal = 8.dp),
+            textAlign = TextAlign.Center,
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.width(72.dp),
         )
-        Slider(
-            value = progress,
-            onValueChange = { seekingProgress = it },
+
+        Seeker(
+            value = position.coerceIn(0f, duration),
+            range = 0f..duration,
+            onValueChange = { seekingPosition = it },
             onValueChangeFinished = {
-                if (seekingProgress >= 0f) {
-                    onSeek(seekingProgress)
-                    seekingProgress = -1f
+                if (seekingPosition >= 0f) {
+                    onSeek(seekingPosition / duration)
+                    seekingPosition = -1f
                 }
             },
-            colors = SliderDefaults.colors(
-                thumbColor = Color.White,
-                activeTrackColor = Color.White,
-                inactiveTrackColor = Color.White.copy(alpha = 0.3f),
-            ),
+            segments = chapters
+                .filter { it.start in 0f..duration }
+                .let {
+                    if (it.isNotEmpty() && it[0].start != 0f) {
+                        persistentListOf(Segment("", 0f)) + it
+                    } else {
+                        it
+                    }
+                },
             modifier = Modifier.weight(1f),
+            colors = SeekerDefaults.seekerColors(
+                progressColor = MaterialTheme.colorScheme.primary,
+                thumbColor = MaterialTheme.colorScheme.primary,
+                trackColor = MaterialTheme.colorScheme.background,
+                readAheadColor = MaterialTheme.colorScheme.inversePrimary,
+            ),
         )
+
         Text(
             text = formatTime(durationSec),
-            style = MaterialTheme.typography.bodySmall,
             color = Color.White,
-            modifier = Modifier.padding(horizontal = 8.dp),
+            textAlign = TextAlign.Center,
+            style = MaterialTheme.typography.bodySmall,
+            modifier = Modifier.width(72.dp),
         )
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/BrightnessVolumeIndicator.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/BrightnessVolumeIndicator.kt
new file mode 100644
index 0000000000..2409711d80
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/BrightnessVolumeIndicator.kt
@@ -0,0 +1,95 @@
+package eu.kanade.tachiyomi.ui.player.controls.components
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.VolumeUp
+import androidx.compose.material.icons.filled.BrightnessHigh
+import androidx.compose.material3.Icon
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+
+@Composable
+fun BrightnessVolumeIndicator(
+    isBrightness: Boolean,
+    value: Float,
+    maxValue: Float,
+    visible: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    AnimatedVisibility(
+        visible = visible,
+        enter = fadeIn(),
+        exit = fadeOut(),
+        modifier = modifier,
+    ) {
+        Box(
+            modifier = Modifier.fillMaxSize(),
+            contentAlignment = if (isBrightness) Alignment.CenterStart else Alignment.CenterEnd,
+        ) {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.Center,
+                modifier = Modifier
+                    .padding(horizontal = 24.dp)
+                    .width(48.dp)
+                    .fillMaxHeight(0.5f)
+                    .clip(RoundedCornerShape(8.dp))
+                    .background(Color.Black.copy(alpha = 0.6f))
+                    .padding(vertical = 16.dp),
+            ) {
+                Icon(
+                    imageVector = if (isBrightness) {
+                        Icons.Default.BrightnessHigh
+                    } else {
+                        Icons.AutoMirrored.Filled.VolumeUp
+                    },
+                    contentDescription = null,
+                    tint = Color.White,
+                )
+
+                val fraction = if (maxValue > 0) (value / maxValue).coerceIn(0f, 1f) else 0f
+                val percent = (fraction * 100).toInt()
+                Text(
+                    text = "$percent%",
+                    color = Color.White,
+                    fontSize = 10.sp,
+                    modifier = Modifier.padding(vertical = 8.dp),
+                )
+
+                Box(
+                    modifier = Modifier
+                        .weight(1f)
+                        .width(4.dp)
+                        .clip(RoundedCornerShape(2.dp)),
+                ) {
+                    LinearProgressIndicator(
+                        progress = { fraction },
+                        modifier = Modifier
+                            .fillMaxHeight()
+                            .width(4.dp),
+                        color = Color.White,
+                        trackColor = Color.White.copy(alpha = 0.3f),
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/CurrentChapter.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/CurrentChapter.kt
new file mode 100644
index 0000000000..dd95b80a60
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/CurrentChapter.kt
@@ -0,0 +1,104 @@
+package eu.kanade.tachiyomi.ui.player.controls.components
+
+import androidx.compose.animation.AnimatedContent
+import androidx.compose.animation.SizeTransform
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.slideInVertically
+import androidx.compose.animation.slideOutVertically
+import androidx.compose.animation.togetherWith
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Bookmarks
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import eu.kanade.tachiyomi.ui.player.formatTime
+import tachiyomi.presentation.core.components.material.padding
+
+@Composable
+fun CurrentChapter(
+    chapter: IndexedSegment,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit = {},
+) {
+    Box(
+        modifier = modifier
+            .clip(RoundedCornerShape(25))
+            .background(MaterialTheme.colorScheme.background.copy(alpha = 0.6F))
+            .clickable(onClick = onClick)
+            .padding(horizontal = 12.dp, vertical = MaterialTheme.padding.small),
+    ) {
+        AnimatedContent(
+            targetState = chapter,
+            transitionSpec = {
+                if (targetState.start > initialState.start) {
+                    (slideInVertically { height -> height } + fadeIn())
+                        .togetherWith(slideOutVertically { height -> -height } + fadeOut())
+                } else {
+                    (slideInVertically { height -> -height } + fadeIn())
+                        .togetherWith(slideOutVertically { height -> height } + fadeOut())
+                }.using(
+                    SizeTransform(clip = false),
+                )
+            },
+            label = "Chapter",
+        ) { currentChapter ->
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.extraSmall),
+            ) {
+                Icon(
+                    imageVector = Icons.Default.Bookmarks,
+                    contentDescription = null,
+                    modifier = Modifier
+                        .padding(end = MaterialTheme.padding.extraSmall)
+                        .size(16.dp),
+                    tint = MaterialTheme.colorScheme.onBackground,
+                )
+                Text(
+                    text = formatTime(currentChapter.start.toLong()),
+                    fontWeight = FontWeight.ExtraBold,
+                    style = MaterialTheme.typography.bodyMedium,
+                    maxLines = 1,
+                    overflow = TextOverflow.Clip,
+                    color = MaterialTheme.colorScheme.tertiary,
+                )
+                if (currentChapter.name.isNotEmpty()) {
+                    Text(
+                        text = Typography.bullet.toString(),
+                        textAlign = TextAlign.Center,
+                        style = MaterialTheme.typography.bodyMedium,
+                        maxLines = 1,
+                        color = MaterialTheme.colorScheme.onSurface,
+                        overflow = TextOverflow.Clip,
+                    )
+                    Text(
+                        text = currentChapter.name,
+                        textAlign = TextAlign.Center,
+                        style = MaterialTheme.typography.bodyMedium,
+                        maxLines = 1,
+                        overflow = TextOverflow.Ellipsis,
+                        fontWeight = FontWeight.Bold,
+                        color = MaterialTheme.colorScheme.onBackground,
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/DoubleTapSeekTriangles.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/DoubleTapSeekTriangles.kt
new file mode 100644
index 0000000000..29c9cc8bfb
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/DoubleTapSeekTriangles.kt
@@ -0,0 +1,60 @@
+package eu.kanade.tachiyomi.ui.player.controls.components
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+import eu.kanade.tachiyomi.R
+
+@Composable
+fun DoubleTapSeekTriangles(isForward: Boolean) {
+    val animationDuration = 750L
+
+    val alpha1 = remember { Animatable(0f) }
+    val alpha2 = remember { Animatable(0f) }
+    val alpha3 = remember { Animatable(0f) }
+
+    LaunchedEffect(animationDuration) {
+        while (true) {
+            alpha1.animateTo(1f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha2.animateTo(1f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha3.animateTo(1f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha1.animateTo(0f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha2.animateTo(0f, animationSpec = tween((animationDuration / 5).toInt()))
+            alpha3.animateTo(0f, animationSpec = tween((animationDuration / 5).toInt()))
+        }
+    }
+
+    val rotation = if (isForward) 0f else 180f
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier.rotate(rotation),
+    ) {
+        DoubleTapArrow(alpha1.value)
+        DoubleTapArrow(alpha2.value)
+        DoubleTapArrow(alpha3.value)
+    }
+}
+
+@Composable
+private fun DoubleTapArrow(alpha: Float) {
+    Icon(
+        painter = painterResource(R.drawable.ic_play_seek_triangle),
+        contentDescription = null,
+        modifier = Modifier
+            .size(width = 16.dp, height = 20.dp)
+            .alpha(alpha = alpha),
+        tint = Color.White,
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/IndexedSegment.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/IndexedSegment.kt
new file mode 100644
index 0000000000..341fd049a2
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/IndexedSegment.kt
@@ -0,0 +1,21 @@
+package eu.kanade.tachiyomi.ui.player.controls.components
+
+import androidx.compose.runtime.Immutable
+import androidx.compose.ui.graphics.Color
+import dev.vivvvek.seeker.Segment
+import eu.kanade.tachiyomi.animesource.model.ChapterType
+
+@Immutable
+data class IndexedSegment(
+    val name: String,
+    val start: Float,
+    val color: Color = Color.Unspecified,
+    val index: Int = 0,
+    val chapterType: ChapterType = ChapterType.Other,
+) {
+    companion object {
+        val Unspecified = IndexedSegment(name = "", start = 0f)
+    }
+
+    fun toSegment(): Segment = Segment(name, start, color)
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/StatsOverlay.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/StatsOverlay.kt
new file mode 100644
index 0000000000..9043db88af
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/StatsOverlay.kt
@@ -0,0 +1,81 @@
+package eu.kanade.tachiyomi.ui.player.controls.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import `is`.xyz.mpv.MPVLib
+import kotlinx.coroutines.delay
+
+@Composable
+fun StatsOverlay(
+    modifier: Modifier = Modifier,
+) {
+    var stats by remember { mutableStateOf(StatsData()) }
+
+    LaunchedEffect(Unit) {
+        while (true) {
+            val newStats = StatsData(
+                videoCodec = MPVLib.getPropertyString("video-codec") ?: "N/A",
+                audioCodec = MPVLib.getPropertyString("audio-codec") ?: "N/A",
+                hwdec = MPVLib.getPropertyString("hwdec-current") ?: "none",
+                videoWidth = MPVLib.getPropertyInt("video-params/w") ?: 0,
+                videoHeight = MPVLib.getPropertyInt("video-params/h") ?: 0,
+                fps = MPVLib.getPropertyString("estimated-vf-fps") ?: "?",
+                droppedFrames = MPVLib.getPropertyInt("frame-drop-count") ?: 0,
+                avsync = MPVLib.getPropertyString("avsync") ?: "?",
+                cacheDuration = MPVLib.getPropertyString("demuxer-cache-duration") ?: "?",
+            )
+            if (newStats != stats) stats = newStats
+            delay(1000)
+        }
+    }
+
+    Column(
+        modifier = modifier
+            .padding(16.dp)
+            .background(Color.Black.copy(alpha = 0.7f), RoundedCornerShape(8.dp))
+            .padding(12.dp),
+    ) {
+        StatLine("Video", "${stats.videoWidth}x${stats.videoHeight} ${stats.videoCodec}")
+        StatLine("HW Decode", stats.hwdec)
+        StatLine("FPS", stats.fps)
+        StatLine("Audio", stats.audioCodec)
+        StatLine("A/V Sync", "${stats.avsync}s")
+        StatLine("Dropped", "${stats.droppedFrames}")
+        StatLine("Cache", "${stats.cacheDuration}s")
+    }
+}
+
+@Composable
+private fun StatLine(label: String, value: String) {
+    Text(
+        text = "$label: $value",
+        color = Color.White,
+        fontSize = 11.sp,
+        lineHeight = 16.sp,
+    )
+}
+
+private data class StatsData(
+    val videoCodec: String = "",
+    val audioCodec: String = "",
+    val hwdec: String = "",
+    val videoWidth: Int = 0,
+    val videoHeight: Int = 0,
+    val fps: String = "",
+    val droppedFrames: Int = 0,
+    val avsync: String = "",
+    val cacheDuration: String = "",
+)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/dialogs/PlayerDialog.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/dialogs/PlayerDialog.kt
new file mode 100644
index 0000000000..8b4a4caa38
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/dialogs/PlayerDialog.kt
@@ -0,0 +1,46 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.dialogs
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+
+@Composable
+fun PlayerDialog(
+    title: String,
+    modifier: Modifier = Modifier,
+    onConfirmRequest: () -> Unit,
+    onDismissRequest: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismissRequest,
+        modifier = modifier,
+        title = {
+            Text(
+                text = title,
+                style = MaterialTheme.typography.titleMedium,
+            )
+        },
+        confirmButton = {
+            TextButton(onClick = {
+                onConfirmRequest()
+                onDismissRequest()
+            }) {
+                Text(stringResource(MR.strings.action_ok))
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismissRequest) {
+                Text(stringResource(MR.strings.action_cancel))
+            }
+        },
+    )
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/DelayPanel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/DelayPanel.kt
new file mode 100644
index 0000000000..559437d8bd
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/DelayPanel.kt
@@ -0,0 +1,104 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.panels
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import eu.kanade.tachiyomi.ui.player.setting.AudioPreferences
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
+import `is`.xyz.mpv.MPVLib
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import kotlin.math.roundToInt
+
+@Composable
+fun DelayPanel(
+    title: String,
+    mpvProperty: String,
+    onDismiss: () -> Unit,
+) {
+    val subtitlePreferences = remember { Injekt.get<SubtitlePreferences>() }
+    val audioPreferences = remember { Injekt.get<AudioPreferences>() }
+
+    var delayMs by remember {
+        mutableIntStateOf((MPVLib.getPropertyDouble(mpvProperty) * 1000).roundToInt())
+    }
+
+    LaunchedEffect(delayMs) {
+        MPVLib.setPropertyDouble(mpvProperty, delayMs / 1000.0)
+        when (mpvProperty) {
+            "sub-delay" -> subtitlePreferences.subtitlesDelay().set(delayMs)
+            "audio-delay" -> audioPreferences.audioDelay().set(delayMs)
+        }
+    }
+
+    Dialog(onDismissRequest = onDismiss) {
+        Surface(
+            shape = MaterialTheme.shapes.extraLarge,
+            color = MaterialTheme.colorScheme.surface,
+            tonalElevation = 6.dp,
+        ) {
+            Column(modifier = Modifier.padding(24.dp)) {
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Text(title, style = MaterialTheme.typography.titleLarge)
+                    IconButton(onClick = onDismiss) {
+                        Icon(Icons.Default.Close, contentDescription = stringResource(MR.strings.action_close))
+                    }
+                }
+
+                Text(
+                    text = "${delayMs}ms",
+                    style = MaterialTheme.typography.headlineMedium,
+                    modifier = Modifier
+                        .align(Alignment.CenterHorizontally)
+                        .padding(vertical = 16.dp),
+                )
+
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.spacedBy(8.dp, Alignment.CenterHorizontally),
+                ) {
+                    OutlinedButton(onClick = { delayMs -= 500 }) { Text("-500") }
+                    OutlinedButton(onClick = { delayMs -= 100 }) { Text("-100") }
+                    OutlinedButton(onClick = { delayMs += 100 }) { Text("+100") }
+                    OutlinedButton(onClick = { delayMs += 500 }) { Text("+500") }
+                }
+
+                Button(
+                    onClick = { delayMs = 0 },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(top = 16.dp),
+                ) {
+                    Text(stringResource(MR.strings.action_reset))
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/SubtitleSettingsPanel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/SubtitleSettingsPanel.kt
new file mode 100644
index 0000000000..d1e435d97f
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/SubtitleSettingsPanel.kt
@@ -0,0 +1,356 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.panels
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.pager.HorizontalPager
+import androidx.compose.foundation.pager.rememberPagerState
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.FormatBold
+import androidx.compose.material.icons.filled.FormatItalic
+import androidx.compose.material3.Button
+
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.IconToggleButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.SliderDefaults
+import androidx.compose.material3.Surface
+
+import androidx.compose.material3.Tab
+import androidx.compose.material3.TabRow
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import androidx.core.graphics.alpha
+import androidx.core.graphics.blue
+import androidx.core.graphics.green
+import androidx.core.graphics.red
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
+import `is`.xyz.mpv.MPVLib
+import kotlinx.coroutines.launch
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+@OptIn(ExperimentalStdlibApi::class)
+@Composable
+fun SubtitleSettingsPanel(
+    onDismiss: () -> Unit,
+) {
+    val preferences = remember { Injekt.get<SubtitlePreferences>() }
+    val pagerState = rememberPagerState { 3 }
+    val scope = rememberCoroutineScope()
+    val tabs = listOf(MR.strings.player_subtitle_typography, MR.strings.player_subtitle_colors, MR.strings.player_subtitle_misc)
+
+    Dialog(
+        onDismissRequest = onDismiss,
+        properties = DialogProperties(usePlatformDefaultWidth = false),
+    ) {
+        Surface(
+            shape = MaterialTheme.shapes.extraLarge,
+            color = MaterialTheme.colorScheme.surface,
+            tonalElevation = 6.dp,
+            modifier = Modifier
+                .fillMaxWidth(0.92f)
+                .padding(vertical = 24.dp),
+        ) {
+            Column {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(horizontal = 16.dp, vertical = 8.dp),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Text(stringResource(MR.strings.player_subtitle_settings), style = MaterialTheme.typography.titleLarge)
+                    IconButton(onClick = onDismiss) {
+                        Icon(Icons.Default.Close, contentDescription = stringResource(MR.strings.action_close))
+                    }
+                }
+
+                TabRow(selectedTabIndex = pagerState.currentPage) {
+                    tabs.forEachIndexed { index, titleRes ->
+                        Tab(
+                            selected = pagerState.currentPage == index,
+                            onClick = { scope.launch { pagerState.animateScrollToPage(index) } },
+                            text = { Text(stringResource(titleRes)) },
+                        )
+                    }
+                }
+
+                HorizontalPager(
+                    state = pagerState,
+                    modifier = Modifier.height(400.dp),
+                ) { page ->
+                    Column(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .verticalScroll(rememberScrollState())
+                            .padding(16.dp),
+                    ) {
+                        when (page) {
+                            0 -> TypographyPage(preferences)
+                            1 -> ColorsPage(preferences)
+                            2 -> MiscPage(preferences)
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun TypographyPage(preferences: SubtitlePreferences) {
+    var fontSize by remember { mutableIntStateOf(MPVLib.getPropertyInt("sub-font-size") ?: 55) }
+    var borderSize by remember { mutableIntStateOf(MPVLib.getPropertyInt("sub-border-size") ?: 3) }
+    var shadowOffset by remember { mutableIntStateOf(MPVLib.getPropertyInt("sub-shadow-offset") ?: 0) }
+    var isBold by remember { mutableStateOf(MPVLib.getPropertyBoolean("sub-bold") ?: false) }
+    var isItalic by remember { mutableStateOf(MPVLib.getPropertyBoolean("sub-italic") ?: false) }
+
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        IconToggleButton(checked = isBold, onCheckedChange = {
+            isBold = it
+            preferences.boldSubtitles().set(it)
+            MPVLib.setPropertyBoolean("sub-bold", it)
+        }) { Icon(Icons.Default.FormatBold, null) }
+
+        IconToggleButton(checked = isItalic, onCheckedChange = {
+            isItalic = it
+            preferences.italicSubtitles().set(it)
+            MPVLib.setPropertyBoolean("sub-italic", it)
+        }) { Icon(Icons.Default.FormatItalic, null) }
+    }
+
+    Spacer(Modifier.height(8.dp))
+    LabeledSlider(stringResource(MR.strings.player_subtitle_font_size), fontSize, 1, 100) {
+        fontSize = it
+        preferences.subtitleFontSize().set(it)
+        MPVLib.setPropertyInt("sub-font-size", it)
+    }
+    LabeledSlider(stringResource(MR.strings.player_subtitle_border_size), borderSize, 0, 20) {
+        borderSize = it
+        preferences.subtitleBorderSize().set(it)
+        MPVLib.setPropertyInt("sub-border-size", it)
+    }
+    LabeledSlider(stringResource(MR.strings.player_subtitle_shadow_offset), shadowOffset, 0, 20) {
+        shadowOffset = it
+        preferences.shadowOffsetSubtitles().set(it)
+        MPVLib.setPropertyInt("sub-shadow-offset", it)
+    }
+
+    Spacer(Modifier.height(8.dp))
+    Button(
+        onClick = {
+            fontSize = 55; borderSize = 3; shadowOffset = 0; isBold = false; isItalic = false
+            MPVLib.setPropertyInt("sub-font-size", 55)
+            MPVLib.setPropertyInt("sub-border-size", 3)
+            MPVLib.setPropertyInt("sub-shadow-offset", 0)
+            MPVLib.setPropertyBoolean("sub-bold", false)
+            MPVLib.setPropertyBoolean("sub-italic", false)
+        },
+        modifier = Modifier.fillMaxWidth(),
+    ) { Text(stringResource(MR.strings.action_reset)) }
+}
+
+@OptIn(ExperimentalStdlibApi::class)
+@Composable
+private fun ColorsPage(preferences: SubtitlePreferences) {
+    var colorType by remember { mutableStateOf(SubColorType.Text) }
+    var currentColor by remember { mutableIntStateOf(getCurrentColor(SubColorType.Text)) }
+
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        SubColorType.entries.forEach { type ->
+            Button(
+                onClick = {
+                    colorType = type
+                    currentColor = getCurrentColor(type)
+                },
+                modifier = Modifier.weight(1f),
+                colors = if (colorType == type) {
+                    androidx.compose.material3.ButtonDefaults.buttonColors()
+                } else {
+                    androidx.compose.material3.ButtonDefaults.outlinedButtonColors()
+                },
+            ) { Text(type.label, maxLines = 1) }
+        }
+    }
+
+    Spacer(Modifier.height(12.dp))
+
+    ColorSlider(stringResource(MR.strings.player_subtitle_color_red), currentColor.red, Color.Red) {
+        currentColor = currentColor.copyAsArgb(red = it)
+        applyColor(preferences, colorType, currentColor)
+    }
+    ColorSlider(stringResource(MR.strings.player_subtitle_color_green), currentColor.green, Color.Green) {
+        currentColor = currentColor.copyAsArgb(green = it)
+        applyColor(preferences, colorType, currentColor)
+    }
+    ColorSlider(stringResource(MR.strings.player_subtitle_color_blue), currentColor.blue, Color.Blue) {
+        currentColor = currentColor.copyAsArgb(blue = it)
+        applyColor(preferences, colorType, currentColor)
+    }
+    ColorSlider(stringResource(MR.strings.player_subtitle_color_alpha), currentColor.alpha, Color.White) {
+        currentColor = currentColor.copyAsArgb(alpha = it)
+        applyColor(preferences, colorType, currentColor)
+    }
+
+    Spacer(Modifier.height(8.dp))
+    Button(
+        onClick = {
+            val default = when (colorType) {
+                SubColorType.Text -> preferences.textColorSubtitles().defaultValue()
+                SubColorType.Border -> preferences.borderColorSubtitles().defaultValue()
+                SubColorType.Background -> preferences.backgroundColorSubtitles().defaultValue()
+            }
+            currentColor = default
+            applyColor(preferences, colorType, default)
+        },
+        modifier = Modifier.fillMaxWidth(),
+    ) { Text(stringResource(MR.strings.player_reset_color, colorType.label)) }
+}
+
+@Composable
+private fun MiscPage(preferences: SubtitlePreferences) {
+    var subScale by remember {
+        mutableFloatStateOf(MPVLib.getPropertyDouble("sub-scale")?.toFloat() ?: 1f)
+    }
+    var subPos by remember {
+        mutableIntStateOf(MPVLib.getPropertyInt("sub-pos") ?: 100)
+    }
+
+    LabeledFloatSlider(stringResource(MR.strings.player_subtitle_scale), subScale, 0f, 5f) {
+        subScale = it
+        preferences.subtitleFontScale().set(it)
+        MPVLib.setPropertyDouble("sub-scale", it.toDouble())
+    }
+    LabeledSlider(stringResource(MR.strings.player_subtitle_position), subPos, 0, 150) {
+        subPos = it
+        preferences.subtitlePos().set(it)
+        MPVLib.setPropertyInt("sub-pos", it)
+    }
+
+    Spacer(Modifier.height(8.dp))
+    Button(
+        onClick = {
+            subScale = 1f; subPos = 100
+            MPVLib.setPropertyDouble("sub-scale", 1.0)
+            MPVLib.setPropertyInt("sub-pos", 100)
+        },
+        modifier = Modifier.fillMaxWidth(),
+    ) { Text(stringResource(MR.strings.action_reset)) }
+}
+
+@Composable
+private fun LabeledSlider(label: String, value: Int, min: Int, max: Int, onChange: (Int) -> Unit) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween,
+    ) {
+        Text(label, style = MaterialTheme.typography.bodyMedium)
+        Text("$value", style = MaterialTheme.typography.bodyMedium)
+    }
+    Slider(
+        value = value.toFloat(),
+        onValueChange = { onChange(it.toInt()) },
+        valueRange = min.toFloat()..max.toFloat(),
+    )
+}
+
+@Composable
+private fun LabeledFloatSlider(label: String, value: Float, min: Float, max: Float, onChange: (Float) -> Unit) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween,
+    ) {
+        Text(label, style = MaterialTheme.typography.bodyMedium)
+        Text("%.2f".format(value), style = MaterialTheme.typography.bodyMedium)
+    }
+    Slider(
+        value = value,
+        onValueChange = { onChange(kotlin.math.round(it * 100) / 100f) },
+        valueRange = min..max,
+    )
+}
+
+@Composable
+private fun ColorSlider(label: String, value: Int, tint: Color, onChange: (Int) -> Unit) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween,
+    ) {
+        Text(label, style = MaterialTheme.typography.bodyMedium)
+        Text("$value", style = MaterialTheme.typography.bodyMedium)
+    }
+    Slider(
+        value = value.toFloat(),
+        onValueChange = { onChange(it.toInt()) },
+        valueRange = 0f..255f,
+        colors = SliderDefaults.colors(thumbColor = tint, activeTrackColor = tint),
+    )
+}
+
+private enum class SubColorType(val label: String, val property: String) {
+    Text("Text", "sub-color"),
+    Border("Border", "sub-border-color"),
+    Background("BG", "sub-back-color"),
+}
+
+private fun Int.copyAsArgb(
+    alpha: Int = this.alpha,
+    red: Int = this.red,
+    green: Int = this.green,
+    blue: Int = this.blue,
+) = (alpha shl 24) or (red shl 16) or (green shl 8) or blue
+
+@OptIn(ExperimentalStdlibApi::class)
+private fun Int.toColorHexString() = "#" + this.toHexString().uppercase()
+
+private fun getCurrentColor(type: SubColorType): Int {
+    return try {
+        MPVLib.getPropertyString(type.property)?.let {
+            android.graphics.Color.parseColor(it.uppercase())
+        } ?: android.graphics.Color.WHITE
+    } catch (_: Exception) {
+        android.graphics.Color.WHITE
+    }
+}
+
+@OptIn(ExperimentalStdlibApi::class)
+private fun applyColor(preferences: SubtitlePreferences, type: SubColorType, color: Int) {
+    val hex = color.toColorHexString()
+    MPVLib.setPropertyString(type.property, hex)
+    when (type) {
+        SubColorType.Text -> preferences.textColorSubtitles().set(color)
+        SubColorType.Border -> preferences.borderColorSubtitles().set(color)
+        SubColorType.Background -> preferences.backgroundColorSubtitles().set(color)
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/VideoFiltersPanel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/VideoFiltersPanel.kt
new file mode 100644
index 0000000000..44130ab5a1
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/panels/VideoFiltersPanel.kt
@@ -0,0 +1,128 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.panels
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Slider
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import eu.kanade.tachiyomi.ui.player.VideoFilters
+import eu.kanade.tachiyomi.ui.player.setting.DecoderPreferences
+import `is`.xyz.mpv.MPVLib
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+@Composable
+fun VideoFiltersPanel(
+    onDismiss: () -> Unit,
+) {
+    val decoderPreferences = remember { Injekt.get<DecoderPreferences>() }
+    var resetKey by remember { mutableStateOf(0) }
+
+    Dialog(onDismissRequest = onDismiss) {
+        Surface(
+            shape = MaterialTheme.shapes.extraLarge,
+            color = MaterialTheme.colorScheme.surface,
+            tonalElevation = 6.dp,
+        ) {
+            Column(modifier = Modifier.padding(24.dp)) {
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.SpaceBetween,
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Text(stringResource(MR.strings.player_video_filters), style = MaterialTheme.typography.titleLarge)
+                    IconButton(onClick = onDismiss) {
+                        Icon(Icons.Default.Close, contentDescription = stringResource(MR.strings.action_close))
+                    }
+                }
+
+                VideoFilters.entries.forEach { filter ->
+                    FilterSlider(
+                        key = resetKey,
+                        filter = filter,
+                        decoderPreferences = decoderPreferences,
+                    )
+                }
+
+                Button(
+                    onClick = {
+                        VideoFilters.entries.forEach {
+                            MPVLib.setPropertyInt(it.mpvProperty, 0)
+                            persistFilter(decoderPreferences, it, 0)
+                        }
+                        resetKey++
+                    },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(top = 8.dp),
+                ) {
+                    Text(stringResource(MR.strings.player_reset_all))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun FilterSlider(
+    key: Int,
+    filter: VideoFilters,
+    decoderPreferences: DecoderPreferences,
+) {
+    var value by remember(key) {
+        mutableIntStateOf(MPVLib.getPropertyInt(filter.mpvProperty) ?: 0)
+    }
+
+    Column(modifier = Modifier.padding(vertical = 4.dp)) {
+        Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.SpaceBetween,
+        ) {
+            Text(
+                filter.name.lowercase().replaceFirstChar { it.uppercase() },
+                style = MaterialTheme.typography.bodyMedium,
+            )
+            Text("$value", style = MaterialTheme.typography.bodyMedium)
+        }
+        Slider(
+            value = value.toFloat(),
+            onValueChange = {
+                value = it.toInt()
+                MPVLib.setPropertyInt(filter.mpvProperty, value)
+                persistFilter(decoderPreferences, filter, value)
+            },
+            valueRange = -100f..100f,
+        )
+    }
+}
+
+private fun persistFilter(prefs: DecoderPreferences, filter: VideoFilters, value: Int) {
+    when (filter) {
+        VideoFilters.BRIGHTNESS -> prefs.brightnessFilter().set(value)
+        VideoFilters.SATURATION -> prefs.saturationFilter().set(value)
+        VideoFilters.CONTRAST -> prefs.contrastFilter().set(value)
+        VideoFilters.GAMMA -> prefs.gammaFilter().set(value)
+        VideoFilters.HUE -> prefs.hueFilter().set(value)
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ChaptersSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ChaptersSheet.kt
new file mode 100644
index 0000000000..413fc5ee51
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ChaptersSheet.kt
@@ -0,0 +1,81 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.sheets
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import dev.vivvvek.seeker.Segment
+import eu.kanade.tachiyomi.ui.player.controls.components.IndexedSegment
+import eu.kanade.tachiyomi.ui.player.formatTime
+import kotlinx.collections.immutable.ImmutableList
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.material.padding
+import tachiyomi.presentation.core.i18n.stringResource
+
+@Composable
+fun ChaptersSheet(
+    chapters: ImmutableList<IndexedSegment>,
+    currentChapter: IndexedSegment?,
+    onClick: (IndexedSegment) -> Unit,
+    onDismissRequest: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    GenericTracksSheet(
+        tracks = chapters,
+        header = {
+            TrackSheetTitle(
+                title = stringResource(MR.strings.player_sheets_chapters_title),
+                modifier = modifier.padding(top = MaterialTheme.padding.small),
+            )
+        },
+        track = { chapter ->
+            ChapterTrack(
+                chapter = chapter,
+                index = chapters.indexOf(chapter),
+                selected = currentChapter == chapter,
+                onClick = { onClick(chapter) },
+            )
+        },
+        onDismissRequest = onDismissRequest,
+        modifier = modifier,
+    )
+}
+
+@Composable
+fun ChapterTrack(
+    chapter: IndexedSegment,
+    index: Int,
+    selected: Boolean,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(vertical = MaterialTheme.padding.small, horizontal = MaterialTheme.padding.medium),
+        horizontalArrangement = Arrangement.SpaceBetween,
+    ) {
+        Text(
+            "${index + 1}. ${chapter.name}",
+            fontStyle = if (selected) FontStyle.Italic else FontStyle.Normal,
+            fontWeight = if (selected) FontWeight.ExtraBold else FontWeight.Normal,
+            maxLines = 1,
+            modifier = Modifier.weight(1f),
+            overflow = TextOverflow.Ellipsis,
+        )
+        Text(
+            formatTime(chapter.start.toLong()),
+            fontStyle = if (selected) FontStyle.Italic else FontStyle.Normal,
+            fontWeight = if (selected) FontWeight.ExtraBold else FontWeight.Normal,
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/GenericTracksSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/GenericTracksSheet.kt
new file mode 100644
index 0000000000..8225aacb61
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/GenericTracksSheet.kt
@@ -0,0 +1,73 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.sheets
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import eu.kanade.presentation.player.components.PlayerSheet
+import kotlinx.collections.immutable.ImmutableList
+import tachiyomi.presentation.core.components.material.padding
+
+@Composable
+fun <T> GenericTracksSheet(
+    tracks: ImmutableList<T>,
+    onDismissRequest: () -> Unit,
+    modifier: Modifier = Modifier,
+    dismissEvent: Boolean = false,
+    header: @Composable () -> Unit = {},
+    track: @Composable (T) -> Unit = {},
+    footer: @Composable () -> Unit = {},
+) {
+    PlayerSheet(onDismissRequest, dismissEvent = dismissEvent) {
+        Column(modifier) {
+            header()
+            LazyColumn {
+                items(tracks) {
+                    track(it)
+                }
+                item {
+                    footer()
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun TrackSheetTitle(
+    title: String,
+    modifier: Modifier = Modifier,
+    actions: @Composable RowScope.() -> Unit = {},
+) {
+    Row(
+        modifier = modifier.fillMaxWidth()
+            .padding(
+                start = MaterialTheme.padding.medium,
+                end = MaterialTheme.padding.medium,
+                top = MaterialTheme.padding.small,
+                bottom = MaterialTheme.padding.extraSmall,
+            ),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = title,
+            style = MaterialTheme.typography.headlineMedium,
+        )
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.extraSmall),
+        ) {
+            actions()
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/MoreSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/MoreSheet.kt
new file mode 100644
index 0000000000..afd5626c28
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/MoreSheet.kt
@@ -0,0 +1,210 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.sheets
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Alarm
+import androidx.compose.material.icons.filled.AlarmOff
+import androidx.compose.material.icons.filled.GraphicEq
+import androidx.compose.material.icons.filled.MusicNote
+import androidx.compose.material.icons.filled.Speed
+import androidx.compose.material.icons.filled.Subtitles
+import androidx.compose.material.icons.filled.TextFields
+import androidx.compose.material.icons.filled.Tune
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.rememberModalBottomSheetState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.unit.dp
+import eu.kanade.tachiyomi.ui.player.controls.components.panels.DelayPanel
+import eu.kanade.tachiyomi.ui.player.controls.components.panels.SubtitleSettingsPanel
+import eu.kanade.tachiyomi.ui.player.controls.components.panels.VideoFiltersPanel
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun MoreSheet(
+    currentSpeed: Float,
+    onSpeedSelected: (Float) -> Unit,
+    onToggleStats: () -> Unit = {},
+    onDismiss: () -> Unit,
+    remainingTimerSeconds: Int? = null,
+    onStartTimer: (Int) -> Unit = {},
+    onCancelTimer: () -> Unit = {},
+) {
+    var showSubtitleDelay by remember { mutableStateOf(false) }
+    var showSubtitleSettings by remember { mutableStateOf(false) }
+    var showAudioDelay by remember { mutableStateOf(false) }
+    var showVideoFilters by remember { mutableStateOf(false) }
+    var showSpeedSheet by remember { mutableStateOf(false) }
+    var showTimerDialog by remember { mutableStateOf(false) }
+
+    if (showSubtitleSettings) {
+        SubtitleSettingsPanel(onDismiss = { showSubtitleSettings = false })
+        return
+    }
+    if (showSubtitleDelay) {
+        DelayPanel(title = stringResource(MR.strings.player_subtitle_delay), mpvProperty = "sub-delay", onDismiss = { showSubtitleDelay = false })
+        return
+    }
+    if (showAudioDelay) {
+        DelayPanel(title = stringResource(MR.strings.player_audio_delay), mpvProperty = "audio-delay", onDismiss = { showAudioDelay = false })
+        return
+    }
+    if (showVideoFilters) {
+        VideoFiltersPanel(onDismiss = { showVideoFilters = false })
+        return
+    }
+    if (showSpeedSheet) {
+        SpeedSheet(
+            currentSpeed = currentSpeed,
+            onSpeedSelected = {
+                onSpeedSelected(it)
+                showSpeedSheet = false
+            },
+            onDismiss = { showSpeedSheet = false },
+        )
+        return
+    }
+
+    ModalBottomSheet(
+        onDismissRequest = onDismiss,
+        sheetState = rememberModalBottomSheetState(),
+    ) {
+        Column(modifier = Modifier.padding(bottom = 24.dp)) {
+            MoreSheetItem(
+                icon = Icons.Default.Speed,
+                title = stringResource(MR.strings.player_playback_speed_with_value, currentSpeed.toString()),
+                onClick = { showSpeedSheet = true },
+            )
+            MoreSheetItem(
+                icon = Icons.Default.TextFields,
+                title = stringResource(MR.strings.player_subtitle_settings),
+                onClick = { showSubtitleSettings = true },
+            )
+            MoreSheetItem(
+                icon = Icons.Default.Subtitles,
+                title = stringResource(MR.strings.player_subtitle_delay),
+                onClick = { showSubtitleDelay = true },
+            )
+            MoreSheetItem(
+                icon = Icons.Default.MusicNote,
+                title = stringResource(MR.strings.player_audio_delay),
+                onClick = { showAudioDelay = true },
+            )
+            MoreSheetItem(
+                icon = Icons.Default.Tune,
+                title = stringResource(MR.strings.player_video_filters),
+                onClick = { showVideoFilters = true },
+            )
+            MoreSheetItem(
+                icon = Icons.Default.GraphicEq,
+                title = stringResource(MR.strings.player_statistics),
+                onClick = onToggleStats,
+            )
+
+            if (remainingTimerSeconds != null) {
+                val mins = remainingTimerSeconds / 60
+                val secs = remainingTimerSeconds % 60
+                MoreSheetItem(
+                    icon = Icons.Default.AlarmOff,
+                    title = stringResource(MR.strings.player_sleep_timer_active, "${mins}:${"%02d".format(secs)}"),
+                    onClick = {
+                        onCancelTimer()
+                        onDismiss()
+                    },
+                )
+            } else {
+                MoreSheetItem(
+                    icon = Icons.Default.Alarm,
+                    title = stringResource(MR.strings.player_sleep_timer),
+                    onClick = { showTimerDialog = true },
+                )
+            }
+        }
+    }
+
+    if (showTimerDialog) {
+        SleepTimerDialog(
+            onSelectDuration = { minutes ->
+                onStartTimer(minutes * 60)
+                showTimerDialog = false
+                onDismiss()
+            },
+            onDismiss = { showTimerDialog = false },
+        )
+    }
+}
+
+@Composable
+private fun SleepTimerDialog(
+    onSelectDuration: (Int) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(stringResource(MR.strings.player_sleep_timer)) },
+        text = {
+            Column(verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                listOf(15, 30, 45, 60).forEach { minutes ->
+                    TextButton(
+                        onClick = { onSelectDuration(minutes) },
+                        modifier = Modifier.fillMaxWidth(),
+                    ) {
+                        Text(stringResource(MR.strings.player_sleep_timer_minutes, minutes))
+                    }
+                }
+            }
+        },
+        confirmButton = {},
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text(stringResource(MR.strings.action_cancel))
+            }
+        },
+    )
+}
+
+@Composable
+private fun MoreSheetItem(
+    icon: ImageVector,
+    title: String,
+    onClick: () -> Unit,
+) {
+    Row(
+        verticalAlignment = Alignment.CenterVertically,
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(horizontal = 24.dp, vertical = 14.dp),
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = null,
+            modifier = Modifier.size(24.dp),
+        )
+        Text(
+            text = title,
+            style = MaterialTheme.typography.bodyLarge,
+            modifier = Modifier.padding(start = 16.dp),
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ScreenshotSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ScreenshotSheet.kt
new file mode 100644
index 0000000000..e0dbf46a42
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ScreenshotSheet.kt
@@ -0,0 +1,110 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.sheets
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Photo
+import androidx.compose.material.icons.outlined.Save
+import androidx.compose.material.icons.outlined.Share
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import eu.kanade.presentation.player.components.PlayerSheet
+import eu.kanade.presentation.player.components.SwitchPreference
+import eu.kanade.tachiyomi.ui.player.controls.components.dialogs.PlayerDialog
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.ActionButton
+import tachiyomi.presentation.core.components.material.padding
+import tachiyomi.presentation.core.i18n.stringResource
+import java.io.InputStream
+
+@Composable
+fun ScreenshotSheet(
+    hasSubTracks: Boolean,
+    showSubtitles: Boolean,
+    onToggleShowSubtitles: (Boolean) -> Unit,
+    cachePath: String,
+    onSetAsCover: (() -> InputStream) -> Unit,
+    onShare: (() -> InputStream) -> Unit,
+    onSave: (() -> InputStream) -> Unit,
+    takeScreenshot: (String, Boolean) -> InputStream?,
+    onDismissRequest: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    var showSetCoverDialog by remember { mutableStateOf(false) }
+
+    PlayerSheet(
+        onDismissRequest,
+        modifier,
+    ) {
+        Column {
+            Row(
+                modifier = Modifier.padding(vertical = MaterialTheme.padding.medium),
+                horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.small),
+            ) {
+                ActionButton(
+                    modifier = Modifier.weight(1f),
+                    title = stringResource(MR.strings.action_edit),
+                    icon = Icons.Outlined.Photo,
+                    onClick = { showSetCoverDialog = true },
+                )
+                ActionButton(
+                    modifier = Modifier.weight(1f),
+                    title = stringResource(MR.strings.action_share),
+                    icon = Icons.Outlined.Share,
+                    onClick = {
+                        takeScreenshot(cachePath, showSubtitles)?.let { stream ->
+                            onShare { stream }
+                        }
+                    },
+                )
+                ActionButton(
+                    modifier = Modifier.weight(1f),
+                    title = stringResource(MR.strings.action_save),
+                    icon = Icons.Outlined.Save,
+                    onClick = {
+                        takeScreenshot(cachePath, showSubtitles)?.let { stream ->
+                            onSave { stream }
+                        }
+                    },
+                )
+            }
+
+            if (hasSubTracks) {
+                SwitchPreference(
+                    value = showSubtitles,
+                    onValueChange = onToggleShowSubtitles,
+                    modifier = Modifier.padding(MaterialTheme.padding.medium),
+                    content = {
+                        Text(
+                            text = stringResource(MR.strings.screenshot_show_subs),
+                            style = MaterialTheme.typography.labelLarge,
+                            color = MaterialTheme.colorScheme.primary,
+                        )
+                    },
+                )
+            }
+        }
+    }
+
+    if (showSetCoverDialog) {
+        PlayerDialog(
+            title = stringResource(MR.strings.confirm_set_image_as_cover),
+            modifier = Modifier.fillMaxWidth(fraction = 0.6F).padding(MaterialTheme.padding.medium),
+            onConfirmRequest = {
+                takeScreenshot(cachePath, showSubtitles)?.let { stream ->
+                    onSetAsCover { stream }
+                }
+            },
+            onDismissRequest = { showSetCoverDialog = false },
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/SpeedSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/SpeedSheet.kt
new file mode 100644
index 0000000000..32d956af37
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/SpeedSheet.kt
@@ -0,0 +1,77 @@
+package eu.kanade.tachiyomi.ui.player.controls.components.sheets
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.RadioButton
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.minimumInteractiveComponentSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+@Composable
+fun SpeedSheet(
+    currentSpeed: Float,
+    onSpeedSelected: (Float) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    val playerPreferences = remember { Injekt.get<PlayerPreferences>() }
+    val speeds = remember {
+        playerPreferences.speedPresets().get()
+            .mapNotNull { it.toFloatOrNull() }
+            .sorted()
+            .ifEmpty { listOf(0.25f, 0.5f, 0.75f, 1.0f, 1.25f, 1.5f, 1.75f, 2.0f) }
+    }
+    Dialog(onDismissRequest = onDismiss) {
+        Surface(
+            shape = MaterialTheme.shapes.extraLarge,
+            color = MaterialTheme.colorScheme.surface,
+            tonalElevation = 6.dp,
+        ) {
+            Column(modifier = Modifier.padding(vertical = 16.dp)) {
+                Text(
+                    text = stringResource(MR.strings.player_playback_speed),
+                    style = MaterialTheme.typography.titleMedium,
+                    modifier = Modifier.padding(horizontal = 24.dp, vertical = 8.dp),
+                )
+                speeds.forEach { speed ->
+                    androidx.compose.foundation.layout.Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        modifier = Modifier
+                            .clip(RoundedCornerShape(8.dp))
+                            .selectable(
+                                selected = speed == currentSpeed,
+                                onClick = { onSpeedSelected(speed) },
+                            )
+                            .fillMaxWidth()
+                            .minimumInteractiveComponentSize(),
+                    ) {
+                        RadioButton(
+                            selected = speed == currentSpeed,
+                            onClick = null,
+                        )
+                        Text(
+                            text = "${speed}x",
+                            style = MaterialTheme.typography.bodyLarge,
+                            modifier = Modifier.padding(start = 24.dp),
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
index 84cd6c09d8..afb7e3af82 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/MPVView.kt
@@ -6,6 +6,12 @@ import android.graphics.Bitmap
 import android.view.SurfaceHolder
 import android.view.SurfaceView
 import androidx.core.content.ContextCompat
+import eu.kanade.tachiyomi.ui.player.Debanding
+import eu.kanade.tachiyomi.ui.player.VideoFilters
+import eu.kanade.tachiyomi.ui.player.setting.AudioChannels
+import eu.kanade.tachiyomi.ui.player.setting.AudioPreferences
+import eu.kanade.tachiyomi.ui.player.setting.DecoderPreferences
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
 import eu.kanade.tachiyomi.util.system.isDebugBuildType
 import `is`.xyz.mpv.MPVLib
 import java.io.File
@@ -22,7 +28,13 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
         holder.addCallback(this)
     }
 
-    fun initialize(configDir: String, cacheDir: String) {
+    fun initialize(
+        configDir: String,
+        cacheDir: String,
+        decoderPreferences: DecoderPreferences? = null,
+        audioPreferences: AudioPreferences? = null,
+        subtitlePreferences: SubtitlePreferences? = null,
+    ) {
         if (isInitialized) return
 
         File(configDir).mkdirs()
@@ -38,17 +50,33 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
         MPVLib.setOptionString("icc-cache-dir", cacheDir)
         MPVLib.setOptionString("gpu-context", "android")
         MPVLib.setOptionString("opengl-es", "yes")
-        MPVLib.setOptionString("vo", "gpu")
+        MPVLib.setOptionString("vo", if (decoderPreferences?.gpuNext()?.get() == true) "gpu-next" else "gpu")
         MPVLib.setOptionString("ao", "audiotrack")
-        MPVLib.setOptionString("hwdec", "mediacodec-copy")
+
+        val hwdec = if (decoderPreferences?.tryHWDecoding()?.get() != false) "mediacodec-copy" else "no"
+        MPVLib.setOptionString("hwdec", hwdec)
         MPVLib.setOptionString("hwdec-codecs", "all")
         MPVLib.setOptionString("save-position-on-quit", "no")
         MPVLib.setOptionString("keep-open", "always")
         MPVLib.setOptionString("demux-max-bytes", "32MiB")
         MPVLib.setOptionString("demux-max-back-bytes", "16MiB")
         MPVLib.setOptionString("sub-auto", "fuzzy")
-        MPVLib.setOptionString("sub-font-size", "36")
-        MPVLib.setOptionString("sub-border-size", "3")
+
+        if (decoderPreferences?.useYUV420P()?.get() != false) {
+            MPVLib.setOptionString("vf", "format=yuv420p")
+        }
+
+        when (decoderPreferences?.videoDebanding()?.get()) {
+            Debanding.CPU -> MPVLib.setOptionString("deband", "yes")
+            Debanding.GPU -> {
+                MPVLib.setOptionString("deband", "yes")
+                MPVLib.setOptionString("deband-grain", "0")
+            }
+            else -> {}
+        }
+
+        applySubtitleOptions(subtitlePreferences)
+        applyAudioOptions(audioPreferences)
 
         try {
             val display = ContextCompat.getDisplayOrDefault(context)
@@ -63,12 +91,78 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
         MPVLib.setOptionString("idle", "once")
         MPVLib.setPropertyString("sub-visibility", "no")
 
+        applyVideoFilters(decoderPreferences)
+
         MPVLib.observeProperty(PROP_TIME_POS, MPVLib.mpvFormat.MPV_FORMAT_INT64)
         MPVLib.observeProperty(PROP_DURATION, MPVLib.mpvFormat.MPV_FORMAT_INT64)
         MPVLib.observeProperty(PROP_PAUSE, MPVLib.mpvFormat.MPV_FORMAT_FLAG)
         MPVLib.observeProperty(PROP_EOF_REACHED, MPVLib.mpvFormat.MPV_FORMAT_FLAG)
         MPVLib.observeProperty(PROP_SUB_TEXT, MPVLib.mpvFormat.MPV_FORMAT_STRING)
         MPVLib.observeProperty(PROP_TRACK_LIST, MPVLib.mpvFormat.MPV_FORMAT_NONE)
+        MPVLib.observeProperty("chapter-list", MPVLib.mpvFormat.MPV_FORMAT_NONE)
+    }
+
+    private fun applySubtitleOptions(prefs: SubtitlePreferences?) {
+        if (prefs == null) {
+            MPVLib.setOptionString("sub-font-size", "36")
+            MPVLib.setOptionString("sub-border-size", "3")
+            return
+        }
+        MPVLib.setOptionString("sub-font-size", prefs.subtitleFontSize().get().toString())
+        MPVLib.setOptionString("sub-border-size", prefs.subtitleBorderSize().get().toString())
+        MPVLib.setOptionString("sub-shadow-offset", prefs.shadowOffsetSubtitles().get().toString())
+        MPVLib.setOptionString("sub-bold", if (prefs.boldSubtitles().get()) "yes" else "no")
+        MPVLib.setOptionString("sub-italic", if (prefs.italicSubtitles().get()) "yes" else "no")
+        MPVLib.setOptionString("sub-scale", prefs.subtitleFontScale().get().toString())
+        MPVLib.setOptionString("sub-pos", prefs.subtitlePos().get().toString())
+        if (prefs.overrideSubsASS().get()) {
+            MPVLib.setOptionString("sub-ass-override", "force")
+        }
+        val subDelay = prefs.subtitlesDelay().get()
+        if (subDelay != 0) {
+            MPVLib.setOptionString("sub-delay", (subDelay / 1000.0).toString())
+        }
+        val subSpeed = prefs.subtitlesSpeed().get()
+        if (subSpeed != 1f) {
+            MPVLib.setOptionString("sub-speed", subSpeed.toString())
+        }
+    }
+
+    private fun applyAudioOptions(prefs: AudioPreferences?) {
+        if (prefs == null) return
+        if (prefs.enablePitchCorrection().get()) {
+            MPVLib.setOptionString("audio-pitch-correction", "yes")
+        } else {
+            MPVLib.setOptionString("audio-pitch-correction", "no")
+        }
+        val channels = prefs.audioChannels().get()
+        if (channels == AudioChannels.ReverseStereo) {
+            MPVLib.setOptionString("af", "pan=[stereo|c0=c1|c1=c0]")
+        } else {
+            MPVLib.setOptionString(channels.property, channels.value)
+        }
+        val boostCap = prefs.volumeBoostCap().get()
+        if (boostCap > 0) {
+            MPVLib.setOptionString("volume-max", (100 + boostCap).toString())
+        }
+        val audioDelay = prefs.audioDelay().get()
+        if (audioDelay != 0) {
+            MPVLib.setOptionString("audio-delay", (audioDelay / 1000.0).toString())
+        }
+    }
+
+    private fun applyVideoFilters(prefs: DecoderPreferences?) {
+        if (prefs == null) return
+        val brightness = prefs.brightnessFilter().get()
+        val saturation = prefs.saturationFilter().get()
+        val contrast = prefs.contrastFilter().get()
+        val gamma = prefs.gammaFilter().get()
+        val hue = prefs.hueFilter().get()
+        if (brightness != 0) MPVLib.setPropertyInt(VideoFilters.BRIGHTNESS.mpvProperty, brightness)
+        if (saturation != 0) MPVLib.setPropertyInt(VideoFilters.SATURATION.mpvProperty, saturation)
+        if (contrast != 0) MPVLib.setPropertyInt(VideoFilters.CONTRAST.mpvProperty, contrast)
+        if (gamma != 0) MPVLib.setPropertyInt(VideoFilters.GAMMA.mpvProperty, gamma)
+        if (hue != 0) MPVLib.setPropertyInt(VideoFilters.HUE.mpvProperty, hue)
     }
 
     override fun surfaceCreated(holder: SurfaceHolder) {
@@ -90,6 +184,8 @@ class MPVView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
     override fun surfaceDestroyed(holder: SurfaceHolder) {
         MPVLib.setOptionString("force-window", "no")
         MPVLib.detachSurface()
+        lastSurfaceWidth = -1
+        lastSurfaceHeight = -1
     }
 
     fun playFile(url: String, startPositionSec: Long = 0, headers: Map<String, String>? = null) {
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
index e9bb681823..f26a429bd6 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/mpv/PlayerObserver.kt
@@ -11,11 +11,13 @@ class PlayerObserver(
     private val onEofReached: () -> Unit = {},
     private val onSubTextChanged: (text: String) -> Unit = {},
     private val onTrackListChanged: () -> Unit = {},
+    private val onChapterListChanged: () -> Unit = {},
 ) : MPVLib.EventObserver {
 
     override fun eventProperty(property: String) {
         when (property) {
             MPVView.PROP_TRACK_LIST -> onTrackListChanged()
+            PROP_CHAPTER_LIST -> onChapterListChanged()
         }
     }
 
@@ -52,4 +54,8 @@ class PlayerObserver(
             MPVView.PROP_DURATION -> onDurationChanged(value)
         }
     }
+
+    companion object {
+        const val PROP_CHAPTER_LIST = "chapter-list"
+    }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/AdvancedPlayerPreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/AdvancedPlayerPreferences.kt
new file mode 100644
index 0000000000..70ec2d1ad0
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/AdvancedPlayerPreferences.kt
@@ -0,0 +1,11 @@
+package eu.kanade.tachiyomi.ui.player.setting
+
+import tachiyomi.core.common.preference.PreferenceStore
+
+class AdvancedPlayerPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+    fun mpvConf() = preferenceStore.getString("pref_mpv_conf", "")
+    fun mpvInput() = preferenceStore.getString("pref_mpv_input", "")
+    fun playerStatisticsPage() = preferenceStore.getInt("pref_player_statistics_page", 0)
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/AudioPreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/AudioPreferences.kt
new file mode 100644
index 0000000000..1499907f87
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/AudioPreferences.kt
@@ -0,0 +1,23 @@
+package eu.kanade.tachiyomi.ui.player.setting
+
+import tachiyomi.core.common.preference.PreferenceStore
+import tachiyomi.core.common.preference.getEnum
+
+class AudioPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+    fun preferredAudioLanguages() = preferenceStore.getString("pref_audio_lang", "")
+    fun enablePitchCorrection() = preferenceStore.getBoolean("pref_audio_pitch_correction", true)
+    fun audioChannels() = preferenceStore.getEnum("pref_audio_config", AudioChannels.AutoSafe)
+    fun volumeBoostCap() = preferenceStore.getInt("pref_audio_volume_boost_cap", 30)
+
+    fun audioDelay() = preferenceStore.getInt("pref_audio_delay", 0)
+}
+
+enum class AudioChannels(val property: String, val value: String) {
+    Auto("audio-channels", "auto-safe"),
+    AutoSafe("audio-channels", "auto"),
+    Mono("audio-channels", "mono"),
+    Stereo("audio-channels", "stereo"),
+    ReverseStereo("af", "pan=[stereo|c0=c1|c1=c0]"),
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/DecoderPreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/DecoderPreferences.kt
new file mode 100644
index 0000000000..b2a23a706d
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/DecoderPreferences.kt
@@ -0,0 +1,20 @@
+package eu.kanade.tachiyomi.ui.player.setting
+
+import eu.kanade.tachiyomi.ui.player.Debanding
+import tachiyomi.core.common.preference.PreferenceStore
+import tachiyomi.core.common.preference.getEnum
+
+class DecoderPreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+    fun tryHWDecoding() = preferenceStore.getBoolean("pref_try_hwdec", true)
+    fun gpuNext() = preferenceStore.getBoolean("pref_gpu_next", false)
+    fun videoDebanding() = preferenceStore.getEnum("pref_video_debanding", Debanding.None)
+    fun useYUV420P() = preferenceStore.getBoolean("use_yuv420p", true)
+
+    fun brightnessFilter() = preferenceStore.getInt("pref_player_filter_brightness")
+    fun saturationFilter() = preferenceStore.getInt("pref_player_filter_saturation")
+    fun contrastFilter() = preferenceStore.getInt("pref_player_filter_contrast")
+    fun gammaFilter() = preferenceStore.getInt("pref_player_filter_gamma")
+    fun hueFilter() = preferenceStore.getInt("pref_player_filter_hue")
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/GesturePreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/GesturePreferences.kt
new file mode 100644
index 0000000000..4e4f50454e
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/GesturePreferences.kt
@@ -0,0 +1,23 @@
+package eu.kanade.tachiyomi.ui.player.setting
+
+import eu.kanade.tachiyomi.ui.player.SingleActionGesture
+import tachiyomi.core.common.preference.PreferenceStore
+import tachiyomi.core.common.preference.getEnum
+
+class GesturePreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+    fun gestureVolumeBrightness() = preferenceStore.getBoolean(
+        "pref_gesture_volume_brightness",
+        true,
+    )
+    fun swapVolumeBrightness() = preferenceStore.getBoolean("pref_swap_volume_and_brightness", false)
+
+    fun gestureHorizontalSeek() = preferenceStore.getBoolean("pref_gesture_horizontal_seek", true)
+    fun skipLengthPreference() = preferenceStore.getInt("pref_skip_length_preference", 10)
+    fun playerSmoothSeek() = preferenceStore.getBoolean("pref_player_smooth_seek", false)
+
+    fun leftDoubleTapGesture() = preferenceStore.getEnum("pref_left_double_tap", SingleActionGesture.Seek)
+    fun centerDoubleTapGesture() = preferenceStore.getEnum("pref_center_double_tap", SingleActionGesture.PlayPause)
+    fun rightDoubleTapGesture() = preferenceStore.getEnum("pref_right_double_tap", SingleActionGesture.Seek)
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
index bd88fee098..656eb0b47c 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
@@ -1,6 +1,8 @@
 package eu.kanade.tachiyomi.ui.player.setting
 
+import eu.kanade.tachiyomi.ui.player.VideoAspect
 import tachiyomi.core.common.preference.PreferenceStore
+import tachiyomi.core.common.preference.getEnum
 
 class PlayerPreferences(
     private val preferenceStore: PreferenceStore,
@@ -11,11 +13,62 @@ class PlayerPreferences(
         PlayerOrientation.FREE.flag,
     )
 
-    fun doubleTapSeekLength() = preferenceStore.getInt("player_double_tap_seek_length", 10)
-
     fun keepScreenOn() = preferenceStore.getBoolean("player_keep_screen_on", true)
 
     fun progressSaveIntervalSec() = preferenceStore.getInt("player_progress_save_interval", 5)
 
-    fun preferredSubLanguage() = preferenceStore.getString("player_preferred_sub_language", "")
+    // Controls
+
+    fun showLoadingCircle() = preferenceStore.getBoolean("pref_show_loading", true)
+    fun rememberPlayerBrightness() = preferenceStore.getBoolean("pref_remember_brightness", false)
+    fun playerBrightnessValue() = preferenceStore.getFloat("player_brightness_value", -1.0f)
+    fun rememberPlayerVolume() = preferenceStore.getBoolean("pref_remember_volume", false)
+    fun playerVolumeValue() = preferenceStore.getFloat("player_volume_value", -1.0f)
+    fun playerTimeToDisappear() = preferenceStore.getInt("pref_player_time_to_disappear", 4000)
+
+    // Display
+
+    fun playerFullscreen() = preferenceStore.getBoolean("player_fullscreen", true)
+    fun reduceMotion() = preferenceStore.getBoolean("pref_reduce_motion", false)
+
+    // PiP
+
+    fun enablePip() = preferenceStore.getBoolean("pref_enable_pip", true)
+    fun pipOnExit() = preferenceStore.getBoolean("pref_pip_on_exit", true)
+
+    // External player
+
+    fun alwaysUseExternalPlayer() = preferenceStore.getBoolean(
+        "pref_always_use_external_player",
+        false,
+    )
+    fun externalPlayerPreference() = preferenceStore.getString("external_player_preference", "")
+
+    // Non-preferences
+
+    fun playerSpeed() = preferenceStore.getFloat("pref_player_speed", 1f)
+    fun speedPresets() = preferenceStore.getStringSet(
+        "default_speed_presets",
+        setOf("0.25", "0.5", "0.75", "1.0", "1.25", "1.5", "1.75", "2.0"),
+    )
+    fun aspectState() = preferenceStore.getEnum("pref_player_aspect_state", VideoAspect.Fit)
+    fun autoplayEnabled() = preferenceStore.getBoolean("pref_auto_play_enabled", false)
+
+    // AniSkip
+    fun aniSkipEnabled() = preferenceStore.getBoolean("pref_aniskip_enabled", false)
+    fun enableSkipIntro() = preferenceStore.getBoolean("pref_enable_skip_intro", true)
+    fun autoSkipIntro() = preferenceStore.getBoolean("pref_auto_skip_intro", false)
+    fun enableNetflixStyleIntroSkip() = preferenceStore.getBoolean("pref_netflix_style_intro_skip", false)
+    fun waitingTimeIntroSkip() = preferenceStore.getInt("pref_waiting_time_intro_skip", 5)
+
+    // Chapter display
+    fun showCurrentChapter() = preferenceStore.getBoolean("pref_show_current_chapter", true)
+
+    // Progress
+    fun progressPreference() = preferenceStore.getFloat("pref_progress_preference", 0.85f)
+    fun preserveWatchingPosition() = preferenceStore.getBoolean("pref_preserve_watching_position", false)
+
+    fun doubleTapSeekLength() = preferenceStore.getInt("pref_double_tap_seek_length", 10)
+
+    fun customSubtitlesForEpisode(episodeId: Long) = preferenceStore.getString("custom_subs_$episodeId", "")
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/SubtitlePreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/SubtitlePreferences.kt
new file mode 100644
index 0000000000..d46d074a09
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/SubtitlePreferences.kt
@@ -0,0 +1,46 @@
+package eu.kanade.tachiyomi.ui.player.setting
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import tachiyomi.core.common.preference.PreferenceStore
+import tachiyomi.core.common.preference.getEnum
+
+class SubtitlePreferences(
+    private val preferenceStore: PreferenceStore,
+) {
+    fun preferredSubLanguages() = preferenceStore.getString("pref_subtitle_lang", "")
+
+    fun subtitleFont() = preferenceStore.getString("pref_subtitle_font", "Sans Serif")
+    fun subtitleFontSize() = preferenceStore.getInt("pref_subtitles_font_size", 55)
+    fun subtitleFontScale() = preferenceStore.getFloat("pref_sub_scale", 1f)
+    fun subtitleBorderSize() = preferenceStore.getInt("pref_sub_border_size", 3)
+    fun boldSubtitles() = preferenceStore.getBoolean("pref_bold_subtitles", false)
+    fun italicSubtitles() = preferenceStore.getBoolean("pref_italic_subtitles", false)
+
+    fun textColorSubtitles() = preferenceStore.getInt("pref_text_color_subtitles", Color.White.toArgb())
+    fun borderColorSubtitles() = preferenceStore.getInt("pref_border_color_subtitles", Color.Black.toArgb())
+    fun borderStyleSubtitles() = preferenceStore.getEnum(
+        "pref_border_style_subtitles",
+        SubtitlesBorderStyle.OutlineAndShadow,
+    )
+    fun shadowOffsetSubtitles() = preferenceStore.getInt("sub_shadow_offset", 0)
+    fun backgroundColorSubtitles() = preferenceStore.getInt(
+        "pref_background_color_subtitles",
+        Color.Transparent.toArgb(),
+    )
+
+    fun subtitlePos() = preferenceStore.getInt("pref_sub_pos", 100)
+    fun overrideSubsASS() = preferenceStore.getBoolean("pref_override_subtitles_ass", false)
+
+    fun subtitlesDelay() = preferenceStore.getInt("pref_subtitles_delay", 0)
+    fun subtitlesSpeed() = preferenceStore.getFloat("pref_subtitles_speed", 1f)
+    fun subtitlesSecondaryDelay() = preferenceStore.getInt("pref_subtitles_secondary_delay", 0)
+
+    fun screenshotSubtitles() = preferenceStore.getBoolean("pref_screenshot_subtitles", false)
+}
+
+enum class SubtitlesBorderStyle(val value: Int) {
+    OutlineAndShadow(1),
+    OpaqueBox(3),
+    BackgroundBox(4),
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/AniSkipApi.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/AniSkipApi.kt
new file mode 100644
index 0000000000..4cf748c0d9
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/AniSkipApi.kt
@@ -0,0 +1,121 @@
+package eu.kanade.tachiyomi.ui.player.utils
+
+import eu.kanade.tachiyomi.animesource.model.ChapterType
+import eu.kanade.tachiyomi.animesource.model.TimeStamp
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.network.jsonMime
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
+import okhttp3.OkHttpClient
+import okhttp3.RequestBody.Companion.toRequestBody
+import uy.kohesive.injekt.injectLazy
+
+class AniSkipApi {
+    private val client = OkHttpClient()
+    private val json: Json by injectLazy()
+
+    fun getResult(malId: Int, episodeNumber: Int, episodeLength: Long): List<TimeStamp>? {
+        val url =
+            "https://api.aniskip.com/v2/skip-times/$malId/$episodeNumber?types[]=ed" +
+                "&types[]=mixed-ed&types[]=mixed-op&types[]=op&types[]=recap&episodeLength=$episodeLength"
+        return try {
+            val a = client.newCall(GET(url)).execute().body.string()
+            val res = json.decodeFromString<AniSkipResponse>(a)
+            if (res.found) {
+                res.results?.map {
+                    TimeStamp(
+                        start = it.interval.startTime,
+                        end = it.interval.endTime,
+                        name = it.skipType.getString(),
+                        type = it.skipType.toChapterType(),
+                    )
+                }
+            } else {
+                null
+            }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    fun getMalIdFromAL(id: Long): Long {
+        val query = """
+                query{
+                Media(id:$id){idMal}
+                }
+        """.trimIndent()
+        val response = try {
+            client.newCall(
+                POST(
+                    "https://graphql.anilist.co",
+                    body = buildJsonObject { put("query", query) }.toString()
+                        .toRequestBody(jsonMime),
+                ),
+            ).execute()
+        } catch (_: Exception) {
+            return 0
+        }
+        return response.body.string().substringAfter("idMal\":").substringBefore("}")
+            .toLongOrNull() ?: 0
+    }
+}
+
+@Serializable
+data class AniSkipResponse(
+    val found: Boolean,
+    val results: List<Stamp>?,
+)
+
+@Serializable
+data class Stamp(
+    val interval: AniSkipInterval,
+    val skipType: SkipType,
+)
+
+@Serializable
+enum class SkipType {
+    @SerialName("op")
+    OP,
+
+    @SerialName("ed")
+    ED,
+
+    @SerialName("recap")
+    RECAP,
+
+    @SerialName("mixed-op")
+    MIXED_OP,
+
+    @SerialName("mixed-ed")
+    MIXED_ED, ;
+
+    fun getString(): String {
+        return when (this) {
+            OP -> "Opening"
+            ED -> "Ending"
+            RECAP -> "Recap"
+            MIXED_OP -> "Mixed-op"
+            MIXED_ED -> "Mixed-ed"
+        }
+    }
+
+    fun toChapterType(): ChapterType {
+        return when (this) {
+            OP -> ChapterType.Opening
+            ED -> ChapterType.Ending
+            RECAP -> ChapterType.Recap
+            MIXED_OP -> ChapterType.MixedOp
+            MIXED_ED -> ChapterType.MixedEd
+        }
+    }
+}
+
+@Serializable
+data class AniSkipInterval(
+    val startTime: Double,
+    val endTime: Double,
+)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/ChapterUtils.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/ChapterUtils.kt
new file mode 100644
index 0000000000..5261341ab0
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/ChapterUtils.kt
@@ -0,0 +1,94 @@
+package eu.kanade.tachiyomi.ui.player.utils
+
+import androidx.compose.ui.graphics.Color
+import eu.kanade.tachiyomi.animesource.model.ChapterType
+import eu.kanade.tachiyomi.animesource.model.TimeStamp
+import eu.kanade.tachiyomi.ui.player.controls.components.IndexedSegment
+import kotlin.math.abs
+
+class ChapterUtils {
+    companion object {
+        fun mergeChapters(
+            currentChapters: List<IndexedSegment>,
+            stamps: List<TimeStamp>,
+            duration: Int? = null,
+        ): List<IndexedSegment> {
+            val sortedStamps = stamps.sortedBy { it.start }
+            val chapters = sortedStamps.mapIndexed { i, it ->
+                val startTime = if (i == 0 && it.start < 1.0) {
+                    0.0
+                } else {
+                    it.start
+                }
+                val startChapter = IndexedSegment(
+                    index = -2,
+                    name = it.name,
+                    start = startTime.toFloat(),
+                    color = if (it.type == ChapterType.Other) Color.Unspecified else Color(0xFFD8BBDF),
+                    chapterType = it.type,
+                )
+                val nextStart = sortedStamps.getOrNull(i + 1)?.start
+                val isNotLastChapter = abs(it.end - (duration?.toDouble() ?: -2.0)) > 1.0
+                val isNotAdjacent = nextStart == null || (abs(it.end - nextStart) > 1.0)
+                if (isNotLastChapter && isNotAdjacent) {
+                    val endChapter = IndexedSegment(
+                        index = -1,
+                        name = "",
+                        start = it.end.toFloat(),
+                    )
+                    return@mapIndexed listOf(startChapter, endChapter)
+                } else {
+                    listOf(startChapter)
+                }
+            }.flatten()
+            val playerChapters = currentChapters.filter { playerChapter ->
+                chapters.none { chapter ->
+                    abs(chapter.start - playerChapter.start) < 1.0 && chapter.index == -2
+                }
+            }.map {
+                IndexedSegment(it.name, it.start, it.color, chapterType = it.chapterType)
+            }.sortedBy { it.start }.mapIndexed { i, it ->
+                if (i == 0 && it.start < 1.0) {
+                    IndexedSegment(
+                        it.name,
+                        0.0f,
+                        index = it.index,
+                        chapterType = it.chapterType,
+                    )
+                } else {
+                    it
+                }
+            }
+            val filteredChapters = chapters.filter { chapter ->
+                playerChapters.none { playerChapter ->
+                    abs(chapter.start - playerChapter.start) < 1.0 && chapter.index != -2
+                }
+            }
+            val startChapter = if ((playerChapters + filteredChapters).isNotEmpty() &&
+                playerChapters.none { it.start == 0.0f } &&
+                filteredChapters.none { it.start == 0.0f }
+            ) {
+                listOf(
+                    IndexedSegment(
+                        index = -1,
+                        name = "",
+                        start = 0.0f,
+                    ),
+                )
+            } else {
+                emptyList()
+            }
+
+            val combined = (startChapter + playerChapters + filteredChapters).sortedBy { it.start }
+
+            return combined.filterIndexed { index, segment ->
+                if (index == 0) {
+                    true
+                } else {
+                    val previousSegment = combined[index - 1]
+                    !(segment.name.isEmpty() && previousSegment.name.isEmpty())
+                }
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/TrackSelect.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/TrackSelect.kt
new file mode 100644
index 0000000000..e216d92c6e
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/utils/TrackSelect.kt
@@ -0,0 +1,52 @@
+package eu.kanade.tachiyomi.ui.player.utils
+
+import androidx.core.os.LocaleListCompat
+import eu.kanade.tachiyomi.ui.player.mpv.MPVView
+import eu.kanade.tachiyomi.ui.player.setting.AudioPreferences
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.util.Locale
+
+class TrackSelect(
+    private val subtitlePreferences: SubtitlePreferences = Injekt.get(),
+    private val audioPreferences: AudioPreferences = Injekt.get(),
+) {
+
+    fun getPreferredSubTrack(tracks: List<MPVView.Track>): MPVView.Track? {
+        return getPreferredTrack(tracks, subtitlePreferences.preferredSubLanguages().get())
+    }
+
+    fun getPreferredAudioTrack(tracks: List<MPVView.Track>): MPVView.Track? {
+        return getPreferredTrack(tracks, audioPreferences.preferredAudioLanguages().get())
+    }
+
+    private fun getPreferredTrack(tracks: List<MPVView.Track>, prefLangsStr: String): MPVView.Track? {
+        if (tracks.isEmpty()) return null
+
+        val prefLangs = prefLangsStr.split(",").filter { it.isNotEmpty() }
+        val locales = prefLangs.map { Locale(it) }.ifEmpty {
+            listOf(LocaleListCompat.getDefault()[0] ?: Locale.getDefault())
+        }
+
+        val matchers = locales.mapNotNull { locale ->
+            if (locale.language.isNullOrEmpty()) return@mapNotNull null
+            val englishName = locale.getDisplayName(Locale.ENGLISH).substringBefore(" (")
+            val iso3 = try { locale.isO3Language } catch (_: Exception) { null }
+            val pattern = listOfNotNull(iso3, locale.language).joinToString("|")
+            val langRegex = Regex("""\b$pattern\b""", RegexOption.IGNORE_CASE)
+            Triple(locale, englishName, langRegex)
+        }
+
+        val chosen = matchers.firstOrNull { (_, name, regex) ->
+            tracks.any { matchesLang(it, name, regex) }
+        } ?: return null
+
+        return tracks.firstOrNull { matchesLang(it, chosen.second, chosen.third) }
+    }
+
+    private fun matchesLang(track: MPVView.Track, englishName: String, langRegex: Regex): Boolean {
+        return track.name.contains(englishName, ignoreCase = true) ||
+            track.language?.let { langRegex.containsMatchIn(it) } == true
+    }
+}
diff --git a/app/src/main/res/drawable/ic_play_seek_triangle.xml b/app/src/main/res/drawable/ic_play_seek_triangle.xml
new file mode 100644
index 0000000000..822c545bec
--- /dev/null
+++ b/app/src/main/res/drawable/ic_play_seek_triangle.xml
@@ -0,0 +1,11 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="16dp"
+    android:height="20dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M3,2 L22,12 L3,22 Z" />
+
+</vector>
diff --git a/app/src/main/res/drawable/ic_skip_next_24dp.xml b/app/src/main/res/drawable/ic_skip_next_24dp.xml
new file mode 100644
index 0000000000..274f550797
--- /dev/null
+++ b/app/src/main/res/drawable/ic_skip_next_24dp.xml
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="?attr/colorControlNormal">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M6,18l8.5,-6L6,6v12zM16,6v12h2V6h-2z"/>
+</vector>
diff --git a/app/src/main/res/drawable/ic_skip_previous_24dp.xml b/app/src/main/res/drawable/ic_skip_previous_24dp.xml
new file mode 100644
index 0000000000..c859fedd34
--- /dev/null
+++ b/app/src/main/res/drawable/ic_skip_previous_24dp.xml
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24"
+    android:tint="?attr/colorControlNormal">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M6,6h2v12H6V6zM9.5,12l8.5,6V6L9.5,12z"/>
+</vector>
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c580385e83..3c981f9a54 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -17,6 +17,9 @@ image-cropper = "4.7.0"
 datastore = "1.1.2"
 media3 = "1.5.1"
 aniyomi-mpv-lib = "1.17.n"
+seeker = "1.2.2"
+media = "1.7.1"
+truetypeparser = "2.1.4"
 ffmpeg-kit = "1.17"
 
 
@@ -81,6 +84,12 @@ media3-exoplayer = { module = "androidx.media3:media3-exoplayer", version.ref =
 media3-common = { module = "androidx.media3:media3-common", version.ref = "media3" }
 
 aniyomi-mpv = { module = "com.github.aniyomiorg:aniyomi-mpv-lib", version.ref = "aniyomi-mpv-lib" }
+seeker = { module = "io.github.2307vivek:seeker", version.ref = "seeker" }
+mediasession = { module = "androidx.media:media", version.ref = "media" }
+truetypeparser = { module = "io.github.yubyf:truetypeparser-light", version.ref = "truetypeparser" }
+torrentserver = "com.github.Diegopyl1209:torrentserver-aniyomi:c18f58e51b"
+media-router = "androidx.mediarouter:mediarouter:1.8.1"
+cast-play-services = "com.google.android.gms:play-services-cast-framework:22.1.0"
 ffmpeg-kit = { module = "com.github.jmir1:ffmpeg-kit", version.ref = "ffmpeg-kit" }
 smart-exception-java = "com.arthenica:smart-exception-java:0.2.1"
 
diff --git a/i18n/src/commonMain/moko-resources/base/strings.xml b/i18n/src/commonMain/moko-resources/base/strings.xml
index 13a31255e8..1eaa21043a 100644
--- a/i18n/src/commonMain/moko-resources/base/strings.xml
+++ b/i18n/src/commonMain/moko-resources/base/strings.xml
@@ -1171,4 +1171,55 @@
     <string name="player_subtitles">Subtitles</string>
     <string name="player_audio">Audio</string>
     <string name="player_tracks">Tracks</string>
+    <string name="player_skip_action">Skip %1$s</string>
+    <string name="player_intro_skipped">%1$s skipped</string>
+    <string name="player_chapter_type_opening">Opening</string>
+    <string name="player_chapter_type_ending">Ending</string>
+    <string name="player_chapter_type_recap">Recap</string>
+    <string name="player_chapter_type_mixedop">Mixed opening</string>
+    <string name="player_aniskip_dontskip">Don\'t skip</string>
+    <string name="player_aniskip_dontskip_toast">Skipping %1$s in %2$d seconds</string>
+    <string name="player_aniskip_skip">%1$s skipped</string>
+    <string name="player_sheets_chapters_title">Chapters</string>
+    <string name="player_sheets_track_title_wo_lang">%1$d. %2$s</string>
+    <string name="player_episodes">Episodes</string>
+    <string name="player_lock">Lock</string>
+    <string name="player_unlock">Unlock</string>
+    <string name="player_speed">Speed</string>
+    <string name="player_more">More</string>
+    <string name="player_previous">Previous</string>
+    <string name="player_next">Next</string>
+    <string name="player_aspect_ratio">Aspect ratio</string>
+    <string name="player_rotate">Rotate</string>
+    <string name="player_add_subtitle_file">Add subtitle file</string>
+    <string name="player_playback_speed">Playback Speed</string>
+    <string name="player_playback_speed_with_value">Playback Speed (%1$sx)</string>
+    <string name="player_subtitle_settings">Subtitle Settings</string>
+    <string name="player_subtitle_delay">Subtitle Delay</string>
+    <string name="player_audio_delay">Audio Delay</string>
+    <string name="player_video_filters">Video Filters</string>
+    <string name="player_statistics">Statistics</string>
+    <string name="player_reset_all">Reset All</string>
+    <string name="player_subtitle_typography">Typography</string>
+    <string name="player_subtitle_colors">Colors</string>
+    <string name="player_subtitle_misc">Misc</string>
+    <string name="player_subtitle_font_size">Font Size</string>
+    <string name="player_subtitle_border_size">Border Size</string>
+    <string name="player_subtitle_shadow_offset">Shadow Offset</string>
+    <string name="player_subtitle_scale">Scale</string>
+    <string name="player_subtitle_position">Position</string>
+    <string name="player_subtitle_color_text">Text</string>
+    <string name="player_subtitle_color_border">Border</string>
+    <string name="player_subtitle_color_bg">BG</string>
+    <string name="player_subtitle_color_red">Red</string>
+    <string name="player_subtitle_color_green">Green</string>
+    <string name="player_subtitle_color_blue">Blue</string>
+    <string name="player_subtitle_color_alpha">Alpha</string>
+    <string name="player_reset_color">Reset %1$s</string>
+    <string name="screenshot_show_subs">Include Subtitles</string>
+    <string name="confirm_set_image_as_cover">Set image as cover?</string>
+    <string name="player_sleep_timer">Sleep Timer</string>
+    <string name="player_sleep_timer_active">Sleep Timer (%1$s)</string>
+    <string name="player_sleep_timer_minutes">%1$d minutes</string>
+    <string name="player_screenshot">Screenshot</string>
 </resources>
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
index db12d0153e..df3dedffd1 100644
--- a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
@@ -15,6 +15,7 @@ enum class ChapterType {
     Ending,
     Recap,
     MixedOp,
+    MixedEd,
     Other,
 }
 

From ecafc4bad4250337ec75d97775836e745ff5bd9e Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sun, 10 May 2026 04:59:37 +0200
Subject: [PATCH 11/13] More details in anime detail screens

---
 .../kanade/presentation/anime/AnimeScreen.kt  | 621 +++++++++++++++---
 .../anime/EpisodeSettingsDialog.kt            | 124 ++++
 .../anime/components/AnimeBottomActionMenu.kt | 217 ++++++
 .../anime/components/AnimeEpisodeListItem.kt  |  11 +-
 .../anime/components/AnimeInfoHeader.kt       |   7 +-
 .../anime/components/AnimeToolbar.kt          | 112 ++++
 .../anime/components/EpisodeHeader.kt         |  45 ++
 .../kanade/tachiyomi/ui/anime/AnimeScreen.kt  |  41 +-
 .../tachiyomi/ui/anime/AnimeScreenModel.kt    | 320 +++++++--
 .../eu/kanade/tachiyomi/ui/anime/AnimeTab.kt  |  85 ++-
 .../globalsearch/GlobalAnimeSearchScreen.kt   | 217 ++++++
 .../GlobalAnimeSearchScreenModel.kt           | 135 ++++
 12 files changed, 1751 insertions(+), 184 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/EpisodeSettingsDialog.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/components/AnimeBottomActionMenu.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/components/AnimeToolbar.kt
 create mode 100644 app/src/main/java/eu/kanade/presentation/anime/components/EpisodeHeader.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/globalsearch/GlobalAnimeSearchScreen.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/globalsearch/GlobalAnimeSearchScreenModel.kt

diff --git a/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt b/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
index 45b9f26456..ce595dcd5f 100644
--- a/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
@@ -1,147 +1,157 @@
 package eu.kanade.presentation.anime
 
-import androidx.compose.foundation.clickable
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.calculateEndPadding
+import androidx.compose.foundation.layout.calculateStartPadding
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListScope
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.outlined.ArrowBack
-import androidx.compose.material.icons.filled.Delete
 import androidx.compose.material.icons.filled.PlayArrow
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.CircularProgressIndicator
-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
-import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SmallExtendedFloatingActionButton
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
-import androidx.compose.material3.TopAppBar
-import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.material3.animateFloatingActionButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.foundation.clickable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.input.nestedscroll.nestedScroll
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.dp
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.util.fastAll
+import androidx.compose.ui.util.fastAny
+import androidx.compose.ui.util.fastMap
+import eu.kanade.presentation.anime.components.AnimeBottomActionMenu
 import eu.kanade.presentation.anime.components.AnimeEpisodeListItem
 import eu.kanade.presentation.anime.components.AnimeInfoHeader
+import eu.kanade.presentation.anime.components.AnimeToolbar
+import eu.kanade.presentation.anime.components.EpisodeHeader
 import eu.kanade.tachiyomi.animesource.model.Video
+import tachiyomi.core.common.preference.TriState
 import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
 import eu.kanade.tachiyomi.ui.anime.AnimeScreenModel
+import eu.kanade.tachiyomi.ui.anime.EpisodeList
 import tachiyomi.domain.episode.model.Episode
 import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.TwoPanelBox
+import tachiyomi.presentation.core.components.VerticalFastScroller
+import tachiyomi.presentation.core.components.material.PullRefresh
 import tachiyomi.presentation.core.components.material.Scaffold
 import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.util.shouldExpandFAB
 
-@OptIn(ExperimentalMaterial3Api::class)
 @Composable
-fun AnimeScreenContent(
+fun AnimeScreen(
     state: AnimeScreenModel.State.Success,
+    snackbarHostState: SnackbarHostState,
+    isTabletUi: Boolean,
     navigateUp: () -> Unit,
     onEpisodeClicked: (Episode) -> Unit,
     onContinueWatching: () -> Unit,
-    onToggleFavorite: () -> Unit,
-    onDeleteClicked: () -> Unit,
-    onDismissDialog: () -> Unit,
-    onConfirmDelete: () -> Unit,
-    onDownloadEpisode: (Episode) -> Unit = {},
-    onDeleteEpisodeDownload: (Episode) -> Unit = {},
+    onAddToLibraryClicked: () -> Unit,
+    onTagSearch: (String) -> Unit,
+    onFilterButtonClicked: () -> Unit,
+    onRefresh: () -> Unit,
+    onShareClicked: (() -> Unit)? = null,
+    onEditCategoryClicked: (() -> Unit)? = null,
+    onCoverClicked: () -> Unit = {},
+    onDownloadEpisode: (EpisodeList.Item) -> Unit = {},
+    onDeleteEpisodeDownload: (EpisodeList.Item) -> Unit = {},
     onConfirmDownloadQuality: (Episode, Video) -> Unit = { _, _ -> },
+    onMultiBookmarkClicked: (List<Episode>, bookmarked: Boolean) -> Unit,
+    onMultiMarkAsSeenClicked: (List<Episode>, markAsSeen: Boolean) -> Unit,
+    onMarkPreviousAsSeenClicked: (Episode) -> Unit,
+    onMultiDeleteClicked: (List<Episode>) -> Unit,
+    onEpisodeSelected: (EpisodeList.Item, Boolean, Boolean, Boolean) -> Unit,
+    onAllEpisodeSelected: (Boolean) -> Unit,
+    onInvertSelection: () -> Unit,
+    onUnseenFilterChanged: (TriState) -> Unit = {},
+    onBookmarkedFilterChanged: (TriState) -> Unit = {},
+    onSortModeChanged: (Long) -> Unit = {},
+    onDisplayModeChanged: (Long) -> Unit = {},
+    onDismissDialog: () -> Unit,
+    onDeleteClicked: () -> Unit = {},
+    onConfirmDelete: () -> Unit = {},
 ) {
-    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
-
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = {
-                    Text(
-                        text = state.anime.title,
-                        maxLines = 1,
-                        overflow = TextOverflow.Ellipsis,
-                    )
-                },
-                navigationIcon = {
-                    IconButton(onClick = navigateUp) {
-                        Icon(
-                            imageVector = Icons.AutoMirrored.Outlined.ArrowBack,
-                            contentDescription = null,
-                        )
-                    }
-                },
-                actions = {
-                    IconButton(onClick = onDeleteClicked) {
-                        Icon(
-                            imageVector = Icons.Filled.Delete,
-                            contentDescription = stringResource(MR.strings.action_delete),
-                        )
-                    }
-                },
-                scrollBehavior = scrollBehavior,
-            )
-        },
-        floatingActionButton = {
-            if (state.nextUnseenEpisode != null) {
-                SmallExtendedFloatingActionButton(
-                    onClick = onContinueWatching,
-                    icon = {
-                        Icon(
-                            imageVector = Icons.Filled.PlayArrow,
-                            contentDescription = null,
-                        )
-                    },
-                    text = { Text(stringResource(MR.strings.anime_continue_watching)) },
-                )
-            }
-        },
-    ) { contentPadding ->
-        LazyColumn(
-            contentPadding = PaddingValues(
-                bottom = contentPadding.calculateBottomPadding() + 80.dp,
-            ),
-            modifier = Modifier
-                .padding(top = contentPadding.calculateTopPadding())
-                .nestedScroll(scrollBehavior.nestedScrollConnection),
-        ) {
-            item(key = "info_header") {
-                AnimeInfoHeader(
-                    anime = state.anime,
-                    onFavoriteToggle = onToggleFavorite,
-                )
-            }
-
-            item(key = "episode_header") {
-                HorizontalDivider()
-                Text(
-                    text = stringResource(MR.strings.anime_episode_count, state.allEpisodeCount),
-                    style = MaterialTheme.typography.titleSmall,
-                    color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
-                )
-            }
-
-            items(
-                items = state.episodes,
-                key = { it.id },
-            ) { episode ->
-                val dlState = state.episodeDownloadState[episode.id]
-                AnimeEpisodeListItem(
-                    episode = episode,
-                    downloadState = dlState?.status ?: AnimeDownload.State.NOT_DOWNLOADED,
-                    downloadProgress = dlState?.progress ?: 0,
-                    onClick = { onEpisodeClicked(episode) },
-                    onDownloadClick = { onDownloadEpisode(episode) },
-                    onDeleteDownloadClick = { onDeleteEpisodeDownload(episode) },
-                )
-                HorizontalDivider()
-            }
-        }
+    if (!isTabletUi) {
+        AnimeScreenSmallImpl(
+            state = state,
+            snackbarHostState = snackbarHostState,
+            navigateUp = navigateUp,
+            onEpisodeClicked = onEpisodeClicked,
+            onContinueWatching = onContinueWatching,
+            onAddToLibraryClicked = onAddToLibraryClicked,
+            onTagSearch = onTagSearch,
+            onFilterClicked = onFilterButtonClicked,
+            onRefresh = onRefresh,
+            onShareClicked = onShareClicked,
+            onEditCategoryClicked = onEditCategoryClicked,
+            onCoverClicked = onCoverClicked,
+            onDownloadEpisode = onDownloadEpisode,
+            onDeleteEpisodeDownload = onDeleteEpisodeDownload,
+            onMultiBookmarkClicked = onMultiBookmarkClicked,
+            onMultiMarkAsSeenClicked = onMultiMarkAsSeenClicked,
+            onMarkPreviousAsSeenClicked = onMarkPreviousAsSeenClicked,
+            onMultiDeleteClicked = onMultiDeleteClicked,
+            onEpisodeSelected = onEpisodeSelected,
+            onAllEpisodeSelected = onAllEpisodeSelected,
+            onInvertSelection = onInvertSelection,
+        )
+    } else {
+        AnimeScreenLargeImpl(
+            state = state,
+            snackbarHostState = snackbarHostState,
+            navigateUp = navigateUp,
+            onEpisodeClicked = onEpisodeClicked,
+            onContinueWatching = onContinueWatching,
+            onAddToLibraryClicked = onAddToLibraryClicked,
+            onTagSearch = onTagSearch,
+            onFilterClicked = onFilterButtonClicked,
+            onRefresh = onRefresh,
+            onShareClicked = onShareClicked,
+            onEditCategoryClicked = onEditCategoryClicked,
+            onCoverClicked = onCoverClicked,
+            onDownloadEpisode = onDownloadEpisode,
+            onDeleteEpisodeDownload = onDeleteEpisodeDownload,
+            onMultiBookmarkClicked = onMultiBookmarkClicked,
+            onMultiMarkAsSeenClicked = onMultiMarkAsSeenClicked,
+            onMarkPreviousAsSeenClicked = onMarkPreviousAsSeenClicked,
+            onMultiDeleteClicked = onMultiDeleteClicked,
+            onEpisodeSelected = onEpisodeSelected,
+            onAllEpisodeSelected = onAllEpisodeSelected,
+            onInvertSelection = onInvertSelection,
+        )
     }
 
+    // Dialogs
     when (val dialog = state.dialog) {
+        is AnimeScreenModel.Dialog.SettingsSheet -> {
+            EpisodeSettingsDialog(
+                onDismissRequest = onDismissDialog,
+                anime = state.anime,
+                onUnseenFilterChanged = onUnseenFilterChanged,
+                onBookmarkedFilterChanged = onBookmarkedFilterChanged,
+                onSortModeChanged = onSortModeChanged,
+                onDisplayModeChanged = onDisplayModeChanged,
+            )
+        }
         is AnimeScreenModel.Dialog.ConfirmDelete -> {
             AlertDialog(
                 onDismissRequest = onDismissDialog,
@@ -206,3 +216,402 @@ fun AnimeScreenContent(
         null -> {}
     }
 }
+
+@Composable
+private fun AnimeScreenSmallImpl(
+    state: AnimeScreenModel.State.Success,
+    snackbarHostState: SnackbarHostState,
+    navigateUp: () -> Unit,
+    onEpisodeClicked: (Episode) -> Unit,
+    onContinueWatching: () -> Unit,
+    onAddToLibraryClicked: () -> Unit,
+    onTagSearch: (String) -> Unit,
+    onFilterClicked: () -> Unit,
+    onRefresh: () -> Unit,
+    onShareClicked: (() -> Unit)?,
+    onEditCategoryClicked: (() -> Unit)?,
+    onCoverClicked: () -> Unit,
+    onDownloadEpisode: (EpisodeList.Item) -> Unit,
+    onDeleteEpisodeDownload: (EpisodeList.Item) -> Unit,
+    onMultiBookmarkClicked: (List<Episode>, bookmarked: Boolean) -> Unit,
+    onMultiMarkAsSeenClicked: (List<Episode>, markAsSeen: Boolean) -> Unit,
+    onMarkPreviousAsSeenClicked: (Episode) -> Unit,
+    onMultiDeleteClicked: (List<Episode>) -> Unit,
+    onEpisodeSelected: (EpisodeList.Item, Boolean, Boolean, Boolean) -> Unit,
+    onAllEpisodeSelected: (Boolean) -> Unit,
+    onInvertSelection: () -> Unit,
+) {
+    val episodeListState = rememberLazyListState()
+
+    val (episodes, isAnySelected) = remember(state) {
+        Pair(state.episodes, state.isAnySelected)
+    }
+
+    BackHandler(onBack = {
+        if (isAnySelected) {
+            onAllEpisodeSelected(false)
+        } else {
+            navigateUp()
+        }
+    })
+
+    Scaffold(
+        topBar = {
+            val selectedEpisodeCount = remember(episodes) {
+                episodes.count { it.selected }
+            }
+            val isFirstItemVisible by remember {
+                derivedStateOf { episodeListState.firstVisibleItemIndex == 0 }
+            }
+            val isFirstItemScrolled by remember {
+                derivedStateOf { episodeListState.firstVisibleItemScrollOffset > 0 }
+            }
+            val titleAlpha by animateFloatAsState(
+                if (!isFirstItemVisible) 1f else 0f,
+                label = "Top Bar Title",
+            )
+            val backgroundAlpha by animateFloatAsState(
+                if (!isFirstItemVisible || isFirstItemScrolled) 1f else 0f,
+                label = "Top Bar Background",
+            )
+            AnimeToolbar(
+                title = state.anime.title,
+                hasFilters = state.filterActive,
+                navigateUp = navigateUp,
+                onClickFilter = onFilterClicked,
+                onClickRefresh = onRefresh,
+                onClickShare = onShareClicked,
+                onClickEditCategory = onEditCategoryClicked,
+                actionModeCounter = selectedEpisodeCount,
+                onCancelActionMode = { onAllEpisodeSelected(false) },
+                onSelectAll = { onAllEpisodeSelected(true) },
+                onInvertSelection = onInvertSelection,
+                titleAlphaProvider = { titleAlpha },
+                backgroundAlphaProvider = { backgroundAlpha },
+            )
+        },
+        bottomBar = {
+            val selectedEpisodes = remember(episodes) {
+                episodes.filter { it.selected }
+            }
+            SharedAnimeBottomActionMenu(
+                selected = selectedEpisodes,
+                onMultiBookmarkClicked = onMultiBookmarkClicked,
+                onMultiMarkAsSeenClicked = onMultiMarkAsSeenClicked,
+                onMarkPreviousAsSeenClicked = onMarkPreviousAsSeenClicked,
+                onMultiDeleteClicked = onMultiDeleteClicked,
+            )
+        },
+        snackbarHost = { SnackbarHost(hostState = snackbarHostState) },
+        floatingActionButton = {
+            val isFABVisible = remember(episodes) {
+                episodes.fastAny { !it.episode.seen } && !isAnySelected
+            }
+            SmallExtendedFloatingActionButton(
+                text = {
+                    val isWatching = remember(state.episodes) {
+                        state.episodes.fastAny { it.episode.seen }
+                    }
+                    Text(
+                        text = stringResource(
+                            if (isWatching) MR.strings.action_resume else MR.strings.action_start,
+                        ),
+                    )
+                },
+                icon = { Icon(imageVector = Icons.Filled.PlayArrow, contentDescription = null) },
+                onClick = onContinueWatching,
+                expanded = episodeListState.shouldExpandFAB(),
+                modifier = Modifier.animateFloatingActionButton(
+                    visible = isFABVisible,
+                    alignment = Alignment.BottomEnd,
+                ),
+            )
+        },
+    ) { contentPadding ->
+        PullRefresh(
+            refreshing = state.isRefreshingData,
+            onRefresh = onRefresh,
+            enabled = !isAnySelected,
+            indicatorPadding = contentPadding,
+        ) {
+            val layoutDirection = LocalLayoutDirection.current
+            VerticalFastScroller(
+                listState = episodeListState,
+                topContentPadding = contentPadding.calculateTopPadding(),
+                endContentPadding = contentPadding.calculateEndPadding(layoutDirection),
+            ) {
+                LazyColumn(
+                    modifier = Modifier.fillMaxHeight(),
+                    state = episodeListState,
+                    contentPadding = PaddingValues(
+                        start = contentPadding.calculateStartPadding(layoutDirection),
+                        end = contentPadding.calculateEndPadding(layoutDirection),
+                        bottom = contentPadding.calculateBottomPadding(),
+                    ),
+                ) {
+                    item(
+                        key = AnimeScreenItem.INFO_BOX,
+                        contentType = AnimeScreenItem.INFO_BOX,
+                    ) {
+                        AnimeInfoHeader(
+                            anime = state.anime,
+                            onFavoriteToggle = onAddToLibraryClicked,
+                            onTagSearch = onTagSearch,
+                            onCoverClick = onCoverClicked,
+                        )
+                    }
+
+                    item(
+                        key = AnimeScreenItem.EPISODE_HEADER,
+                        contentType = AnimeScreenItem.EPISODE_HEADER,
+                    ) {
+                        EpisodeHeader(
+                            enabled = !isAnySelected,
+                            episodeCount = state.allEpisodeCount,
+                            onClick = onFilterClicked,
+                        )
+                    }
+
+                    sharedEpisodeItems(
+                        episodes = episodes,
+                        isAnySelected = isAnySelected,
+                        onEpisodeClicked = onEpisodeClicked,
+                        onDownloadEpisode = onDownloadEpisode,
+                        onDeleteEpisodeDownload = onDeleteEpisodeDownload,
+                        onEpisodeSelected = onEpisodeSelected,
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeScreenLargeImpl(
+    state: AnimeScreenModel.State.Success,
+    snackbarHostState: SnackbarHostState,
+    navigateUp: () -> Unit,
+    onEpisodeClicked: (Episode) -> Unit,
+    onContinueWatching: () -> Unit,
+    onAddToLibraryClicked: () -> Unit,
+    onTagSearch: (String) -> Unit,
+    onFilterClicked: () -> Unit,
+    onRefresh: () -> Unit,
+    onShareClicked: (() -> Unit)?,
+    onEditCategoryClicked: (() -> Unit)?,
+    onCoverClicked: () -> Unit,
+    onDownloadEpisode: (EpisodeList.Item) -> Unit,
+    onDeleteEpisodeDownload: (EpisodeList.Item) -> Unit,
+    onMultiBookmarkClicked: (List<Episode>, bookmarked: Boolean) -> Unit,
+    onMultiMarkAsSeenClicked: (List<Episode>, markAsSeen: Boolean) -> Unit,
+    onMarkPreviousAsSeenClicked: (Episode) -> Unit,
+    onMultiDeleteClicked: (List<Episode>) -> Unit,
+    onEpisodeSelected: (EpisodeList.Item, Boolean, Boolean, Boolean) -> Unit,
+    onAllEpisodeSelected: (Boolean) -> Unit,
+    onInvertSelection: () -> Unit,
+) {
+    val episodeListState = rememberLazyListState()
+
+    val (episodes, isAnySelected) = remember(state) {
+        Pair(state.episodes, state.isAnySelected)
+    }
+
+    BackHandler(onBack = {
+        if (isAnySelected) {
+            onAllEpisodeSelected(false)
+        } else {
+            navigateUp()
+        }
+    })
+
+    Scaffold(
+        topBar = {
+            val selectedEpisodeCount = remember(episodes) {
+                episodes.count { it.selected }
+            }
+            AnimeToolbar(
+                title = state.anime.title,
+                hasFilters = state.filterActive,
+                navigateUp = navigateUp,
+                onClickFilter = onFilterClicked,
+                onClickRefresh = onRefresh,
+                onClickShare = onShareClicked,
+                onClickEditCategory = onEditCategoryClicked,
+                actionModeCounter = selectedEpisodeCount,
+                onCancelActionMode = { onAllEpisodeSelected(false) },
+                onSelectAll = { onAllEpisodeSelected(true) },
+                onInvertSelection = onInvertSelection,
+                titleAlphaProvider = { 1f },
+                backgroundAlphaProvider = { 1f },
+            )
+        },
+        bottomBar = {
+            val selectedEpisodes = remember(episodes) {
+                episodes.filter { it.selected }
+            }
+            SharedAnimeBottomActionMenu(
+                selected = selectedEpisodes,
+                onMultiBookmarkClicked = onMultiBookmarkClicked,
+                onMultiMarkAsSeenClicked = onMultiMarkAsSeenClicked,
+                onMarkPreviousAsSeenClicked = onMarkPreviousAsSeenClicked,
+                onMultiDeleteClicked = onMultiDeleteClicked,
+                fillFraction = 0.5f,
+            )
+        },
+        snackbarHost = { SnackbarHost(hostState = snackbarHostState) },
+        floatingActionButton = {
+            val isFABVisible = remember(episodes) {
+                episodes.fastAny { !it.episode.seen } && !isAnySelected
+            }
+            SmallExtendedFloatingActionButton(
+                text = {
+                    val isWatching = remember(state.episodes) {
+                        state.episodes.fastAny { it.episode.seen }
+                    }
+                    Text(
+                        text = stringResource(
+                            if (isWatching) MR.strings.action_resume else MR.strings.action_start,
+                        ),
+                    )
+                },
+                icon = { Icon(imageVector = Icons.Filled.PlayArrow, contentDescription = null) },
+                onClick = onContinueWatching,
+                expanded = episodeListState.shouldExpandFAB(),
+                modifier = Modifier.animateFloatingActionButton(
+                    visible = isFABVisible,
+                    alignment = Alignment.BottomEnd,
+                ),
+            )
+        },
+    ) { contentPadding ->
+        TwoPanelBox(
+            modifier = Modifier.padding(
+                start = contentPadding.calculateStartPadding(LocalLayoutDirection.current),
+                end = contentPadding.calculateEndPadding(LocalLayoutDirection.current),
+            ),
+            startContent = {
+                AnimeInfoHeader(
+                    anime = state.anime,
+                    onFavoriteToggle = onAddToLibraryClicked,
+                    onTagSearch = onTagSearch,
+                    onCoverClick = onCoverClicked,
+                    modifier = Modifier
+                        .verticalScroll(rememberScrollState())
+                        .padding(bottom = contentPadding.calculateBottomPadding()),
+                )
+            },
+            endContent = {
+                VerticalFastScroller(
+                    listState = episodeListState,
+                    topContentPadding = contentPadding.calculateTopPadding(),
+                ) {
+                    LazyColumn(
+                        modifier = Modifier.fillMaxHeight(),
+                        state = episodeListState,
+                        contentPadding = PaddingValues(
+                            top = contentPadding.calculateTopPadding(),
+                            bottom = contentPadding.calculateBottomPadding(),
+                        ),
+                    ) {
+                        item(
+                            key = AnimeScreenItem.EPISODE_HEADER,
+                            contentType = AnimeScreenItem.EPISODE_HEADER,
+                        ) {
+                            EpisodeHeader(
+                                enabled = !isAnySelected,
+                                episodeCount = state.allEpisodeCount,
+                                onClick = onFilterClicked,
+                            )
+                        }
+
+                        sharedEpisodeItems(
+                            episodes = episodes,
+                            isAnySelected = isAnySelected,
+                            onEpisodeClicked = onEpisodeClicked,
+                            onDownloadEpisode = onDownloadEpisode,
+                            onDeleteEpisodeDownload = onDeleteEpisodeDownload,
+                            onEpisodeSelected = onEpisodeSelected,
+                        )
+                    }
+                }
+            },
+        )
+    }
+}
+
+@Composable
+private fun SharedAnimeBottomActionMenu(
+    selected: List<EpisodeList.Item>,
+    onMultiBookmarkClicked: (List<Episode>, bookmarked: Boolean) -> Unit,
+    onMultiMarkAsSeenClicked: (List<Episode>, markAsSeen: Boolean) -> Unit,
+    onMarkPreviousAsSeenClicked: (Episode) -> Unit,
+    onMultiDeleteClicked: (List<Episode>) -> Unit,
+    fillFraction: Float = 1f,
+    modifier: Modifier = Modifier,
+) {
+    AnimeBottomActionMenu(
+        visible = selected.isNotEmpty(),
+        modifier = modifier.fillMaxWidth(fillFraction),
+        onBookmarkClicked = {
+            onMultiBookmarkClicked(selected.fastMap { it.episode }, true)
+        }.takeIf { selected.fastAny { !it.episode.bookmark } },
+        onRemoveBookmarkClicked = {
+            onMultiBookmarkClicked(selected.fastMap { it.episode }, false)
+        }.takeIf { selected.fastAll { it.episode.bookmark } },
+        onMarkAsSeenClicked = {
+            onMultiMarkAsSeenClicked(selected.fastMap { it.episode }, true)
+        }.takeIf { selected.fastAny { !it.episode.seen } },
+        onMarkAsUnseenClicked = {
+            onMultiMarkAsSeenClicked(selected.fastMap { it.episode }, false)
+        }.takeIf { selected.fastAny { it.episode.seen || it.episode.lastSecondSeen > 0L } },
+        onMarkPreviousAsSeenClicked = {
+            onMarkPreviousAsSeenClicked(selected[0].episode)
+        }.takeIf { selected.size == 1 },
+        onDownloadClicked = null,
+        onDeleteClicked = {
+            onMultiDeleteClicked(selected.fastMap { it.episode })
+        }.takeIf {
+            selected.fastAny { it.downloadState == AnimeDownload.State.DOWNLOADED }
+        },
+    )
+}
+
+private fun LazyListScope.sharedEpisodeItems(
+    episodes: List<EpisodeList.Item>,
+    isAnySelected: Boolean,
+    onEpisodeClicked: (Episode) -> Unit,
+    onDownloadEpisode: (EpisodeList.Item) -> Unit,
+    onDeleteEpisodeDownload: (EpisodeList.Item) -> Unit,
+    onEpisodeSelected: (EpisodeList.Item, Boolean, Boolean, Boolean) -> Unit,
+) {
+    items(
+        items = episodes,
+        key = { it.id },
+        contentType = { AnimeScreenItem.EPISODE },
+    ) { item ->
+        AnimeEpisodeListItem(
+            episode = item.episode,
+            downloadState = item.downloadState,
+            downloadProgress = item.downloadProgress,
+            selected = item.selected,
+            onClick = {
+                when {
+                    isAnySelected -> onEpisodeSelected(item, !item.selected, true, false)
+                    else -> onEpisodeClicked(item.episode)
+                }
+            },
+            onLongClick = {
+                onEpisodeSelected(item, !item.selected, true, true)
+            },
+            onDownloadClick = { onDownloadEpisode(item) },
+            onDeleteDownloadClick = { onDeleteEpisodeDownload(item) },
+        )
+        HorizontalDivider()
+    }
+}
+
+private enum class AnimeScreenItem {
+    INFO_BOX,
+    EPISODE_HEADER,
+    EPISODE,
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/EpisodeSettingsDialog.kt b/app/src/main/java/eu/kanade/presentation/anime/EpisodeSettingsDialog.kt
new file mode 100644
index 0000000000..f7ae8d1af3
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/EpisodeSettingsDialog.kt
@@ -0,0 +1,124 @@
+package eu.kanade.presentation.anime
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import eu.kanade.presentation.components.TabbedDialog
+import eu.kanade.presentation.components.TabbedDialogPaddings
+import kotlinx.collections.immutable.persistentListOf
+import tachiyomi.core.common.preference.TriState
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.components.RadioItem
+import tachiyomi.presentation.core.components.SortItem
+import tachiyomi.presentation.core.components.TriStateItem
+import tachiyomi.presentation.core.i18n.stringResource
+
+@Composable
+fun EpisodeSettingsDialog(
+    onDismissRequest: () -> Unit,
+    anime: Anime? = null,
+    onUnseenFilterChanged: (TriState) -> Unit,
+    onBookmarkedFilterChanged: (TriState) -> Unit,
+    onSortModeChanged: (Long) -> Unit,
+    onDisplayModeChanged: (Long) -> Unit,
+) {
+    TabbedDialog(
+        onDismissRequest = onDismissRequest,
+        tabTitles = persistentListOf(
+            stringResource(MR.strings.action_filter),
+            stringResource(MR.strings.action_sort),
+            stringResource(MR.strings.action_display),
+        ),
+    ) { page ->
+        Column(
+            modifier = Modifier
+                .padding(vertical = TabbedDialogPaddings.Vertical)
+                .verticalScroll(rememberScrollState()),
+        ) {
+            when (page) {
+                0 -> {
+                    FilterPage(
+                        unseenFilter = anime?.unseenFilter ?: TriState.DISABLED,
+                        onUnseenFilterChanged = onUnseenFilterChanged,
+                        bookmarkedFilter = anime?.bookmarkedFilter ?: TriState.DISABLED,
+                        onBookmarkedFilterChanged = onBookmarkedFilterChanged,
+                    )
+                }
+                1 -> {
+                    SortPage(
+                        sortingMode = anime?.sorting ?: 0,
+                        sortDescending = anime?.sortDescending() ?: false,
+                        onItemSelected = onSortModeChanged,
+                    )
+                }
+                2 -> {
+                    DisplayPage(
+                        displayMode = anime?.displayMode ?: 0,
+                        onItemSelected = onDisplayModeChanged,
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ColumnScope.FilterPage(
+    unseenFilter: TriState,
+    onUnseenFilterChanged: (TriState) -> Unit,
+    bookmarkedFilter: TriState,
+    onBookmarkedFilterChanged: (TriState) -> Unit,
+) {
+    TriStateItem(
+        label = stringResource(MR.strings.action_filter_unread),
+        state = unseenFilter,
+        onClick = onUnseenFilterChanged,
+    )
+    TriStateItem(
+        label = stringResource(MR.strings.action_filter_bookmarked),
+        state = bookmarkedFilter,
+        onClick = onBookmarkedFilterChanged,
+    )
+}
+
+@Composable
+private fun ColumnScope.SortPage(
+    sortingMode: Long,
+    sortDescending: Boolean,
+    onItemSelected: (Long) -> Unit,
+) {
+    listOf(
+        MR.strings.sort_by_source to Anime.EPISODE_SORTING_SOURCE,
+        MR.strings.sort_by_number to Anime.EPISODE_SORTING_NUMBER,
+        MR.strings.sort_by_upload_date to Anime.EPISODE_SORTING_UPLOAD_DATE,
+        MR.strings.action_sort_alpha to Anime.EPISODE_SORTING_ALPHABET,
+    ).map { (titleRes, mode) ->
+        SortItem(
+            label = stringResource(titleRes),
+            sortDescending = sortDescending.takeIf { sortingMode == mode },
+            onClick = { onItemSelected(mode) },
+        )
+    }
+}
+
+@Composable
+private fun ColumnScope.DisplayPage(
+    displayMode: Long,
+    onItemSelected: (Long) -> Unit,
+) {
+    listOf(
+        MR.strings.show_title to Anime.EPISODE_DISPLAY_NAME,
+        MR.strings.show_chapter_number to Anime.EPISODE_DISPLAY_NUMBER,
+    ).map { (titleRes, mode) ->
+        RadioItem(
+            label = stringResource(titleRes),
+            selected = displayMode == mode,
+            onClick = { onItemSelected(mode) },
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeBottomActionMenu.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeBottomActionMenu.kt
new file mode 100644
index 0000000000..19aede18b8
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeBottomActionMenu.kt
@@ -0,0 +1,217 @@
+package eu.kanade.presentation.anime.components
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.animation.expandVertically
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.animation.shrinkVertically
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.navigationBars
+import androidx.compose.foundation.layout.only
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.ZeroCornerSize
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.BookmarkAdd
+import androidx.compose.material.icons.outlined.BookmarkRemove
+import androidx.compose.material.icons.outlined.Delete
+import androidx.compose.material.icons.outlined.DoneAll
+import androidx.compose.material.icons.outlined.Download
+import androidx.compose.material.icons.outlined.RemoveDone
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.ripple
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.res.vectorResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import eu.kanade.tachiyomi.R
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+import kotlin.time.Duration.Companion.seconds
+
+@Composable
+fun AnimeBottomActionMenu(
+    visible: Boolean,
+    modifier: Modifier = Modifier,
+    onBookmarkClicked: (() -> Unit)? = null,
+    onRemoveBookmarkClicked: (() -> Unit)? = null,
+    onMarkAsSeenClicked: (() -> Unit)? = null,
+    onMarkAsUnseenClicked: (() -> Unit)? = null,
+    onMarkPreviousAsSeenClicked: (() -> Unit)? = null,
+    onDownloadClicked: (() -> Unit)? = null,
+    onDeleteClicked: (() -> Unit)? = null,
+) {
+    AnimatedVisibility(
+        visible = visible,
+        enter = expandVertically(expandFrom = Alignment.Bottom),
+        exit = shrinkVertically(shrinkTowards = Alignment.Bottom),
+    ) {
+        val scope = rememberCoroutineScope()
+        Surface(
+            modifier = modifier,
+            shape = MaterialTheme.shapes.large.copy(bottomEnd = ZeroCornerSize, bottomStart = ZeroCornerSize),
+            color = MaterialTheme.colorScheme.surfaceContainerHigh,
+        ) {
+            val haptic = LocalHapticFeedback.current
+            val confirm = remember { mutableStateListOf(false, false, false, false, false, false, false) }
+            var resetJob by remember { mutableStateOf<Job?>(null) }
+            val onLongClickItem: (Int) -> Unit = { toConfirmIndex ->
+                haptic.performHapticFeedback(HapticFeedbackType.LongPress)
+                confirm.indices.forEach { i -> confirm[i] = i == toConfirmIndex }
+                resetJob?.cancel()
+                resetJob = scope.launch {
+                    delay(1.seconds)
+                    if (isActive) confirm[toConfirmIndex] = false
+                }
+            }
+            Row(
+                modifier = Modifier
+                    .padding(
+                        WindowInsets.navigationBars
+                            .only(WindowInsetsSides.Bottom)
+                            .asPaddingValues(),
+                    )
+                    .padding(horizontal = 8.dp, vertical = 12.dp),
+            ) {
+                if (onBookmarkClicked != null) {
+                    Button(
+                        title = stringResource(MR.strings.action_bookmark),
+                        icon = Icons.Outlined.BookmarkAdd,
+                        toConfirm = confirm[0],
+                        onLongClick = { onLongClickItem(0) },
+                        onClick = onBookmarkClicked,
+                    )
+                }
+                if (onRemoveBookmarkClicked != null) {
+                    Button(
+                        title = stringResource(MR.strings.action_remove_bookmark),
+                        icon = Icons.Outlined.BookmarkRemove,
+                        toConfirm = confirm[1],
+                        onLongClick = { onLongClickItem(1) },
+                        onClick = onRemoveBookmarkClicked,
+                    )
+                }
+                if (onMarkAsSeenClicked != null) {
+                    Button(
+                        title = stringResource(MR.strings.action_mark_as_read),
+                        icon = Icons.Outlined.DoneAll,
+                        toConfirm = confirm[2],
+                        onLongClick = { onLongClickItem(2) },
+                        onClick = onMarkAsSeenClicked,
+                    )
+                }
+                if (onMarkAsUnseenClicked != null) {
+                    Button(
+                        title = stringResource(MR.strings.action_mark_as_unread),
+                        icon = Icons.Outlined.RemoveDone,
+                        toConfirm = confirm[3],
+                        onLongClick = { onLongClickItem(3) },
+                        onClick = onMarkAsUnseenClicked,
+                    )
+                }
+                if (onMarkPreviousAsSeenClicked != null) {
+                    Button(
+                        title = stringResource(MR.strings.action_mark_previous_as_read),
+                        icon = ImageVector.vectorResource(R.drawable.ic_done_prev_24dp),
+                        toConfirm = confirm[4],
+                        onLongClick = { onLongClickItem(4) },
+                        onClick = onMarkPreviousAsSeenClicked,
+                    )
+                }
+                if (onDownloadClicked != null) {
+                    Button(
+                        title = stringResource(MR.strings.action_download),
+                        icon = Icons.Outlined.Download,
+                        toConfirm = confirm[5],
+                        onLongClick = { onLongClickItem(5) },
+                        onClick = onDownloadClicked,
+                    )
+                }
+                if (onDeleteClicked != null) {
+                    Button(
+                        title = stringResource(MR.strings.action_delete),
+                        icon = Icons.Outlined.Delete,
+                        toConfirm = confirm[6],
+                        onLongClick = { onLongClickItem(6) },
+                        onClick = onDeleteClicked,
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun RowScope.Button(
+    title: String,
+    icon: ImageVector,
+    toConfirm: Boolean,
+    onLongClick: () -> Unit,
+    onClick: () -> Unit,
+) {
+    val animatedWeight by animateFloatAsState(
+        targetValue = if (toConfirm) 2f else 1f,
+        label = "weight",
+    )
+    Box(
+        modifier = Modifier
+            .size(48.dp)
+            .weight(animatedWeight)
+            .combinedClickable(
+                interactionSource = null,
+                indication = ripple(bounded = false),
+                onLongClick = onLongClick,
+                onClick = onClick,
+            ),
+        contentAlignment = Alignment.Center,
+    ) {
+        Column(
+            verticalArrangement = Arrangement.Center,
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            Icon(
+                imageVector = icon,
+                contentDescription = title,
+            )
+            AnimatedVisibility(
+                visible = toConfirm,
+                enter = expandVertically(expandFrom = Alignment.Top) + fadeIn(),
+                exit = shrinkVertically(shrinkTowards = Alignment.Top) + fadeOut(),
+            ) {
+                Text(
+                    text = title,
+                    overflow = TextOverflow.Visible,
+                    maxLines = 1,
+                    style = MaterialTheme.typography.labelSmall,
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
index db4f551dee..1d9aaa4e74 100644
--- a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
@@ -1,6 +1,6 @@
 package eu.kanade.presentation.anime.components
 
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -27,13 +27,16 @@ import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
 import eu.kanade.tachiyomi.ui.player.buildProgressString
 import tachiyomi.domain.episode.model.Episode
 import tachiyomi.presentation.core.components.material.DISABLED_ALPHA
+import tachiyomi.presentation.core.util.selectedBackground
 
 @Composable
 fun AnimeEpisodeListItem(
     episode: Episode,
     downloadState: AnimeDownload.State,
     downloadProgress: Int,
+    selected: Boolean = false,
     onClick: () -> Unit,
+    onLongClick: () -> Unit = {},
     onDownloadClick: () -> Unit,
     onDeleteDownloadClick: () -> Unit,
     modifier: Modifier = Modifier,
@@ -47,7 +50,11 @@ fun AnimeEpisodeListItem(
     Row(
         modifier = modifier
             .fillMaxWidth()
-            .clickable(onClick = onClick)
+            .selectedBackground(selected)
+            .combinedClickable(
+                onClick = onClick,
+                onLongClick = onLongClick,
+            )
             .padding(horizontal = 16.dp, vertical = 12.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
index 28117e334f..ec2585b517 100644
--- a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
@@ -43,6 +43,8 @@ import tachiyomi.domain.anime.model.Anime
 fun AnimeInfoHeader(
     anime: Anime,
     onFavoriteToggle: () -> Unit,
+    onTagSearch: (String) -> Unit = {},
+    onCoverClick: () -> Unit = {},
     modifier: Modifier = Modifier,
 ) {
     Column(
@@ -62,7 +64,8 @@ fun AnimeInfoHeader(
                     modifier = Modifier
                         .width(100.dp)
                         .aspectRatio(2f / 3f)
-                        .clip(RoundedCornerShape(4.dp)),
+                        .clip(RoundedCornerShape(4.dp))
+                        .clickable(onClick = onCoverClick),
                 )
             } else {
                 Icon(
@@ -127,7 +130,7 @@ fun AnimeInfoHeader(
             ) {
                 genres.forEach { genre ->
                     AssistChip(
-                        onClick = {},
+                        onClick = { onTagSearch(genre) },
                         label = { Text(genre, style = MaterialTheme.typography.labelSmall) },
                     )
                 }
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeToolbar.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeToolbar.kt
new file mode 100644
index 0000000000..5fbc5e3723
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeToolbar.kt
@@ -0,0 +1,112 @@
+package eu.kanade.presentation.anime.components
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.FilterList
+import androidx.compose.material.icons.outlined.FlipToBack
+import androidx.compose.material.icons.outlined.SelectAll
+import androidx.compose.material3.LocalContentColor
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.surfaceColorAtElevation
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.unit.dp
+import eu.kanade.presentation.components.AppBar
+import eu.kanade.presentation.components.AppBarActions
+import eu.kanade.presentation.components.AppBarTitle
+import kotlinx.collections.immutable.persistentListOf
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.theme.active
+
+@Composable
+fun AnimeToolbar(
+    title: String,
+    hasFilters: Boolean,
+    navigateUp: () -> Unit,
+    onClickFilter: () -> Unit,
+    onClickRefresh: () -> Unit,
+    onClickShare: (() -> Unit)? = null,
+    onClickEditCategory: (() -> Unit)? = null,
+
+    actionModeCounter: Int,
+    onCancelActionMode: () -> Unit,
+    onSelectAll: () -> Unit,
+    onInvertSelection: () -> Unit,
+
+    titleAlphaProvider: () -> Float,
+    backgroundAlphaProvider: () -> Float,
+    modifier: Modifier = Modifier,
+) {
+    val isActionMode = actionModeCounter > 0
+    AppBar(
+        titleContent = {
+            if (isActionMode) {
+                AppBarTitle(actionModeCounter.toString())
+            } else {
+                AppBarTitle(title, modifier = Modifier.alpha(titleAlphaProvider()))
+            }
+        },
+        modifier = modifier,
+        backgroundColor = MaterialTheme.colorScheme
+            .surfaceColorAtElevation(3.dp)
+            .copy(alpha = if (isActionMode) 1f else backgroundAlphaProvider()),
+        navigateUp = navigateUp,
+        actions = {
+            val filterTint = if (hasFilters) MaterialTheme.colorScheme.active else LocalContentColor.current
+            AppBarActions(
+                actions = persistentListOf<AppBar.AppBarAction>().builder().apply {
+                    if (isActionMode) {
+                        add(
+                            AppBar.Action(
+                                title = stringResource(MR.strings.action_select_all),
+                                icon = Icons.Outlined.SelectAll,
+                                onClick = onSelectAll,
+                            ),
+                        )
+                        add(
+                            AppBar.Action(
+                                title = stringResource(MR.strings.action_select_inverse),
+                                icon = Icons.Outlined.FlipToBack,
+                                onClick = onInvertSelection,
+                            ),
+                        )
+                        return@apply
+                    }
+                    add(
+                        AppBar.Action(
+                            title = stringResource(MR.strings.action_filter),
+                            icon = Icons.Outlined.FilterList,
+                            iconTint = filterTint,
+                            onClick = onClickFilter,
+                        ),
+                    )
+                    add(
+                        AppBar.OverflowAction(
+                            title = stringResource(MR.strings.action_webview_refresh),
+                            onClick = onClickRefresh,
+                        ),
+                    )
+                    if (onClickEditCategory != null) {
+                        add(
+                            AppBar.OverflowAction(
+                                title = stringResource(MR.strings.action_edit_categories),
+                                onClick = onClickEditCategory,
+                            ),
+                        )
+                    }
+                    if (onClickShare != null) {
+                        add(
+                            AppBar.OverflowAction(
+                                title = stringResource(MR.strings.action_share),
+                                onClick = onClickShare,
+                            ),
+                        )
+                    }
+                }.build(),
+            )
+        },
+        isActionMode = isActionMode,
+        onCancelActionMode = onCancelActionMode,
+    )
+}
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/EpisodeHeader.kt b/app/src/main/java/eu/kanade/presentation/anime/components/EpisodeHeader.kt
new file mode 100644
index 0000000000..322933f59a
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/EpisodeHeader.kt
@@ -0,0 +1,45 @@
+package eu.kanade.presentation.anime.components
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+
+@Composable
+fun EpisodeHeader(
+    enabled: Boolean,
+    episodeCount: Int?,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = modifier
+            .fillMaxWidth()
+            .clickable(
+                enabled = enabled,
+                onClick = onClick,
+            )
+            .padding(horizontal = 16.dp, vertical = 4.dp),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            text = if (episodeCount == null) {
+                stringResource(MR.strings.label_anime)
+            } else {
+                stringResource(MR.strings.anime_episode_count, episodeCount)
+            },
+            style = MaterialTheme.typography.titleMedium,
+            color = MaterialTheme.colorScheme.onBackground,
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
index 53609229b2..2900e69bb1 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
@@ -1,15 +1,20 @@
 package eu.kanade.tachiyomi.ui.anime
 
+import androidx.compose.material3.SnackbarHostState
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
 import cafe.adriel.voyager.core.model.rememberScreenModel
 import cafe.adriel.voyager.navigator.LocalNavigator
 import cafe.adriel.voyager.navigator.currentOrThrow
-import eu.kanade.presentation.anime.AnimeScreenContent
+import eu.kanade.presentation.anime.AnimeScreen
 import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.ui.browse.animesource.globalsearch.GlobalAnimeSearchScreen
 import eu.kanade.tachiyomi.ui.player.PlayerActivity
+import eu.kanade.tachiyomi.util.system.isTabletUi
 import tachiyomi.presentation.core.screens.LoadingScreen
 
 class AnimeScreen(
@@ -22,14 +27,18 @@ class AnimeScreen(
         val context = LocalContext.current
         val screenModel = rememberScreenModel { AnimeScreenModel(animeId = animeId) }
         val state by screenModel.state.collectAsState()
+        val snackbarHostState = remember { SnackbarHostState() }
+        val isTabletUi = LocalConfiguration.current.isTabletUi()
 
         when (val s = state) {
             is AnimeScreenModel.State.Loading -> {
                 LoadingScreen()
             }
             is AnimeScreenModel.State.Success -> {
-                AnimeScreenContent(
+                AnimeScreen(
                     state = s,
+                    snackbarHostState = snackbarHostState,
+                    isTabletUi = isTabletUi,
                     navigateUp = navigator::pop,
                     onEpisodeClicked = { episode ->
                         context.startActivity(
@@ -37,12 +46,17 @@ class AnimeScreen(
                         )
                     },
                     onContinueWatching = {
-                        val episode = s.nextUnseenEpisode ?: return@AnimeScreenContent
+                        val episode = s.nextUnseenEpisode ?: return@AnimeScreen
                         context.startActivity(
                             PlayerActivity.newIntent(context, animeId, episode.id),
                         )
                     },
-                    onToggleFavorite = screenModel::toggleFavorite,
+                    onAddToLibraryClicked = screenModel::toggleFavorite,
+                    onTagSearch = { tag -> navigator.push(GlobalAnimeSearchScreen(tag)) },
+                    onFilterButtonClicked = {
+                        screenModel.showDialog(AnimeScreenModel.Dialog.SettingsSheet)
+                    },
+                    onRefresh = screenModel::refreshEpisodes,
                     onDeleteClicked = {
                         screenModel.showDialog(AnimeScreenModel.Dialog.ConfirmDelete)
                     },
@@ -51,9 +65,24 @@ class AnimeScreen(
                         screenModel.deleteAnime()
                         navigator.pop()
                     },
-                    onDownloadEpisode = screenModel::startDownload,
-                    onDeleteEpisodeDownload = screenModel::deleteEpisodeDownload,
+                    onDownloadEpisode = { item -> screenModel.startDownload(item.episode) },
+                    onDeleteEpisodeDownload = { item -> screenModel.deleteEpisodeDownload(item.episode) },
                     onConfirmDownloadQuality = screenModel::confirmDownload,
+                    onUnseenFilterChanged = screenModel::setUnseenFilter,
+                    onBookmarkedFilterChanged = screenModel::setBookmarkFilter,
+                    onSortModeChanged = screenModel::setSortMode,
+                    onDisplayModeChanged = screenModel::setDisplayMode,
+                    onMultiBookmarkClicked = { episodes, bookmarked ->
+                        screenModel.toggleBookmark(episodes)
+                    },
+                    onMultiMarkAsSeenClicked = { episodes, markAsSeen ->
+                        screenModel.markEpisodesSeen(episodes, markAsSeen)
+                    },
+                    onMarkPreviousAsSeenClicked = screenModel::markPreviousAsSeen,
+                    onMultiDeleteClicked = screenModel::deleteEpisodeDownloads,
+                    onEpisodeSelected = screenModel::toggleSelection,
+                    onAllEpisodeSelected = screenModel::toggleAllSelection,
+                    onInvertSelection = screenModel::invertSelection,
                 )
             }
         }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
index 958eebe11e..b79bc2ab6c 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
@@ -3,6 +3,7 @@ package eu.kanade.tachiyomi.ui.anime
 import androidx.compose.runtime.Immutable
 import cafe.adriel.voyager.core.model.StateScreenModel
 import cafe.adriel.voyager.core.model.screenModelScope
+import eu.kanade.core.util.addOrRemove
 import eu.kanade.tachiyomi.animesource.model.SAnime
 import eu.kanade.tachiyomi.animesource.model.SEpisode
 import eu.kanade.tachiyomi.animesource.model.Video
@@ -30,6 +31,7 @@ import tachiyomi.domain.episode.interactor.UpdateEpisode
 import tachiyomi.domain.episode.model.Episode
 import tachiyomi.domain.episode.model.EpisodeUpdate
 import tachiyomi.domain.episode.repository.EpisodeRepository
+import tachiyomi.core.common.preference.TriState
 import tachiyomi.domain.manga.model.applyFilter
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
@@ -48,8 +50,12 @@ class AnimeScreenModel(
     private val animeDownloadManager: AnimeDownloadManager = Injekt.get(),
 ) : StateScreenModel<AnimeScreenModel.State>(State.Loading) {
 
+    private val selectedPositions: Array<Int> = arrayOf(-1, -1)
+    private val selectedEpisodeIds: HashSet<Long> = HashSet()
+
     init {
         screenModelScope.launchIO {
+            fetchAnimeFromSourceIfNeeded()
             fetchEpisodesFromSourceIfNeeded()
         }
 
@@ -63,29 +69,180 @@ class AnimeScreenModel(
                 val sortedEpisodes = applySort(anime, episodes)
                 val filteredEpisodes = applyFilters(anime, sortedEpisodes)
                 val queueById = downloadQueue.associateBy { it.episode.id }
-                val episodeDownloadState = buildMap {
-                    for (ep in episodes) {
-                        val dl = queueById[ep.id]
-                        if (dl != null) {
-                            put(ep.id, EpisodeDownloadState(dl.status, dl.progress))
-                        } else if (animeDownloadManager.isEpisodeDownloaded(ep.name, ep.scanlator, anime.title, anime.source)) {
-                            put(ep.id, EpisodeDownloadState(AnimeDownload.State.DOWNLOADED, 100))
-                        }
+
+                val episodeItems = filteredEpisodes.map { episode ->
+                    val dl = queueById[episode.id]
+                    val downloadState = when {
+                        dl != null -> dl.status
+                        animeDownloadManager.isEpisodeDownloaded(
+                            episode.name,
+                            episode.scanlator,
+                            anime.title,
+                            anime.source,
+                        ) -> AnimeDownload.State.DOWNLOADED
+                        else -> AnimeDownload.State.NOT_DOWNLOADED
                     }
+                    EpisodeList.Item(
+                        episode = episode,
+                        downloadState = downloadState,
+                        downloadProgress = dl?.progress ?: 0,
+                        selected = episode.id in selectedEpisodeIds,
+                    )
                 }
+
+                val allEpisodes = episodes
+                val nextUnseen = allEpisodes.asSequence()
+                    .filter { !it.seen }
+                    .minByOrNull { it.sourceOrder }
+
                 State.Success(
                     anime = anime,
-                    episodes = filteredEpisodes,
-                    allEpisodeCount = episodes.size,
-                    nextUnseenEpisode = episodes.asSequence().filter { !it.seen }.minByOrNull { it.sourceOrder },
-                    episodeDownloadState = episodeDownloadState,
+                    episodes = episodeItems,
+                    allEpisodeCount = allEpisodes.size,
+                    nextUnseenEpisode = nextUnseen,
                 )
             }.collectLatest { newState ->
                 mutableState.update { old ->
                     val dialog = (old as? State.Success)?.dialog
-                    newState.copy(dialog = dialog)
+                    val refreshing = (old as? State.Success)?.isRefreshingData ?: false
+                    newState.copy(dialog = dialog, isRefreshingData = refreshing)
+                }
+            }
+        }
+    }
+
+    private inline fun updateSuccessState(func: (State.Success) -> State.Success) {
+        mutableState.update {
+            when (it) {
+                State.Loading -> it
+                is State.Success -> func(it)
+            }
+        }
+    }
+
+    // region Selection
+
+    fun toggleSelection(
+        item: EpisodeList.Item,
+        selected: Boolean,
+        userSelected: Boolean = false,
+        fromLongPress: Boolean = false,
+    ) {
+        updateSuccessState { successState ->
+            val newEpisodes = successState.episodes.toMutableList().apply {
+                val selectedIndex = indexOfFirst { it.id == item.episode.id }
+                if (selectedIndex < 0) return@apply
+
+                val selectedItem = get(selectedIndex)
+                if (selectedItem.selected == selected) return@apply
+
+                val firstSelection = none { it.selected }
+                set(selectedIndex, selectedItem.copy(selected = selected))
+                selectedEpisodeIds.addOrRemove(item.id, selected)
+
+                if (selected && userSelected && fromLongPress) {
+                    if (firstSelection) {
+                        selectedPositions[0] = selectedIndex
+                        selectedPositions[1] = selectedIndex
+                    } else {
+                        val range: IntRange
+                        if (selectedIndex < selectedPositions[0]) {
+                            range = selectedIndex + 1..<selectedPositions[0]
+                            selectedPositions[0] = selectedIndex
+                        } else if (selectedIndex > selectedPositions[1]) {
+                            range = (selectedPositions[1] + 1)..<selectedIndex
+                            selectedPositions[1] = selectedIndex
+                        } else {
+                            range = IntRange.EMPTY
+                        }
+
+                        range.forEach {
+                            val inBetweenItem = get(it)
+                            if (!inBetweenItem.selected) {
+                                selectedEpisodeIds.add(inBetweenItem.id)
+                                set(it, inBetweenItem.copy(selected = true))
+                            }
+                        }
+                    }
+                } else if (userSelected && !fromLongPress) {
+                    if (!selected) {
+                        if (selectedIndex == selectedPositions[0]) {
+                            selectedPositions[0] = indexOfFirst { it.selected }
+                        } else if (selectedIndex == selectedPositions[1]) {
+                            selectedPositions[1] = indexOfLast { it.selected }
+                        }
+                    } else {
+                        if (selectedIndex < selectedPositions[0]) {
+                            selectedPositions[0] = selectedIndex
+                        } else if (selectedIndex > selectedPositions[1]) {
+                            selectedPositions[1] = selectedIndex
+                        }
+                    }
                 }
             }
+            successState.copy(episodes = newEpisodes)
+        }
+    }
+
+    fun toggleAllSelection(selected: Boolean) {
+        updateSuccessState { successState ->
+            val newEpisodes = successState.episodes.map {
+                selectedEpisodeIds.addOrRemove(it.id, selected)
+                it.copy(selected = selected)
+            }
+            selectedPositions[0] = -1
+            selectedPositions[1] = -1
+            successState.copy(episodes = newEpisodes)
+        }
+    }
+
+    fun invertSelection() {
+        updateSuccessState { successState ->
+            val newEpisodes = successState.episodes.map {
+                selectedEpisodeIds.addOrRemove(it.id, !it.selected)
+                it.copy(selected = !it.selected)
+            }
+            selectedPositions[0] = -1
+            selectedPositions[1] = -1
+            successState.copy(episodes = newEpisodes)
+        }
+    }
+
+    // endregion
+
+    // region Source sync
+
+    private suspend fun fetchAnimeFromSourceIfNeeded() {
+        val anime = getAnime.await(animeId) ?: return
+        if (anime.initialized && !anime.description.isNullOrBlank()) return
+        fetchAnimeFromSource()
+    }
+
+    private suspend fun fetchAnimeFromSource() {
+        val anime = getAnime.await(animeId) ?: return
+        val source = animeSourceManager.get(anime.source) ?: return
+
+        try {
+            val sAnime = SAnime.create().apply {
+                url = anime.url
+                title = anime.title
+            }
+            val networkAnime = source.getAnimeDetails(sAnime)
+            updateAnime.await(
+                AnimeUpdate(
+                    id = anime.id,
+                    title = networkAnime.title.takeIf { it.isNotBlank() } ?: anime.title,
+                    artist = networkAnime.artist,
+                    author = networkAnime.author,
+                    description = networkAnime.description,
+                    genre = networkAnime.getGenres(),
+                    status = networkAnime.status.toLong(),
+                    thumbnailUrl = networkAnime.thumbnail_url,
+                    initialized = true,
+                ),
+            )
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, e) { "Failed to fetch anime details from source" }
         }
     }
 
@@ -134,6 +291,10 @@ class AnimeScreenModel(
         )
     }
 
+    // endregion
+
+    // region Sorting & Filtering
+
     private fun applySort(anime: Anime, episodes: List<Episode>): List<Episode> {
         val comparator: Comparator<Episode> = when (anime.sorting) {
             Anime.EPISODE_SORTING_NUMBER -> compareBy { it.episodeNumber }
@@ -155,9 +316,16 @@ class AnimeScreenModel(
         }
     }
 
+    // endregion
+
+    // region Actions
+
     fun refreshEpisodes() {
         screenModelScope.launchIO {
+            updateSuccessState { it.copy(isRefreshingData = true) }
+            fetchAnimeFromSource()
             syncEpisodesFromSource()
+            updateSuccessState { it.copy(isRefreshingData = false) }
         }
     }
 
@@ -183,6 +351,25 @@ class AnimeScreenModel(
         }
     }
 
+    fun markPreviousAsSeen(episode: Episode) {
+        screenModelScope.launchNonCancellable {
+            val successState = state.value as? State.Success ?: return@launchNonCancellable
+            val allEpisodes = successState.episodes.map { it.episode }
+            val index = allEpisodes.indexOfFirst { it.id == episode.id }
+            if (index < 0) return@launchNonCancellable
+
+            val previousEpisodes = if (successState.anime.sortDescending()) {
+                allEpisodes.subList(index + 1, allEpisodes.size)
+            } else {
+                allEpisodes.subList(0, index)
+            }
+            setSeenStatus.await(
+                seen = true,
+                episodes = previousEpisodes.toTypedArray(),
+            )
+        }
+    }
+
     fun toggleBookmark(episodes: List<Episode>) {
         screenModelScope.launchNonCancellable {
             val updates = episodes.map {
@@ -205,20 +392,43 @@ class AnimeScreenModel(
         }
     }
 
-    fun setUnseenFilter(flag: Long) {
+    fun setUnseenFilter(state: TriState) {
+        val flag = when (state) {
+            TriState.DISABLED -> Anime.SHOW_ALL
+            TriState.ENABLED_IS -> Anime.EPISODE_SHOW_UNSEEN
+            TriState.ENABLED_NOT -> Anime.EPISODE_SHOW_SEEN
+        }
         screenModelScope.launchNonCancellable {
-            val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
+            val anime = (this@AnimeScreenModel.state.value as? State.Success)?.anime
+                ?: return@launchNonCancellable
             setAnimeEpisodeFlags.awaitSetUnseenFilter(anime, flag)
         }
     }
 
-    fun setBookmarkFilter(flag: Long) {
+    fun setBookmarkFilter(state: TriState) {
+        val flag = when (state) {
+            TriState.DISABLED -> Anime.SHOW_ALL
+            TriState.ENABLED_IS -> Anime.EPISODE_SHOW_BOOKMARKED
+            TriState.ENABLED_NOT -> Anime.EPISODE_SHOW_NOT_BOOKMARKED
+        }
         screenModelScope.launchNonCancellable {
-            val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
+            val anime = (this@AnimeScreenModel.state.value as? State.Success)?.anime
+                ?: return@launchNonCancellable
             setAnimeEpisodeFlags.awaitSetBookmarkFilter(anime, flag)
         }
     }
 
+    fun setDisplayMode(mode: Long) {
+        screenModelScope.launchNonCancellable {
+            val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
+            setAnimeEpisodeFlags.awaitSetDisplayMode(anime, mode)
+        }
+    }
+
+    // endregion
+
+    // region Downloads
+
     fun startDownload(episode: Episode) {
         screenModelScope.launchIO {
             val successState = state.value as? State.Success ?: return@launchIO
@@ -275,6 +485,15 @@ class AnimeScreenModel(
         }
     }
 
+    fun deleteEpisodeDownloads(episodes: List<Episode>) {
+        screenModelScope.launchNonCancellable {
+            val successState = state.value as? State.Success ?: return@launchNonCancellable
+            val anime = successState.anime
+            val source = animeSourceManager.get(anime.source) ?: return@launchNonCancellable
+            animeDownloadManager.deleteEpisodes(episodes, anime, source)
+        }
+    }
+
     private suspend fun resolveVideosForEpisode(source: AnimeHttpSource, episode: Episode): List<Video> {
         return withIOContext {
             val sEpisode = SEpisode.create().apply {
@@ -302,7 +521,6 @@ class AnimeScreenModel(
                 } catch (_: Throwable) {}
             }
 
-            // Resolve URLs
             videos.mapNotNull { video ->
                 var resolved = video
                 try {
@@ -324,29 +542,21 @@ class AnimeScreenModel(
         }
     }
 
+    // endregion
+
+    // region Dialog
+
     fun showDialog(dialog: Dialog) {
-        mutableState.update { state ->
-            when (state) {
-                is State.Success -> state.copy(dialog = dialog)
-                else -> state
-            }
-        }
+        updateSuccessState { it.copy(dialog = dialog) }
     }
 
     fun dismissDialog() {
-        mutableState.update { state ->
-            when (state) {
-                is State.Success -> state.copy(dialog = null)
-                else -> state
-            }
-        }
+        updateSuccessState { it.copy(dialog = null) }
     }
 
-    @Immutable
-    data class EpisodeDownloadState(
-        val status: AnimeDownload.State,
-        val progress: Int,
-    )
+    // endregion
+
+    // region State definitions
 
     sealed interface State {
         @Immutable
@@ -355,17 +565,51 @@ class AnimeScreenModel(
         @Immutable
         data class Success(
             val anime: Anime,
-            val episodes: List<Episode>,
+            val episodes: List<EpisodeList.Item>,
             val allEpisodeCount: Int = 0,
             val nextUnseenEpisode: Episode? = null,
-            val episodeDownloadState: Map<Long, EpisodeDownloadState> = emptyMap(),
+            val isRefreshingData: Boolean = false,
             val dialog: Dialog? = null,
-        ) : State
+        ) : State {
+            val isAnySelected by lazy {
+                episodes.any { it.selected }
+            }
+
+            val selectedEpisodes by lazy {
+                episodes.filter { it.selected }
+            }
+
+            val filterActive: Boolean
+                get() = anime.unseenFilter != TriState.DISABLED || anime.bookmarkedFilter != TriState.DISABLED
+        }
     }
 
     sealed interface Dialog {
         data object ConfirmDelete : Dialog
+        data object SettingsSheet : Dialog
         data class DownloadLoading(val episode: Episode) : Dialog
         data class QualitySelection(val episode: Episode, val videos: List<Video>) : Dialog
     }
+
+    // endregion
+}
+
+@Immutable
+sealed class EpisodeList {
+    @Immutable
+    data class MissingCount(
+        val id: String,
+        val count: Int,
+    ) : EpisodeList()
+
+    @Immutable
+    data class Item(
+        val episode: Episode,
+        val downloadState: AnimeDownload.State,
+        val downloadProgress: Int,
+        val selected: Boolean = false,
+    ) : EpisodeList() {
+        val id = episode.id
+        val isDownloaded = downloadState == AnimeDownload.State.DOWNLOADED
+    }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
index 4aae7a89dc..4a32de5a20 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
@@ -1,6 +1,7 @@
 package eu.kanade.tachiyomi.ui.anime
 
 import android.content.Intent
+import androidx.activity.compose.BackHandler
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.layout.padding
@@ -21,6 +22,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Modifier
@@ -32,9 +34,11 @@ import cafe.adriel.voyager.navigator.currentOrThrow
 import cafe.adriel.voyager.navigator.tab.TabOptions
 import eu.kanade.presentation.anime.library.AnimeLibraryContent
 import eu.kanade.presentation.anime.library.AnimeLibrarySettingsDialog
+import eu.kanade.presentation.components.BulkSelectionToolbar
 import eu.kanade.presentation.util.Tab
 import eu.kanade.tachiyomi.ui.anime.library.AnimeLibraryScreenModel
 import eu.kanade.tachiyomi.ui.player.PlayerActivity
+import kotlinx.coroutines.launch
 import tachiyomi.domain.library.model.LibraryDisplayMode
 import tachiyomi.domain.library.service.AnimeLibraryPreferences
 import tachiyomi.i18n.MR
@@ -60,6 +64,7 @@ data object AnimeTab : Tab {
     override fun Content() {
         val navigator = LocalNavigator.currentOrThrow
         val context = LocalContext.current
+        val scope = rememberCoroutineScope()
         val screenModel = rememberScreenModel { AnimeLibraryScreenModel() }
         val state by screenModel.state.collectAsState()
         val preferences: AnimeLibraryPreferences = remember { Injekt.get() }
@@ -86,37 +91,52 @@ data object AnimeTab : Tab {
             }
         }
 
+        BackHandler(enabled = state.selectionMode) {
+            screenModel.clearSelection()
+        }
+
         Scaffold(
             topBar = {
-                TopAppBar(
-                    title = { Text(stringResource(MR.strings.label_anime)) },
-                    actions = {
-                        IconButton(onClick = { showSettingsDialog = true }) {
-                            Icon(
-                                imageVector = Icons.Default.FilterList,
-                                contentDescription = "Filter",
-                            )
-                        }
-                        IconButton(onClick = { showOverflowMenu = true }) {
-                            Icon(
-                                imageVector = Icons.Outlined.PlayCircle,
-                                contentDescription = "More",
-                            )
-                        }
-                        DropdownMenu(
-                            expanded = showOverflowMenu,
-                            onDismissRequest = { showOverflowMenu = false },
-                        ) {
-                            DropdownMenuItem(
-                                text = { Text(stringResource(MR.strings.action_open_video)) },
-                                onClick = {
-                                    showOverflowMenu = false
-                                    showOpenVideoDialog = true
-                                },
-                            )
-                        }
-                    },
-                )
+                if (state.selectionMode) {
+                    BulkSelectionToolbar(
+                        selectedCount = state.selection.size,
+                        isRunning = false,
+                        onClickClearSelection = screenModel::clearSelection,
+                        onChangeCategoryClick = { /* TODO: open category picker */ },
+                        onSelectAll = { screenModel.selectAll(currentPage) },
+                        onReverseSelection = { screenModel.invertSelection(currentPage) },
+                    )
+                } else {
+                    TopAppBar(
+                        title = { Text(stringResource(MR.strings.label_anime)) },
+                        actions = {
+                            IconButton(onClick = { showSettingsDialog = true }) {
+                                Icon(
+                                    imageVector = Icons.Default.FilterList,
+                                    contentDescription = "Filter",
+                                )
+                            }
+                            IconButton(onClick = { showOverflowMenu = true }) {
+                                Icon(
+                                    imageVector = Icons.Outlined.PlayCircle,
+                                    contentDescription = "More",
+                                )
+                            }
+                            DropdownMenu(
+                                expanded = showOverflowMenu,
+                                onDismissRequest = { showOverflowMenu = false },
+                            ) {
+                                DropdownMenuItem(
+                                    text = { Text(stringResource(MR.strings.action_open_video)) },
+                                    onClick = {
+                                        showOverflowMenu = false
+                                        showOpenVideoDialog = true
+                                    },
+                                )
+                            }
+                        },
+                    )
+                }
             },
             snackbarHost = { SnackbarHost(hostState = snackbarHostState) },
         ) { contentPadding ->
@@ -136,7 +156,12 @@ data object AnimeTab : Tab {
                     onAnimeClicked = { animeId -> navigator.push(AnimeScreen(animeId)) },
                     onContinueWatchingClicked = null,
                     onToggleSelection = { anime -> screenModel.toggleSelection(anime) },
-                    onRefresh = { false },
+                    onRefresh = {
+                        scope.launch {
+                            snackbarHostState.showSnackbar("Refreshing anime library...")
+                        }
+                        false
+                    },
                     getItemsForCategory = { category ->
                         state.library[category].orEmpty()
                     },
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/globalsearch/GlobalAnimeSearchScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/globalsearch/GlobalAnimeSearchScreen.kt
new file mode 100644
index 0000000000..d0eac32582
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/globalsearch/GlobalAnimeSearchScreen.kt
@@ -0,0 +1,217 @@
+package eu.kanade.tachiyomi.ui.browse.animesource.globalsearch
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.aspectRatio
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.ArrowBack
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+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
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import cafe.adriel.voyager.core.model.rememberScreenModel
+import cafe.adriel.voyager.navigator.LocalNavigator
+import cafe.adriel.voyager.navigator.currentOrThrow
+import coil3.compose.AsyncImage
+import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.ui.anime.AnimeScreen
+import tachiyomi.presentation.core.components.material.Scaffold
+import tachiyomi.presentation.core.components.material.padding
+import tachiyomi.presentation.core.screens.LoadingScreen
+
+class GlobalAnimeSearchScreen(
+    val searchQuery: String = "",
+) : Screen() {
+
+    @Composable
+    override fun Content() {
+        val navigator = LocalNavigator.currentOrThrow
+        val screenModel = rememberScreenModel {
+            GlobalAnimeSearchScreenModel(initialQuery = searchQuery)
+        }
+        val state by screenModel.state.collectAsState()
+
+        Scaffold(
+            topBar = {
+                Column {
+                    TopAppBar(
+                        title = {
+                            Text(
+                                text = "Anime Search: ${state.searchQuery.orEmpty()}",
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis,
+                            )
+                        },
+                        navigationIcon = {
+                            IconButton(onClick = navigator::pop) {
+                                Icon(
+                                    imageVector = Icons.AutoMirrored.Outlined.ArrowBack,
+                                    contentDescription = null,
+                                )
+                            }
+                        },
+                    )
+                    if (state.progress in 1..<state.total) {
+                        LinearProgressIndicator(
+                            progress = { state.progress / state.total.toFloat() },
+                            modifier = Modifier.fillMaxWidth(),
+                        )
+                    }
+                }
+            },
+        ) { contentPadding ->
+            if (state.items.isEmpty()) {
+                LoadingScreen(modifier = Modifier.padding(contentPadding))
+            } else {
+                LazyColumn(contentPadding = contentPadding) {
+                    state.items.forEach { (source, result) ->
+                        item(key = source.id) {
+                            AnimeSearchSourceResult(
+                                source = source,
+                                result = result,
+                                onAnimeClicked = { sAnime ->
+                                    screenModel.addAnimeToDatabase(sAnime, source.id) { animeId ->
+                                        navigator.push(AnimeScreen(animeId))
+                                    }
+                                },
+                            )
+                            HorizontalDivider()
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeSearchSourceResult(
+    source: AnimeCatalogueSource,
+    result: AnimeSearchItemResult,
+    onAnimeClicked: (SAnime) -> Unit,
+) {
+    Column(modifier = Modifier.fillMaxWidth()) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    horizontal = MaterialTheme.padding.medium,
+                    vertical = MaterialTheme.padding.small,
+                ),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Text(
+                text = source.name,
+                style = MaterialTheme.typography.titleSmall,
+            )
+        }
+
+        when (result) {
+            AnimeSearchItemResult.Loading -> {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(vertical = 16.dp),
+                    horizontalArrangement = Arrangement.Center,
+                ) {
+                    CircularProgressIndicator()
+                }
+            }
+            is AnimeSearchItemResult.Error -> {
+                Text(
+                    text = result.throwable.message ?: "Error",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.error,
+                    modifier = Modifier.padding(
+                        horizontal = MaterialTheme.padding.medium,
+                        vertical = MaterialTheme.padding.small,
+                    ),
+                )
+            }
+            is AnimeSearchItemResult.Success -> {
+                if (result.isEmpty) {
+                    Text(
+                        text = "No results",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.padding(
+                            horizontal = MaterialTheme.padding.medium,
+                            vertical = MaterialTheme.padding.small,
+                        ),
+                    )
+                } else {
+                    LazyRow(
+                        contentPadding = PaddingValues(horizontal = MaterialTheme.padding.small),
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        items(
+                            items = result.result,
+                            key = { it.url },
+                        ) { anime ->
+                            AnimeSearchCard(
+                                anime = anime,
+                                onClick = { onAnimeClicked(anime) },
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun AnimeSearchCard(
+    anime: SAnime,
+    onClick: () -> Unit,
+) {
+    Column(
+        modifier = Modifier
+            .width(96.dp)
+            .clickable(onClick = onClick)
+            .padding(4.dp),
+    ) {
+        AsyncImage(
+            model = anime.thumbnail_url,
+            contentDescription = null,
+            contentScale = ContentScale.Crop,
+            modifier = Modifier
+                .fillMaxWidth()
+                .aspectRatio(2f / 3f)
+                .clip(RoundedCornerShape(4.dp)),
+        )
+        Text(
+            text = anime.title,
+            style = MaterialTheme.typography.bodySmall,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+            modifier = Modifier.padding(top = 4.dp),
+        )
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/globalsearch/GlobalAnimeSearchScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/globalsearch/GlobalAnimeSearchScreenModel.kt
new file mode 100644
index 0000000000..67bb3937ee
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/browse/animesource/globalsearch/GlobalAnimeSearchScreenModel.kt
@@ -0,0 +1,135 @@
+package eu.kanade.tachiyomi.ui.browse.animesource.globalsearch
+
+import androidx.compose.runtime.Immutable
+import cafe.adriel.voyager.core.model.StateScreenModel
+import cafe.adriel.voyager.core.model.screenModelScope
+import eu.kanade.tachiyomi.animesource.AnimeCatalogueSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import kotlinx.collections.immutable.ImmutableMap
+import kotlinx.collections.immutable.persistentMapOf
+import kotlinx.collections.immutable.toPersistentMap
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import tachiyomi.core.common.util.lang.launchIO
+import tachiyomi.core.common.util.lang.withUIContext
+import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.repository.AnimeRepository
+import tachiyomi.domain.animesource.service.AnimeSourceManager
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.util.concurrent.Executors
+
+class GlobalAnimeSearchScreenModel(
+    initialQuery: String = "",
+    private val animeSourceManager: AnimeSourceManager = Injekt.get(),
+    private val getAnime: GetAnime = Injekt.get(),
+    private val animeRepository: AnimeRepository = Injekt.get(),
+) : StateScreenModel<GlobalAnimeSearchScreenModel.State>(State(searchQuery = initialQuery)) {
+
+    private val coroutineDispatcher = Executors.newFixedThreadPool(5).asCoroutineDispatcher()
+    private var searchJob: Job? = null
+
+    init {
+        if (initialQuery.isNotBlank()) {
+            search()
+        }
+    }
+
+    fun updateSearchQuery(query: String?) {
+        mutableState.update { it.copy(searchQuery = query) }
+    }
+
+    fun search() {
+        val query = state.value.searchQuery
+        if (query.isNullOrBlank()) return
+
+        searchJob?.cancel()
+
+        val sources = animeSourceManager.getCatalogueSources()
+        if (sources.isEmpty()) return
+
+        mutableState.update {
+            it.copy(
+                items = sources.associateWith { AnimeSearchItemResult.Loading as AnimeSearchItemResult }
+                    .toPersistentMap(),
+            )
+        }
+
+        searchJob = screenModelScope.launch {
+            sources.map { source ->
+                async {
+                    try {
+                        val page = withContext(coroutineDispatcher) {
+                            source.getSearchAnime(1, query, AnimeFilterList())
+                        }
+                        val results = page.animes.distinctBy { it.url }
+                        if (isActive) {
+                            updateItem(source, AnimeSearchItemResult.Success(results))
+                        }
+                    } catch (e: Exception) {
+                        if (isActive) {
+                            updateItem(source, AnimeSearchItemResult.Error(e))
+                        }
+                    }
+                }
+            }.awaitAll()
+        }
+    }
+
+    private fun updateItem(source: AnimeCatalogueSource, result: AnimeSearchItemResult) {
+        mutableState.update { state ->
+            val newItems = state.items.toPersistentMap().put(source, result)
+            state.copy(items = newItems)
+        }
+    }
+
+    fun addAnimeToDatabase(sAnime: SAnime, sourceId: Long, onAdded: (Long) -> Unit) {
+        screenModelScope.launchIO {
+            val existing = getAnime.await(sAnime.url, sourceId)
+            if (existing != null) {
+                withUIContext { onAdded(existing.id) }
+                return@launchIO
+            }
+
+            val anime = Anime.create().copy(
+                source = sourceId,
+                url = sAnime.url,
+                title = sAnime.title,
+                artist = sAnime.artist,
+                author = sAnime.author,
+                description = sAnime.description,
+                genre = sAnime.getGenres(),
+                thumbnailUrl = sAnime.thumbnail_url,
+                status = sAnime.status.toLong(),
+                initialized = true,
+            )
+            val id = animeRepository.insert(anime)
+            withUIContext { onAdded(id) }
+        }
+    }
+
+    @Immutable
+    data class State(
+        val searchQuery: String? = null,
+        val items: ImmutableMap<AnimeCatalogueSource, AnimeSearchItemResult> = persistentMapOf(),
+    ) {
+        val progress: Int = items.count { it.value !is AnimeSearchItemResult.Loading }
+        val total: Int = items.size
+    }
+}
+
+sealed interface AnimeSearchItemResult {
+    data object Loading : AnimeSearchItemResult
+    data class Error(val throwable: Throwable) : AnimeSearchItemResult
+    data class Success(val result: List<SAnime>) : AnimeSearchItemResult {
+        val isEmpty: Boolean get() = result.isEmpty()
+    }
+}

From bf46bd5bf209ce6bea55412a75bdf8c114bbc7a2 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sun, 10 May 2026 07:27:57 +0200
Subject: [PATCH 12/13] Settings, bug fixes & polish

---
 .../eu/kanade/domain/AnimeDomainModule.kt     |   4 +
 .../java/eu/kanade/domain/DomainModule.kt     |  10 +
 .../kanade/presentation/anime/AnimeScreen.kt  |  48 +-
 .../anime/components/AnimeEpisodeListItem.kt  |  18 +
 .../anime/components/AnimeInfoHeader.kt       | 190 ++++---
 .../settings/screen/SettingsMainScreen.kt     |   7 +
 .../settings/screen/SettingsPlayerScreen.kt   | 481 ++++++++++++++++++
 .../settings/screen/SettingsSearchScreen.kt   |   1 +
 .../data/animedownload/AnimeDownloadJob.kt    |   4 +-
 .../animedownload/AnimeDownloadManager.kt     |  22 +-
 .../animedownload/AnimeDownloadNotifier.kt    |  16 +
 .../data/animedownload/AnimeDownloadStore.kt  |   7 +-
 .../data/animedownload/AnimeDownloader.kt     | 284 ++++++++++-
 .../data/animedownload/model/AnimeDownload.kt |   5 +-
 .../data/notification/NotificationReceiver.kt |  17 +-
 .../java/eu/kanade/tachiyomi/di/AppModule.kt  |   4 +
 .../torrentServer/TorrentServerApi.kt         |  30 ++
 .../kanade/tachiyomi/ui/anime/AnimeScreen.kt  |  36 +-
 .../tachiyomi/ui/anime/AnimeScreenModel.kt    |  30 +-
 .../ui/download/DownloadQueueScreen.kt        | 149 +++++-
 .../ui/download/DownloadQueueScreenModel.kt   |  18 +-
 .../eu/kanade/tachiyomi/ui/more/MoreTab.kt    |  11 +-
 .../tachiyomi/ui/player/PlayerActivity.kt     | 142 ++++--
 .../tachiyomi/ui/player/PlayerScreen.kt       |   8 +-
 .../tachiyomi/ui/player/PlayerViewModel.kt    |  76 ++-
 .../ui/player/controls/GestureHandler.kt      |   4 +-
 .../player/controls/PlayerControlsOverlay.kt  |   3 +-
 .../controls/components/sheets/MoreSheet.kt   |   1 -
 .../components/sheets/ScreenshotSheet.kt      | 110 ----
 .../ui/player/setting/PlayerPreferences.kt    |   2 +-
 .../tachiyomi/util/storage/FFmpegUtils.kt     |  22 +
 .../data/anime/AnimeRepositoryImpl.kt         |   4 +
 .../data/history/AnimeHistoryMapper.kt        |  55 ++
 .../history/AnimeHistoryRepositoryImpl.kt     |  69 +++
 .../tachiyomi/data/anime_history.sq           |  57 +++
 .../main/sqldelight/tachiyomi/data/animes.sq  |   8 +
 .../tachiyomi/data/animes_categories.sq       |   2 +
 .../sqldelight/tachiyomi/data/episodes.sq     |   1 +
 .../tachiyomi/view/animeHistoryView.sq        |  73 +++
 .../interactor/GetDuplicateLibraryAnime.kt    |  13 +
 .../anime/repository/AnimeRepository.kt       |   2 +
 .../interactor/ShouldUpdateDbEpisode.kt       |  14 +
 .../history/interactor/GetAnimeHistory.kt     |  19 +
 .../history/interactor/RemoveAnimeHistory.kt  |  16 +
 .../history/interactor/UpsertAnimeHistory.kt  |  13 +
 .../domain/history/model/AnimeHistory.kt      |  10 +
 .../history/model/AnimeHistoryUpdate.kt       |   9 +
 .../model/AnimeHistoryWithRelations.kt        |  18 +
 .../repository/AnimeHistoryRepository.kt      |  23 +
 .../moko-resources/base/strings.xml           |  98 ++++
 .../tachiyomi/animesource/model/Video.kt      |  26 +
 .../animesource/utils/Preferences.kt          |  19 +
 52 files changed, 2009 insertions(+), 300 deletions(-)
 create mode 100644 app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsPlayerScreen.kt
 delete mode 100644 app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ScreenshotSheet.kt
 create mode 100644 app/src/main/java/eu/kanade/tachiyomi/util/storage/FFmpegUtils.kt
 create mode 100644 data/src/main/java/tachiyomi/data/history/AnimeHistoryMapper.kt
 create mode 100644 data/src/main/java/tachiyomi/data/history/AnimeHistoryRepositoryImpl.kt
 create mode 100644 data/src/main/sqldelight/tachiyomi/data/anime_history.sq
 create mode 100644 data/src/main/sqldelight/tachiyomi/view/animeHistoryView.sq
 create mode 100644 domain/src/main/java/tachiyomi/domain/anime/interactor/GetDuplicateLibraryAnime.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/episode/interactor/ShouldUpdateDbEpisode.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/history/interactor/GetAnimeHistory.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/history/interactor/RemoveAnimeHistory.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/history/interactor/UpsertAnimeHistory.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/history/model/AnimeHistory.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/history/model/AnimeHistoryUpdate.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/history/model/AnimeHistoryWithRelations.kt
 create mode 100644 domain/src/main/java/tachiyomi/domain/history/repository/AnimeHistoryRepository.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/utils/Preferences.kt

diff --git a/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt b/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
index cae9693b09..1594874c2d 100644
--- a/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
+++ b/app/src/main/java/eu/kanade/domain/AnimeDomainModule.kt
@@ -4,6 +4,7 @@ import tachiyomi.data.anime.AnimeRepositoryImpl
 import tachiyomi.data.category.AnimeCategoryRepositoryImpl
 import tachiyomi.data.episode.EpisodeRepositoryImpl
 import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.interactor.GetDuplicateLibraryAnime
 import tachiyomi.domain.anime.interactor.GetFavoriteAnime
 import tachiyomi.domain.anime.interactor.GetLibraryAnime
 import tachiyomi.domain.anime.interactor.SetAnimeEpisodeFlags
@@ -17,6 +18,7 @@ import tachiyomi.domain.category.repository.AnimeCategoryRepository
 import tachiyomi.domain.episode.interactor.GetEpisode
 import tachiyomi.domain.episode.interactor.GetEpisodesByAnimeId
 import tachiyomi.domain.episode.interactor.SetSeenStatus
+import tachiyomi.domain.episode.interactor.ShouldUpdateDbEpisode
 import tachiyomi.domain.episode.interactor.UpdateEpisode
 import tachiyomi.domain.episode.repository.EpisodeRepository
 import tachiyomi.domain.library.service.AnimeLibraryPreferences
@@ -35,12 +37,14 @@ class AnimeDomainModule : InjektModule {
         addFactory { GetFavoriteAnime(get()) }
         addFactory { GetLibraryAnime(get()) }
         addFactory { SetAnimeEpisodeFlags(get()) }
+        addFactory { GetDuplicateLibraryAnime(get()) }
 
         addSingletonFactory<EpisodeRepository> { EpisodeRepositoryImpl(get()) }
         addFactory { GetEpisode(get()) }
         addFactory { GetEpisodesByAnimeId(get()) }
         addFactory { UpdateEpisode(get()) }
         addFactory { SetSeenStatus(get()) }
+        addFactory { ShouldUpdateDbEpisode() }
 
         addSingletonFactory<AnimeCategoryRepository> { AnimeCategoryRepositoryImpl(get()) }
         addFactory { GetAnimeCategories(get()) }
diff --git a/app/src/main/java/eu/kanade/domain/DomainModule.kt b/app/src/main/java/eu/kanade/domain/DomainModule.kt
index 3dd354f534..9aaf9ed507 100644
--- a/app/src/main/java/eu/kanade/domain/DomainModule.kt
+++ b/app/src/main/java/eu/kanade/domain/DomainModule.kt
@@ -52,6 +52,7 @@ import mihon.domain.upcoming.interactor.GetUpcomingManga
 import tachiyomi.data.animesource.StubAnimeSourceRepositoryImpl
 import tachiyomi.data.category.CategoryRepositoryImpl
 import tachiyomi.data.chapter.ChapterRepositoryImpl
+import tachiyomi.data.history.AnimeHistoryRepositoryImpl
 import tachiyomi.data.history.HistoryRepositoryImpl
 import tachiyomi.data.manga.MangaRepositoryImpl
 import tachiyomi.data.release.ReleaseServiceImpl
@@ -79,11 +80,15 @@ import tachiyomi.domain.chapter.interactor.SetMangaDefaultChapterFlags
 import tachiyomi.domain.chapter.interactor.ShouldUpdateDbChapter
 import tachiyomi.domain.chapter.interactor.UpdateChapter
 import tachiyomi.domain.chapter.repository.ChapterRepository
+import tachiyomi.domain.history.interactor.GetAnimeHistory
 import tachiyomi.domain.history.interactor.GetHistory
 import tachiyomi.domain.history.interactor.GetNextChapters
 import tachiyomi.domain.history.interactor.GetTotalReadDuration
+import tachiyomi.domain.history.interactor.RemoveAnimeHistory
 import tachiyomi.domain.history.interactor.RemoveHistory
+import tachiyomi.domain.history.interactor.UpsertAnimeHistory
 import tachiyomi.domain.history.interactor.UpsertHistory
+import tachiyomi.domain.history.repository.AnimeHistoryRepository
 import tachiyomi.domain.history.repository.HistoryRepository
 import tachiyomi.domain.manga.interactor.FetchInterval
 import tachiyomi.domain.manga.interactor.GetDuplicateLibraryManga
@@ -189,6 +194,11 @@ class DomainModule : InjektModule {
         addFactory { RemoveHistory(get()) }
         addFactory { GetTotalReadDuration(get()) }
 
+        addSingletonFactory<AnimeHistoryRepository> { AnimeHistoryRepositoryImpl(get()) }
+        addFactory { GetAnimeHistory(get()) }
+        addFactory { UpsertAnimeHistory(get()) }
+        addFactory { RemoveAnimeHistory(get()) }
+
         addFactory { DeleteDownload(get(), get()) }
         addFactory { DeleteAnimeDownload(get(), get()) }
 
diff --git a/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt b/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
index ce595dcd5f..ba8473192e 100644
--- a/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/anime/AnimeScreen.kt
@@ -79,6 +79,7 @@ fun AnimeScreen(
     onMultiMarkAsSeenClicked: (List<Episode>, markAsSeen: Boolean) -> Unit,
     onMarkPreviousAsSeenClicked: (Episode) -> Unit,
     onMultiDeleteClicked: (List<Episode>) -> Unit,
+    onMultiDownloadClicked: (List<Episode>) -> Unit = {},
     onEpisodeSelected: (EpisodeList.Item, Boolean, Boolean, Boolean) -> Unit,
     onAllEpisodeSelected: (Boolean) -> Unit,
     onInvertSelection: () -> Unit,
@@ -89,6 +90,7 @@ fun AnimeScreen(
     onDismissDialog: () -> Unit,
     onDeleteClicked: () -> Unit = {},
     onConfirmDelete: () -> Unit = {},
+    onAddToLibraryAnywayClicked: () -> Unit = {},
 ) {
     if (!isTabletUi) {
         AnimeScreenSmallImpl(
@@ -110,6 +112,7 @@ fun AnimeScreen(
             onMultiMarkAsSeenClicked = onMultiMarkAsSeenClicked,
             onMarkPreviousAsSeenClicked = onMarkPreviousAsSeenClicked,
             onMultiDeleteClicked = onMultiDeleteClicked,
+            onMultiDownloadClicked = onMultiDownloadClicked,
             onEpisodeSelected = onEpisodeSelected,
             onAllEpisodeSelected = onAllEpisodeSelected,
             onInvertSelection = onInvertSelection,
@@ -134,6 +137,7 @@ fun AnimeScreen(
             onMultiMarkAsSeenClicked = onMultiMarkAsSeenClicked,
             onMarkPreviousAsSeenClicked = onMarkPreviousAsSeenClicked,
             onMultiDeleteClicked = onMultiDeleteClicked,
+            onMultiDownloadClicked = onMultiDownloadClicked,
             onEpisodeSelected = onEpisodeSelected,
             onAllEpisodeSelected = onAllEpisodeSelected,
             onInvertSelection = onInvertSelection,
@@ -213,6 +217,31 @@ fun AnimeScreen(
                 },
             )
         }
+        is AnimeScreenModel.Dialog.DuplicateAnime -> {
+            AlertDialog(
+                onDismissRequest = onDismissDialog,
+                title = { Text("Duplicate in library") },
+                text = {
+                    Text(
+                        "An anime with the same title already exists in your library: " +
+                            dialog.duplicates.joinToString { it.title },
+                    )
+                },
+                confirmButton = {
+                    TextButton(onClick = {
+                        onDismissDialog()
+                        onAddToLibraryAnywayClicked()
+                    }) {
+                        Text("Add anyway")
+                    }
+                },
+                dismissButton = {
+                    TextButton(onClick = onDismissDialog) {
+                        Text(stringResource(MR.strings.action_cancel))
+                    }
+                },
+            )
+        }
         null -> {}
     }
 }
@@ -237,6 +266,7 @@ private fun AnimeScreenSmallImpl(
     onMultiMarkAsSeenClicked: (List<Episode>, markAsSeen: Boolean) -> Unit,
     onMarkPreviousAsSeenClicked: (Episode) -> Unit,
     onMultiDeleteClicked: (List<Episode>) -> Unit,
+    onMultiDownloadClicked: (List<Episode>) -> Unit,
     onEpisodeSelected: (EpisodeList.Item, Boolean, Boolean, Boolean) -> Unit,
     onAllEpisodeSelected: (Boolean) -> Unit,
     onInvertSelection: () -> Unit,
@@ -300,6 +330,7 @@ private fun AnimeScreenSmallImpl(
                 onMultiMarkAsSeenClicked = onMultiMarkAsSeenClicked,
                 onMarkPreviousAsSeenClicked = onMarkPreviousAsSeenClicked,
                 onMultiDeleteClicked = onMultiDeleteClicked,
+                onMultiDownloadClicked = onMultiDownloadClicked,
             )
         },
         snackbarHost = { SnackbarHost(hostState = snackbarHostState) },
@@ -328,16 +359,18 @@ private fun AnimeScreenSmallImpl(
             )
         },
     ) { contentPadding ->
+        val topPadding = contentPadding.calculateTopPadding()
+
         PullRefresh(
             refreshing = state.isRefreshingData,
             onRefresh = onRefresh,
             enabled = !isAnySelected,
-            indicatorPadding = contentPadding,
+            indicatorPadding = PaddingValues(top = topPadding),
         ) {
             val layoutDirection = LocalLayoutDirection.current
             VerticalFastScroller(
                 listState = episodeListState,
-                topContentPadding = contentPadding.calculateTopPadding(),
+                topContentPadding = topPadding,
                 endContentPadding = contentPadding.calculateEndPadding(layoutDirection),
             ) {
                 LazyColumn(
@@ -355,6 +388,7 @@ private fun AnimeScreenSmallImpl(
                     ) {
                         AnimeInfoHeader(
                             anime = state.anime,
+                            appBarPadding = topPadding,
                             onFavoriteToggle = onAddToLibraryClicked,
                             onTagSearch = onTagSearch,
                             onCoverClick = onCoverClicked,
@@ -406,6 +440,7 @@ private fun AnimeScreenLargeImpl(
     onMultiMarkAsSeenClicked: (List<Episode>, markAsSeen: Boolean) -> Unit,
     onMarkPreviousAsSeenClicked: (Episode) -> Unit,
     onMultiDeleteClicked: (List<Episode>) -> Unit,
+    onMultiDownloadClicked: (List<Episode>) -> Unit,
     onEpisodeSelected: (EpisodeList.Item, Boolean, Boolean, Boolean) -> Unit,
     onAllEpisodeSelected: (Boolean) -> Unit,
     onInvertSelection: () -> Unit,
@@ -455,6 +490,7 @@ private fun AnimeScreenLargeImpl(
                 onMultiMarkAsSeenClicked = onMultiMarkAsSeenClicked,
                 onMarkPreviousAsSeenClicked = onMarkPreviousAsSeenClicked,
                 onMultiDeleteClicked = onMultiDeleteClicked,
+                onMultiDownloadClicked = onMultiDownloadClicked,
                 fillFraction = 0.5f,
             )
         },
@@ -492,6 +528,7 @@ private fun AnimeScreenLargeImpl(
             startContent = {
                 AnimeInfoHeader(
                     anime = state.anime,
+                    appBarPadding = contentPadding.calculateTopPadding(),
                     onFavoriteToggle = onAddToLibraryClicked,
                     onTagSearch = onTagSearch,
                     onCoverClick = onCoverClicked,
@@ -546,6 +583,7 @@ private fun SharedAnimeBottomActionMenu(
     onMultiMarkAsSeenClicked: (List<Episode>, markAsSeen: Boolean) -> Unit,
     onMarkPreviousAsSeenClicked: (Episode) -> Unit,
     onMultiDeleteClicked: (List<Episode>) -> Unit,
+    onMultiDownloadClicked: (List<Episode>) -> Unit = {},
     fillFraction: Float = 1f,
     modifier: Modifier = Modifier,
 ) {
@@ -567,7 +605,11 @@ private fun SharedAnimeBottomActionMenu(
         onMarkPreviousAsSeenClicked = {
             onMarkPreviousAsSeenClicked(selected[0].episode)
         }.takeIf { selected.size == 1 },
-        onDownloadClicked = null,
+        onDownloadClicked = {
+            onMultiDownloadClicked(selected.fastMap { it.episode })
+        }.takeIf {
+            selected.fastAny { it.downloadState != AnimeDownload.State.DOWNLOADED }
+        },
         onDeleteClicked = {
             onMultiDeleteClicked(selected.fastMap { it.episode })
         }.takeIf {
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
index 1d9aaa4e74..2e6ab22f82 100644
--- a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeEpisodeListItem.kt
@@ -4,7 +4,9 @@ import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.material.icons.Icons
@@ -14,6 +16,7 @@ import androidx.compose.material.icons.outlined.Download
 import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.Icon
 import androidx.compose.material3.IconButton
+import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.LocalContentColor
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
@@ -87,6 +90,21 @@ fun AnimeEpisodeListItem(
                         maxLines = 1,
                     )
                 }
+
+                if (!episode.seen && episode.lastSecondSeen > 0 && episode.totalSeconds > 0) {
+                    Spacer(modifier = Modifier.height(4.dp))
+                    LinearProgressIndicator(
+                        progress = {
+                            (episode.lastSecondSeen.toFloat() / episode.totalSeconds.toFloat())
+                                .coerceIn(0f, 1f)
+                        },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .height(2.dp),
+                        color = MaterialTheme.colorScheme.primary,
+                        trackColor = MaterialTheme.colorScheme.surfaceVariant,
+                    )
+                }
             }
         }
 
diff --git a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
index ec2585b517..3e85f22d2f 100644
--- a/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
+++ b/app/src/main/java/eu/kanade/presentation/anime/components/AnimeInfoHeader.kt
@@ -1,8 +1,10 @@
 package eu.kanade.presentation.anime.components
 
 import androidx.compose.animation.animateContentSize
+import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ExperimentalLayoutApi
 import androidx.compose.foundation.layout.FlowRow
@@ -27,112 +29,152 @@ import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 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
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.blur
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import coil3.compose.AsyncImage
+import coil3.request.ImageRequest
+import coil3.request.crossfade
 import tachiyomi.domain.anime.model.Anime
 
 @OptIn(ExperimentalLayoutApi::class)
 @Composable
 fun AnimeInfoHeader(
     anime: Anime,
+    appBarPadding: Dp = 0.dp,
     onFavoriteToggle: () -> Unit,
     onTagSearch: (String) -> Unit = {},
     onCoverClick: () -> Unit = {},
     modifier: Modifier = Modifier,
 ) {
-    Column(
-        modifier = modifier
-            .fillMaxWidth()
-            .padding(16.dp),
-    ) {
-        Row(
-            modifier = Modifier.fillMaxWidth(),
-            verticalAlignment = Alignment.Top,
-        ) {
-            if (anime.thumbnailUrl != null) {
-                AsyncImage(
-                    model = anime.thumbnailUrl,
-                    contentDescription = null,
-                    contentScale = ContentScale.Crop,
-                    modifier = Modifier
-                        .width(100.dp)
-                        .aspectRatio(2f / 3f)
-                        .clip(RoundedCornerShape(4.dp))
-                        .clickable(onClick = onCoverClick),
-                )
-            } else {
-                Icon(
-                    imageVector = Icons.Filled.PlayCircle,
-                    contentDescription = null,
-                    tint = MaterialTheme.colorScheme.onSurfaceVariant,
-                    modifier = Modifier
-                        .size(100.dp)
-                        .padding(16.dp),
-                )
-            }
+    Box(modifier = modifier.fillMaxWidth()) {
+        val backgroundColor = MaterialTheme.colorScheme.background
+        val backdropGradientColors = remember(backgroundColor) {
+            listOf(Color.Transparent, backgroundColor)
+        }
+        AsyncImage(
+            model = ImageRequest.Builder(LocalContext.current)
+                .data(anime.thumbnailUrl)
+                .crossfade(true)
+                .build(),
+            contentDescription = null,
+            contentScale = ContentScale.Crop,
+            modifier = Modifier
+                .matchParentSize()
+                .drawWithContent {
+                    drawContent()
+                    drawRect(
+                        brush = Brush.verticalGradient(
+                            colors = backdropGradientColors,
+                            startY = size.height / 2,
+                        ),
+                    )
+                }
+                .background(MaterialTheme.colorScheme.surfaceTint.copy(alpha = 0.4f))
+                .blur(7.dp)
+                .alpha(0.2f),
+        )
 
-            Spacer(Modifier.width(16.dp))
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(start = 16.dp, top = appBarPadding + 16.dp, end = 16.dp, bottom = 16.dp),
+        ) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.Top,
+            ) {
+                if (anime.thumbnailUrl != null) {
+                    AsyncImage(
+                        model = anime.thumbnailUrl,
+                        contentDescription = null,
+                        contentScale = ContentScale.Crop,
+                        modifier = Modifier
+                            .width(100.dp)
+                            .aspectRatio(2f / 3f)
+                            .clip(RoundedCornerShape(4.dp))
+                            .clickable(onClick = onCoverClick),
+                    )
+                } else {
+                    Icon(
+                        imageVector = Icons.Filled.PlayCircle,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier
+                            .size(100.dp)
+                            .padding(16.dp),
+                    )
+                }
 
-            Column(modifier = Modifier.weight(1f)) {
-                Text(
-                    text = anime.title,
-                    style = MaterialTheme.typography.titleLarge,
-                    maxLines = 3,
-                    overflow = TextOverflow.Ellipsis,
-                )
+                Spacer(Modifier.width(16.dp))
 
-                val author = anime.author
-                if (!author.isNullOrBlank()) {
+                Column(modifier = Modifier.weight(1f)) {
                     Text(
-                        text = author,
-                        style = MaterialTheme.typography.bodyMedium,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                        maxLines = 1,
+                        text = anime.title,
+                        style = MaterialTheme.typography.titleLarge,
+                        maxLines = 3,
                         overflow = TextOverflow.Ellipsis,
                     )
-                }
 
-                Spacer(Modifier.height(8.dp))
+                    val author = anime.author
+                    if (!author.isNullOrBlank()) {
+                        Text(
+                            text = author,
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                        )
+                    }
 
-                IconButton(onClick = onFavoriteToggle) {
-                    Icon(
-                        imageVector = if (anime.favorite) Icons.Filled.Favorite else Icons.Outlined.FavoriteBorder,
-                        contentDescription = null,
-                        tint = if (anime.favorite) {
-                            MaterialTheme.colorScheme.error
-                        } else {
-                            MaterialTheme.colorScheme.onSurface
-                        },
-                    )
+                    Spacer(Modifier.height(8.dp))
+
+                    IconButton(onClick = onFavoriteToggle) {
+                        Icon(
+                            imageVector = if (anime.favorite) Icons.Filled.Favorite else Icons.Outlined.FavoriteBorder,
+                            contentDescription = null,
+                            tint = if (anime.favorite) {
+                                MaterialTheme.colorScheme.error
+                            } else {
+                                MaterialTheme.colorScheme.onSurface
+                            },
+                        )
+                    }
                 }
             }
-        }
 
-        val description = anime.description
-        if (!description.isNullOrBlank()) {
-            Spacer(Modifier.height(12.dp))
-            ExpandableDescription(description)
-        }
+            val description = anime.description
+            if (!description.isNullOrBlank()) {
+                Spacer(Modifier.height(12.dp))
+                ExpandableDescription(description)
+            }
 
-        val genres = anime.genre
-        if (!genres.isNullOrEmpty()) {
-            Spacer(Modifier.height(8.dp))
-            FlowRow(
-                horizontalArrangement = Arrangement.spacedBy(4.dp),
-                verticalArrangement = Arrangement.spacedBy(4.dp),
-            ) {
-                genres.forEach { genre ->
-                    AssistChip(
-                        onClick = { onTagSearch(genre) },
-                        label = { Text(genre, style = MaterialTheme.typography.labelSmall) },
-                    )
+            val genres = anime.genre
+            if (!genres.isNullOrEmpty()) {
+                Spacer(Modifier.height(8.dp))
+                FlowRow(
+                    horizontalArrangement = Arrangement.spacedBy(4.dp),
+                    verticalArrangement = Arrangement.spacedBy(4.dp),
+                ) {
+                    genres.forEach { genre ->
+                        AssistChip(
+                            onClick = { onTagSearch(genre) },
+                            label = { Text(genre, style = MaterialTheme.typography.labelSmall) },
+                        )
+                    }
                 }
             }
         }
diff --git a/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsMainScreen.kt b/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsMainScreen.kt
index 1596b69d23..37bd46ae26 100644
--- a/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsMainScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsMainScreen.kt
@@ -16,6 +16,7 @@ import androidx.compose.material.icons.outlined.GetApp
 import androidx.compose.material.icons.outlined.Info
 import androidx.compose.material.icons.outlined.Link
 import androidx.compose.material.icons.outlined.MenuBook
+import androidx.compose.material.icons.outlined.OndemandVideo
 import androidx.compose.material.icons.outlined.Palette
 import androidx.compose.material.icons.outlined.Search
 import androidx.compose.material.icons.outlined.Security
@@ -202,6 +203,12 @@ object SettingsMainScreen : Screen() {
             icon = Icons.AutoMirrored.Outlined.ChromeReaderMode,
             screen = SettingsReaderScreen,
         ),
+        Item(
+            titleRes = MR.strings.pref_category_player,
+            subtitleRes = MR.strings.pref_player_summary,
+            icon = Icons.Outlined.OndemandVideo,
+            screen = SettingsPlayerScreen,
+        ),
         Item(
             titleRes = MR.strings.pref_category_downloads,
             subtitleRes = MR.strings.pref_downloads_summary,
diff --git a/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsPlayerScreen.kt b/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsPlayerScreen.kt
new file mode 100644
index 0000000000..780800a812
--- /dev/null
+++ b/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsPlayerScreen.kt
@@ -0,0 +1,481 @@
+package eu.kanade.presentation.more.settings.screen
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.ReadOnlyComposable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import eu.kanade.presentation.more.settings.Preference
+import eu.kanade.tachiyomi.ui.player.Debanding
+import eu.kanade.tachiyomi.ui.player.SingleActionGesture
+import eu.kanade.tachiyomi.ui.player.setting.AdvancedPlayerPreferences
+import eu.kanade.tachiyomi.ui.player.setting.AudioChannels
+import eu.kanade.tachiyomi.ui.player.setting.AudioPreferences
+import eu.kanade.tachiyomi.ui.player.setting.DecoderPreferences
+import eu.kanade.tachiyomi.ui.player.setting.GesturePreferences
+import eu.kanade.tachiyomi.ui.player.setting.PlayerOrientation
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
+import eu.kanade.tachiyomi.ui.player.setting.SubtitlesBorderStyle
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.persistentMapOf
+import kotlinx.collections.immutable.toImmutableMap
+import tachiyomi.i18n.MR
+import tachiyomi.presentation.core.i18n.stringResource
+import tachiyomi.presentation.core.util.collectAsState
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+@Suppress("unused")
+object SettingsPlayerScreen : SearchableSettings {
+    private fun readResolve(): Any = SettingsPlayerScreen
+
+    @ReadOnlyComposable
+    @Composable
+    override fun getTitleRes() = MR.strings.pref_category_player
+
+    @Composable
+    override fun getPreferences(): List<Preference> {
+        val playerPreferences = remember { Injekt.get<PlayerPreferences>() }
+        val gesturePreferences = remember { Injekt.get<GesturePreferences>() }
+        val subtitlePreferences = remember { Injekt.get<SubtitlePreferences>() }
+        val audioPreferences = remember { Injekt.get<AudioPreferences>() }
+        val decoderPreferences = remember { Injekt.get<DecoderPreferences>() }
+        val advancedPlayerPreferences = remember { Injekt.get<AdvancedPlayerPreferences>() }
+
+        return listOf(
+            getGeneralGroup(playerPreferences),
+            getPipGroup(playerPreferences),
+            getExternalPlayerGroup(playerPreferences),
+            getAniSkipGroup(playerPreferences),
+            getGesturesGroup(gesturePreferences),
+            getSubtitlesGroup(subtitlePreferences),
+            getAudioGroup(audioPreferences),
+            getAdvancedGroup(decoderPreferences, advancedPlayerPreferences),
+        )
+    }
+
+    @Composable
+    private fun getGeneralGroup(playerPreferences: PlayerPreferences): Preference.PreferenceGroup {
+        val progressInterval by playerPreferences.progressSaveIntervalSec().collectAsState()
+        val controlsDelay by playerPreferences.playerTimeToDisappear().collectAsState()
+        val doubleTapSeek by playerPreferences.doubleTapSeekLength().collectAsState()
+        val progressThreshold by playerPreferences.progressPreference().collectAsState()
+
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_category_general),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.ListPreference(
+                    preference = playerPreferences.defaultPlayerOrientation(),
+                    entries = PlayerOrientation.entries
+                        .associate { it.flag to playerOrientationString(it) }
+                        .toImmutableMap(),
+                    title = stringResource(MR.strings.pref_player_orientation),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.keepScreenOn(),
+                    title = stringResource(MR.strings.pref_player_keep_screen_on),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.playerFullscreen(),
+                    title = stringResource(MR.strings.pref_player_fullscreen),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.autoplayEnabled(),
+                    title = stringResource(MR.strings.pref_player_autoplay),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.showLoadingCircle(),
+                    title = stringResource(MR.strings.pref_player_show_loading),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.showCurrentChapter(),
+                    title = stringResource(MR.strings.pref_player_show_chapter),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.reduceMotion(),
+                    title = stringResource(MR.strings.pref_player_reduce_motion),
+                    subtitle = stringResource(MR.strings.pref_player_reduce_motion_summary),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.rememberPlayerBrightness(),
+                    title = stringResource(MR.strings.pref_player_remember_brightness),
+                    subtitle = stringResource(MR.strings.pref_player_remember_brightness_summary),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.rememberPlayerVolume(),
+                    title = stringResource(MR.strings.pref_player_remember_volume),
+                    subtitle = stringResource(MR.strings.pref_player_remember_volume_summary),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.preserveWatchingPosition(),
+                    title = stringResource(MR.strings.pref_player_preserve_position),
+                    subtitle = stringResource(MR.strings.pref_player_preserve_position_summary),
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = progressInterval,
+                    valueRange = 1..30,
+                    title = stringResource(MR.strings.pref_player_progress_interval),
+                    valueString = "${progressInterval}s",
+                    onValueChanged = {
+                        playerPreferences.progressSaveIntervalSec().set(it)
+                    },
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = controlsDelay / 1000,
+                    valueRange = 1..10,
+                    title = stringResource(MR.strings.pref_player_controls_hide_delay),
+                    valueString = "${controlsDelay / 1000}s",
+                    onValueChanged = {
+                        playerPreferences.playerTimeToDisappear().set(it * 1000)
+                    },
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = doubleTapSeek,
+                    valueRange = 5..30,
+                    title = stringResource(MR.strings.pref_player_double_tap_seek),
+                    valueString = "${doubleTapSeek}s",
+                    onValueChanged = {
+                        playerPreferences.doubleTapSeekLength().set(it)
+                    },
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = (progressThreshold * 100).toInt(),
+                    valueRange = 50..100,
+                    title = stringResource(MR.strings.pref_player_progress_threshold),
+                    valueString = "${(progressThreshold * 100).toInt()}%",
+                    onValueChanged = {
+                        playerPreferences.progressPreference().set(it / 100f)
+                    },
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getPipGroup(playerPreferences: PlayerPreferences): Preference.PreferenceGroup {
+        val pipEnabled by playerPreferences.enablePip().collectAsState()
+
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_player_pip),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.enablePip(),
+                    title = stringResource(MR.strings.pref_player_enable_pip),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.pipOnExit(),
+                    title = stringResource(MR.strings.pref_player_pip_on_exit),
+                    subtitle = stringResource(MR.strings.pref_player_pip_on_exit_summary),
+                    enabled = pipEnabled,
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getExternalPlayerGroup(playerPreferences: PlayerPreferences): Preference.PreferenceGroup {
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_player_external),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.alwaysUseExternalPlayer(),
+                    title = stringResource(MR.strings.pref_player_always_external),
+                ),
+                Preference.PreferenceItem.EditTextPreference(
+                    preference = playerPreferences.externalPlayerPreference(),
+                    title = stringResource(MR.strings.pref_player_external_app),
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getAniSkipGroup(playerPreferences: PlayerPreferences): Preference.PreferenceGroup {
+        val aniSkipEnabled by playerPreferences.aniSkipEnabled().collectAsState()
+        val skipIntroEnabled by playerPreferences.enableSkipIntro().collectAsState()
+        val autoSkipIntro by playerPreferences.autoSkipIntro().collectAsState()
+        val netflixStyleEnabled by playerPreferences.enableNetflixStyleIntroSkip().collectAsState()
+        val waitingTime by playerPreferences.waitingTimeIntroSkip().collectAsState()
+
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_player_aniskip),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.aniSkipEnabled(),
+                    title = stringResource(MR.strings.pref_player_aniskip_enabled),
+                    subtitle = stringResource(MR.strings.pref_player_aniskip_summary),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.enableSkipIntro(),
+                    title = stringResource(MR.strings.pref_player_skip_intro),
+                    enabled = aniSkipEnabled,
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.autoSkipIntro(),
+                    title = stringResource(MR.strings.pref_player_auto_skip_intro),
+                    enabled = aniSkipEnabled && skipIntroEnabled,
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = playerPreferences.enableNetflixStyleIntroSkip(),
+                    title = stringResource(MR.strings.pref_player_netflix_skip),
+                    enabled = aniSkipEnabled && skipIntroEnabled && !autoSkipIntro,
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = waitingTime,
+                    valueRange = 1..15,
+                    title = stringResource(MR.strings.pref_player_skip_wait_time),
+                    valueString = "${waitingTime}s",
+                    enabled = aniSkipEnabled && skipIntroEnabled && !autoSkipIntro && netflixStyleEnabled,
+                    onValueChanged = {
+                        playerPreferences.waitingTimeIntroSkip().set(it)
+                    },
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getGesturesGroup(gesturePreferences: GesturePreferences): Preference.PreferenceGroup {
+        val volBrightEnabled by gesturePreferences.gestureVolumeBrightness().collectAsState()
+        val skipLength by gesturePreferences.skipLengthPreference().collectAsState()
+
+        val gestureEntries = persistentMapOf(
+            SingleActionGesture.None to stringResource(MR.strings.pref_player_gesture_none),
+            SingleActionGesture.Seek to stringResource(MR.strings.pref_player_gesture_seek),
+            SingleActionGesture.PlayPause to stringResource(MR.strings.pref_player_gesture_play_pause),
+        )
+
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_player_gestures),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = gesturePreferences.gestureVolumeBrightness(),
+                    title = stringResource(MR.strings.pref_player_gesture_vol_bright),
+                    subtitle = stringResource(MR.strings.pref_player_gesture_vol_bright_summary),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = gesturePreferences.swapVolumeBrightness(),
+                    title = stringResource(MR.strings.pref_player_swap_vol_bright),
+                    subtitle = stringResource(MR.strings.pref_player_swap_vol_bright_summary),
+                    enabled = volBrightEnabled,
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = gesturePreferences.gestureHorizontalSeek(),
+                    title = stringResource(MR.strings.pref_player_gesture_h_seek),
+                    subtitle = stringResource(MR.strings.pref_player_gesture_h_seek_summary),
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = skipLength,
+                    valueRange = 3..30,
+                    title = stringResource(MR.strings.pref_player_skip_length),
+                    valueString = "${skipLength}s",
+                    onValueChanged = {
+                        gesturePreferences.skipLengthPreference().set(it)
+                    },
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = gesturePreferences.playerSmoothSeek(),
+                    title = stringResource(MR.strings.pref_player_smooth_seek),
+                    subtitle = stringResource(MR.strings.pref_player_smooth_seek_summary),
+                ),
+                Preference.PreferenceItem.ListPreference(
+                    preference = gesturePreferences.leftDoubleTapGesture(),
+                    entries = gestureEntries,
+                    title = stringResource(MR.strings.pref_player_left_double_tap),
+                ),
+                Preference.PreferenceItem.ListPreference(
+                    preference = gesturePreferences.centerDoubleTapGesture(),
+                    entries = gestureEntries,
+                    title = stringResource(MR.strings.pref_player_center_double_tap),
+                ),
+                Preference.PreferenceItem.ListPreference(
+                    preference = gesturePreferences.rightDoubleTapGesture(),
+                    entries = gestureEntries,
+                    title = stringResource(MR.strings.pref_player_right_double_tap),
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getSubtitlesGroup(subtitlePreferences: SubtitlePreferences): Preference.PreferenceGroup {
+        val fontSize by subtitlePreferences.subtitleFontSize().collectAsState()
+        val borderSize by subtitlePreferences.subtitleBorderSize().collectAsState()
+        val shadowOffset by subtitlePreferences.shadowOffsetSubtitles().collectAsState()
+        val subtitlePos by subtitlePreferences.subtitlePos().collectAsState()
+
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_player_subtitles),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.EditTextPreference(
+                    preference = subtitlePreferences.preferredSubLanguages(),
+                    title = stringResource(MR.strings.pref_player_preferred_sub_lang),
+                ),
+                Preference.PreferenceItem.EditTextPreference(
+                    preference = subtitlePreferences.subtitleFont(),
+                    title = stringResource(MR.strings.pref_player_subtitle_font),
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = fontSize,
+                    valueRange = 20..100,
+                    title = stringResource(MR.strings.pref_player_subtitle_font_size),
+                    valueString = "$fontSize",
+                    onValueChanged = {
+                        subtitlePreferences.subtitleFontSize().set(it)
+                    },
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = subtitlePreferences.boldSubtitles(),
+                    title = stringResource(MR.strings.pref_player_subtitle_bold),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = subtitlePreferences.italicSubtitles(),
+                    title = stringResource(MR.strings.pref_player_subtitle_italic),
+                ),
+                Preference.PreferenceItem.ListPreference(
+                    preference = subtitlePreferences.borderStyleSubtitles(),
+                    entries = persistentMapOf(
+                        SubtitlesBorderStyle.OutlineAndShadow to stringResource(MR.strings.pref_player_subtitle_outline),
+                        SubtitlesBorderStyle.OpaqueBox to stringResource(MR.strings.pref_player_subtitle_opaque_box),
+                        SubtitlesBorderStyle.BackgroundBox to stringResource(MR.strings.pref_player_subtitle_bg_box),
+                    ),
+                    title = stringResource(MR.strings.pref_player_subtitle_border_style),
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = borderSize,
+                    valueRange = 0..10,
+                    title = stringResource(MR.strings.pref_player_subtitle_border_size),
+                    valueString = "$borderSize",
+                    onValueChanged = {
+                        subtitlePreferences.subtitleBorderSize().set(it)
+                    },
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = shadowOffset,
+                    valueRange = 0..10,
+                    title = stringResource(MR.strings.pref_player_subtitle_shadow_offset),
+                    valueString = "$shadowOffset",
+                    onValueChanged = {
+                        subtitlePreferences.shadowOffsetSubtitles().set(it)
+                    },
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = subtitlePos,
+                    valueRange = 0..100,
+                    title = stringResource(MR.strings.pref_player_subtitle_position),
+                    valueString = "$subtitlePos",
+                    onValueChanged = {
+                        subtitlePreferences.subtitlePos().set(it)
+                    },
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = subtitlePreferences.overrideSubsASS(),
+                    title = stringResource(MR.strings.pref_player_subtitle_override_ass),
+                    subtitle = stringResource(MR.strings.pref_player_subtitle_override_ass_summary),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = subtitlePreferences.screenshotSubtitles(),
+                    title = stringResource(MR.strings.pref_player_screenshot_subs),
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getAudioGroup(audioPreferences: AudioPreferences): Preference.PreferenceGroup {
+        val volumeBoostCap by audioPreferences.volumeBoostCap().collectAsState()
+
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_player_audio),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.EditTextPreference(
+                    preference = audioPreferences.preferredAudioLanguages(),
+                    title = stringResource(MR.strings.pref_player_preferred_audio_lang),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = audioPreferences.enablePitchCorrection(),
+                    title = stringResource(MR.strings.pref_player_pitch_correction),
+                    subtitle = stringResource(MR.strings.pref_player_pitch_correction_summary),
+                ),
+                Preference.PreferenceItem.ListPreference(
+                    preference = audioPreferences.audioChannels(),
+                    entries = persistentMapOf(
+                        AudioChannels.Auto to stringResource(MR.strings.pref_player_audio_auto),
+                        AudioChannels.AutoSafe to stringResource(MR.strings.pref_player_audio_auto_safe),
+                        AudioChannels.Mono to stringResource(MR.strings.pref_player_audio_mono),
+                        AudioChannels.Stereo to stringResource(MR.strings.pref_player_audio_stereo),
+                        AudioChannels.ReverseStereo to stringResource(MR.strings.pref_player_audio_reverse_stereo),
+                    ),
+                    title = stringResource(MR.strings.pref_player_audio_channels),
+                ),
+                Preference.PreferenceItem.SliderPreference(
+                    value = volumeBoostCap,
+                    valueRange = 0..200,
+                    title = stringResource(MR.strings.pref_player_volume_boost_cap),
+                    valueString = "$volumeBoostCap%",
+                    onValueChanged = {
+                        audioPreferences.volumeBoostCap().set(it)
+                    },
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun getAdvancedGroup(
+        decoderPreferences: DecoderPreferences,
+        advancedPlayerPreferences: AdvancedPlayerPreferences,
+    ): Preference.PreferenceGroup {
+        return Preference.PreferenceGroup(
+            title = stringResource(MR.strings.pref_player_advanced),
+            preferenceItems = persistentListOf(
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = decoderPreferences.tryHWDecoding(),
+                    title = stringResource(MR.strings.pref_player_hw_decoding),
+                    subtitle = stringResource(MR.strings.pref_player_hw_decoding_summary),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = decoderPreferences.gpuNext(),
+                    title = stringResource(MR.strings.pref_player_gpu_next),
+                    subtitle = stringResource(MR.strings.pref_player_gpu_next_summary),
+                ),
+                Preference.PreferenceItem.ListPreference(
+                    preference = decoderPreferences.videoDebanding(),
+                    entries = persistentMapOf(
+                        Debanding.None to stringResource(MR.strings.pref_player_debanding_none),
+                        Debanding.CPU to stringResource(MR.strings.pref_player_debanding_cpu),
+                        Debanding.GPU to stringResource(MR.strings.pref_player_debanding_gpu),
+                    ),
+                    title = stringResource(MR.strings.pref_player_debanding),
+                ),
+                Preference.PreferenceItem.SwitchPreference(
+                    preference = decoderPreferences.useYUV420P(),
+                    title = stringResource(MR.strings.pref_player_yuv420p),
+                    subtitle = stringResource(MR.strings.pref_player_yuv420p_summary),
+                ),
+                Preference.PreferenceItem.EditTextPreference(
+                    preference = advancedPlayerPreferences.mpvConf(),
+                    title = stringResource(MR.strings.pref_player_mpv_conf),
+                    subtitle = stringResource(MR.strings.pref_player_mpv_conf_summary),
+                ),
+                Preference.PreferenceItem.EditTextPreference(
+                    preference = advancedPlayerPreferences.mpvInput(),
+                    title = stringResource(MR.strings.pref_player_mpv_input),
+                    subtitle = stringResource(MR.strings.pref_player_mpv_input_summary),
+                ),
+            ),
+        )
+    }
+
+    @Composable
+    private fun playerOrientationString(orientation: PlayerOrientation): String {
+        return when (orientation) {
+            PlayerOrientation.FREE -> stringResource(MR.strings.pref_player_orientation_free)
+            PlayerOrientation.PORTRAIT -> stringResource(MR.strings.pref_player_orientation_portrait)
+            PlayerOrientation.LANDSCAPE -> stringResource(MR.strings.pref_player_orientation_landscape)
+            PlayerOrientation.LOCKED_PORTRAIT -> stringResource(MR.strings.pref_player_orientation_locked_portrait)
+            PlayerOrientation.LOCKED_LANDSCAPE -> stringResource(MR.strings.pref_player_orientation_locked_landscape)
+            PlayerOrientation.REVERSE_PORTRAIT -> stringResource(MR.strings.pref_player_orientation_reverse_portrait)
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsSearchScreen.kt b/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsSearchScreen.kt
index bf292a7dc0..391641eaa4 100644
--- a/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsSearchScreen.kt
+++ b/app/src/main/java/eu/kanade/presentation/more/settings/screen/SettingsSearchScreen.kt
@@ -289,6 +289,7 @@ private val settingScreens = listOf(
     SettingsAppearanceScreen,
     SettingsLibraryScreen,
     SettingsReaderScreen,
+    SettingsPlayerScreen,
     SettingsDownloadScreen,
     SettingsTrackingScreen,
     // AM (CONNECTIONS) -->
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadJob.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadJob.kt
index 4ef8393c9d..ac3c2e32f1 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadJob.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadJob.kt
@@ -36,8 +36,8 @@ class AnimeDownloadJob(
     workerParams: WorkerParameters,
 ) : CoroutineWorker(context, workerParams) {
 
-    private val animeDownloadManager: AnimeDownloadManager = Injekt.get()
-    private val downloadPreferences: DownloadPreferences = Injekt.get()
+    private val animeDownloadManager: AnimeDownloadManager by lazy { Injekt.get() }
+    private val downloadPreferences: DownloadPreferences by lazy { Injekt.get() }
 
     override suspend fun getForegroundInfo(): ForegroundInfo {
         val notification = applicationContext.notificationBuilder(Notifications.CHANNEL_ANIME_DOWNLOADER_PROGRESS) {
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadManager.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadManager.kt
index 7bf41de714..929aaebf3a 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadManager.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadManager.kt
@@ -6,8 +6,14 @@ import eu.kanade.tachiyomi.animesource.model.SerializableVideo.Companion.toVideo
 import eu.kanade.tachiyomi.animesource.model.Track
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
+import logcat.LogPriority
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.anime.model.Anime
 import tachiyomi.domain.animesource.service.AnimeSourceManager
 import tachiyomi.domain.episode.model.Episode
@@ -21,25 +27,29 @@ class AnimeDownloadManager(
     private val animeSourceManager: AnimeSourceManager = Injekt.get(),
 ) {
 
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
     private val downloader = AnimeDownloader(context, provider, cache)
     private val pendingDeleter = AnimeDownloadPendingDeleter(context)
 
     val isRunning: Boolean
         get() = downloader.isRunning
 
+    val isDownloaderRunning
+        get() = AnimeDownloadJob.isRunningFlow(context)
+
     val queueState
         get() = downloader.queueState
 
     val stateVersion
         get() = downloader.stateVersion
 
-    fun downloaderStart() = downloader.start()
+    suspend fun downloaderStart() = downloader.start()
     fun downloaderStop(reason: String? = null) = downloader.stop(reason)
 
     fun startDownloads() {
         if (downloader.isRunning) return
         if (AnimeDownloadJob.isRunning(context)) {
-            downloader.start()
+            scope.launch { downloader.start() }
         } else {
             AnimeDownloadJob.start(context)
         }
@@ -55,6 +65,10 @@ class AnimeDownloadManager(
         AnimeDownloadJob.stop(context)
     }
 
+    fun cancelEpisodeDownload(download: AnimeDownload) {
+        downloader.removeFromQueue(listOf(download.episode))
+    }
+
     fun downloadEpisodes(anime: Anime, episodes: List<Episode>, videos: List<Video?>, autoStart: Boolean = true) {
         downloader.queueEpisodes(anime, episodes, videos, autoStart)
     }
@@ -119,7 +133,9 @@ class AnimeDownloadManager(
                         )
                     }
                 }
-            } catch (_: Exception) {}
+            } catch (e: Exception) {
+                logcat(LogPriority.WARN, e) { "Failed to parse metadata for downloaded episode" }
+            }
         }
 
         return Video(
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadNotifier.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadNotifier.kt
index 3907391dba..4cb2f4d879 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadNotifier.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadNotifier.kt
@@ -7,6 +7,7 @@ import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.core.security.SecurityPreferences
 import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
 import eu.kanade.tachiyomi.data.notification.NotificationHandler
+import eu.kanade.tachiyomi.data.notification.NotificationReceiver
 import eu.kanade.tachiyomi.data.notification.Notifications
 import eu.kanade.tachiyomi.util.lang.chop
 import eu.kanade.tachiyomi.util.system.cancelNotification
@@ -58,6 +59,11 @@ internal class AnimeDownloadNotifier(private val context: Context) {
                 clearActions()
                 setContentIntent(NotificationHandler.openDownloadManagerPendingActivity(context))
                 isDownloading = true
+                addAction(
+                    R.drawable.ic_pause_24dp,
+                    context.stringResource(MR.strings.action_pause),
+                    NotificationReceiver.pauseDownloadsPendingBroadcast(context),
+                )
             }
 
             val title = if (preferences.hideNotificationContent().get()) {
@@ -89,6 +95,16 @@ internal class AnimeDownloadNotifier(private val context: Context) {
             setOngoing(false)
             clearActions()
             setContentIntent(NotificationHandler.openDownloadManagerPendingActivity(context))
+            addAction(
+                R.drawable.ic_play_arrow_24dp,
+                context.stringResource(MR.strings.action_resume),
+                NotificationReceiver.resumeDownloadsPendingBroadcast(context),
+            )
+            addAction(
+                R.drawable.ic_close_24dp,
+                context.stringResource(MR.strings.action_cancel_all),
+                NotificationReceiver.clearDownloadsPendingBroadcast(context),
+            )
 
             show(Notifications.ID_ANIME_DOWNLOAD_PAUSED)
         }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadStore.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadStore.kt
index 6e11d1455a..9a68cfa409 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadStore.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloadStore.kt
@@ -4,7 +4,6 @@ import android.content.Context
 import androidx.core.content.edit
 import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
-import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
@@ -55,7 +54,7 @@ class AnimeDownloadStore(
         return download.episode.id.toString()
     }
 
-    fun restore(): List<AnimeDownload> {
+    suspend fun restore(): List<AnimeDownload> {
         val objs = preferences.all
             .mapNotNull { it.value as? String }
             .mapNotNull { deserialize(it) }
@@ -66,10 +65,10 @@ class AnimeDownloadStore(
             val cachedAnime = mutableMapOf<Long, Anime?>()
             for ((animeId, episodeId) in objs) {
                 val anime = cachedAnime.getOrPut(animeId) {
-                    runBlocking { getAnime.await(animeId) }
+                    getAnime.await(animeId)
                 } ?: continue
                 val source = animeSourceManager.get(anime.source) as? AnimeHttpSource ?: continue
-                val episode = runBlocking { getEpisode.await(episodeId) } ?: continue
+                val episode = getEpisode.await(episodeId) ?: continue
                 downloads.add(AnimeDownload(source, anime, episode))
             }
         }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
index 0f72832020..fc24aad486 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
@@ -1,14 +1,26 @@
 package eu.kanade.tachiyomi.data.animedownload
 
 import android.content.Context
+import com.arthenica.ffmpegkit.FFmpegKitConfig
+import com.arthenica.ffmpegkit.FFmpegSession
+import com.arthenica.ffmpegkit.FFprobeSession
+import com.arthenica.ffmpegkit.ReturnCode
+import com.arthenica.ffmpegkit.StatisticsCallback
 import com.hippo.unifile.UniFile
+import eu.kanade.tachiyomi.animesource.model.SEpisode
 import eu.kanade.tachiyomi.animesource.model.SerializableVideo.Companion.serialize
+import eu.kanade.tachiyomi.animesource.model.Track
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
+import eu.kanade.tachiyomi.data.torrentServer.service.TorrentServerService
 import eu.kanade.tachiyomi.network.NetworkHelper
+import eu.kanade.tachiyomi.torrentServer.TorrentServerApi
+import eu.kanade.tachiyomi.torrentServer.TorrentServerUtils
+import eu.kanade.tachiyomi.ui.player.PlayerViewModel
 import eu.kanade.tachiyomi.network.ProgressListener
 import eu.kanade.tachiyomi.util.storage.DiskUtil
+import eu.kanade.tachiyomi.util.storage.toFFmpegString
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.async
 import kotlinx.coroutines.awaitAll
@@ -34,6 +46,7 @@ import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.io.File
 import java.io.RandomAccessFile
+import java.util.concurrent.atomic.AtomicBoolean
 
 class AnimeDownloader(
     private val context: Context,
@@ -59,6 +72,10 @@ class AnimeDownloader(
     val queueState = _queueState.asStateFlow()
     val stateVersion = _stateVersion.asStateFlow()
 
+    private val isFFmpegRunning = AtomicBoolean(false)
+    @Volatile
+    private var currentFFmpegSession: FFmpegSession? = null
+
     private fun notifyQueueChanged() {
         _stateVersion.update { it + 1 }
     }
@@ -68,7 +85,7 @@ class AnimeDownloader(
     val isRunning: Boolean
         get() = downloaderJob?.isActive == true
 
-    fun start(): Boolean {
+    suspend fun start(): Boolean {
         if (downloaderJob?.isActive == true) {
             logcat(LogPriority.INFO) { "AnimeDownloader: already running" }
             return true
@@ -93,6 +110,7 @@ class AnimeDownloader(
     }
 
     fun stop(reason: String? = null) {
+        cancelFFmpeg()
         downloaderJob?.cancel()
         downloaderJob = null
 
@@ -114,6 +132,7 @@ class AnimeDownloader(
     }
 
     fun pause() {
+        cancelFFmpeg()
         downloaderJob?.cancel()
         downloaderJob = null
         _queueState.value
@@ -136,6 +155,12 @@ class AnimeDownloader(
             return
         }
 
+        // Remove any errored items for these episodes so they can be re-queued
+        val episodeIds = episodes.map { it.id }.toSet()
+        _queueState.update { queue ->
+            queue.filter { it.episode.id !in episodeIds || it.status != AnimeDownload.State.ERROR }
+        }
+
         val episodesToQueue = episodes.zip(videos).filter { (episode, _) ->
             val isDuplicate = _queueState.value.any { it.episode.id == episode.id }
             val isDownloaded = provider.findEpisodeDir(
@@ -217,25 +242,29 @@ class AnimeDownloader(
     }
 
     private suspend fun downloadEpisode(download: AnimeDownload) {
+        if (download.video == null) {
+            resolveVideo(download)
+        }
+
         val video = download.video
-            ?: throw IllegalStateException("Video not resolved for episode ${download.episode.name}")
+            ?: throw IllegalStateException("Could not resolve video for episode ${download.episode.name}")
 
         val videoUrl = video.videoUrl
         if (videoUrl.isBlank()) {
             throw IllegalStateException("Video URL is blank for episode ${download.episode.name}")
         }
 
-        if (isStreamingUrl(videoUrl)) {
-            throw IllegalStateException(
-                "Cannot download streaming content (DASH/HLS). URL: ${videoUrl.take(80)}",
-            )
-        }
-
         download.status = AnimeDownload.State.DOWNLOADING
         notifyQueueChanged()
         notifier.onProgressChange(download)
 
         val animeDir = provider.getAnimeDir(download.anime.title, download.source).getOrThrow()
+
+        val availSpace = DiskUtil.getAvailableStorageSpace(animeDir)
+        if (availSpace != -1L && availSpace < MIN_DISK_SPACE) {
+            throw IllegalStateException("Insufficient storage space (${availSpace / 1024 / 1024}MB free, ${MIN_DISK_SPACE / 1024 / 1024}MB required)")
+        }
+
         val episodeDirName = provider.getEpisodeDirName(download.episode.name, download.episode.scanlator)
         val tmpDirName = episodeDirName + AnimeDownloadProvider.TMP_DIR_SUFFIX
         val tmpDir = animeDir.createDirectory(tmpDirName)
@@ -244,13 +273,20 @@ class AnimeDownloader(
         try {
             DiskUtil.createNoMediaFile(tmpDir, context)
 
-            downloadVideoFile(video, tmpDir, download)
+            if (PlayerViewModel.isTorrentUrl(videoUrl)) {
+                resolveTorrentVideo(video)
+            }
+
+            if (video.videoUrl.startsWith("http")) {
+                ffmpegDownloadVideo(video, tmpDir, download)
+            } else {
+                downloadVideoFile(video, tmpDir, download)
+            }
 
             downloadSubtitles(video, tmpDir)
 
             writeMetadata(video, tmpDir)
 
-            // Rename tmp → final
             val finalDir = animeDir.findFile(episodeDirName)
             finalDir?.delete()
             tmpDir.renameTo(episodeDirName)
@@ -264,6 +300,217 @@ class AnimeDownloader(
         }
     }
 
+    private suspend fun resolveVideo(download: AnimeDownload) {
+        withContext(Dispatchers.IO) {
+            val source = download.source
+            val episode = download.episode
+            val sEpisode = SEpisode.create().apply {
+                url = episode.url
+                name = episode.name
+                date_upload = episode.dateUpload
+                episode_number = episode.episodeNumber.toFloat()
+                scanlator = episode.scanlator
+            }
+
+            val videos = mutableListOf<Video>()
+
+            try {
+                videos.addAll(source.getVideoList(sEpisode))
+            } catch (e: Throwable) {
+                logcat(LogPriority.WARN, e) { "Failed to get video list for ${episode.name}" }
+            }
+
+            if (videos.isEmpty()) {
+                try {
+                    val hosters = source.getHosterList(sEpisode)
+                    for (hoster in hosters) {
+                        val hosterVideos = hoster.videoList ?: try {
+                            source.getVideoList(hoster)
+                        } catch (e: Throwable) {
+                            logcat(LogPriority.WARN, e) { "Failed to get videos from hoster ${hoster.hosterName}" }
+                            emptyList()
+                        }
+                        videos.addAll(hosterVideos)
+                    }
+                } catch (e: Throwable) {
+                    logcat(LogPriority.WARN, e) { "Failed to get hoster list for ${episode.name}" }
+                }
+            }
+
+            if (videos.isEmpty()) {
+                logcat(LogPriority.ERROR) { "No videos found for ${episode.name} from source ${source.name}" }
+            }
+
+            val resolved = videos.firstNotNullOfOrNull { video ->
+                try {
+                    var v = source.resolveVideo(video) ?: return@firstNotNullOfOrNull null
+                    if (v.videoUrl.isBlank() && v.videoPageUrl.isNotBlank()) {
+                        val url = try {
+                            source.getVideoUrl(v)
+                        } catch (e: Throwable) {
+                            logcat(LogPriority.WARN, e) { "Failed to resolve video URL for ${video.videoTitle}" }
+                            null
+                        }
+                        if (!url.isNullOrBlank()) {
+                            v = v.copy(videoUrl = url)
+                        }
+                    }
+                    val headers = v.headers ?: source.headers
+                    v.copy(headers = headers).takeIf { it.videoUrl.isNotBlank() }
+                } catch (e: Throwable) {
+                    logcat(LogPriority.WARN, e) { "Failed to resolve video: ${video.videoTitle}" }
+                    null
+                }
+            }
+
+            download.video = resolved
+        }
+    }
+
+    private fun resolveTorrentVideo(video: Video) {
+        TorrentServerService.start()
+        TorrentServerService.wait(10)
+        var index = 0
+        if (video.videoUrl.contains("index=")) {
+            index = try {
+                video.videoUrl.substringAfter("index=").substringBefore("&").toInt()
+            } catch (_: Exception) {
+                0
+            }
+        }
+        val torrent = TorrentServerApi.addTorrent(video.videoUrl, video.videoTitle, "", "", false)
+        video.videoUrl = TorrentServerUtils.getTorrentPlayLink(torrent, index)
+    }
+
+    private suspend fun ffmpegDownloadVideo(video: Video, tmpDir: UniFile, download: AnimeDownload) {
+        withContext(Dispatchers.IO) {
+            isFFmpegRunning.set(true)
+
+            val filename = DiskUtil.buildValidFilename(download.episode.name)
+            tmpDir.findFile("$filename.tmp")?.delete()
+            val videoFile = tmpDir.createFile("$filename.tmp")
+                ?: throw IllegalStateException("Failed to create temp video file")
+
+            try {
+                val ffmpegFilename = videoFile.uri.toFFmpegString(context)
+                val headers = video.headers ?: download.source.headers ?: Headers.Builder().build()
+                val headerOptions = headers.joinToString("", "-headers '", "'") {
+                    "${it.first}: ${it.second.replace("'", "'\\''")}\r\n"
+                }
+
+                val ffmpegOptions = buildFFmpegOptions(video, headerOptions, ffmpegFilename)
+
+                val ffprobeCommand = FFmpegKitConfig.parseArguments(
+                    "$headerOptions -v quiet -show_entries format=duration " +
+                        "-of default=noprint_wrappers=1:nokey=1 \"${video.videoUrl}\"",
+                )
+                val inputDuration = getDuration(ffprobeCommand) ?: 0F
+                val duration = inputDuration.toLong().coerceAtLeast(1L)
+
+                var lastNotifyTime = 0L
+                val statCallback = StatisticsCallback { stats ->
+                    val outTime = stats.time
+                    if (outTime > 0) {
+                        download.progress = ((100 * outTime) / duration).toInt().coerceIn(0, 99)
+                        val now = System.currentTimeMillis()
+                        if (now - lastNotifyTime >= 1000) {
+                            lastNotifyTime = now
+                            notifier.onProgressChange(download)
+                            notifyQueueChanged()
+                        }
+                    }
+                }
+
+                val session = FFmpegSession.create(
+                    ffmpegOptions,
+                    {},
+                    { },
+                    statCallback,
+                )
+
+                if (!isFFmpegRunning.get()) throw Exception("FFmpeg was cancelled")
+
+                currentFFmpegSession = session
+                FFmpegKitConfig.ffmpegExecute(session)
+                currentFFmpegSession = null
+
+                if (ReturnCode.isSuccess(session.returnCode)) {
+                    tmpDir.findFile("$filename.tmp")?.apply {
+                        renameTo("$filename.mkv")
+                    } ?: throw Exception("Downloaded file not found")
+                } else {
+                    session.failStackTrace?.let { trace ->
+                        logcat(LogPriority.ERROR) { trace }
+                    }
+                    throw Exception("FFmpeg download failed")
+                }
+            } finally {
+                currentFFmpegSession = null
+                isFFmpegRunning.set(false)
+            }
+        }
+    }
+
+    private fun buildFFmpegOptions(video: Video, headerOptions: String, ffmpegFilename: String): Array<String> {
+        fun formatInputs(tracks: List<Track>) = tracks.joinToString(" ", postfix = " ") {
+            buildList {
+                if (it.url.startsWith("http")) {
+                    add(headerOptions)
+                }
+                add("-i")
+                add("\"${it.url}\"")
+            }.joinToString(" ")
+        }
+
+        fun formatMaps(tracks: List<Track>, type: String, offset: Int = 0) = tracks.indices.joinToString(" ") {
+            "-map ${it + 1 + offset}:$type"
+        }
+
+        fun formatMetadata(tracks: List<Track>, type: String) = tracks.mapIndexed { i, track ->
+            "-metadata:s:$type:$i \"title=${track.lang}\""
+        }.joinToString(" ")
+
+        val subtitleInputs = formatInputs(video.subtitleTracks)
+        val subtitleMaps = formatMaps(video.subtitleTracks, "s")
+        val subtitleMetadata = formatMetadata(video.subtitleTracks, "s")
+
+        val audioInputs = formatInputs(video.audioTracks)
+        val audioMaps = formatMaps(video.audioTracks, "a", video.subtitleTracks.size)
+        val audioMetadata = formatMetadata(video.audioTracks, "a")
+
+        val videoInput = buildList {
+            if (video.videoUrl.startsWith("http")) {
+                add(headerOptions)
+            }
+            add("-i")
+            add("\"${video.videoUrl}\"")
+        }.joinToString(" ")
+
+        val command = listOf(
+            videoInput, subtitleInputs, audioInputs,
+            "-map 0:v", audioMaps, "-map 0:a?", subtitleMaps, "-map 0:s? -map 0:t?",
+            "-f matroska -c:a copy -c:v copy -c:s copy",
+            subtitleMetadata, audioMetadata,
+            "\"$ffmpegFilename\" -y",
+        )
+            .filter(String::isNotBlank)
+            .joinToString(" ")
+
+        return FFmpegKitConfig.parseArguments(command)
+    }
+
+    private fun getDuration(ffprobeCommand: Array<String>): Float? {
+        val session = FFprobeSession.create(ffprobeCommand)
+        FFmpegKitConfig.ffprobeExecute(session)
+        return session.allLogsAsString.trim().toFloatOrNull()
+    }
+
+    private fun cancelFFmpeg() {
+        isFFmpegRunning.set(false)
+        currentFFmpegSession?.cancel()
+        currentFFmpegSession = null
+    }
+
     private suspend fun downloadVideoFile(video: Video, tmpDir: UniFile, download: AnimeDownload) {
         withContext(Dispatchers.IO) {
             val extension = guessVideoExtension(video.videoUrl)
@@ -334,7 +581,12 @@ class AnimeDownloader(
                         }
 
                         val body = response.body
-                        val contentLength = body.contentLength() + (if (response.code == 206) downloadedBytes else 0)
+                        val rawContentLength = body.contentLength()
+                        val contentLength = if (rawContentLength >= 0) {
+                            rawContentLength + (if (response.code == 206) downloadedBytes else 0)
+                        } else {
+                            -1L
+                        }
 
                         RandomAccessFile(outputFile, "rw").use { raf ->
                             val startPos = if (response.code == 206) downloadedBytes else 0
@@ -424,14 +676,10 @@ class AnimeDownloader(
         }
     }
 
-    private fun isStreamingUrl(url: String): Boolean {
-        val path = url.substringBefore('?').lowercase()
-        return path.endsWith(".mpd") ||
-            path.endsWith(".m3u8") ||
-            path.endsWith(".m3u") ||
-            path.contains("/manifest") && (path.endsWith(".mpd") || path.contains("dash"))
-    }
 }
 
+// Video files are much larger than manga pages — require 500 MB free
+private const val MIN_DISK_SPACE = 500L * 1024 * 1024
+
 internal fun subtitleExtensionFromUrl(url: String): String =
     url.substringAfterLast('.').substringBefore('?').take(5).ifBlank { "srt" }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/model/AnimeDownload.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/model/AnimeDownload.kt
index a2841768ae..ff650bd746 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/model/AnimeDownload.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/model/AnimeDownload.kt
@@ -11,9 +11,12 @@ data class AnimeDownload(
     val source: AnimeHttpSource,
     val anime: Anime,
     val episode: Episode,
-    val video: Video? = null,
+    @Volatile var video: Video? = null,
 ) {
+    @Volatile
     var totalBytes: Long = -1L
+
+    @Volatile
     var downloadedBytes: Long = 0L
 
     @Transient
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/notification/NotificationReceiver.kt b/app/src/main/java/eu/kanade/tachiyomi/data/notification/NotificationReceiver.kt
index eba32ac59e..b082167ad3 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/notification/NotificationReceiver.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/notification/NotificationReceiver.kt
@@ -7,6 +7,7 @@ import android.content.Intent
 import android.net.Uri
 import androidx.core.net.toUri
 import eu.kanade.tachiyomi.data.backup.restore.BackupRestoreJob
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.library.LibraryUpdateJob
 import eu.kanade.tachiyomi.data.sync.SyncDataJob
@@ -48,17 +49,27 @@ class NotificationReceiver : BroadcastReceiver() {
     private val getChapter: GetChapter by injectLazy()
     private val updateChapter: UpdateChapter by injectLazy()
     private val downloadManager: DownloadManager by injectLazy()
+    private val animeDownloadManager: AnimeDownloadManager by injectLazy()
 
     override fun onReceive(context: Context, intent: Intent) {
         when (intent.action) {
             // Dismiss notification
             ACTION_DISMISS_NOTIFICATION -> dismissNotification(context, intent.getIntExtra(EXTRA_NOTIFICATION_ID, -1))
             // Resume the download service
-            ACTION_RESUME_DOWNLOADS -> downloadManager.startDownloads()
+            ACTION_RESUME_DOWNLOADS -> {
+                downloadManager.startDownloads()
+                animeDownloadManager.startDownloads()
+            }
             // Pause the download service
-            ACTION_PAUSE_DOWNLOADS -> downloadManager.pauseDownloads()
+            ACTION_PAUSE_DOWNLOADS -> {
+                downloadManager.pauseDownloads()
+                animeDownloadManager.pauseDownloads()
+            }
             // Clear the download queue
-            ACTION_CLEAR_DOWNLOADS -> downloadManager.clearQueue()
+            ACTION_CLEAR_DOWNLOADS -> {
+                downloadManager.clearQueue()
+                animeDownloadManager.clearQueue()
+            }
             // Launch share activity and dismiss notification
             ACTION_SHARE_IMAGE ->
                 shareImage(
diff --git a/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt b/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
index a27fcf6bfc..83ec45b367 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/di/AppModule.kt
@@ -54,6 +54,7 @@ import tachiyomi.core.common.storage.AndroidStorageFolderProvider
 import tachiyomi.core.common.storage.UniFileTempFileManager
 import tachiyomi.data.AndroidDatabaseHandler
 import tachiyomi.data.Database
+import tachiyomi.data.Anime_history
 import tachiyomi.data.Animes
 import tachiyomi.data.AnimeUpdateStrategyColumnAdapter
 import tachiyomi.data.DatabaseHandler
@@ -139,6 +140,9 @@ class AppModule(val app: Application) : InjektModule {
                     genreAdapter = StringListColumnAdapter,
                     update_strategyAdapter = UpdateStrategyColumnAdapter,
                 ),
+                anime_historyAdapter = Anime_history.Adapter(
+                    last_watchedAdapter = DateColumnAdapter,
+                ),
                 animesAdapter = Animes.Adapter(
                     genreAdapter = StringListColumnAdapter,
                     update_strategyAdapter = AnimeUpdateStrategyColumnAdapter,
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
index b490cb1034..34b8881434 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
@@ -8,9 +8,11 @@ import eu.kanade.tachiyomi.torrentServer.model.TorrentRequest
 import kotlinx.serialization.json.Json
 import logcat.LogPriority
 import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.MultipartBody
 import okhttp3.RequestBody.Companion.toRequestBody
 import tachiyomi.core.common.util.system.logcat
 import uy.kohesive.injekt.injectLazy
+import java.io.InputStream
 
 object TorrentServerApi {
     private val network: NetworkHelper by injectLazy()
@@ -77,4 +79,32 @@ object TorrentServerApi {
         ).execute()
         return Json.decodeFromString<List<Torrent>>(resp.body.string())
     }
+
+    fun uploadTorrent(
+        file: InputStream,
+        title: String,
+        poster: String = "",
+        data: String = "",
+        save: Boolean = false,
+    ): Torrent {
+        val fileBytes = file.readBytes()
+        val body = MultipartBody.Builder()
+            .setType(MultipartBody.FORM)
+            .addFormDataPart("title", title)
+            .addFormDataPart("poster", poster)
+            .addFormDataPart("data", data)
+            .addFormDataPart("save", save.toString())
+            .addFormDataPart(
+                "file1",
+                "filename",
+                fileBytes.toRequestBody("application/x-bittorrent".toMediaTypeOrNull()),
+            )
+            .build()
+        val request = okhttp3.Request.Builder()
+            .url("$hostUrl/torrent/upload")
+            .post(body)
+            .build()
+        val resp = network.client.newCall(request).execute()
+        return Json.decodeFromString(Torrent.serializer(), resp.body.string())
+    }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
index 2900e69bb1..bfb6d4743e 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreen.kt
@@ -10,12 +10,18 @@ import androidx.compose.ui.platform.LocalContext
 import cafe.adriel.voyager.core.model.rememberScreenModel
 import cafe.adriel.voyager.navigator.LocalNavigator
 import cafe.adriel.voyager.navigator.currentOrThrow
+import android.content.Intent
 import eu.kanade.presentation.anime.AnimeScreen
 import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.ui.browse.animesource.globalsearch.GlobalAnimeSearchScreen
 import eu.kanade.tachiyomi.ui.player.PlayerActivity
 import eu.kanade.tachiyomi.util.system.isTabletUi
+import eu.kanade.tachiyomi.util.system.toast
 import tachiyomi.presentation.core.screens.LoadingScreen
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
 
 class AnimeScreen(
     private val animeId: Long,
@@ -51,11 +57,36 @@ class AnimeScreen(
                             PlayerActivity.newIntent(context, animeId, episode.id),
                         )
                     },
-                    onAddToLibraryClicked = screenModel::toggleFavorite,
+                    onAddToLibraryClicked = { screenModel.toggleFavorite() },
+                    onAddToLibraryAnywayClicked = { screenModel.toggleFavorite(checkDuplicate = false) },
                     onTagSearch = { tag -> navigator.push(GlobalAnimeSearchScreen(tag)) },
                     onFilterButtonClicked = {
                         screenModel.showDialog(AnimeScreenModel.Dialog.SettingsSheet)
                     },
+                    onShareClicked = run {
+                        val sourceManager = Injekt.get<tachiyomi.domain.animesource.service.AnimeSourceManager>()
+                        val source = sourceManager.get(s.anime.source) as? AnimeHttpSource
+                        if (source != null) {
+                            {
+                                try {
+                                    val sAnime = SAnime.create().apply {
+                                        url = s.anime.url
+                                        title = s.anime.title
+                                    }
+                                    val url = source.getAnimeUrl(sAnime)
+                                    val intent = Intent(Intent.ACTION_SEND).apply {
+                                        type = "text/plain"
+                                        putExtra(Intent.EXTRA_TEXT, url)
+                                    }
+                                    context.startActivity(Intent.createChooser(intent, null))
+                                } catch (e: Exception) {
+                                    context.toast(e.message)
+                                }
+                            }
+                        } else {
+                            null
+                        }
+                    },
                     onRefresh = screenModel::refreshEpisodes,
                     onDeleteClicked = {
                         screenModel.showDialog(AnimeScreenModel.Dialog.ConfirmDelete)
@@ -73,13 +104,14 @@ class AnimeScreen(
                     onSortModeChanged = screenModel::setSortMode,
                     onDisplayModeChanged = screenModel::setDisplayMode,
                     onMultiBookmarkClicked = { episodes, bookmarked ->
-                        screenModel.toggleBookmark(episodes)
+                        screenModel.toggleBookmark(episodes, bookmarked)
                     },
                     onMultiMarkAsSeenClicked = { episodes, markAsSeen ->
                         screenModel.markEpisodesSeen(episodes, markAsSeen)
                     },
                     onMarkPreviousAsSeenClicked = screenModel::markPreviousAsSeen,
                     onMultiDeleteClicked = screenModel::deleteEpisodeDownloads,
+                    onMultiDownloadClicked = screenModel::downloadEpisodes,
                     onEpisodeSelected = screenModel::toggleSelection,
                     onAllEpisodeSelected = screenModel::toggleAllSelection,
                     onInvertSelection = screenModel::invertSelection,
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
index b79bc2ab6c..56330053e3 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
@@ -19,6 +19,7 @@ import tachiyomi.core.common.util.lang.launchNonCancellable
 import tachiyomi.core.common.util.lang.withIOContext
 import tachiyomi.core.common.util.system.logcat
 import tachiyomi.domain.anime.interactor.GetAnime
+import tachiyomi.domain.anime.interactor.GetDuplicateLibraryAnime
 import tachiyomi.domain.anime.interactor.SetAnimeEpisodeFlags
 import tachiyomi.domain.anime.interactor.UpdateAnime
 import tachiyomi.domain.anime.model.Anime
@@ -48,6 +49,7 @@ class AnimeScreenModel(
     private val episodeRepository: EpisodeRepository = Injekt.get(),
     private val animeSourceManager: AnimeSourceManager = Injekt.get(),
     private val animeDownloadManager: AnimeDownloadManager = Injekt.get(),
+    private val getDuplicateLibraryAnime: GetDuplicateLibraryAnime = Injekt.get(),
 ) : StateScreenModel<AnimeScreenModel.State>(State.Loading) {
 
     private val selectedPositions: Array<Int> = arrayOf(-1, -1)
@@ -329,9 +331,18 @@ class AnimeScreenModel(
         }
     }
 
-    fun toggleFavorite() {
+    fun toggleFavorite(checkDuplicate: Boolean = true) {
         screenModelScope.launchNonCancellable {
             val anime = (state.value as? State.Success)?.anime ?: return@launchNonCancellable
+
+            if (!anime.favorite && checkDuplicate) {
+                val duplicates = getDuplicateLibraryAnime(anime)
+                if (duplicates.isNotEmpty()) {
+                    updateSuccessState { it.copy(dialog = Dialog.DuplicateAnime(duplicates)) }
+                    return@launchNonCancellable
+                }
+            }
+
             updateAnime.await(
                 AnimeUpdate(
                     id = anime.id,
@@ -370,10 +381,10 @@ class AnimeScreenModel(
         }
     }
 
-    fun toggleBookmark(episodes: List<Episode>) {
+    fun toggleBookmark(episodes: List<Episode>, bookmarked: Boolean) {
         screenModelScope.launchNonCancellable {
             val updates = episodes.map {
-                EpisodeUpdate(id = it.id, bookmark = !it.bookmark)
+                EpisodeUpdate(id = it.id, bookmark = bookmarked)
             }
             updateEpisode.awaitAll(updates)
         }
@@ -485,6 +496,15 @@ class AnimeScreenModel(
         }
     }
 
+    fun downloadEpisodes(episodes: List<Episode>) {
+        screenModelScope.launchNonCancellable {
+            val successState = state.value as? State.Success ?: return@launchNonCancellable
+            val anime = successState.anime
+            val videos = episodes.map { null as Video? }
+            animeDownloadManager.downloadEpisodes(anime, episodes, videos)
+        }
+    }
+
     fun deleteEpisodeDownloads(episodes: List<Episode>) {
         screenModelScope.launchNonCancellable {
             val successState = state.value as? State.Success ?: return@launchNonCancellable
@@ -499,6 +519,9 @@ class AnimeScreenModel(
             val sEpisode = SEpisode.create().apply {
                 url = episode.url
                 name = episode.name
+                date_upload = episode.dateUpload
+                episode_number = episode.episodeNumber.toFloat()
+                scanlator = episode.scanlator
             }
 
             val videos = mutableListOf<Video>()
@@ -589,6 +612,7 @@ class AnimeScreenModel(
         data object SettingsSheet : Dialog
         data class DownloadLoading(val episode: Episode) : Dialog
         data class QualitySelection(val episode: Episode, val videos: List<Video>) : Dialog
+        data class DuplicateAnime(val duplicates: List<Anime>) : Dialog
     }
 
     // endregion
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadQueueScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadQueueScreen.kt
index b65a258473..e13a1215a9 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadQueueScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadQueueScreen.kt
@@ -60,6 +60,7 @@ import eu.kanade.presentation.components.DropdownMenu
 import eu.kanade.presentation.components.NestedMenuItem
 import eu.kanade.presentation.theme.colorscheme.AndroidViewColorScheme
 import eu.kanade.presentation.util.Screen
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
 import eu.kanade.tachiyomi.data.ocr.OcrQueueItem
 import eu.kanade.tachiyomi.data.ocr.OcrQueueStatus
 import eu.kanade.tachiyomi.databinding.DownloadListBinding
@@ -89,8 +90,9 @@ object DownloadQueueScreen : Screen() {
         }
         val downloadList by screenModel.state.collectAsState()
         val ocrQueue by screenModel.ocrQueueState.collectAsState()
+        val animeQueue by screenModel.animeQueueState.collectAsState()
         val downloadCount by remember {
-            derivedStateOf { downloadList.sumOf { it.subItems.size } }
+            derivedStateOf { downloadList.sumOf { it.subItems.size } + animeQueue.size }
         }
 
         val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior(rememberTopAppBarState())
@@ -252,7 +254,7 @@ object DownloadQueueScreen : Screen() {
                 )
             },
         ) { contentPadding ->
-            if (downloadList.isEmpty() && ocrQueue.isEmpty()) {
+            if (downloadList.isEmpty() && animeQueue.isEmpty() && ocrQueue.isEmpty()) {
                 EmptyScreen(
                     stringRes = MR.strings.information_no_downloads,
                     modifier = Modifier.padding(contentPadding),
@@ -312,6 +314,17 @@ object DownloadQueueScreen : Screen() {
                     },
                 )
 
+                if (animeQueue.isNotEmpty()) {
+                    AnimeQueueSection(
+                        animeQueue = animeQueue,
+                        onCancelClick = { screenModel.cancelAnimeDownload(it) },
+                        modifier = Modifier.padding(
+                            start = with(density) { left.toDp() },
+                            end = with(density) { right.toDp() },
+                        ),
+                    )
+                }
+
                 if (ocrQueue.isNotEmpty()) {
                     OcrQueueSection(
                         ocrQueue = ocrQueue,
@@ -473,3 +486,135 @@ private fun OcrQueueItemRow(
         }
     }
 }
+
+@Composable
+private fun AnimeQueueSection(
+    animeQueue: List<AnimeDownload>,
+    onCancelClick: (AnimeDownload) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(modifier = modifier) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 16.dp, vertical = 8.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Text(
+                text = stringResource(MR.strings.label_anime),
+                style = MaterialTheme.typography.titleSmall,
+                color = MaterialTheme.colorScheme.primary,
+            )
+            Spacer(modifier = Modifier.width(8.dp))
+            Pill(
+                text = "${animeQueue.size}",
+                color = MaterialTheme.colorScheme.primary.copy(alpha = 0.12f),
+                fontSize = 12.sp,
+            )
+        }
+
+        animeQueue.forEach { download ->
+            AnimeDownloadItemRow(
+                download = download,
+                onCancelClick = { onCancelClick(download) },
+            )
+        }
+    }
+}
+
+@Composable
+private fun AnimeDownloadItemRow(
+    download: AnimeDownload,
+    onCancelClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val progress by download.progressFlow.collectAsState()
+    val status by download.statusFlow.collectAsState()
+
+    Row(
+        modifier = modifier
+            .fillMaxWidth()
+            .padding(horizontal = 16.dp, vertical = 8.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Column(modifier = Modifier.weight(1f)) {
+            Text(
+                text = download.episode.name,
+                style = MaterialTheme.typography.bodyMedium,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
+            Text(
+                text = download.anime.title,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+            )
+
+            val statusText = when (status) {
+                AnimeDownload.State.QUEUE -> stringResource(MR.strings.paused)
+                AnimeDownload.State.DOWNLOADING -> "$progress%"
+                AnimeDownload.State.DOWNLOADED -> stringResource(MR.strings.completed)
+                AnimeDownload.State.ERROR -> stringResource(MR.strings.download_notifier_title_error)
+                AnimeDownload.State.NOT_DOWNLOADED -> ""
+            }
+
+            if (statusText.isNotEmpty()) {
+                Text(
+                    text = statusText,
+                    style = MaterialTheme.typography.labelSmall,
+                    color = when (status) {
+                        AnimeDownload.State.ERROR -> MaterialTheme.colorScheme.error
+                        else -> MaterialTheme.colorScheme.onSurfaceVariant
+                    },
+                )
+            }
+        }
+
+        Box(
+            modifier = Modifier.size(48.dp),
+            contentAlignment = Alignment.Center,
+        ) {
+            when (status) {
+                AnimeDownload.State.QUEUE -> {
+                    CircularProgressIndicator(
+                        modifier = Modifier.size(24.dp),
+                        strokeWidth = 2.dp,
+                    )
+                }
+                AnimeDownload.State.DOWNLOADING -> {
+                    CircularProgressIndicator(
+                        progress = { progress / 100f },
+                        modifier = Modifier.size(32.dp),
+                        strokeWidth = 3.dp,
+                    )
+                }
+                AnimeDownload.State.DOWNLOADED -> {
+                    Icon(
+                        imageVector = Icons.Filled.CheckCircle,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.primary,
+                    )
+                }
+                AnimeDownload.State.ERROR -> {
+                    Icon(
+                        imageVector = Icons.Outlined.ErrorOutline,
+                        contentDescription = null,
+                        tint = MaterialTheme.colorScheme.error,
+                    )
+                }
+                else -> {}
+            }
+        }
+
+        if (status != AnimeDownload.State.DOWNLOADED) {
+            IconButton(onClick = onCancelClick) {
+                Icon(
+                    imageVector = Icons.Outlined.Close,
+                    contentDescription = stringResource(MR.strings.action_cancel),
+                )
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadQueueScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadQueueScreenModel.kt
index 4630e65014..885f3a0d07 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadQueueScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/download/DownloadQueueScreenModel.kt
@@ -5,6 +5,8 @@ import cafe.adriel.voyager.core.model.ScreenModel
 import cafe.adriel.voyager.core.model.screenModelScope
 import cafe.adriel.voyager.navigator.Navigator
 import eu.kanade.tachiyomi.R
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
+import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.data.download.model.Download
 import eu.kanade.tachiyomi.data.ocr.OcrManager
@@ -32,6 +34,7 @@ import uy.kohesive.injekt.api.get
 
 class DownloadQueueScreenModel(
     private val downloadManager: DownloadManager = Injekt.get(),
+    private val animeDownloadManager: AnimeDownloadManager = Injekt.get(),
     // KMK -->
     private val navigator: Navigator? = null,
     // KMK <--
@@ -45,6 +48,9 @@ class DownloadQueueScreenModel(
     // OCR queue state
     val ocrQueueState: StateFlow<List<OcrQueueItem>> = ocrManager.queueState
 
+    // Anime download queue state
+    val animeQueueState = animeDownloadManager.queueState
+
     lateinit var controllerBinding: DownloadListBinding
 
     var adapter: DownloadAdapter? = null
@@ -142,7 +148,10 @@ class DownloadQueueScreenModel(
         adapter = null
     }
 
-    val isDownloaderRunning = downloadManager.isDownloaderRunning
+    val isDownloaderRunning = combine(
+        downloadManager.isDownloaderRunning,
+        animeDownloadManager.isDownloaderRunning,
+    ) { manga, anime -> manga || anime }
         .stateIn(screenModelScope, SharingStarted.WhileSubscribed(5000), false)
 
     val isOcrRunning: StateFlow<Boolean> = ocrManager.queueState
@@ -154,14 +163,17 @@ class DownloadQueueScreenModel(
 
     fun startDownloads() {
         downloadManager.startDownloads()
+        animeDownloadManager.startDownloads()
     }
 
     fun pauseDownloads() {
         downloadManager.pauseDownloads()
+        animeDownloadManager.pauseDownloads()
     }
 
     fun clearQueue() {
         downloadManager.clearQueue()
+        animeDownloadManager.clearQueue()
     }
 
     fun reorder(downloads: List<Download>) {
@@ -178,6 +190,10 @@ class DownloadQueueScreenModel(
     }
     // KMK <--
 
+    fun cancelAnimeDownload(download: AnimeDownload) {
+        animeDownloadManager.cancelEpisodeDownload(download)
+    }
+
     // Chimahon: OCR methods
     fun cancelOcr(chapterId: Long) {
         screenModelScope.launch {
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/more/MoreTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/more/MoreTab.kt
index 728ac356e1..90b90d78b0 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/more/MoreTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/more/MoreTab.kt
@@ -25,6 +25,7 @@ import eu.kanade.presentation.util.Tab
 import eu.kanade.tachiyomi.R
 import eu.kanade.tachiyomi.data.connections.discord.DiscordRPCService
 import eu.kanade.tachiyomi.data.connections.discord.DiscordScreen
+import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
 import eu.kanade.tachiyomi.data.download.DownloadManager
 import eu.kanade.tachiyomi.ui.category.CategoryScreen
 import eu.kanade.tachiyomi.ui.download.DownloadQueueScreen
@@ -114,6 +115,7 @@ data object MoreTab : Tab {
 
 private class MoreScreenModel(
     private val downloadManager: DownloadManager = Injekt.get(),
+    private val animeDownloadManager: AnimeDownloadManager = Injekt.get(),
     preferences: BasePreferences = Injekt.get(),
     // SY -->
     uiPreferences: UiPreferences = Injekt.get(),
@@ -131,12 +133,17 @@ private class MoreScreenModel(
     val downloadQueueState: StateFlow<DownloadQueueState> = _downloadQueueState.asStateFlow()
 
     init {
-        // Handle running/paused status change and queue progress updating
         screenModelScope.launchIO {
             combine(
                 downloadManager.isDownloaderRunning,
                 downloadManager.queueState,
-            ) { isRunning, downloadQueue -> Pair(isRunning, downloadQueue.size) }
+                animeDownloadManager.isDownloaderRunning,
+                animeDownloadManager.queueState,
+            ) { mangaRunning, mangaQueue, animeRunning, animeQueue ->
+                val totalSize = mangaQueue.size + animeQueue.size
+                val isRunning = mangaRunning || animeRunning
+                Pair(isRunning, totalSize)
+            }
                 .collectLatest { (isDownloading, downloadQueueSize) ->
                     val pendingDownloadExists = downloadQueueSize != 0
                     _downloadQueueState.value = when {
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
index 82f862069f..aeeb63897f 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
@@ -57,14 +57,15 @@ import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
 import eu.kanade.tachiyomi.ui.player.setting.SubtitlePreferences
 import eu.kanade.tachiyomi.ui.player.utils.TrackSelect
 import eu.kanade.tachiyomi.ui.reader.viewer.OcrLookupPopup
+import eu.kanade.tachiyomi.data.torrentServer.service.TorrentServerService
+import eu.kanade.tachiyomi.torrentServer.TorrentServerApi
+import eu.kanade.tachiyomi.torrentServer.TorrentServerUtils
 import `is`.xyz.mpv.MPVLib
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import logcat.LogPriority
@@ -97,6 +98,7 @@ class PlayerActivity : ComponentActivity() {
     private var restoreAudioFocus: () -> Unit = {}
     private var hideSliderJob: Job? = null
     private var aniSkipFetched = false
+    private var pausedByBackgrounding = false
 
     private val subtitleFilePicker = registerForActivityResult(
         ActivityResultContracts.OpenDocument(),
@@ -245,30 +247,33 @@ class PlayerActivity : ComponentActivity() {
             )
         }
 
-        viewModel.eventFlow
-            .onEach { event ->
-                when (event) {
-                    is PlayerViewModel.Event.Error -> {
-                        logcat(LogPriority.ERROR) { "Player error: ${event.message}" }
-                        finish()
-                    }
-                    is PlayerViewModel.Event.PlaybackCompleted -> {}
-                    is PlayerViewModel.Event.PauseForLookup -> mpvView?.pause()
-                    is PlayerViewModel.Event.ResumeFromLookup -> mpvView?.resume()
-                    is PlayerViewModel.Event.EpisodeChanged -> playCurrentEpisode()
-                    is PlayerViewModel.Event.ShowToast -> {
-                        android.widget.Toast.makeText(this@PlayerActivity, event.message, android.widget.Toast.LENGTH_SHORT).show()
-                    }
-                    is PlayerViewModel.Event.SeekTo -> {
-                        mpvView?.seekTo(event.positionSec)
-                    }
-                    is PlayerViewModel.Event.PauseForTimer -> {
-                        mpvView?.pause()
-                        window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+        lifecycleScope.launch {
+            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                viewModel.eventFlow.collect { event ->
+                    when (event) {
+                        is PlayerViewModel.Event.Error -> {
+                            logcat(LogPriority.ERROR) { "Player error: ${event.message}" }
+                            android.widget.Toast.makeText(this@PlayerActivity, event.message, android.widget.Toast.LENGTH_LONG).show()
+                            finish()
+                        }
+                        is PlayerViewModel.Event.PlaybackCompleted -> {}
+                        is PlayerViewModel.Event.PauseForLookup -> mpvView?.pause()
+                        is PlayerViewModel.Event.ResumeFromLookup -> mpvView?.resume()
+                        is PlayerViewModel.Event.EpisodeChanged -> playCurrentEpisode()
+                        is PlayerViewModel.Event.ShowToast -> {
+                            android.widget.Toast.makeText(this@PlayerActivity, event.message, android.widget.Toast.LENGTH_SHORT).show()
+                        }
+                        is PlayerViewModel.Event.SeekTo -> {
+                            mpvView?.seekTo(event.positionSec)
+                        }
+                        is PlayerViewModel.Event.PauseForTimer -> {
+                            mpvView?.pause()
+                            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
+                        }
                     }
                 }
             }
-            .launchIn(lifecycleScope)
+        }
     }
 
     private fun onMPVViewReady(view: MPVView) {
@@ -313,12 +318,6 @@ class PlayerActivity : ComponentActivity() {
         playerObserver = observer
         MPVLib.addObserver(observer)
 
-        val screenshotDir = android.os.Environment.getExternalStoragePublicDirectory(
-            android.os.Environment.DIRECTORY_PICTURES,
-        )
-        screenshotDir.mkdirs()
-        MPVLib.setOptionString("screenshot-directory", screenshotDir.path)
-
         val animeId = intent.getLongExtra(PlayerViewModel.KEY_ANIME_ID, -1L)
         val episodeId = intent.getLongExtra(PlayerViewModel.KEY_EPISODE_ID, -1L)
         val videoUrl = resolveVideoUrl(intent)
@@ -340,9 +339,25 @@ class PlayerActivity : ComponentActivity() {
                 logcat(LogPriority.ERROR, tag = "Player") { "No playable video URL found for episode" }
                 return@launchIO
             }
+            if (playerPreferences.alwaysUseExternalPlayer().get()) {
+                val extIntent = ExternalIntents.newIntent(
+                    this@PlayerActivity, animeId, episodeId, url, resolvedVideo,
+                )
+                if (extIntent != null) {
+                    withContext(Dispatchers.Main) {
+                        startActivity(extIntent)
+                        finish()
+                    }
+                    return@launchIO
+                }
+            }
             val resumePos = state.currentPositionSec
                 .takeIf { it > 0 } ?: episode.lastSecondSeen
-            val playUrl = resolvePlaybackUrl(url)
+            val playUrl = if (PlayerViewModel.isTorrentUrl(url)) {
+                resolveTorrentUrl(url, resolvedVideo?.videoTitle ?: episode.name)
+            } else {
+                resolvePlaybackUrl(url)
+            }
             val headers = resolvedVideo?.headers?.let { h ->
                 (0 until h.size).associate { i -> h.name(i) to h.value(i) }
             }
@@ -561,7 +576,7 @@ class PlayerActivity : ComponentActivity() {
     }
 
     private fun handleBack() {
-        if (playerPreferences.enablePip().get() && !isInPictureInPictureMode) {
+        if (playerPreferences.pipOnExit().get() && !isInPictureInPictureMode) {
             enterPipMode()
         } else {
             finish()
@@ -693,6 +708,7 @@ class PlayerActivity : ComponentActivity() {
 
     private fun playCurrentEpisode() {
         val view = mpvView ?: return
+        aniSkipFetched = false
         val state = viewModel.state.value
         val episode = state.episode ?: return
         val resolvedVideo = state.resolvedVideo
@@ -700,15 +716,28 @@ class PlayerActivity : ComponentActivity() {
             ?: episode.url.takeIf { PlayerViewModel.isPlayableScheme(it) }
         if (url.isNullOrBlank()) return
         val resumePos = episode.lastSecondSeen
-        val playUrl = resolvePlaybackUrl(url)
         val headers = resolvedVideo?.headers?.let { h ->
             (0 until h.size).associate { i -> h.name(i) to h.value(i) }
         }
-        view.playFile(playUrl, resumePos, headers)
-        resolvedVideo?.subtitleTracks?.forEach { track ->
-            view.addSubtitleTrack(track.url, track.lang)
+        if (PlayerViewModel.isTorrentUrl(url)) {
+            lifecycleScope.launchIO {
+                val playUrl = resolveTorrentUrl(url, resolvedVideo?.videoTitle ?: episode.name)
+                withContext(Dispatchers.Main) {
+                    view.playFile(playUrl, resumePos, headers)
+                    resolvedVideo?.subtitleTracks?.forEach { track ->
+                        view.addSubtitleTrack(track.url, track.lang)
+                    }
+                    loadCustomSubtitles(view)
+                }
+            }
+        } else {
+            val playUrl = resolvePlaybackUrl(url)
+            view.playFile(playUrl, resumePos, headers)
+            resolvedVideo?.subtitleTracks?.forEach { track ->
+                view.addSubtitleTrack(track.url, track.lang)
+            }
+            loadCustomSubtitles(view)
         }
-        loadCustomSubtitles(view)
     }
 
     override fun onUserLeaveHint() {
@@ -722,11 +751,16 @@ class PlayerActivity : ComponentActivity() {
         super.onPictureInPictureModeChanged(isInPipMode, newConfig)
         viewModel.updatePipMode(isInPipMode)
         if (!isInPipMode) {
-            setupImmersiveMode()
+            if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
+                setupImmersiveMode()
+            } else {
+                finish()
+            }
         }
     }
 
     private fun enterPipMode() {
+        if (!playerPreferences.enablePip().get()) return
         if (!packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)) return
         val state = viewModel.state.value
         val params = PictureInPictureParams.Builder()
@@ -753,6 +787,18 @@ class PlayerActivity : ComponentActivity() {
         super.onStop()
         if (!isInPictureInPictureMode) {
             viewModel.saveProgress()
+            if (mpvView?.paused == false) {
+                mpvView?.pause()
+                pausedByBackgrounding = true
+            }
+        }
+    }
+
+    override fun onStart() {
+        super.onStart()
+        if (pausedByBackgrounding) {
+            pausedByBackgrounding = false
+            mpvView?.resume()
         }
     }
 
@@ -782,6 +828,7 @@ class PlayerActivity : ComponentActivity() {
     }
 
     private fun setupImmersiveMode() {
+        if (!playerPreferences.playerFullscreen().get()) return
         enableEdgeToEdge()
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
             window.isNavigationBarContrastEnforced = false
@@ -809,13 +856,30 @@ class PlayerActivity : ComponentActivity() {
     private fun resolvePlaybackUrl(url: String): String {
         if (url.startsWith("content://")) {
             val uri = Uri.parse(url)
-            val fd = contentResolver.openFileDescriptor(uri, "r")?.detachFd()
-                ?: return url
+            val pfd = contentResolver.openFileDescriptor(uri, "r") ?: return url
+            val fd = pfd.detachFd()
             return "fdclose://$fd"
         }
         return url
     }
 
+    private fun resolveTorrentUrl(videoUrl: String, title: String): String {
+        TorrentServerService.start()
+        TorrentServerService.wait(10)
+
+        var index = 0
+        if (videoUrl.startsWith("magnet") && videoUrl.contains("index=")) {
+            index = try {
+                videoUrl.substringAfter("index=").substringBefore("&").toInt()
+            } catch (_: NumberFormatException) {
+                0
+            }
+        }
+
+        val torrent = TorrentServerApi.addTorrent(videoUrl, title, "", "", false)
+        return TorrentServerUtils.getTorrentPlayLink(torrent, index)
+    }
+
     private fun resolveVideoUrl(intent: Intent): String? {
         if (intent.action == Intent.ACTION_VIEW) {
             return intent.data?.toString()
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
index a02dbc0c8f..9abe3283a7 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerScreen.kt
@@ -7,6 +7,7 @@ import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -17,6 +18,9 @@ import eu.kanade.tachiyomi.ui.player.controls.SubtitleTapOverlay
 import eu.kanade.tachiyomi.ui.player.controls.components.BrightnessVolumeIndicator
 import eu.kanade.tachiyomi.ui.player.controls.components.StatsOverlay
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
 
 @Composable
 fun PlayerScreen(
@@ -43,6 +47,8 @@ fun PlayerScreen(
     lookupContent: @Composable () -> Unit = {},
 ) {
     val state by viewModel.state.collectAsState()
+    val playerPreferences = remember { Injekt.get<PlayerPreferences>() }
+    val showLoadingCircle = remember { playerPreferences.showLoadingCircle().get() }
 
     Box(
         modifier = Modifier
@@ -73,7 +79,7 @@ fun PlayerScreen(
             onSeekEnd = onSeekEnd,
         )
 
-        if (state.isLoading) {
+        if (state.isLoading && showLoadingCircle) {
             CircularProgressIndicator(
                 color = Color.White,
                 modifier = Modifier.align(Alignment.Center),
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
index c995c2dde3..917a79213c 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
@@ -55,11 +55,12 @@ import tachiyomi.domain.episode.interactor.UpdateEpisode
 import tachiyomi.domain.episode.model.Episode
 import tachiyomi.domain.episode.model.EpisodeUpdate
 import tachiyomi.domain.episode.repository.EpisodeRepository
+import tachiyomi.domain.history.interactor.UpsertAnimeHistory
+import tachiyomi.domain.history.model.AnimeHistoryUpdate
 import tachiyomi.domain.track.interactor.GetTracks
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import java.io.File
-import java.io.InputStream
+import java.util.Date
 import kotlin.time.Duration.Companion.seconds
 
 class PlayerViewModel @JvmOverloads constructor(
@@ -76,6 +77,7 @@ class PlayerViewModel @JvmOverloads constructor(
     private val animeSourceManager: AnimeSourceManager = Injekt.get(),
     private val animeDownloadManager: AnimeDownloadManager = Injekt.get(),
     private val getTracks: GetTracks = Injekt.get(),
+    private val upsertAnimeHistory: UpsertAnimeHistory = Injekt.get(),
 ) : ViewModel() {
 
     private val mutableState = MutableStateFlow(
@@ -105,6 +107,7 @@ class PlayerViewModel @JvmOverloads constructor(
     private val autoSkip = playerPreferences.autoSkipIntro().get()
     private val netflixStyle = playerPreferences.enableNetflixStyleIntroSkip().get()
     private val defaultWaitingTime = playerPreferences.waitingTimeIntroSkip().get()
+    @Volatile
     private var waitingSkipIntro = defaultWaitingTime
 
     init {
@@ -157,10 +160,7 @@ class PlayerViewModel @JvmOverloads constructor(
             var resolvedVideo: Video? = null
             if (anime.source != LOCAL_ANIME_SOURCE_ID) {
                 val source = animeSourceManager.get(anime.source)
-                if (source != null && animeDownloadManager.isEpisodeDownloaded(
-                        episode.name, episode.scanlator, anime.title, anime.source,
-                    )
-                ) {
+                if (source != null) {
                     resolvedVideo = animeDownloadManager.buildVideoForPlayer(anime, episode, source)
                 }
                 if (resolvedVideo == null) {
@@ -168,6 +168,11 @@ class PlayerViewModel @JvmOverloads constructor(
                 }
             }
 
+            if (resolvedVideo == null && anime.source != LOCAL_ANIME_SOURCE_ID) {
+                eventChannel.send(Event.Error("Could not find a playable video for ${episode.name}"))
+                return
+            }
+
             aniSkipStamps = emptyList()
             mpvChapters = emptyList()
             waitingSkipIntro = defaultWaitingTime
@@ -198,11 +203,15 @@ class PlayerViewModel @JvmOverloads constructor(
                 val sEpisode = SEpisode.create().apply {
                     url = episode.url
                     name = episode.name
+                    date_upload = episode.dateUpload
+                    episode_number = episode.episodeNumber.toFloat()
+                    scanlator = episode.scanlator
                 }
 
                 val videos = try {
                     source.getVideoList(sEpisode)
-                } catch (_: Exception) {
+                } catch (e: Exception) {
+                    logcat(LogPriority.WARN, e) { "Failed to get video list for ${episode.name}" }
                     emptyList()
                 }
 
@@ -215,7 +224,8 @@ class PlayerViewModel @JvmOverloads constructor(
                     for (hoster in hosters) {
                         val hosterVideos = hoster.videoList ?: try {
                             source.getVideoList(hoster)
-                        } catch (_: Throwable) {
+                        } catch (e: Throwable) {
+                            logcat(LogPriority.WARN, e) { "Failed to get videos from hoster" }
                             emptyList()
                         }
                         resolveFirstPlayableVideo(source, hosterVideos)?.let {
@@ -226,6 +236,7 @@ class PlayerViewModel @JvmOverloads constructor(
                     logcat(LogPriority.WARN, e) { "Hoster list resolution failed" }
                 }
 
+                logcat(LogPriority.ERROR) { "No playable video found for ${episode.name}" }
                 null
             } catch (e: Exception) {
                 logcat(LogPriority.ERROR, e) { "Failed to resolve video URL from source" }
@@ -250,7 +261,8 @@ class PlayerViewModel @JvmOverloads constructor(
             if (httpSource != null) {
                 resolved = try {
                     httpSource.resolveVideo(video) ?: continue
-                } catch (_: Exception) {
+                } catch (e: Exception) {
+                    logcat(LogPriority.WARN, e) { "Failed to resolve video: ${video.videoTitle}" }
                     video
                 }
             }
@@ -258,7 +270,8 @@ class PlayerViewModel @JvmOverloads constructor(
             if (resolved.videoUrl.isBlank() && resolved.videoPageUrl.isNotBlank() && httpSource != null) {
                 val url = try {
                     httpSource.getVideoUrl(resolved)
-                } catch (_: Throwable) {
+                } catch (e: Throwable) {
+                    logcat(LogPriority.WARN, e) { "Failed to get video URL: ${resolved.videoTitle}" }
                     null
                 }
                 if (!url.isNullOrBlank()) {
@@ -471,13 +484,26 @@ class PlayerViewModel @JvmOverloads constructor(
         val ep = mutableState.value.episode ?: return
         try {
             withIOContext {
-                updateEpisode.await(
-                    EpisodeUpdate(
-                        id = ep.id,
-                        lastSecondSeen = positionSec,
-                        totalSeconds = durationSec,
-                    ),
-                )
+                coroutineScope {
+                    launch {
+                        updateEpisode.await(
+                            EpisodeUpdate(
+                                id = ep.id,
+                                lastSecondSeen = positionSec,
+                                totalSeconds = durationSec,
+                            ),
+                        )
+                    }
+                    launch {
+                        upsertAnimeHistory.await(
+                            AnimeHistoryUpdate(
+                                episodeId = ep.id,
+                                watchedAt = Date(),
+                                sessionWatchDuration = positionSec,
+                            ),
+                        )
+                    }
+                }
             }
         } catch (e: Exception) {
             logcat(LogPriority.ERROR, e) { "Failed to save playback progress" }
@@ -650,16 +676,6 @@ class PlayerViewModel @JvmOverloads constructor(
         return chapters.withIndex().lastOrNull { it.value.start <= pos }
     }
 
-    // Screenshot
-
-    fun takeScreenshot(cachePath: String, showSubtitles: Boolean): InputStream? {
-        val filename = "$cachePath/${System.currentTimeMillis()}_mpv_screenshot_tmp.png"
-        val subtitleFlag = if (showSubtitles) "subtitles" else "video"
-        MPVLib.command(arrayOf("screenshot-to-file", filename, subtitleFlag))
-        val newFile = File("$cachePath/mpv_screenshot.png")
-        File(filename).renameTo(newFile)
-        return newFile.takeIf { it.exists() }?.inputStream()
-    }
 
     // Sleep timer
 
@@ -815,7 +831,11 @@ class PlayerViewModel @JvmOverloads constructor(
         const val KEY_ANIME_ID = "anime_id"
         const val KEY_EPISODE_ID = "episode_id"
         const val LOCAL_ANIME_SOURCE_ID = 0L
-        private val STREAMABLE_SCHEMES = setOf("http", "https", "rtmp", "rtsp", "file", "content")
+        private val STREAMABLE_SCHEMES = setOf("http", "https", "rtmp", "rtsp", "file", "content", "magnet")
+
+        fun isTorrentUrl(url: String): Boolean {
+            return url.startsWith("magnet") || url.endsWith(".torrent")
+        }
 
         fun isPlayableScheme(url: String): Boolean {
             val scheme = url.substringBefore("://").lowercase()
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/GestureHandler.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/GestureHandler.kt
index c45e3ab726..434f0d9195 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/GestureHandler.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/GestureHandler.kt
@@ -32,6 +32,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import eu.kanade.tachiyomi.ui.player.controls.components.DoubleTapSeekTriangles
 import eu.kanade.tachiyomi.ui.player.setting.GesturePreferences
+import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
 import kotlinx.coroutines.delay
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
@@ -53,7 +54,8 @@ fun GestureHandler(
     modifier: Modifier = Modifier,
 ) {
     val gesturePreferences = remember { Injekt.get<GesturePreferences>() }
-    val skipLength = remember { gesturePreferences.skipLengthPreference().get() }
+    val playerPreferences = remember { Injekt.get<PlayerPreferences>() }
+    val skipLength = remember { playerPreferences.doubleTapSeekLength().get() }
     val gestureVolumeBrightness = remember { gesturePreferences.gestureVolumeBrightness().get() }
     val seekGesture = remember { gesturePreferences.gestureHorizontalSeek().get() }
     val swapVolumeBrightness = remember { gesturePreferences.swapVolumeBrightness().get() }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
index 3683b028cb..91c3ffad2e 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/PlayerControlsOverlay.kt
@@ -105,6 +105,7 @@ fun PlayerControlsOverlay(
     val playerPreferences = remember { Injekt.get<PlayerPreferences>() }
     val controlsTimeout = remember { playerPreferences.playerTimeToDisappear().get().toLong() }
     val reduceMotion = remember { playerPreferences.reduceMotion().get() }
+    val showCurrentChapter = remember { playerPreferences.showCurrentChapter().get() }
     val enterAnim = if (reduceMotion) EnterTransition.None else fadeIn()
     val exitAnim = if (reduceMotion) ExitTransition.None else fadeOut()
     LaunchedEffect(state.controlsVisible, state.isPlaying, state.isLocked) {
@@ -291,7 +292,7 @@ fun PlayerControlsOverlay(
                     horizontalArrangement = Arrangement.SpaceBetween,
                     verticalAlignment = Alignment.CenterVertically,
                 ) {
-                    if (state.currentChapter != null && state.currentChapter.name.isNotEmpty()) {
+                    if (showCurrentChapter && state.currentChapter != null && state.currentChapter.name.isNotEmpty()) {
                         CurrentChapter(
                             chapter = state.currentChapter,
                             onClick = { showChaptersSheet = true },
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/MoreSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/MoreSheet.kt
index afd5626c28..e70a1166f1 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/MoreSheet.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/MoreSheet.kt
@@ -84,7 +84,6 @@ fun MoreSheet(
         )
         return
     }
-
     ModalBottomSheet(
         onDismissRequest = onDismiss,
         sheetState = rememberModalBottomSheetState(),
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ScreenshotSheet.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ScreenshotSheet.kt
deleted file mode 100644
index e0dbf46a42..0000000000
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/controls/components/sheets/ScreenshotSheet.kt
+++ /dev/null
@@ -1,110 +0,0 @@
-package eu.kanade.tachiyomi.ui.player.controls.components.sheets
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Photo
-import androidx.compose.material.icons.outlined.Save
-import androidx.compose.material.icons.outlined.Share
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import eu.kanade.presentation.player.components.PlayerSheet
-import eu.kanade.presentation.player.components.SwitchPreference
-import eu.kanade.tachiyomi.ui.player.controls.components.dialogs.PlayerDialog
-import tachiyomi.i18n.MR
-import tachiyomi.presentation.core.components.ActionButton
-import tachiyomi.presentation.core.components.material.padding
-import tachiyomi.presentation.core.i18n.stringResource
-import java.io.InputStream
-
-@Composable
-fun ScreenshotSheet(
-    hasSubTracks: Boolean,
-    showSubtitles: Boolean,
-    onToggleShowSubtitles: (Boolean) -> Unit,
-    cachePath: String,
-    onSetAsCover: (() -> InputStream) -> Unit,
-    onShare: (() -> InputStream) -> Unit,
-    onSave: (() -> InputStream) -> Unit,
-    takeScreenshot: (String, Boolean) -> InputStream?,
-    onDismissRequest: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    var showSetCoverDialog by remember { mutableStateOf(false) }
-
-    PlayerSheet(
-        onDismissRequest,
-        modifier,
-    ) {
-        Column {
-            Row(
-                modifier = Modifier.padding(vertical = MaterialTheme.padding.medium),
-                horizontalArrangement = Arrangement.spacedBy(MaterialTheme.padding.small),
-            ) {
-                ActionButton(
-                    modifier = Modifier.weight(1f),
-                    title = stringResource(MR.strings.action_edit),
-                    icon = Icons.Outlined.Photo,
-                    onClick = { showSetCoverDialog = true },
-                )
-                ActionButton(
-                    modifier = Modifier.weight(1f),
-                    title = stringResource(MR.strings.action_share),
-                    icon = Icons.Outlined.Share,
-                    onClick = {
-                        takeScreenshot(cachePath, showSubtitles)?.let { stream ->
-                            onShare { stream }
-                        }
-                    },
-                )
-                ActionButton(
-                    modifier = Modifier.weight(1f),
-                    title = stringResource(MR.strings.action_save),
-                    icon = Icons.Outlined.Save,
-                    onClick = {
-                        takeScreenshot(cachePath, showSubtitles)?.let { stream ->
-                            onSave { stream }
-                        }
-                    },
-                )
-            }
-
-            if (hasSubTracks) {
-                SwitchPreference(
-                    value = showSubtitles,
-                    onValueChange = onToggleShowSubtitles,
-                    modifier = Modifier.padding(MaterialTheme.padding.medium),
-                    content = {
-                        Text(
-                            text = stringResource(MR.strings.screenshot_show_subs),
-                            style = MaterialTheme.typography.labelLarge,
-                            color = MaterialTheme.colorScheme.primary,
-                        )
-                    },
-                )
-            }
-        }
-    }
-
-    if (showSetCoverDialog) {
-        PlayerDialog(
-            title = stringResource(MR.strings.confirm_set_image_as_cover),
-            modifier = Modifier.fillMaxWidth(fraction = 0.6F).padding(MaterialTheme.padding.medium),
-            onConfirmRequest = {
-                takeScreenshot(cachePath, showSubtitles)?.let { stream ->
-                    onSetAsCover { stream }
-                }
-            },
-            onDismissRequest = { showSetCoverDialog = false },
-        )
-    }
-}
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
index 656eb0b47c..decd34ff47 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/setting/PlayerPreferences.kt
@@ -34,7 +34,7 @@ class PlayerPreferences(
     // PiP
 
     fun enablePip() = preferenceStore.getBoolean("pref_enable_pip", true)
-    fun pipOnExit() = preferenceStore.getBoolean("pref_pip_on_exit", true)
+    fun pipOnExit() = preferenceStore.getBoolean("pref_pip_on_exit", false)
 
     // External player
 
diff --git a/app/src/main/java/eu/kanade/tachiyomi/util/storage/FFmpegUtils.kt b/app/src/main/java/eu/kanade/tachiyomi/util/storage/FFmpegUtils.kt
new file mode 100644
index 0000000000..97bd65b38f
--- /dev/null
+++ b/app/src/main/java/eu/kanade/tachiyomi/util/storage/FFmpegUtils.kt
@@ -0,0 +1,22 @@
+package eu.kanade.tachiyomi.util.storage
+
+import android.content.Context
+import android.net.Uri
+import com.arthenica.ffmpegkit.FFmpegKitConfig
+import com.hippo.unifile.UniFile
+
+fun Uri.toFFmpegString(context: Context): String {
+    return if (this.scheme == "content") {
+        FFmpegKitConfig.getSafParameter(context, this, "rw")
+    } else {
+        this.path!!
+    }.replace("\"", "\\\"")
+}
+
+fun UniFile.toFFmpegString(context: Context? = null): String {
+    return if (context != null && this.uri.scheme == "content") {
+        FFmpegKitConfig.getSafParameter(context, this.uri, "rw")
+    } else {
+        this.filePath!!
+    }.replace("\"", "\\\"")
+}
diff --git a/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
index 373002195e..04e9e8a1e9 100644
--- a/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
+++ b/data/src/main/java/tachiyomi/data/anime/AnimeRepositoryImpl.kt
@@ -124,6 +124,10 @@ class AnimeRepositoryImpl(
         return handler.awaitList { animesQueries.getAllAnime(AnimeMapper::mapAnime) }
     }
 
+    override suspend fun getDuplicateLibraryAnime(id: Long, title: String): List<Anime> {
+        return handler.awaitList { animesQueries.getDuplicateLibraryAnime(title, id, AnimeMapper::mapAnime) }
+    }
+
     private suspend fun partialUpdate(vararg animeUpdates: AnimeUpdate) {
         handler.await(inTransaction = true) {
             animeUpdates.forEach { value ->
diff --git a/data/src/main/java/tachiyomi/data/history/AnimeHistoryMapper.kt b/data/src/main/java/tachiyomi/data/history/AnimeHistoryMapper.kt
new file mode 100644
index 0000000000..188a26d739
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/history/AnimeHistoryMapper.kt
@@ -0,0 +1,55 @@
+package tachiyomi.data.history
+
+import tachiyomi.domain.anime.model.AnimeCover
+import tachiyomi.domain.history.model.AnimeHistory
+import tachiyomi.domain.history.model.AnimeHistoryWithRelations
+import java.util.Date
+
+object AnimeHistoryMapper {
+    fun mapAnimeHistory(
+        id: Long,
+        episodeId: Long,
+        watchedAt: Date?,
+        watchDuration: Long,
+    ): AnimeHistory = AnimeHistory(
+        id = id,
+        episodeId = episodeId,
+        watchedAt = watchedAt,
+        watchDuration = watchDuration,
+    )
+
+    fun mapAnimeHistoryWithRelations(
+        historyId: Long,
+        animeId: Long,
+        episodeId: Long,
+        title: String,
+        thumbnailUrl: String?,
+        sourceId: Long,
+        isFavorite: Boolean,
+        coverLastModified: Long,
+        episodeNumber: Double,
+        seen: Boolean,
+        lastSecondSeen: Long,
+        totalSeconds: Long,
+        watchedAt: Date?,
+        watchDuration: Long,
+    ): AnimeHistoryWithRelations = AnimeHistoryWithRelations(
+        id = historyId,
+        episodeId = episodeId,
+        animeId = animeId,
+        title = title,
+        episodeNumber = episodeNumber,
+        seen = seen,
+        lastSecondSeen = lastSecondSeen,
+        totalSeconds = totalSeconds,
+        watchedAt = watchedAt,
+        watchDuration = watchDuration,
+        coverData = AnimeCover(
+            animeId = animeId,
+            sourceId = sourceId,
+            isAnimeFavorite = isFavorite,
+            url = thumbnailUrl,
+            lastModified = coverLastModified,
+        ),
+    )
+}
diff --git a/data/src/main/java/tachiyomi/data/history/AnimeHistoryRepositoryImpl.kt b/data/src/main/java/tachiyomi/data/history/AnimeHistoryRepositoryImpl.kt
new file mode 100644
index 0000000000..07b7531072
--- /dev/null
+++ b/data/src/main/java/tachiyomi/data/history/AnimeHistoryRepositoryImpl.kt
@@ -0,0 +1,69 @@
+package tachiyomi.data.history
+
+import kotlinx.coroutines.flow.Flow
+import logcat.LogPriority
+import tachiyomi.core.common.util.system.logcat
+import tachiyomi.data.DatabaseHandler
+import tachiyomi.domain.history.model.AnimeHistory
+import tachiyomi.domain.history.model.AnimeHistoryUpdate
+import tachiyomi.domain.history.model.AnimeHistoryWithRelations
+import tachiyomi.domain.history.repository.AnimeHistoryRepository
+
+class AnimeHistoryRepositoryImpl(
+    private val handler: DatabaseHandler,
+) : AnimeHistoryRepository {
+
+    override fun getAnimeHistory(query: String): Flow<List<AnimeHistoryWithRelations>> {
+        return handler.subscribeToList {
+            animeHistoryViewQueries.animeHistory(query, AnimeHistoryMapper::mapAnimeHistoryWithRelations)
+        }
+    }
+
+    override suspend fun getLastAnimeHistory(): AnimeHistoryWithRelations? {
+        return handler.awaitOneOrNull {
+            animeHistoryViewQueries.getLatestAnimeHistory(AnimeHistoryMapper::mapAnimeHistoryWithRelations)
+        }
+    }
+
+    override suspend fun getTotalWatchDuration(): Long {
+        return handler.awaitOne { anime_historyQueries.getWatchDuration() }
+    }
+
+    override suspend fun getHistoryByAnimeId(animeId: Long): List<AnimeHistory> {
+        return handler.awaitList {
+            anime_historyQueries.getHistoryByAnimeId(animeId, AnimeHistoryMapper::mapAnimeHistory)
+        }
+    }
+
+    override suspend fun resetHistoryByAnimeIds(animeIds: List<Long>) {
+        try {
+            handler.await { anime_historyQueries.resetHistoryByAnimeIds(animeIds) }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e)
+        }
+    }
+
+    override suspend fun deleteAllHistory(): Boolean {
+        return try {
+            handler.await { anime_historyQueries.removeAllHistory() }
+            true
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e)
+            false
+        }
+    }
+
+    override suspend fun upsertHistory(historyUpdate: AnimeHistoryUpdate) {
+        try {
+            handler.await {
+                anime_historyQueries.upsert(
+                    historyUpdate.episodeId,
+                    historyUpdate.watchedAt,
+                    historyUpdate.sessionWatchDuration,
+                )
+            }
+        } catch (e: Exception) {
+            logcat(LogPriority.ERROR, throwable = e)
+        }
+    }
+}
diff --git a/data/src/main/sqldelight/tachiyomi/data/anime_history.sq b/data/src/main/sqldelight/tachiyomi/data/anime_history.sq
new file mode 100644
index 0000000000..3ddf5aaace
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/data/anime_history.sq
@@ -0,0 +1,57 @@
+import java.util.Date;
+
+CREATE TABLE anime_history(
+    _id INTEGER NOT NULL PRIMARY KEY,
+    episode_id INTEGER NOT NULL UNIQUE,
+    last_watched INTEGER AS Date,
+    watch_duration INTEGER NOT NULL,
+    FOREIGN KEY(episode_id) REFERENCES episodes (_id)
+    ON DELETE CASCADE
+);
+
+CREATE INDEX anime_history_episode_id_index ON anime_history(episode_id);
+
+getHistoryByAnimeId:
+SELECT
+H._id,
+H.episode_id,
+H.last_watched,
+H.watch_duration
+FROM anime_history H
+JOIN episodes EP
+ON H.episode_id = EP._id
+WHERE EP.anime_id = :animeId AND EP._id = H.episode_id;
+
+resetHistoryByAnimeIds:
+UPDATE anime_history
+SET last_watched = 0
+WHERE _id IN (
+    SELECT H._id
+    FROM animes AN
+    INNER JOIN episodes EP
+    ON AN._id = EP.anime_id
+    INNER JOIN anime_history H
+    ON EP._id = H.episode_id
+    WHERE AN._id IN :animeIds
+);
+
+removeAllHistory:
+DELETE FROM anime_history;
+
+removeResettedHistory:
+DELETE FROM anime_history
+WHERE last_watched = 0;
+
+upsert:
+INSERT INTO anime_history(episode_id, last_watched, watch_duration)
+VALUES (:episodeId, :watchedAt, :watchDuration)
+ON CONFLICT(episode_id)
+DO UPDATE
+SET
+    last_watched = :watchedAt,
+    watch_duration = watch_duration + :watchDuration
+WHERE episode_id = :episodeId;
+
+getWatchDuration:
+SELECT coalesce(sum(watch_duration), 0)
+FROM anime_history;
diff --git a/data/src/main/sqldelight/tachiyomi/data/animes.sq b/data/src/main/sqldelight/tachiyomi/data/animes.sq
index 684457ebdf..b7c3e80fa0 100644
--- a/data/src/main/sqldelight/tachiyomi/data/animes.sq
+++ b/data/src/main/sqldelight/tachiyomi/data/animes.sq
@@ -32,6 +32,7 @@ CREATE TABLE animes(
 
 CREATE INDEX library_favorite_anime_index ON animes(favorite) WHERE favorite = 1;
 CREATE INDEX animes_url_index ON animes(url);
+CREATE INDEX animes_source_index ON animes(source);
 
 CREATE TRIGGER update_last_favorited_at_animes
 AFTER UPDATE OF favorite ON animes
@@ -87,6 +88,13 @@ getAllAnime:
 SELECT *
 FROM animes;
 
+getDuplicateLibraryAnime:
+SELECT *
+FROM animes
+WHERE favorite = 1
+AND lower(title) = :title
+AND _id != :id;
+
 resetIsSyncing:
 UPDATE animes
 SET is_syncing = 0
diff --git a/data/src/main/sqldelight/tachiyomi/data/animes_categories.sq b/data/src/main/sqldelight/tachiyomi/data/animes_categories.sq
index a61049bf9e..f36b9e84a5 100644
--- a/data/src/main/sqldelight/tachiyomi/data/animes_categories.sq
+++ b/data/src/main/sqldelight/tachiyomi/data/animes_categories.sq
@@ -8,6 +8,8 @@ CREATE TABLE animes_categories(
     ON DELETE CASCADE
 );
 
+CREATE INDEX animes_categories_anime_id_index ON animes_categories(anime_id);
+
 CREATE TRIGGER insert_anime_category_update_version AFTER INSERT ON animes_categories
 BEGIN
     UPDATE animes
diff --git a/data/src/main/sqldelight/tachiyomi/data/episodes.sq b/data/src/main/sqldelight/tachiyomi/data/episodes.sq
index b694c084c4..de7b307c83 100644
--- a/data/src/main/sqldelight/tachiyomi/data/episodes.sq
+++ b/data/src/main/sqldelight/tachiyomi/data/episodes.sq
@@ -24,6 +24,7 @@ CREATE TABLE episodes(
 
 CREATE INDEX episodes_anime_id_index ON episodes(anime_id);
 CREATE INDEX episodes_unseen_by_anime_index ON episodes(anime_id, seen) WHERE seen = 0;
+CREATE INDEX episodes_url_index ON episodes(url);
 
 CREATE TRIGGER update_last_modified_at_episodes
 AFTER UPDATE ON episodes
diff --git a/data/src/main/sqldelight/tachiyomi/view/animeHistoryView.sq b/data/src/main/sqldelight/tachiyomi/view/animeHistoryView.sq
new file mode 100644
index 0000000000..3700767752
--- /dev/null
+++ b/data/src/main/sqldelight/tachiyomi/view/animeHistoryView.sq
@@ -0,0 +1,73 @@
+CREATE VIEW animeHistoryView AS
+SELECT
+    anime_history._id AS id,
+    animes._id AS animeId,
+    episodes._id AS episodeId,
+    animes.title,
+    animes.thumbnail_url AS thumbnailUrl,
+    animes.source,
+    animes.favorite,
+    animes.cover_last_modified,
+    episodes.episode_number AS episodeNumber,
+    episodes.seen,
+    episodes.last_second_seen AS lastSecondSeen,
+    episodes.total_seconds AS totalSeconds,
+    anime_history.last_watched AS watchedAt,
+    anime_history.watch_duration AS watchDuration,
+    max_last_watched.last_watched AS maxWatchedAt,
+    max_last_watched.episode_id AS maxWatchedAtEpisodeId
+FROM animes
+JOIN episodes
+ON animes._id = episodes.anime_id
+JOIN anime_history
+ON episodes._id = anime_history.episode_id
+JOIN (
+    SELECT episodes.anime_id, episodes._id AS episode_id, MAX(anime_history.last_watched) AS last_watched
+    FROM episodes JOIN anime_history
+    ON episodes._id = anime_history.episode_id
+    GROUP BY episodes.anime_id
+) AS max_last_watched
+ON episodes.anime_id = max_last_watched.anime_id;
+
+animeHistory:
+SELECT
+id,
+animeId,
+episodeId,
+title,
+thumbnailUrl,
+source,
+favorite,
+cover_last_modified,
+episodeNumber,
+seen,
+lastSecondSeen,
+totalSeconds,
+watchedAt,
+watchDuration
+FROM animeHistoryView
+WHERE animeHistoryView.watchedAt > 0
+AND maxWatchedAtEpisodeId = animeHistoryView.episodeId
+AND lower(animeHistoryView.title) LIKE ('%' || :query || '%')
+ORDER BY watchedAt DESC;
+
+getLatestAnimeHistory:
+SELECT
+id,
+animeId,
+episodeId,
+title,
+thumbnailUrl,
+source,
+favorite,
+cover_last_modified,
+episodeNumber,
+seen,
+lastSecondSeen,
+totalSeconds,
+watchedAt,
+watchDuration
+FROM animeHistoryView
+WHERE animeHistoryView.watchedAt > 0
+ORDER BY watchedAt DESC
+LIMIT 1;
diff --git a/domain/src/main/java/tachiyomi/domain/anime/interactor/GetDuplicateLibraryAnime.kt b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetDuplicateLibraryAnime.kt
new file mode 100644
index 0000000000..e89b766228
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/anime/interactor/GetDuplicateLibraryAnime.kt
@@ -0,0 +1,13 @@
+package tachiyomi.domain.anime.interactor
+
+import tachiyomi.domain.anime.model.Anime
+import tachiyomi.domain.anime.repository.AnimeRepository
+
+class GetDuplicateLibraryAnime(
+    private val animeRepository: AnimeRepository,
+) {
+
+    suspend operator fun invoke(anime: Anime): List<Anime> {
+        return animeRepository.getDuplicateLibraryAnime(anime.id, anime.title.lowercase())
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt b/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
index ff34ccd524..003b43834d 100644
--- a/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
+++ b/domain/src/main/java/tachiyomi/domain/anime/repository/AnimeRepository.kt
@@ -34,4 +34,6 @@ interface AnimeRepository {
     suspend fun deleteAnime(animeId: Long)
 
     suspend fun getAll(): List<Anime>
+
+    suspend fun getDuplicateLibraryAnime(id: Long, title: String): List<Anime>
 }
diff --git a/domain/src/main/java/tachiyomi/domain/episode/interactor/ShouldUpdateDbEpisode.kt b/domain/src/main/java/tachiyomi/domain/episode/interactor/ShouldUpdateDbEpisode.kt
new file mode 100644
index 0000000000..30b8aae1bd
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/episode/interactor/ShouldUpdateDbEpisode.kt
@@ -0,0 +1,14 @@
+package tachiyomi.domain.episode.interactor
+
+import tachiyomi.domain.episode.model.Episode
+
+class ShouldUpdateDbEpisode {
+
+    fun await(dbEpisode: Episode, sourceEpisode: Episode): Boolean {
+        return dbEpisode.scanlator != sourceEpisode.scanlator ||
+            dbEpisode.name != sourceEpisode.name ||
+            dbEpisode.dateUpload != sourceEpisode.dateUpload ||
+            dbEpisode.episodeNumber != sourceEpisode.episodeNumber ||
+            dbEpisode.sourceOrder != sourceEpisode.sourceOrder
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/history/interactor/GetAnimeHistory.kt b/domain/src/main/java/tachiyomi/domain/history/interactor/GetAnimeHistory.kt
new file mode 100644
index 0000000000..45561f4036
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/history/interactor/GetAnimeHistory.kt
@@ -0,0 +1,19 @@
+package tachiyomi.domain.history.interactor
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.history.model.AnimeHistory
+import tachiyomi.domain.history.model.AnimeHistoryWithRelations
+import tachiyomi.domain.history.repository.AnimeHistoryRepository
+
+class GetAnimeHistory(
+    private val repository: AnimeHistoryRepository,
+) {
+
+    suspend fun await(animeId: Long): List<AnimeHistory> {
+        return repository.getHistoryByAnimeId(animeId)
+    }
+
+    fun subscribe(query: String): Flow<List<AnimeHistoryWithRelations>> {
+        return repository.getAnimeHistory(query)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/history/interactor/RemoveAnimeHistory.kt b/domain/src/main/java/tachiyomi/domain/history/interactor/RemoveAnimeHistory.kt
new file mode 100644
index 0000000000..33254351ba
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/history/interactor/RemoveAnimeHistory.kt
@@ -0,0 +1,16 @@
+package tachiyomi.domain.history.interactor
+
+import tachiyomi.domain.history.repository.AnimeHistoryRepository
+
+class RemoveAnimeHistory(
+    private val repository: AnimeHistoryRepository,
+) {
+
+    suspend fun awaitAll(): Boolean {
+        return repository.deleteAllHistory()
+    }
+
+    suspend fun awaitAnime(animeIds: List<Long>) {
+        repository.resetHistoryByAnimeIds(animeIds)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/history/interactor/UpsertAnimeHistory.kt b/domain/src/main/java/tachiyomi/domain/history/interactor/UpsertAnimeHistory.kt
new file mode 100644
index 0000000000..794c518924
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/history/interactor/UpsertAnimeHistory.kt
@@ -0,0 +1,13 @@
+package tachiyomi.domain.history.interactor
+
+import tachiyomi.domain.history.model.AnimeHistoryUpdate
+import tachiyomi.domain.history.repository.AnimeHistoryRepository
+
+class UpsertAnimeHistory(
+    private val animeHistoryRepository: AnimeHistoryRepository,
+) {
+
+    suspend fun await(historyUpdate: AnimeHistoryUpdate) {
+        animeHistoryRepository.upsertHistory(historyUpdate)
+    }
+}
diff --git a/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistory.kt b/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistory.kt
new file mode 100644
index 0000000000..599356b0a0
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistory.kt
@@ -0,0 +1,10 @@
+package tachiyomi.domain.history.model
+
+import java.util.Date
+
+data class AnimeHistory(
+    val id: Long,
+    val episodeId: Long,
+    val watchedAt: Date?,
+    val watchDuration: Long,
+)
diff --git a/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistoryUpdate.kt b/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistoryUpdate.kt
new file mode 100644
index 0000000000..4769f2d47d
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistoryUpdate.kt
@@ -0,0 +1,9 @@
+package tachiyomi.domain.history.model
+
+import java.util.Date
+
+data class AnimeHistoryUpdate(
+    val episodeId: Long,
+    val watchedAt: Date,
+    val sessionWatchDuration: Long,
+)
diff --git a/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistoryWithRelations.kt b/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistoryWithRelations.kt
new file mode 100644
index 0000000000..4e2df15dbb
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/history/model/AnimeHistoryWithRelations.kt
@@ -0,0 +1,18 @@
+package tachiyomi.domain.history.model
+
+import tachiyomi.domain.anime.model.AnimeCover
+import java.util.Date
+
+data class AnimeHistoryWithRelations(
+    val id: Long,
+    val episodeId: Long,
+    val animeId: Long,
+    val title: String,
+    val episodeNumber: Double,
+    val seen: Boolean,
+    val lastSecondSeen: Long,
+    val totalSeconds: Long,
+    val watchedAt: Date?,
+    val watchDuration: Long,
+    val coverData: AnimeCover,
+)
diff --git a/domain/src/main/java/tachiyomi/domain/history/repository/AnimeHistoryRepository.kt b/domain/src/main/java/tachiyomi/domain/history/repository/AnimeHistoryRepository.kt
new file mode 100644
index 0000000000..dc76e60f14
--- /dev/null
+++ b/domain/src/main/java/tachiyomi/domain/history/repository/AnimeHistoryRepository.kt
@@ -0,0 +1,23 @@
+package tachiyomi.domain.history.repository
+
+import kotlinx.coroutines.flow.Flow
+import tachiyomi.domain.history.model.AnimeHistory
+import tachiyomi.domain.history.model.AnimeHistoryUpdate
+import tachiyomi.domain.history.model.AnimeHistoryWithRelations
+
+interface AnimeHistoryRepository {
+
+    fun getAnimeHistory(query: String): Flow<List<AnimeHistoryWithRelations>>
+
+    suspend fun getLastAnimeHistory(): AnimeHistoryWithRelations?
+
+    suspend fun getTotalWatchDuration(): Long
+
+    suspend fun getHistoryByAnimeId(animeId: Long): List<AnimeHistory>
+
+    suspend fun resetHistoryByAnimeIds(animeIds: List<Long>)
+
+    suspend fun deleteAllHistory(): Boolean
+
+    suspend fun upsertHistory(historyUpdate: AnimeHistoryUpdate)
+}
diff --git a/i18n/src/commonMain/moko-resources/base/strings.xml b/i18n/src/commonMain/moko-resources/base/strings.xml
index 1eaa21043a..d77b7d0794 100644
--- a/i18n/src/commonMain/moko-resources/base/strings.xml
+++ b/i18n/src/commonMain/moko-resources/base/strings.xml
@@ -236,6 +236,104 @@
     <string name="pref_appearance_summary">Theme, date &amp; time format</string>
     <string name="pref_library_summary">Categories, global update, chapter swipe</string>
     <string name="pref_reader_summary">Reading mode, display, navigation</string>
+    <string name="pref_category_player">Player</string>
+    <string name="pref_player_summary">Orientation, gestures, subtitles, audio</string>
+    <string name="pref_player_orientation">Default orientation</string>
+    <string name="pref_player_orientation_free">Free</string>
+    <string name="pref_player_orientation_portrait">Portrait</string>
+    <string name="pref_player_orientation_landscape">Landscape</string>
+    <string name="pref_player_orientation_locked_portrait">Locked portrait</string>
+    <string name="pref_player_orientation_locked_landscape">Locked landscape</string>
+    <string name="pref_player_orientation_reverse_portrait">Reverse portrait</string>
+    <string name="pref_player_keep_screen_on">Keep screen on</string>
+    <string name="pref_player_fullscreen">Fullscreen</string>
+    <string name="pref_player_autoplay">Autoplay next episode</string>
+    <string name="pref_player_show_loading">Show loading indicator</string>
+    <string name="pref_player_show_chapter">Show current chapter</string>
+    <string name="pref_player_reduce_motion">Reduce motion</string>
+    <string name="pref_player_reduce_motion_summary">Reduce animations in the player</string>
+    <string name="pref_player_remember_brightness">Remember brightness</string>
+    <string name="pref_player_remember_brightness_summary">Restore brightness when reopening player</string>
+    <string name="pref_player_remember_volume">Remember volume</string>
+    <string name="pref_player_remember_volume_summary">Restore volume when reopening player</string>
+    <string name="pref_player_preserve_position">Preserve watching position</string>
+    <string name="pref_player_preserve_position_summary">Resume from last position on reopen</string>
+    <string name="pref_player_progress_interval">Progress save interval</string>
+    <string name="pref_player_controls_hide_delay">Controls hide delay</string>
+    <string name="pref_player_double_tap_seek">Double tap seek length</string>
+    <string name="pref_player_progress_threshold">Progress threshold</string>
+    <string name="pref_player_pip">Picture-in-Picture</string>
+    <string name="pref_player_enable_pip">Enable PiP</string>
+    <string name="pref_player_pip_on_exit">PiP on exit</string>
+    <string name="pref_player_pip_on_exit_summary">Enter PiP when navigating away</string>
+    <string name="pref_player_external">External player</string>
+    <string name="pref_player_always_external">Always use external player</string>
+    <string name="pref_player_external_app">External player app</string>
+    <string name="pref_player_aniskip">AniSkip</string>
+    <string name="pref_player_aniskip_enabled">Enable AniSkip</string>
+    <string name="pref_player_aniskip_summary">Community-powered intro/outro skip</string>
+    <string name="pref_player_skip_intro">Enable skip intro button</string>
+    <string name="pref_player_auto_skip_intro">Auto-skip intros</string>
+    <string name="pref_player_netflix_skip">Netflix-style skip button</string>
+    <string name="pref_player_skip_wait_time">Skip button display time</string>
+    <string name="pref_player_gestures">Gestures</string>
+    <string name="pref_player_gesture_vol_bright">Volume/brightness swipe</string>
+    <string name="pref_player_gesture_vol_bright_summary">Swipe on sides to adjust volume and brightness</string>
+    <string name="pref_player_swap_vol_bright">Swap volume and brightness</string>
+    <string name="pref_player_swap_vol_bright_summary">Volume on left, brightness on right</string>
+    <string name="pref_player_gesture_h_seek">Horizontal seek gesture</string>
+    <string name="pref_player_gesture_h_seek_summary">Swipe horizontally to seek</string>
+    <string name="pref_player_skip_length">Seek skip length</string>
+    <string name="pref_player_smooth_seek">Smooth seek</string>
+    <string name="pref_player_smooth_seek_summary">Show video while seeking</string>
+    <string name="pref_player_left_double_tap">Left double tap</string>
+    <string name="pref_player_center_double_tap">Center double tap</string>
+    <string name="pref_player_right_double_tap">Right double tap</string>
+    <string name="pref_player_gesture_none">None</string>
+    <string name="pref_player_gesture_seek">Seek</string>
+    <string name="pref_player_gesture_play_pause">Play/Pause</string>
+    <string name="pref_player_subtitles">Subtitles</string>
+    <string name="pref_player_preferred_sub_lang">Preferred subtitle languages</string>
+    <string name="pref_player_subtitle_font">Font</string>
+    <string name="pref_player_subtitle_font_size">Font size</string>
+    <string name="pref_player_subtitle_bold">Bold</string>
+    <string name="pref_player_subtitle_italic">Italic</string>
+    <string name="pref_player_subtitle_border_style">Border style</string>
+    <string name="pref_player_subtitle_outline">Outline and shadow</string>
+    <string name="pref_player_subtitle_opaque_box">Opaque box</string>
+    <string name="pref_player_subtitle_bg_box">Background box</string>
+    <string name="pref_player_subtitle_border_size">Border size</string>
+    <string name="pref_player_subtitle_shadow_offset">Shadow offset</string>
+    <string name="pref_player_subtitle_position">Subtitle position</string>
+    <string name="pref_player_subtitle_override_ass">Override ASS styles</string>
+    <string name="pref_player_subtitle_override_ass_summary">Apply custom styles to ASS subtitles</string>
+    <string name="pref_player_screenshot_subs">Include subtitles in screenshots</string>
+    <string name="pref_player_audio">Audio</string>
+    <string name="pref_player_preferred_audio_lang">Preferred audio languages</string>
+    <string name="pref_player_pitch_correction">Pitch correction</string>
+    <string name="pref_player_pitch_correction_summary">Correct pitch when changing playback speed</string>
+    <string name="pref_player_audio_channels">Audio channels</string>
+    <string name="pref_player_audio_auto">Auto</string>
+    <string name="pref_player_audio_auto_safe">Auto (safe)</string>
+    <string name="pref_player_audio_mono">Mono</string>
+    <string name="pref_player_audio_stereo">Stereo</string>
+    <string name="pref_player_audio_reverse_stereo">Reverse stereo</string>
+    <string name="pref_player_volume_boost_cap">Volume boost cap</string>
+    <string name="pref_player_advanced">Advanced</string>
+    <string name="pref_player_hw_decoding">Hardware decoding</string>
+    <string name="pref_player_hw_decoding_summary">Use hardware decoder when available</string>
+    <string name="pref_player_gpu_next">GPU Next</string>
+    <string name="pref_player_gpu_next_summary">Use next-generation GPU renderer</string>
+    <string name="pref_player_debanding">Video debanding</string>
+    <string name="pref_player_debanding_none">None</string>
+    <string name="pref_player_debanding_cpu">CPU</string>
+    <string name="pref_player_debanding_gpu">GPU</string>
+    <string name="pref_player_yuv420p">Use YUV420P</string>
+    <string name="pref_player_yuv420p_summary">Force YUV420P pixel format</string>
+    <string name="pref_player_mpv_conf">mpv.conf</string>
+    <string name="pref_player_mpv_conf_summary">Custom mpv configuration</string>
+    <string name="pref_player_mpv_input">input.conf</string>
+    <string name="pref_player_mpv_input_summary">Custom mpv input bindings</string>
     <string name="pref_downloads_summary">Automatic download, download ahead</string>
     <string name="pref_tracking_summary">One-way progress sync, enhanced sync</string>
     <string name="pref_browse_summary">Sources, extensions, global search</string>
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
index df3dedffd1..0122e7f514 100644
--- a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/model/Video.kt
@@ -104,6 +104,32 @@ open class Video(
     @Volatile
     var status: State = State.QUEUE
 
+    fun copy(
+        videoUrl: String = this.videoUrl,
+        videoTitle: String = this.videoTitle,
+        resolution: Int? = this.resolution,
+        bitrate: Int? = this.bitrate,
+        headers: Headers? = this.headers,
+        preferred: Boolean = this.preferred,
+        subtitleTracks: List<Track> = this.subtitleTracks,
+        audioTracks: List<Track> = this.audioTracks,
+        timestamps: List<TimeStamp> = this.timestamps,
+        internalData: String = this.internalData,
+    ): Video {
+        return Video(
+            videoUrl = videoUrl,
+            videoTitle = videoTitle,
+            resolution = resolution,
+            bitrate = bitrate,
+            headers = headers,
+            preferred = preferred,
+            subtitleTracks = subtitleTracks,
+            audioTracks = audioTracks,
+            timestamps = timestamps,
+            internalData = internalData,
+        )
+    }
+
     fun copy(
         videoUrl: String = this.videoUrl,
         videoTitle: String = this.videoTitle,
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/utils/Preferences.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/utils/Preferences.kt
new file mode 100644
index 0000000000..a8484656fa
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/animesource/utils/Preferences.kt
@@ -0,0 +1,19 @@
+package eu.kanade.tachiyomi.animesource.utils
+
+import android.app.Application
+import android.content.Context
+import android.content.SharedPreferences
+import eu.kanade.tachiyomi.animesource.AnimeSource
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+fun preferencesKey(id: Long) = "source_$id"
+
+fun AnimeSource.preferencesKey(): String = preferencesKey(id)
+
+fun sourcePreferences(key: String): SharedPreferences =
+    Injekt.get<Application>().getSharedPreferences(key, Context.MODE_PRIVATE)
+
+fun AnimeSource.sourcePreferences(): SharedPreferences = sourcePreferences(preferencesKey())
+
+fun sourcePreferences(id: Long): SharedPreferences = sourcePreferences(preferencesKey(id))

From 424beea788842787f4cdc35e448a5e77e3430027 Mon Sep 17 00:00:00 2001
From: Sirus <5435333+Sirush@users.noreply.github.com>
Date: Sun, 10 May 2026 16:37:11 +0200
Subject: [PATCH 13/13] Fix torrent streaming

---
 .../animeextension/api/AnimeExtensionApi.kt   |  2 +
 .../animeextension/model/AnimeExtension.kt    |  4 ++
 .../util/AnimeExtensionLoader.kt              |  3 ++
 .../data/animedownload/AnimeDownloader.kt     |  7 +++
 .../data/notification/Notifications.kt        |  4 ++
 .../service/TorrentServerService.kt           |  2 +-
 .../tachiyomi/source/SourceExtensions.kt      | 12 +++++
 .../tachiyomi/ui/anime/AnimeListScreen.kt     |  2 +-
 .../tachiyomi/ui/anime/AnimeScreenModel.kt    | 15 ++++++
 .../eu/kanade/tachiyomi/ui/anime/AnimeTab.kt  |  2 +-
 .../tachiyomi/ui/player/PlayerActivity.kt     | 47 +++++++++++++++++--
 .../tachiyomi/ui/player/PlayerViewModel.kt    | 14 +++++-
 core/common/build.gradle.kts                  |  3 ++
 .../torrentServer/TorrentServerApi.kt         |  9 ++--
 .../torrentServer/TorrentServerPreferences.kt |  0
 .../torrentServer/TorrentServerUtils.kt       |  0
 .../tachiyomi/torrentServer/model/Torrent.kt  | 16 +++++++
 .../torrentServer/model/TorrentRequest.kt     |  0
 source-api/consumer-proguard.pro              |  1 +
 .../tachiyomi/torrentutils/TorrentUtils.kt    | 29 ++++++++++++
 .../torrentutils/model/TorrentFile.kt         | 16 +++++++
 .../torrentutils/model/TorrentInfo.kt         | 15 ++++++
 22 files changed, 189 insertions(+), 14 deletions(-)
 rename {app => core/common}/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt (91%)
 rename {app => core/common}/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt (100%)
 rename {app => core/common}/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt (100%)
 rename {app => core/common}/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt (58%)
 rename {app => core/common}/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt (100%)
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/TorrentUtils.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/model/TorrentFile.kt
 create mode 100644 source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/model/TorrentInfo.kt

diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionApi.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionApi.kt
index d30cde42e9..30d0466481 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionApi.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/api/AnimeExtensionApi.kt
@@ -129,6 +129,7 @@ internal class AnimeExtensionApi {
                     libVersion = it.extractLibVersion(),
                     lang = it.lang,
                     isNsfw = it.nsfw == 1,
+                    isTorrent = it.torrent == 1,
                     sources = it.sources?.map(animeExtensionSourceMapper).orEmpty(),
                     apkName = it.apk,
                     iconUrl = "$repoUrl/icon/${it.pkg}.png",
@@ -156,6 +157,7 @@ private data class AnimeExtensionJsonObject(
     val code: Long,
     val version: String,
     val nsfw: Int,
+    val torrent: Int = 0,
     val sources: List<AnimeExtensionSourceJsonObject>?,
 )
 
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeExtension.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeExtension.kt
index 754fa1d72d..20767dc55c 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeExtension.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/model/AnimeExtension.kt
@@ -13,6 +13,7 @@ sealed class AnimeExtension {
     abstract val libVersion: Double
     abstract val lang: String?
     abstract val isNsfw: Boolean
+    abstract val isTorrent: Boolean
     abstract val signatureHash: String
 
     data class Installed(
@@ -23,6 +24,7 @@ sealed class AnimeExtension {
         override val libVersion: Double,
         override val lang: String,
         override val isNsfw: Boolean,
+        override val isTorrent: Boolean,
         override val signatureHash: String,
         val pkgFactory: String?,
         val sources: List<AnimeSource>,
@@ -41,6 +43,7 @@ sealed class AnimeExtension {
         override val libVersion: Double,
         override val lang: String,
         override val isNsfw: Boolean,
+        override val isTorrent: Boolean,
         override val signatureHash: String,
         val sources: List<Source>,
         val apkName: String,
@@ -73,5 +76,6 @@ sealed class AnimeExtension {
         override val signatureHash: String,
         override val lang: String? = null,
         override val isNsfw: Boolean = false,
+        override val isTorrent: Boolean = false,
     ) : AnimeExtension()
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionLoader.kt b/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionLoader.kt
index 417b49b08b..9bb099354c 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionLoader.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/animeextension/util/AnimeExtensionLoader.kt
@@ -40,6 +40,7 @@ internal object AnimeExtensionLoader {
     private const val METADATA_SOURCE_CLASS = "tachiyomi.animeextension.class"
     private const val METADATA_SOURCE_FACTORY = "tachiyomi.animeextension.factory"
     private const val METADATA_NSFW = "tachiyomi.animeextension.nsfw"
+    private const val METADATA_TORRENT = "tachiyomi.animeextension.torrent"
     const val LIB_VERSION_MIN = 14.0
     const val LIB_VERSION_MAX = 15.0
 
@@ -237,6 +238,7 @@ internal object AnimeExtensionLoader {
             logcat(LogPriority.WARN) { "NSFW anime extension $pkgName not allowed" }
             return AnimeLoadResult.Error
         }
+        val isTorrent = appInfo.metaData.getInt(METADATA_TORRENT) == 1
 
         val classLoader = try {
             ChildFirstPathClassLoader(appInfo.sourceDir, null, context.classLoader)
@@ -285,6 +287,7 @@ internal object AnimeExtensionLoader {
             libVersion = libVersion,
             lang = lang,
             isNsfw = isNsfw,
+            isTorrent = isTorrent,
             sources = sources,
             pkgFactory = appInfo.metaData.getString(METADATA_SOURCE_FACTORY),
             icon = appInfo.loadIcon(pkgManager),
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
index fc24aad486..6a4d95f95e 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/animedownload/AnimeDownloader.kt
@@ -17,6 +17,7 @@ import eu.kanade.tachiyomi.data.torrentServer.service.TorrentServerService
 import eu.kanade.tachiyomi.network.NetworkHelper
 import eu.kanade.tachiyomi.torrentServer.TorrentServerApi
 import eu.kanade.tachiyomi.torrentServer.TorrentServerUtils
+import eu.kanade.tachiyomi.source.isSourceForTorrents
 import eu.kanade.tachiyomi.ui.player.PlayerViewModel
 import eu.kanade.tachiyomi.network.ProgressListener
 import eu.kanade.tachiyomi.util.storage.DiskUtil
@@ -303,6 +304,12 @@ class AnimeDownloader(
     private suspend fun resolveVideo(download: AnimeDownload) {
         withContext(Dispatchers.IO) {
             val source = download.source
+            if (source.isSourceForTorrents()) {
+                TorrentServerService.start()
+                if (TorrentServerService.wait(10)) {
+                    TorrentServerUtils.setTrackersList()
+                }
+            }
             val episode = download.episode
             val sEpisode = SEpisode.create().apply {
                 url = episode.url
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt b/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
index 080e0ff6f4..6c25d699a6 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/notification/Notifications.kt
@@ -164,6 +164,10 @@ object Notifications {
                 buildNotificationChannel(CHANNEL_COMMON, IMPORTANCE_LOW) {
                     setName(context.stringResource(MR.strings.channel_common))
                 },
+                buildNotificationChannel(CHANNEL_TORRENT_SERVER, IMPORTANCE_LOW) {
+                    setName("Torrent server")
+                    setShowBadge(false)
+                },
                 buildNotificationChannel(CHANNEL_LIBRARY_PROGRESS, IMPORTANCE_LOW) {
                     setName(context.stringResource(MR.strings.channel_progress))
                     setGroup(GROUP_LIBRARY)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/data/torrentServer/service/TorrentServerService.kt b/app/src/main/java/eu/kanade/tachiyomi/data/torrentServer/service/TorrentServerService.kt
index 29727834b0..e9baa59c9b 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/data/torrentServer/service/TorrentServerService.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/data/torrentServer/service/TorrentServerService.kt
@@ -70,7 +70,7 @@ class TorrentServerService : Service() {
             PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
         )
         val builder = context.notificationBuilder(Notifications.CHANNEL_TORRENT_SERVER) {
-            setSmallIcon(R.mipmap.ic_launcher)
+            setSmallIcon(android.R.drawable.stat_sys_download)
             setContentText("Torrent server is running")
             setContentTitle("Chimahon")
             setAutoCancel(false)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/source/SourceExtensions.kt b/app/src/main/java/eu/kanade/tachiyomi/source/SourceExtensions.kt
index 30e2a822d7..1c102e2ce9 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/source/SourceExtensions.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/source/SourceExtensions.kt
@@ -1,10 +1,13 @@
 package eu.kanade.tachiyomi.source
 
 import eu.kanade.domain.source.service.SourcePreferences
+import eu.kanade.tachiyomi.animeextension.AnimeExtensionManager
+import eu.kanade.tachiyomi.animesource.AnimeSource
 import eu.kanade.tachiyomi.extension.ExtensionManager
 import exh.source.EH_PACKAGE
 import exh.source.LOCAL_SOURCE_PACKAGE
 import exh.source.isEhBasedSource
+import tachiyomi.domain.animesource.model.StubAnimeSource
 import tachiyomi.domain.source.model.StubSource
 import tachiyomi.presentation.core.icons.FlagEmoji
 import tachiyomi.source.local.isLocal
@@ -92,3 +95,12 @@ fun Source.isIncognitoModeEnabled(incognitoExtensions: Set<String>? = null): Boo
     return extensionPackage in (incognitoExtensions ?: Injekt.get<SourcePreferences>().incognitoExtensions().get())
 }
 // KMK <--
+
+// (TORRENT) -->
+fun AnimeSource?.isSourceForTorrents(): Boolean {
+    if (this == null || this is StubAnimeSource) return false
+    val sourceUsed = Injekt.get<AnimeExtensionManager>().installedExtensionsFlow.value
+        .find { ext -> ext.sources.any { it.id == this.id } }
+    return sourceUsed?.isTorrent == true
+}
+// <-- (TORRENT)
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
index bc399d381e..ab28e52230 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeListScreen.kt
@@ -128,7 +128,7 @@ fun AnimeListScreen(
             },
             onPickFile = {
                 showDialog = false
-                filePickerLauncher.launch(arrayOf("video/*"))
+                filePickerLauncher.launch(arrayOf("video/*", "application/x-bittorrent", "application/octet-stream"))
             },
         )
     }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
index 56330053e3..4888096a5c 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeScreenModel.kt
@@ -4,12 +4,16 @@ import androidx.compose.runtime.Immutable
 import cafe.adriel.voyager.core.model.StateScreenModel
 import cafe.adriel.voyager.core.model.screenModelScope
 import eu.kanade.core.util.addOrRemove
+import eu.kanade.tachiyomi.animesource.AnimeSource
 import eu.kanade.tachiyomi.animesource.model.SAnime
 import eu.kanade.tachiyomi.animesource.model.SEpisode
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
 import eu.kanade.tachiyomi.data.animedownload.model.AnimeDownload
+import eu.kanade.tachiyomi.data.torrentServer.service.TorrentServerService
+import eu.kanade.tachiyomi.source.isSourceForTorrents
+import eu.kanade.tachiyomi.torrentServer.TorrentServerUtils
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.update
@@ -223,6 +227,7 @@ class AnimeScreenModel(
     private suspend fun fetchAnimeFromSource() {
         val anime = getAnime.await(animeId) ?: return
         val source = animeSourceManager.get(anime.source) ?: return
+        prepareTorrentSourceIfNeeded(source)
 
         try {
             val sAnime = SAnime.create().apply {
@@ -257,6 +262,7 @@ class AnimeScreenModel(
     private suspend fun syncEpisodesFromSource() {
         val anime = getAnime.await(animeId) ?: return
         val source = animeSourceManager.get(anime.source) ?: return
+        prepareTorrentSourceIfNeeded(source)
 
         try {
             val sAnime = SAnime.create().apply {
@@ -451,6 +457,7 @@ class AnimeScreenModel(
                 logcat(LogPriority.ERROR) { "Source is not AnimeHttpSource, cannot download" }
                 return@launchIO
             }
+            prepareTorrentSourceIfNeeded(httpSource)
 
             mutableState.update { s ->
                 if (s is State.Success) s.copy(dialog = Dialog.DownloadLoading(episode)) else s
@@ -565,6 +572,14 @@ class AnimeScreenModel(
         }
     }
 
+    private fun prepareTorrentSourceIfNeeded(source: AnimeSource) {
+        if (!source.isSourceForTorrents()) return
+        TorrentServerService.start()
+        if (TorrentServerService.wait(10)) {
+            TorrentServerUtils.setTrackersList()
+        }
+    }
+
     // endregion
 
     // region Dialog
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
index 4a32de5a20..d230fa5f4f 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/anime/AnimeTab.kt
@@ -184,7 +184,7 @@ data object AnimeTab : Tab {
                 },
                 onPickFile = {
                     showOpenVideoDialog = false
-                    filePickerLauncher.launch(arrayOf("video/*"))
+                    filePickerLauncher.launch(arrayOf("video/*", "application/x-bittorrent", "application/octet-stream"))
                 },
             )
         }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
index aeeb63897f..32882641c2 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerActivity.kt
@@ -17,6 +17,7 @@ import android.media.session.PlaybackState
 import android.net.Uri
 import android.os.Build
 import android.os.Bundle
+import android.provider.OpenableColumns
 import android.util.Rational
 import android.view.KeyEvent
 import android.view.WindowManager
@@ -339,9 +340,17 @@ class PlayerActivity : ComponentActivity() {
                 logcat(LogPriority.ERROR, tag = "Player") { "No playable video URL found for episode" }
                 return@launchIO
             }
+            val isTorrent = isTorrentPlaybackUrl(url)
+            val title = resolvedVideo?.videoTitle ?: episode.name
+            var resolvedTorrentPlayUrl: String? = null
             if (playerPreferences.alwaysUseExternalPlayer().get()) {
+                val externalUrl = if (isTorrent) {
+                    resolveTorrentUrl(url, title).also { resolvedTorrentPlayUrl = it }
+                } else {
+                    url
+                }
                 val extIntent = ExternalIntents.newIntent(
-                    this@PlayerActivity, animeId, episodeId, url, resolvedVideo,
+                    this@PlayerActivity, animeId, episodeId, externalUrl, resolvedVideo,
                 )
                 if (extIntent != null) {
                     withContext(Dispatchers.Main) {
@@ -353,8 +362,8 @@ class PlayerActivity : ComponentActivity() {
             }
             val resumePos = state.currentPositionSec
                 .takeIf { it > 0 } ?: episode.lastSecondSeen
-            val playUrl = if (PlayerViewModel.isTorrentUrl(url)) {
-                resolveTorrentUrl(url, resolvedVideo?.videoTitle ?: episode.name)
+            val playUrl = if (isTorrent) {
+                resolvedTorrentPlayUrl ?: resolveTorrentUrl(url, title)
             } else {
                 resolvePlaybackUrl(url)
             }
@@ -719,7 +728,7 @@ class PlayerActivity : ComponentActivity() {
         val headers = resolvedVideo?.headers?.let { h ->
             (0 until h.size).associate { i -> h.name(i) to h.value(i) }
         }
-        if (PlayerViewModel.isTorrentUrl(url)) {
+        if (isTorrentPlaybackUrl(url)) {
             lifecycleScope.launchIO {
                 val playUrl = resolveTorrentUrl(url, resolvedVideo?.videoTitle ?: episode.name)
                 withContext(Dispatchers.Main) {
@@ -867,8 +876,17 @@ class PlayerActivity : ComponentActivity() {
         TorrentServerService.start()
         TorrentServerService.wait(10)
 
+        if (videoUrl.startsWith("content://", ignoreCase = true)) {
+            val inputStream = contentResolver.openInputStream(Uri.parse(videoUrl))
+                ?: error("Could not open torrent file")
+            inputStream.use {
+                val torrent = TorrentServerApi.uploadTorrent(it, title, "", "", false)
+                return TorrentServerUtils.getTorrentPlayLink(torrent, 0)
+            }
+        }
+
         var index = 0
-        if (videoUrl.startsWith("magnet") && videoUrl.contains("index=")) {
+        if (videoUrl.startsWith("magnet", ignoreCase = true) && videoUrl.contains("index=")) {
             index = try {
                 videoUrl.substringAfter("index=").substringBefore("&").toInt()
             } catch (_: NumberFormatException) {
@@ -880,6 +898,25 @@ class PlayerActivity : ComponentActivity() {
         return TorrentServerUtils.getTorrentPlayLink(torrent, index)
     }
 
+    private fun isTorrentPlaybackUrl(url: String): Boolean {
+        return PlayerViewModel.isTorrentUrl(url) || isTorrentContentUri(url)
+    }
+
+    private fun isTorrentContentUri(url: String): Boolean {
+        if (!url.startsWith("content://", ignoreCase = true)) return false
+        val uri = Uri.parse(url)
+        val type = runCatching { contentResolver.getType(uri)?.lowercase() }.getOrNull()
+        if (type?.contains("bittorrent") == true || type?.contains("torrent") == true) return true
+
+        val displayName = runCatching {
+            contentResolver.query(uri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)
+                ?.use { cursor ->
+                    if (cursor.moveToFirst()) cursor.getString(0) else null
+                }
+        }.getOrNull()
+        return displayName?.endsWith(".torrent", ignoreCase = true) == true
+    }
+
     private fun resolveVideoUrl(intent: Intent): String? {
         if (intent.action == Intent.ACTION_VIEW) {
             return intent.data?.toString()
diff --git a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
index 917a79213c..41ca8a3f5a 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
+++ b/app/src/main/java/eu/kanade/tachiyomi/ui/player/PlayerViewModel.kt
@@ -15,9 +15,12 @@ import eu.kanade.tachiyomi.animesource.model.TimeStamp
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.data.animedownload.AnimeDownloadManager
+import eu.kanade.tachiyomi.data.torrentServer.service.TorrentServerService
 import eu.kanade.tachiyomi.data.track.TrackerManager
 import eu.kanade.tachiyomi.data.track.anilist.Anilist
 import eu.kanade.tachiyomi.data.track.myanimelist.MyAnimeList
+import eu.kanade.tachiyomi.source.isSourceForTorrents
+import eu.kanade.tachiyomi.torrentServer.TorrentServerUtils
 import eu.kanade.tachiyomi.ui.player.controls.components.IndexedSegment
 import eu.kanade.tachiyomi.ui.player.mpv.MPVView
 import eu.kanade.tachiyomi.ui.player.setting.PlayerPreferences
@@ -200,6 +203,12 @@ class PlayerViewModel @JvmOverloads constructor(
         return withIOContext {
             try {
                 val source = animeSourceManager.get(sourceId) ?: return@withIOContext null
+                if (source.isSourceForTorrents()) {
+                    TorrentServerService.start()
+                    if (TorrentServerService.wait(10)) {
+                        TorrentServerUtils.setTrackersList()
+                    }
+                }
                 val sEpisode = SEpisode.create().apply {
                     url = episode.url
                     name = episode.name
@@ -834,11 +843,12 @@ class PlayerViewModel @JvmOverloads constructor(
         private val STREAMABLE_SCHEMES = setOf("http", "https", "rtmp", "rtsp", "file", "content", "magnet")
 
         fun isTorrentUrl(url: String): Boolean {
-            return url.startsWith("magnet") || url.endsWith(".torrent")
+            val normalized = url.trim().lowercase()
+            return normalized.startsWith("magnet:") || normalized.endsWith(".torrent")
         }
 
         fun isPlayableScheme(url: String): Boolean {
-            val scheme = url.substringBefore("://").lowercase()
+            val scheme = url.substringBefore(":", missingDelimiterValue = "").lowercase()
             return scheme in STREAMABLE_SCHEMES
         }
     }
diff --git a/core/common/build.gradle.kts b/core/common/build.gradle.kts
index af5b4eb865..43a98150d3 100644
--- a/core/common/build.gradle.kts
+++ b/core/common/build.gradle.kts
@@ -60,4 +60,7 @@ dependencies {
     implementation(sylibs.xlog)
     implementation(sylibs.exifinterface)
     // SY <--
+
+    implementation(libs.injekt)
+    implementation(libs.torrentserver)
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt b/core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
similarity index 91%
rename from app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
rename to core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
index 34b8881434..d6b512f75c 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
+++ b/core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerApi.kt
@@ -17,6 +17,7 @@ import java.io.InputStream
 object TorrentServerApi {
     private val network: NetworkHelper by injectLazy()
     private val hostUrl get() = TorrentServerUtils.hostUrl
+    private val json = Json { ignoreUnknownKeys = true }
 
     fun echo(): String {
         return try {
@@ -54,7 +55,7 @@ object TorrentServerApi {
         val resp = network.client.newCall(
             POST("$hostUrl/torrents", body = req.toRequestBody("application/json".toMediaTypeOrNull())),
         ).execute()
-        return Json.decodeFromString(Torrent.serializer(), resp.body.string())
+        return json.decodeFromString(Torrent.serializer(), resp.body.string())
     }
 
     fun getTorrent(hash: String): Torrent {
@@ -62,7 +63,7 @@ object TorrentServerApi {
         val resp = network.client.newCall(
             POST("$hostUrl/torrents", body = req.toRequestBody("application/json".toMediaTypeOrNull())),
         ).execute()
-        return Json.decodeFromString(Torrent.serializer(), resp.body.string())
+        return json.decodeFromString(Torrent.serializer(), resp.body.string())
     }
 
     fun remTorrent(hash: String) {
@@ -77,7 +78,7 @@ object TorrentServerApi {
         val resp = network.client.newCall(
             POST("$hostUrl/torrents", body = req.toRequestBody("application/json".toMediaTypeOrNull())),
         ).execute()
-        return Json.decodeFromString<List<Torrent>>(resp.body.string())
+        return json.decodeFromString<List<Torrent>>(resp.body.string())
     }
 
     fun uploadTorrent(
@@ -105,6 +106,6 @@ object TorrentServerApi {
             .post(body)
             .build()
         val resp = network.client.newCall(request).execute()
-        return Json.decodeFromString(Torrent.serializer(), resp.body.string())
+        return json.decodeFromString(Torrent.serializer(), resp.body.string())
     }
 }
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt b/core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt
similarity index 100%
rename from app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt
rename to core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerPreferences.kt
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt b/core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt
similarity index 100%
rename from app/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt
rename to core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/TorrentServerUtils.kt
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt b/core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt
similarity index 58%
rename from app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt
rename to core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt
index 97811005a5..e367434edf 100644
--- a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt
+++ b/core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/model/Torrent.kt
@@ -20,9 +20,25 @@ data class Torrent(
     var download_speed: Double? = null,
     var upload_speed: Double? = null,
     var total_peers: Int? = null,
+    var pending_peers: Int? = null,
     var active_peers: Int? = null,
     var connected_seeders: Int? = null,
+    var half_open_peers: Int? = null,
+    var bytes_written: Long? = null,
+    var bytes_written_data: Long? = null,
+    var bytes_read: Long? = null,
+    var bytes_read_data: Long? = null,
+    var bytes_read_useful_data: Long? = null,
+    var chunks_written: Long? = null,
+    var chunks_read: Long? = null,
+    var chunks_read_useful: Long? = null,
+    var chunks_read_wasted: Long? = null,
+    var pieces_dirtied_good: Long? = null,
+    var pieces_dirtied_bad: Long? = null,
+    var duration_seconds: Double? = null,
+    var bit_rate: String? = null,
     var file_stats: List<FileStat>? = null,
+    var trackers: List<String>? = null,
 )
 
 @Serializable
diff --git a/app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt b/core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt
similarity index 100%
rename from app/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt
rename to core/common/src/main/java/eu/kanade/tachiyomi/torrentServer/model/TorrentRequest.kt
diff --git a/source-api/consumer-proguard.pro b/source-api/consumer-proguard.pro
index 2546396a4b..826402d2ef 100644
--- a/source-api/consumer-proguard.pro
+++ b/source-api/consumer-proguard.pro
@@ -5,6 +5,7 @@
 -keep class eu.kanade.tachiyomi.animesource.model.** { public protected *; }
 -keep class eu.kanade.tachiyomi.animesource.online.** { public protected *; }
 -keep class eu.kanade.tachiyomi.animesource.** extends eu.kanade.tachiyomi.animesource.AnimeSource { public protected *; }
+-keep class eu.kanade.tachiyomi.animesource.** extends eu.kanade.tachiyomi.torrentutils.** { public protected *; }
 
 -keep,allowoptimization class eu.kanade.tachiyomi.util.JsoupExtensionsKt { public protected *; }
 
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/TorrentUtils.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/TorrentUtils.kt
new file mode 100644
index 0000000000..3c28b4fab8
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/TorrentUtils.kt
@@ -0,0 +1,29 @@
+package eu.kanade.tachiyomi.torrentutils
+
+import eu.kanade.tachiyomi.torrentServer.TorrentServerApi
+import eu.kanade.tachiyomi.torrentutils.model.DeadTorrentException
+import eu.kanade.tachiyomi.torrentutils.model.TorrentFile
+import eu.kanade.tachiyomi.torrentutils.model.TorrentInfo
+import java.net.SocketTimeoutException
+
+object TorrentUtils {
+    fun getTorrentInfo(
+        url: String,
+        title: String,
+    ): TorrentInfo {
+        try {
+            val torrent = TorrentServerApi.addTorrent(url, title, "", "", false)
+            return TorrentInfo(
+                torrent.title,
+                torrent.file_stats?.map { file ->
+                    TorrentFile(file.path, file.id ?: 0, file.length, torrent.hash!!, torrent.trackers ?: emptyList())
+                } ?: emptyList(),
+                torrent.hash!!,
+                torrent.torrent_size!!,
+                torrent.trackers ?: emptyList(),
+            )
+        } catch (e: SocketTimeoutException) {
+            throw DeadTorrentException()
+        }
+    }
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/model/TorrentFile.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/model/TorrentFile.kt
new file mode 100644
index 0000000000..774a425c41
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/model/TorrentFile.kt
@@ -0,0 +1,16 @@
+package eu.kanade.tachiyomi.torrentutils.model
+
+import java.net.URLEncoder
+
+data class TorrentFile(
+    val path: String,
+    val indexFile: Int,
+    val size: Long,
+    private val torrentHash: String,
+    private val trackers: List<String> = emptyList(),
+) {
+    fun toMagnetURI(): String {
+        val trackers = trackers.joinToString("&tr=") { URLEncoder.encode(it, "UTF-8") }
+        return "magnet:?xt=urn:btih:$torrentHash${if (trackers.isNotEmpty()) "&tr=$trackers" else ""}&index=$indexFile"
+    }
+}
diff --git a/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/model/TorrentInfo.kt b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/model/TorrentInfo.kt
new file mode 100644
index 0000000000..26f8676e6f
--- /dev/null
+++ b/source-api/src/commonMain/kotlin/eu/kanade/tachiyomi/torrentutils/model/TorrentInfo.kt
@@ -0,0 +1,15 @@
+package eu.kanade.tachiyomi.torrentutils.model
+
+data class TorrentInfo(
+    val title: String,
+    val files: List<TorrentFile>,
+    val hash: String,
+    val size: Long,
+    val trackers: List<String> = emptyList(),
+) {
+    fun setTrackers(trackers: List<String>): TorrentInfo {
+        return TorrentInfo(title, files, hash, size, trackers)
+    }
+}
+
+class DeadTorrentException : Exception()