diff --git a/lib-multisrc/anilist/build.gradle.kts b/lib-multisrc/anilist/build.gradle.kts
index e2f11e9c..9dce2478 100644
--- a/lib-multisrc/anilist/build.gradle.kts
+++ b/lib-multisrc/anilist/build.gradle.kts
@@ -2,4 +2,4 @@ plugins {
     id("lib-multisrc")
 }
 
-baseVersionCode = 3
+baseVersionCode = 2
diff --git a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListAnimeHttpSource.kt b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListAnimeHttpSource.kt
index e9465a0b..a2c8780d 100644
--- a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListAnimeHttpSource.kt
+++ b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListAnimeHttpSource.kt
@@ -8,10 +8,6 @@ import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.util.parseAs
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.add
-import kotlinx.serialization.json.buildJsonObject
-import kotlinx.serialization.json.put
-import kotlinx.serialization.json.putJsonArray
 import okhttp3.FormBody
 import okhttp3.Request
 import okhttp3.Response
@@ -36,7 +32,7 @@ abstract class AniListAnimeHttpSource : AnimeHttpSource() {
             query = ANIME_LIST_QUERY,
             variables = AnimeListVariables(
                 page = page,
-                sort = AnimeListVariables.MediaSort.TRENDING_DESC,
+                sort = AnimeListVariables.MediaSort.POPULARITY_DESC,
             ),
         )
     }
@@ -62,58 +58,20 @@ abstract class AniListAnimeHttpSource : AnimeHttpSource() {
 
     /* ===================================== Search Anime ===================================== */
     override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val params = AniListFilters.getSearchParameters(filters)
-
-        val variablesObject = buildJsonObject {
-            put("page", page)
-            put("perPage", 30)
-            put("isAdult", false)
-            put("type", "ANIME")
-            put("sort", params.sort)
-            if (query.isNotBlank()) put("search", query)
-
-            if (params.genres.isNotEmpty()) {
-                putJsonArray("genres") {
-                    params.genres.forEach { add(it) }
-                }
-            }
-
-            if (params.format.isNotEmpty()) {
-                putJsonArray("format") {
-                    params.format.forEach { add(it) }
-                }
-            }
-
-            if (params.season.isBlank() && params.year.isNotBlank()) {
-                put("year", "${params.year}%")
-            }
-
-            if (params.season.isNotBlank() && params.year.isBlank()) {
-                throw Exception("Year cannot be blank if season is set")
-            }
-
-            if (params.season.isNotBlank() && params.year.isNotBlank()) {
-                put("season", params.season)
-                put("seasonYear", params.year)
-            }
-
-            if (params.status.isNotBlank()) {
-                put("status", params.status)
-            }
-        }
-        val variables = json.encodeToString(variablesObject)
-
-        return buildRequest(query = SORT_QUERY, variables = variables)
+        return buildAnimeListRequest(
+            query = ANIME_LIST_QUERY,
+            variables = AnimeListVariables(
+                page = page,
+                sort = AnimeListVariables.MediaSort.SEARCH_MATCH,
+                search = query.ifBlank { null },
+            ),
+        )
     }
 
     override fun searchAnimeParse(response: Response): AnimesPage {
         return parseAnimeListResponse(response)
     }
 
-    // ============================== Filters ===============================
-
-    override fun getFilterList(): AnimeFilterList = AniListFilters.FILTER_LIST
-
     /* ===================================== Anime Details ===================================== */
     override fun animeDetailsRequest(anime: SAnime): Request {
         return buildRequest(
@@ -187,9 +145,6 @@ abstract class AniListAnimeHttpSource : AnimeHttpSource() {
             status = when (media.status) {
                 AniListMedia.Status.RELEASING -> SAnime.ONGOING
                 AniListMedia.Status.FINISHED -> SAnime.COMPLETED
-                AniListMedia.Status.NOT_YET_RELEASED -> SAnime.LICENSED
-                AniListMedia.Status.CANCELLED -> SAnime.CANCELLED
-                AniListMedia.Status.HIATUS -> SAnime.ON_HIATUS
             }
             thumbnail_url = media.coverImage.large
         }
diff --git a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListFilters.kt b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListFilters.kt
deleted file mode 100644
index 688d64e4..00000000
--- a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListFilters.kt
+++ /dev/null
@@ -1,236 +0,0 @@
-package eu.kanade.tachiyomi.multisrc.anilist
-
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-
-object AniListFilters {
-    open class QueryPartFilter(
-        displayName: String,
-        val vals: Array<Pair<String, String>>,
-    ) : AnimeFilter.Select<String>(
-        displayName,
-        vals.map { it.first }.toTypedArray(),
-    ) {
-        fun toQueryPart() = vals[state].second
-    }
-
-    open class CheckBoxFilterList(name: String, val pairs: Array<Pair<String, String>>) :
-        AnimeFilter.Group<AnimeFilter.CheckBox>(name, pairs.map { CheckBoxVal(it.first, false) })
-
-    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
-
-    private inline fun <reified R> AnimeFilterList.asQueryPart(): String {
-        return (getFirst<R>() as QueryPartFilter).toQueryPart()
-    }
-
-    private inline fun <reified R> AnimeFilterList.getFirst(): R {
-        return first { it is R } as R
-    }
-
-    private inline fun <reified R> AnimeFilterList.parseCheckboxList(
-        options: Array<Pair<String, String>>,
-    ): List<String> {
-        return (getFirst<R>() as CheckBoxFilterList).state
-            .filter { it.state }
-            .map { checkBox -> options.find { it.first == checkBox.name }!!.second }
-            .filter(String::isNotBlank)
-    }
-
-    private inline fun <reified R> AnimeFilterList.getSort(): String {
-        val state = (getFirst<R>() as AnimeFilter.Sort).state ?: return ""
-        val index = state.index
-        val suffix = if (state.ascending) "" else "_DESC"
-        return AniListFiltersData.SORT_LIST[index].second + suffix
-    }
-
-    class GenreFilter : CheckBoxFilterList("Genres", AniListFiltersData.GENRE_LIST)
-    class YearFilter : QueryPartFilter("Year", AniListFiltersData.YEAR_LIST)
-    class SeasonFilter : QueryPartFilter("Season", AniListFiltersData.SEASON_LIST)
-    class FormatFilter : CheckBoxFilterList("Format", AniListFiltersData.FORMAT_LIST)
-    class StatusFilter : QueryPartFilter("Airing Status", AniListFiltersData.STATUS_LIST)
-
-    class SortFilter : AnimeFilter.Sort(
-        "Sort",
-        AniListFiltersData.SORT_LIST.map { it.first }.toTypedArray(),
-        Selection(1, false),
-    )
-
-    val FILTER_LIST get() = AnimeFilterList(
-        GenreFilter(),
-        YearFilter(),
-        SeasonFilter(),
-        FormatFilter(),
-        StatusFilter(),
-        SortFilter(),
-    )
-
-    class FilterSearchParams(
-        val genres: List<String> = emptyList(),
-        val year: String = "",
-        val season: String = "",
-        val format: List<String> = emptyList(),
-        val status: String = "",
-        val sort: String = "",
-    )
-
-    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
-        if (filters.isEmpty()) return FilterSearchParams()
-
-        return FilterSearchParams(
-            filters.parseCheckboxList<GenreFilter>(AniListFiltersData.GENRE_LIST),
-            filters.asQueryPart<YearFilter>(),
-            filters.asQueryPart<SeasonFilter>(),
-            filters.parseCheckboxList<FormatFilter>(AniListFiltersData.FORMAT_LIST),
-            filters.asQueryPart<StatusFilter>(),
-            filters.getSort<SortFilter>(),
-        )
-    }
-
-    private object AniListFiltersData {
-        val GENRE_LIST = arrayOf(
-            Pair("Action", "Action"),
-            Pair("Adventure", "Adventure"),
-            Pair("Comedy", "Comedy"),
-            Pair("Drama", "Drama"),
-            Pair("Ecchi", "Ecchi"),
-            Pair("Fantasy", "Fantasy"),
-            Pair("Horror", "Horror"),
-            Pair("Mahou Shoujo", "Mahou Shoujo"),
-            Pair("Mecha", "Mecha"),
-            Pair("Music", "Music"),
-            Pair("Mystery", "Mystery"),
-            Pair("Psychological", "Psychological"),
-            Pair("Romance", "Romance"),
-            Pair("Sci-Fi", "Sci-Fi"),
-            Pair("Slice of Life", "Slice of Life"),
-            Pair("Sports", "Sports"),
-            Pair("Supernatural", "Supernatural"),
-            Pair("Thriller", "Thriller"),
-        )
-
-        val YEAR_LIST = arrayOf(
-            Pair("<Select>", ""),
-            Pair("2024", "2024"),
-            Pair("2023", "2023"),
-            Pair("2022", "2022"),
-            Pair("2021", "2021"),
-            Pair("2020", "2020"),
-            Pair("2019", "2019"),
-            Pair("2018", "2018"),
-            Pair("2017", "2017"),
-            Pair("2016", "2016"),
-            Pair("2015", "2015"),
-            Pair("2014", "2014"),
-            Pair("2013", "2013"),
-            Pair("2012", "2012"),
-            Pair("2011", "2011"),
-            Pair("2010", "2010"),
-            Pair("2009", "2009"),
-            Pair("2008", "2008"),
-            Pair("2007", "2007"),
-            Pair("2006", "2006"),
-            Pair("2005", "2005"),
-            Pair("2004", "2004"),
-            Pair("2003", "2003"),
-            Pair("2002", "2002"),
-            Pair("2001", "2001"),
-            Pair("2000", "2000"),
-            Pair("1999", "1999"),
-            Pair("1998", "1998"),
-            Pair("1997", "1997"),
-            Pair("1996", "1996"),
-            Pair("1995", "1995"),
-            Pair("1994", "1994"),
-            Pair("1993", "1993"),
-            Pair("1992", "1992"),
-            Pair("1991", "1991"),
-            Pair("1990", "1990"),
-            Pair("1989", "1989"),
-            Pair("1988", "1988"),
-            Pair("1987", "1987"),
-            Pair("1986", "1986"),
-            Pair("1985", "1985"),
-            Pair("1984", "1984"),
-            Pair("1983", "1983"),
-            Pair("1982", "1982"),
-            Pair("1981", "1981"),
-            Pair("1980", "1980"),
-            Pair("1979", "1979"),
-            Pair("1978", "1978"),
-            Pair("1977", "1977"),
-            Pair("1976", "1976"),
-            Pair("1975", "1975"),
-            Pair("1974", "1974"),
-            Pair("1973", "1973"),
-            Pair("1972", "1972"),
-            Pair("1971", "1971"),
-            Pair("1970", "1970"),
-            Pair("1969", "1969"),
-            Pair("1968", "1968"),
-            Pair("1967", "1967"),
-            Pair("1966", "1966"),
-            Pair("1965", "1965"),
-            Pair("1964", "1964"),
-            Pair("1963", "1963"),
-            Pair("1962", "1962"),
-            Pair("1961", "1961"),
-            Pair("1960", "1960"),
-            Pair("1959", "1959"),
-            Pair("1958", "1958"),
-            Pair("1957", "1957"),
-            Pair("1956", "1956"),
-            Pair("1955", "1955"),
-            Pair("1954", "1954"),
-            Pair("1953", "1953"),
-            Pair("1952", "1952"),
-            Pair("1951", "1951"),
-            Pair("1950", "1950"),
-            Pair("1949", "1949"),
-            Pair("1948", "1948"),
-            Pair("1947", "1947"),
-            Pair("1946", "1946"),
-            Pair("1945", "1945"),
-            Pair("1944", "1944"),
-            Pair("1943", "1943"),
-            Pair("1942", "1942"),
-            Pair("1941", "1941"),
-            Pair("1940", "1940"),
-        )
-
-        val SEASON_LIST = arrayOf(
-            Pair("<Select>", ""),
-            Pair("Winter", "WINTER"),
-            Pair("Spring", "SPRING"),
-            Pair("Summer", "SUMMER"),
-            Pair("Fall", "FALL"),
-        )
-
-        val FORMAT_LIST = arrayOf(
-            Pair("TV Show", "TV"),
-            Pair("Movie", "MOVIE"),
-            Pair("TV Short", "TV_SHORT"),
-            Pair("Special", "SPECIAL"),
-            Pair("OVA", "OVA"),
-            Pair("ONA", "ONA"),
-            Pair("Music", "MUSIC"),
-        )
-
-        val STATUS_LIST = arrayOf(
-            Pair("<Select>", ""),
-            Pair("Airing", "RELEASING"),
-            Pair("Finished", "FINISHED"),
-            Pair("Not Yet Aired", "NOT_YET_RELEASED"),
-            Pair("Cancelled", "CANCELLED"),
-        )
-
-        val SORT_LIST = arrayOf(
-            Pair("Title", "TITLE_ENGLISH"),
-            Pair("Popularity", "POPULARITY"),
-            Pair("Average Score", "SCORE"),
-            Pair("Trending", "TRENDING"),
-            Pair("Favorites", "FAVOURITES"),
-            Pair("Date Added", "ID"),
-            Pair("Release Date", "START_DATE"),
-        )
-    }
-}
diff --git a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListRequest.kt b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListRequest.kt
index 357cefee..00fcfac0 100644
--- a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListRequest.kt
+++ b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListRequest.kt
@@ -55,76 +55,16 @@ internal const val ANIME_DETAILS_QUERY = """
       }
     }
 """
-private fun String.toQuery() = this.trimIndent().replace("%", "$")
-internal val SORT_QUERY = """
-    query (
-        ${"$"}page: Int,
-        ${"$"}perPage: Int,
-        ${"$"}isAdult: Boolean,
-        ${"$"}type: MediaType,
-        ${"$"}sort: [MediaSort],
-        ${"$"}status: MediaStatus,
-        ${"$"}search: String,
-        ${"$"}genres: [String],
-        ${"$"}year: String,
-        ${"$"}seasonYear: Int,
-        ${"$"}season: MediaSeason,
-        ${"$"}format: [MediaFormat]
-    ) {
-        Page (page: ${"$"}page, perPage: ${"$"}perPage) {
-            pageInfo {
-                hasNextPage
-            }
-            media (
-                isAdult: ${"$"}isAdult,
-                type: ${"$"}type,
-                sort: ${"$"}sort,
-                status: ${"$"}status,
-                search: ${"$"}search,
-                genre_in: ${"$"}genres,
-                startDate_like: ${"$"}year,
-                seasonYear: ${"$"}seasonYear,
-                season: ${"$"}season,
-                format_in: ${"$"}format
-            ) {
-                id
-                title {
-                    romaji
-                    english
-                    native
-                }
-                coverImage {
-                    extraLarge
-                    large
-                    medium
-                }
-                status
-                genres
-                studios {
-                    nodes {
-                        name
-                    }
-                }
-            }
-        }
-    }
-""".toQuery()
 
 @Serializable
 internal data class AnimeListVariables(
     val page: Int,
     val sort: MediaSort,
     val search: String? = null,
-    val genre: String? = null,
-    val year: String? = null,
-    val status: String? = null,
-    val format: String? = null,
-    val season: String? = null,
-    val seasonYear: String? = null,
-    val isAdult: Boolean = false,
 ) {
     enum class MediaSort {
-        TRENDING_DESC,
+        POPULARITY_DESC,
+        SEARCH_MATCH,
         START_DATE_DESC,
     }
 }
diff --git a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListResponse.kt b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListResponse.kt
index 4f3d727a..d445e8e9 100644
--- a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListResponse.kt
+++ b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListResponse.kt
@@ -47,9 +47,6 @@ internal data class AniListMedia(
     enum class Status {
         RELEASING,
         FINISHED,
-        NOT_YET_RELEASED,
-        CANCELLED,
-        HIATUS,
     }
 
     @Serializable
diff --git a/src/en/aniplay/build.gradle b/src/en/aniplay/build.gradle
index 64a3a7ab..c805affd 100644
--- a/src/en/aniplay/build.gradle
+++ b/src/en/aniplay/build.gradle
@@ -2,7 +2,7 @@ ext {
     extName = 'AniPlay'
     extClass = '.AniPlay'
     themePkg = 'anilist'
-    overrideVersionCode = 2
+    overrideVersionCode = 1
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlay.kt b/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlay.kt
index 661201f9..d86dfaed 100644
--- a/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlay.kt
+++ b/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlay.kt
@@ -2,7 +2,6 @@ package eu.kanade.tachiyomi.animeextension.en.aniplay
 
 import android.app.Application
 import android.util.Base64
-import android.util.Log
 import android.widget.Toast
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
@@ -18,7 +17,6 @@ import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.util.parallelFlatMapBlocking
 import eu.kanade.tachiyomi.util.parseAs
-import kotlinx.serialization.SerializationException
 import kotlinx.serialization.encodeToString
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.MediaType.Companion.toMediaType
@@ -27,7 +25,6 @@ import okhttp3.RequestBody.Companion.toRequestBody
 import okhttp3.Response
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
-import java.io.IOException
 import java.text.SimpleDateFormat
 import java.util.Locale
 
@@ -86,26 +83,26 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
 
         providers.forEach { provider ->
             provider.episodes.forEach { episode ->
-                val episodeNumber = episode.number.toString().toIntOrNull() ?: episode.number.toInt()
-                if (!episodes.containsKey(episodeNumber)) {
-                    episodes[episodeNumber] = episode
+                if (!episodes.containsKey(episode.number)) {
+                    episodes[episode.number] = episode
                 }
-                val existingEpisodeExtras = episodeExtras.getOrElse(episodeNumber) { emptyList() }
+                val existingEpisodeExtras = episodeExtras.getOrElse(episode.number) { emptyList() }
                 val episodeExtra = EpisodeExtra(
                     source = provider.providerId,
                     episodeId = episode.id,
                     hasDub = episode.hasDub,
                 )
-                episodeExtras[episodeNumber] = existingEpisodeExtras + listOf(episodeExtra)
+                episodeExtras[episode.number] = existingEpisodeExtras + listOf(episodeExtra)
             }
         }
 
         return episodes.map { episodeMap ->
             val episode = episodeMap.value
-            val episodeNumber = episodeMap.key
+            val episodeNumber = episode.number
             val episodeExtra = episodeExtras.getValue(episodeNumber)
             val episodeExtraString = json.encodeToString(episodeExtra)
-                .let { Base64.encodeToString(it.toByteArray(), Base64.DEFAULT) }
+                .let { Base64.encode(it.toByteArray(), Base64.DEFAULT) }
+                .toString(Charsets.UTF_8)
 
             val url = baseUrl.toHttpUrl().newBuilder()
                 .addPathSegment("anime")
@@ -115,7 +112,7 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
                 .addQueryParameter("extras", episodeExtraString)
                 .build()
 
-            val name = parseEpisodeName(episodeNumber.toString(), episode.title)
+            val name = parseEpisodeName(episodeNumber, episode.title)
             val uploadDate = parseDate(episode.createdAt)
             val dub = when {
                 episodeExtra.any { it.hasDub } -> ", Dub"
@@ -145,57 +142,45 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         val episodeNum = episodeUrl.queryParameter("ep") ?: return emptyList()
         val extras = episodeUrl.queryParameter("extras")
             ?.let {
-                try {
-                    Base64.decode(it, Base64.DEFAULT).toString(Charsets.UTF_8)
-                } catch (e: IllegalArgumentException) {
-                    Log.e("AniPlay", "Error decoding base64", e)
-                    return emptyList()
-                }
-            }
-            ?.let {
-                try {
-                    json.decodeFromString<List<EpisodeExtra>>(it)
-                } catch (e: SerializationException) {
-                    Log.e("AniPlay", "Error parsing JSON", e)
-                    emptyList()
-                }
+                Base64.decode(it, Base64.DEFAULT).toString(Charsets.UTF_8)
             }
+            ?.let { json.decodeFromString<List<EpisodeExtra>>(it) }
             ?: emptyList()
 
         val episodeDataList = extras.parallelFlatMapBlocking { extra ->
-            val languages = mutableListOf("sub").apply {
-                if (extra.hasDub) add("dub")
+            val languages = mutableListOf("sub")
+            if (extra.hasDub) {
+                languages.add("dub")
             }
             val url = "$baseUrl/api/anime/source/$animeId"
 
             languages.map { language ->
-                val requestBody = json.encodeToString(
-                    VideoSourceRequest(
-                        source = extra.source,
-                        episodeId = extra.episodeId,
-                        episodeNum = episodeNum,
-                        subType = language,
-                    ),
-                ).toRequestBody("application/json".toMediaType())
-
-                try {
-                    val response = client.newCall(POST(url = url, body = requestBody)).execute().parseAs<VideoSourceResponse>()
-
-                    EpisodeData(
-                        source = extra.source,
-                        language = language,
-                        response = response,
+                val requestBody = json
+                    .encodeToString(
+                        VideoSourceRequest(
+                            source = extra.source,
+                            episodeId = extra.episodeId,
+                            episodeNum = episodeNum,
+                            subType = language,
+                        ),
                     )
-                } catch (e: IOException) {
-                    null // Return null to be filtered out
-                } catch (e: Exception) {
-                    null // Return null to be filtered out
-                }
-            }.filterNotNull() // Filter out null values due to errors
+                    .toRequestBody("application/json".toMediaType())
+
+                val response = client
+                    .newCall(POST(url = url, body = requestBody))
+                    .execute()
+                    .parseAs<VideoSourceResponse>()
+
+                EpisodeData(
+                    source = extra.source,
+                    language = language,
+                    response = response,
+                )
+            }
         }
 
         val videos = episodeDataList.flatMap { episodeData ->
-            val defaultSource = episodeData.response.sources?.firstOrNull {
+            val defaultSource = episodeData.response.sources?.first {
                 it.quality in listOf("default", "auto")
             } ?: return@flatMap emptyList()
 
@@ -331,13 +316,14 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
     }
 
     /* =================================== AniPlay Utilities =================================== */
-    private fun parseEpisodeName(number: String, title: String?): String {
-        return if (title.isNullOrBlank()) {
-            "Episode $number"
-        } else {
-            "Episode $number: $title"
+
+    private fun parseEpisodeName(number: Int, name: String): String {
+        return when {
+            listOf("EP ", "EPISODE ").any(name::startsWith) -> "Episode $number"
+            else -> "Episode $number: $name"
         }
     }
+
     private fun getServerName(value: String): String {
         val index = PREF_SERVER_ENTRY_VALUES.indexOf(value)
         return PREF_SERVER_ENTRIES[index]
diff --git a/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlayDto.kt b/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlayDto.kt
index f85775e9..e0b22126 100644
--- a/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlayDto.kt
+++ b/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlayDto.kt
@@ -12,7 +12,7 @@ data class EpisodeListResponse(
     @Serializable
     data class Episode(
         val id: String,
-        val number: Float,
+        val number: Int,
         val title: String,
         val hasDub: Boolean,
         val isFiller: Boolean,
diff --git a/src/en/nineanime/build.gradle b/src/en/nineanime/build.gradle
new file mode 100644
index 00000000..728eee5b
--- /dev/null
+++ b/src/en/nineanime/build.gradle
@@ -0,0 +1,14 @@
+ext {
+    extName = 'Aniwave'
+    extClass = '.Aniwave'
+    extVersionCode = 75
+}
+
+apply from: "$rootDir/common.gradle"
+
+dependencies {
+    implementation(project(':lib:vidsrc-extractor'))
+    implementation(project(':lib:filemoon-extractor'))
+    implementation(project(':lib:mp4upload-extractor'))
+    implementation(project(':lib:streamtape-extractor'))
+}
diff --git a/src/en/nineanime/res/mipmap-hdpi/ic_launcher.png b/src/en/nineanime/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..becbf10b
Binary files /dev/null and b/src/en/nineanime/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/en/nineanime/res/mipmap-mdpi/ic_launcher.png b/src/en/nineanime/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..2d4aa387
Binary files /dev/null and b/src/en/nineanime/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/en/nineanime/res/mipmap-xhdpi/ic_launcher.png b/src/en/nineanime/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..268ae9c3
Binary files /dev/null and b/src/en/nineanime/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/en/nineanime/res/mipmap-xxhdpi/ic_launcher.png b/src/en/nineanime/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..1df47226
Binary files /dev/null and b/src/en/nineanime/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/en/nineanime/res/mipmap-xxxhdpi/ic_launcher.png b/src/en/nineanime/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..a2a2deea
Binary files /dev/null and b/src/en/nineanime/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/en/nineanime/res/web_hi_res_512.png b/src/en/nineanime/res/web_hi_res_512.png
new file mode 100644
index 00000000..fb3c714c
Binary files /dev/null and b/src/en/nineanime/res/web_hi_res_512.png differ
diff --git a/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/Aniwave.kt b/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/Aniwave.kt
new file mode 100644
index 00000000..c9d85d87
--- /dev/null
+++ b/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/Aniwave.kt
@@ -0,0 +1,538 @@
+package eu.kanade.tachiyomi.animeextension.en.nineanime
+
+import android.app.Application
+import android.content.SharedPreferences
+import android.webkit.URLUtil
+import android.widget.Toast
+import androidx.preference.EditTextPreference
+import androidx.preference.ListPreference
+import androidx.preference.MultiSelectListPreference
+import androidx.preference.PreferenceScreen
+import androidx.preference.SwitchPreferenceCompat
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+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.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
+import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
+import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
+import eu.kanade.tachiyomi.lib.vidsrcextractor.VidsrcExtractor
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelFlatMapBlocking
+import eu.kanade.tachiyomi.util.parallelMapBlocking
+import eu.kanade.tachiyomi.util.parseAs
+import okhttp3.Request
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.text.SimpleDateFormat
+import java.util.Locale
+
+class Aniwave : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
+
+    override val name = "Aniwave"
+
+    override val id: Long = 98855593379717478
+
+    override val baseUrl by lazy {
+        val customDomain = preferences.getString(PREF_CUSTOM_DOMAIN_KEY, null)
+        if (customDomain.isNullOrBlank()) {
+            preferences.getString(PREF_DOMAIN_KEY, PREF_DOMAIN_DEFAULT)!!
+        } else {
+            customDomain
+        }
+    }
+
+    override val lang = "en"
+
+    override val supportsLatest = true
+
+    private val utils by lazy { AniwaveUtils() }
+
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    private val refererHeaders = headers.newBuilder().apply {
+        add("Referer", "$baseUrl/")
+    }.build()
+
+    private val markFiller by lazy { preferences.getBoolean(PREF_MARK_FILLERS_KEY, PREF_MARK_FILLERS_DEFAULT) }
+
+    // ============================== Popular ===============================
+
+    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/filter?sort=trending&page=$page", refererHeaders)
+
+    override fun popularAnimeSelector(): String = "div.ani.items > div.item"
+
+    override fun popularAnimeFromElement(element: Element) = SAnime.create().apply {
+        element.select("a.name").let { a ->
+            setUrlWithoutDomain(a.attr("href").substringBefore("?"))
+            title = a.text()
+        }
+        thumbnail_url = element.select("div.poster img").attr("src")
+    }
+
+    override fun popularAnimeNextPageSelector(): String =
+        "nav > ul.pagination > li.active ~ li"
+
+    // =============================== Latest ===============================
+
+    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/filter?sort=recently_updated&page=$page", refererHeaders)
+
+    override fun latestUpdatesSelector(): String = popularAnimeSelector()
+
+    override fun latestUpdatesFromElement(element: Element) = popularAnimeFromElement(element)
+
+    override fun latestUpdatesNextPageSelector(): String = popularAnimeNextPageSelector()
+
+    // =============================== Search ===============================
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val filters = AniwaveFilters.getSearchParameters(filters)
+
+        val vrf = if (query.isNotBlank()) utils.vrfEncrypt(query) else ""
+        var url = "$baseUrl/filter?keyword=$query"
+
+        if (filters.genre.isNotBlank()) url += filters.genre
+        if (filters.country.isNotBlank()) url += filters.country
+        if (filters.season.isNotBlank()) url += filters.season
+        if (filters.year.isNotBlank()) url += filters.year
+        if (filters.type.isNotBlank()) url += filters.type
+        if (filters.status.isNotBlank()) url += filters.status
+        if (filters.language.isNotBlank()) url += filters.language
+        if (filters.rating.isNotBlank()) url += filters.rating
+
+        return GET("$url&sort=${filters.sort}&page=$page&vrf=$vrf", refererHeaders)
+    }
+
+    override fun searchAnimeSelector(): String = popularAnimeSelector()
+
+    override fun searchAnimeFromElement(element: Element): SAnime = popularAnimeFromElement(element)
+
+    override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
+
+    // ============================== Filters ===============================
+
+    override fun getFilterList(): AnimeFilterList = AniwaveFilters.FILTER_LIST
+
+    // =========================== Anime Details ============================
+
+    override fun animeDetailsParse(document: Document): SAnime {
+        val anime = SAnime.create()
+        val newDocument = resolveSearchAnime(anime, document)
+        anime.apply {
+            title = newDocument.select("h1.title").text()
+            genre = newDocument.select("div:contains(Genre) > span > a").joinToString { it.text() }
+            description = newDocument.select("div.synopsis > div.shorting > div.content").text()
+            author = newDocument.select("div:contains(Studio) > span > a").text()
+            status = parseStatus(newDocument.select("div:contains(Status) > span").text())
+
+            val altName = "Other name(s): "
+            newDocument.select("h1.title").attr("data-jp").let {
+                if (it.isNotBlank()) {
+                    description = when {
+                        description.isNullOrBlank() -> altName + it
+                        else -> description + "\n\n$altName" + it
+                    }
+                }
+            }
+        }
+        return anime
+    }
+
+    // ============================== Episodes ==============================
+
+    override fun episodeListRequest(anime: SAnime): Request {
+        val response = client.newCall(GET(baseUrl + anime.url)).execute()
+        var document = response.asJsoup()
+        document = resolveSearchAnime(anime, document)
+        val id = document.selectFirst("div[data-id]")?.attr("data-id") ?: throw Exception("ID not found")
+
+        val vrf = utils.vrfEncrypt(id)
+
+        val listHeaders = headers.newBuilder().apply {
+            add("Accept", "application/json, text/javascript, */*; q=0.01")
+            add("Referer", baseUrl + anime.url)
+            add("X-Requested-With", "XMLHttpRequest")
+        }.build()
+
+        return GET("$baseUrl/ajax/episode/list/$id?vrf=$vrf#${anime.url}", listHeaders)
+    }
+
+    override fun episodeListSelector() = "div.episodes ul > li > a"
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val animeUrl = response.request.url.fragment!!
+        val document = response.parseAs<ResultResponse>().toDocument()
+
+        val episodeElements = document.select(episodeListSelector())
+        return episodeElements.parallelMapBlocking { episodeFromElements(it, animeUrl) }.reversed()
+    }
+
+    override fun episodeFromElement(element: Element): SEpisode = throw UnsupportedOperationException()
+
+    private fun episodeFromElements(element: Element, url: String): SEpisode {
+        val title = element.parent()?.attr("title") ?: ""
+
+        val epNum = element.attr("data-num")
+        val ids = element.attr("data-ids")
+        val sub = if (element.attr("data-sub").toInt().toBoolean()) "Sub" else ""
+        val dub = if (element.attr("data-dub").toInt().toBoolean()) "Dub" else ""
+        val softSub = if (SOFTSUB_REGEX.find(title) != null) "SoftSub" else ""
+
+        val extraInfo = if (element.hasClass("filler") && markFiller) {
+            " • Filler Episode"
+        } else {
+            ""
+        }
+        val name = element.parent()?.select("span.d-title")?.text().orEmpty()
+        val namePrefix = "Episode $epNum"
+
+        return SEpisode.create().apply {
+            this.name = "Episode $epNum" +
+                if (name.isNotEmpty() && name != namePrefix) ": $name" else ""
+            this.url = "$ids&epurl=$url/ep-$epNum"
+            episode_number = epNum.toFloat()
+            date_upload = RELEASE_REGEX.find(title)?.let {
+                parseDate(it.groupValues[1])
+            } ?: 0L
+            scanlator = arrayOf(sub, softSub, dub).filter(String::isNotBlank).joinToString(", ") + extraInfo
+        }
+    }
+
+    // ============================ Video Links =============================
+
+    override fun videoListRequest(episode: SEpisode): Request {
+        val ids = episode.url.substringBefore("&")
+        val vrf = utils.vrfEncrypt(ids)
+        val url = "/ajax/server/list/$ids?vrf=$vrf"
+        val epurl = episode.url.substringAfter("epurl=")
+
+        val listHeaders = headers.newBuilder().apply {
+            add("Accept", "application/json, text/javascript, */*; q=0.01")
+            add("Referer", baseUrl + epurl)
+            add("X-Requested-With", "XMLHttpRequest")
+        }.build()
+
+        return GET("$baseUrl$url#$epurl", listHeaders)
+    }
+
+    data class VideoData(
+        val type: String,
+        val serverId: String,
+        val serverName: String,
+    )
+
+    override fun videoListParse(response: Response): List<Video> {
+        val epurl = response.request.url.fragment!!
+        val document = response.parseAs<ResultResponse>().toDocument()
+        val hosterSelection = getHosters()
+        val typeSelection = preferences.getStringSet(PREF_TYPE_TOGGLE_KEY, PREF_TYPES_TOGGLE_DEFAULT)!!
+
+        return document.select("div.servers > div").parallelFlatMapBlocking { elem ->
+            val type = elem.attr("data-type").replaceFirstChar { it.uppercase() }
+            elem.select("li").mapNotNull { serverElement ->
+                val serverId = serverElement.attr("data-link-id")
+                val serverName = serverElement.text().lowercase()
+                if (hosterSelection.contains(serverName, true).not()) return@mapNotNull null
+                if (typeSelection.contains(type, true).not()) return@mapNotNull null
+
+                VideoData(type, serverId, serverName)
+            }
+        }
+            .parallelFlatMapBlocking { extractVideo(it, epurl) }
+    }
+
+    override fun videoListSelector() = throw UnsupportedOperationException()
+
+    override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
+
+    override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
+
+    // ============================= Utilities ==============================
+
+    private val vidsrcExtractor by lazy { VidsrcExtractor(client, headers) }
+    private val filemoonExtractor by lazy { FilemoonExtractor(client) }
+    private val streamtapeExtractor by lazy { StreamTapeExtractor(client) }
+    private val mp4uploadExtractor by lazy { Mp4uploadExtractor(client) }
+
+    private fun extractVideo(server: VideoData, epUrl: String): List<Video> {
+        val vrf = utils.vrfEncrypt(server.serverId)
+
+        val listHeaders = headers.newBuilder().apply {
+            add("Accept", "application/json, text/javascript, */*; q=0.01")
+            add("Referer", baseUrl + epUrl)
+            add("X-Requested-With", "XMLHttpRequest")
+        }.build()
+
+        val response = client.newCall(
+            GET("$baseUrl/ajax/server/${server.serverId}?vrf=$vrf", listHeaders),
+        ).execute()
+        if (response.code != 200) return emptyList()
+
+        return runCatching {
+            val parsed = response.parseAs<ServerResponse>()
+            val embedLink = utils.vrfDecrypt(parsed.result.url)
+            when (server.serverName) {
+                "vidstream" -> vidsrcExtractor.videosFromUrl(embedLink, "Vidstream", server.type)
+                "megaf" -> vidsrcExtractor.videosFromUrl(embedLink, "MegaF", server.type)
+                "moonf" -> filemoonExtractor.videosFromUrl(embedLink, "MoonF - ${server.type} - ")
+                "streamtape" -> streamtapeExtractor.videoFromUrl(embedLink, "StreamTape - ${server.type}")?.let(::listOf) ?: emptyList()
+                "mp4u" -> mp4uploadExtractor.videosFromUrl(embedLink, headers, suffix = " - ${server.type}")
+                else -> emptyList()
+            }
+        }.getOrElse { emptyList() }
+    }
+
+    private fun Int.toBoolean() = this == 1
+
+    private fun Set<String>.contains(s: String, ignoreCase: Boolean): Boolean {
+        return any { it.equals(s, ignoreCase) }
+    }
+
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
+        val lang = preferences.getString(PREF_LANG_KEY, PREF_LANG_DEFAULT)!!
+        val server = preferences.getString(PREF_SERVER_KEY, PREF_SERVER_DEFAULT)!!
+
+        return this.sortedWith(
+            compareByDescending<Video> { it.quality.contains(lang) }
+                .thenByDescending { it.quality.contains(quality) }
+                .thenByDescending { it.quality.contains(server, true) },
+        )
+    }
+
+    @Synchronized
+    private fun parseDate(dateStr: String): Long {
+        return runCatching { DATE_FORMATTER.parse(dateStr)?.time }
+            .getOrNull() ?: 0L
+    }
+
+    private fun parseStatus(statusString: String): Int {
+        return when (statusString) {
+            "Releasing" -> SAnime.ONGOING
+            "Completed" -> SAnime.COMPLETED
+            else -> SAnime.UNKNOWN
+        }
+    }
+
+    private fun resolveSearchAnime(anime: SAnime, document: Document): Document {
+        if (document.location().startsWith("$baseUrl/filter?keyword=")) { // redirected to search
+            val element = document.selectFirst(searchAnimeSelector())
+            val foundAnimePath = element?.selectFirst("a[href]")?.attr("href")
+                ?: throw Exception("Search element not found (resolveSearch)")
+            anime.url = foundAnimePath // probably doesn't work as intended
+            return client.newCall(GET(baseUrl + foundAnimePath)).execute().asJsoup()
+        }
+        return document
+    }
+
+    private fun getHosters(): Set<String> {
+        val hosterSelection = preferences.getStringSet(PREF_HOSTER_KEY, PREF_HOSTER_DEFAULT)!!
+        var invalidRecord = false
+        hosterSelection.forEach { str ->
+            val index = HOSTERS_NAMES.indexOf(str)
+            if (index == -1) {
+                invalidRecord = true
+            }
+        }
+
+        // found invalid record, reset to defaults
+        if (invalidRecord) {
+            preferences.edit().putStringSet(PREF_HOSTER_KEY, PREF_HOSTER_DEFAULT).apply()
+            return PREF_HOSTER_DEFAULT.toSet()
+        }
+
+        return hosterSelection.toSet()
+    }
+
+    companion object {
+        private val SOFTSUB_REGEX by lazy { Regex("""\bsoftsub\b""", RegexOption.IGNORE_CASE) }
+        private val RELEASE_REGEX by lazy { Regex("""Release: (\d+\/\d+\/\d+ \d+:\d+)""") }
+
+        private val DATE_FORMATTER by lazy {
+            SimpleDateFormat("yyyy/MM/dd HH:mm", Locale.ENGLISH)
+        }
+
+        private const val PREF_DOMAIN_KEY = "preferred_domain"
+        private const val PREF_DOMAIN_DEFAULT = "https://aniwave.to"
+
+        private const val PREF_CUSTOM_DOMAIN_KEY = "custom_domain"
+
+        private const val PREF_QUALITY_KEY = "preferred_quality"
+        private const val PREF_QUALITY_DEFAULT = "1080"
+
+        private const val PREF_LANG_KEY = "preferred_language"
+        private const val PREF_LANG_DEFAULT = "Sub"
+
+        private const val PREF_SERVER_KEY = "preferred_server"
+        private const val PREF_SERVER_DEFAULT = "Vidstream"
+
+        private const val PREF_MARK_FILLERS_KEY = "mark_fillers"
+        private const val PREF_MARK_FILLERS_DEFAULT = true
+
+        private const val PREF_HOSTER_KEY = "hoster_selection"
+        private val HOSTERS = arrayOf(
+            "Vidstream",
+            "Megaf",
+            "MoonF",
+            "StreamTape",
+            "MP4u",
+        )
+        private val HOSTERS_NAMES = arrayOf(
+            "vidstream",
+            "megaf",
+            "moonf",
+            "streamtape",
+            "mp4u",
+        )
+        private val PREF_HOSTER_DEFAULT = HOSTERS_NAMES.toSet()
+
+        private const val PREF_TYPE_TOGGLE_KEY = "type_selection"
+        private val TYPES = arrayOf("Sub", "Softsub", "Dub")
+        private val PREF_TYPES_TOGGLE_DEFAULT = TYPES.toSet()
+    }
+
+    // ============================== Settings ==============================
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        // validate hosters preferences and if invalid reset
+        try {
+            getHosters()
+        } catch (e: Exception) {
+            Toast.makeText(screen.context, e.toString(), Toast.LENGTH_LONG).show()
+        }
+
+        ListPreference(screen.context).apply {
+            key = PREF_DOMAIN_KEY
+            title = "Preferred domain"
+            entries = arrayOf("aniwave.to", "aniwavetv.to (unofficial)")
+            entryValues = arrayOf("https://aniwave.to", "https://aniwavetv.to")
+            setDefaultValue(PREF_DOMAIN_DEFAULT)
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                Toast.makeText(screen.context, "Restart Aniyomi to apply changes", Toast.LENGTH_LONG).show()
+                preferences.edit().putString(key, entry).commit()
+            }
+        }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = PREF_QUALITY_KEY
+            title = "Preferred quality"
+            entries = arrayOf("1080p", "720p", "480p", "360p")
+            entryValues = arrayOf("1080", "720", "480", "360")
+            setDefaultValue(PREF_QUALITY_DEFAULT)
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = PREF_LANG_KEY
+            title = "Preferred Type"
+            entries = TYPES
+            entryValues = TYPES
+            setDefaultValue(PREF_LANG_DEFAULT)
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = PREF_SERVER_KEY
+            title = "Preferred Server"
+            entries = HOSTERS
+            entryValues = HOSTERS_NAMES
+            setDefaultValue(PREF_SERVER_DEFAULT)
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }.also(screen::addPreference)
+
+        SwitchPreferenceCompat(screen.context).apply {
+            key = PREF_MARK_FILLERS_KEY
+            title = "Mark filler episodes"
+            setDefaultValue(PREF_MARK_FILLERS_DEFAULT)
+            setOnPreferenceChangeListener { _, newValue ->
+                Toast.makeText(screen.context, "Restart Aniyomi to apply new setting.", Toast.LENGTH_LONG).show()
+                preferences.edit().putBoolean(key, newValue as Boolean).commit()
+            }
+        }.also(screen::addPreference)
+
+        MultiSelectListPreference(screen.context).apply {
+            key = PREF_HOSTER_KEY
+            title = "Enable/Disable Hosts"
+            entries = HOSTERS
+            entryValues = HOSTERS_NAMES
+            setDefaultValue(PREF_HOSTER_DEFAULT)
+
+            setOnPreferenceChangeListener { _, newValue ->
+                @Suppress("UNCHECKED_CAST")
+                preferences.edit().putStringSet(key, newValue as Set<String>).commit()
+            }
+        }.also(screen::addPreference)
+
+        MultiSelectListPreference(screen.context).apply {
+            key = PREF_TYPE_TOGGLE_KEY
+            title = "Enable/Disable Types"
+            entries = TYPES
+            entryValues = TYPES
+            setDefaultValue(PREF_TYPES_TOGGLE_DEFAULT)
+
+            setOnPreferenceChangeListener { _, newValue ->
+                @Suppress("UNCHECKED_CAST")
+                preferences.edit().putStringSet(key, newValue as Set<String>).commit()
+            }
+        }.also(screen::addPreference)
+
+        EditTextPreference(screen.context).apply {
+            key = PREF_CUSTOM_DOMAIN_KEY
+            title = "Custom domain"
+            setDefaultValue(null)
+            val currentValue = preferences.getString(PREF_CUSTOM_DOMAIN_KEY, null)
+            summary = if (currentValue.isNullOrBlank()) {
+                "Custom domain of your choosing"
+            } else {
+                "Domain: \"$currentValue\". \nLeave blank to disable. Overrides any domain preferences!"
+            }
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val newDomain = newValue as String
+                if (newDomain.isBlank() || URLUtil.isValidUrl(newDomain)) {
+                    summary = "Restart to apply changes"
+                    Toast.makeText(screen.context, "Restart Aniyomi to apply changes", Toast.LENGTH_LONG).show()
+                    preferences.edit().putString(key, newDomain).apply()
+                    true
+                } else {
+                    Toast.makeText(screen.context, "Invalid url. Url example: https://aniwave.to", Toast.LENGTH_LONG).show()
+                    false
+                }
+            }
+        }.also(screen::addPreference)
+    }
+}
diff --git a/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveDto.kt b/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveDto.kt
new file mode 100644
index 00000000..0d436809
--- /dev/null
+++ b/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveDto.kt
@@ -0,0 +1,49 @@
+package eu.kanade.tachiyomi.animeextension.en.nineanime
+
+import kotlinx.serialization.Serializable
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Document
+
+@Serializable
+data class ServerResponse(
+    val result: Result,
+) {
+
+    @Serializable
+    data class Result(
+        val url: String,
+    )
+}
+
+@Serializable
+data class MediaResponseBody(
+    val status: Int,
+    val result: Result,
+) {
+    @Serializable
+    data class Result(
+        val sources: ArrayList<Source>,
+        val tracks: ArrayList<SubTrack> = ArrayList(),
+    ) {
+        @Serializable
+        data class Source(
+            val file: String,
+        )
+
+        @Serializable
+        data class SubTrack(
+            val file: String,
+            val label: String = "",
+            val kind: String,
+        )
+    }
+}
+
+@Serializable
+data class ResultResponse(
+    val result: String,
+) {
+    fun toDocument(): Document {
+        return Jsoup.parseBodyFragment(result)
+    }
+}
diff --git a/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveFilters.kt b/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveFilters.kt
new file mode 100644
index 00000000..3aa0cf55
--- /dev/null
+++ b/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveFilters.kt
@@ -0,0 +1,270 @@
+package eu.kanade.tachiyomi.animeextension.en.nineanime
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+
+object AniwaveFilters {
+    open class QueryPartFilter(
+        displayName: String,
+        val vals: Array<Pair<String, String>>,
+    ) : AnimeFilter.Select<String>(
+        displayName,
+        vals.map { it.first }.toTypedArray(),
+    ) {
+        fun toQueryPart() = vals[state].second
+    }
+
+    open class CheckBoxFilterList(name: String, values: List<CheckBox>) : AnimeFilter.Group<AnimeFilter.CheckBox>(name, values)
+    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
+
+    private inline fun <reified R> AnimeFilterList.asQueryPart(): String {
+        return this.filterIsInstance<R>().joinToString("") {
+            (it as QueryPartFilter).toQueryPart()
+        }
+    }
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R {
+        return this.filterIsInstance<R>().first()
+    }
+
+    private inline fun <reified R> AnimeFilterList.parseCheckbox(
+        options: Array<Pair<String, String>>,
+        name: String,
+    ): String {
+        return (this.getFirst<R>() as CheckBoxFilterList).state
+            .mapNotNull { checkbox ->
+                if (checkbox.state) {
+                    options.find { it.first == checkbox.name }!!.second
+                } else {
+                    null
+                }
+            }.joinToString("&$name[]=").let {
+                if (it.isBlank()) {
+                    ""
+                } else {
+                    "&$name[]=$it"
+                }
+            }
+    }
+
+    class SortFilter : QueryPartFilter("Sort order", NineAnimeFiltersData.SORT)
+
+    class GenreFilter : CheckBoxFilterList(
+        "Genre",
+        NineAnimeFiltersData.GENRE.map { CheckBoxVal(it.first, false) },
+    )
+
+    class CountryFilter : CheckBoxFilterList(
+        "Country",
+        NineAnimeFiltersData.COUNTRY.map { CheckBoxVal(it.first, false) },
+    )
+
+    class SeasonFilter : CheckBoxFilterList(
+        "Season",
+        NineAnimeFiltersData.SEASON.map { CheckBoxVal(it.first, false) },
+    )
+
+    class YearFilter : CheckBoxFilterList(
+        "Year",
+        NineAnimeFiltersData.YEAR.map { CheckBoxVal(it.first, false) },
+    )
+
+    class TypeFilter : CheckBoxFilterList(
+        "Type",
+        NineAnimeFiltersData.TYPE.map { CheckBoxVal(it.first, false) },
+    )
+
+    class StatusFilter : CheckBoxFilterList(
+        "Status",
+        NineAnimeFiltersData.STATUS.map { CheckBoxVal(it.first, false) },
+    )
+
+    class LanguageFilter : CheckBoxFilterList(
+        "Language",
+        NineAnimeFiltersData.LANGUAGE.map { CheckBoxVal(it.first, false) },
+    )
+
+    class RatingFilter : CheckBoxFilterList(
+        "Rating",
+        NineAnimeFiltersData.RATING.map { CheckBoxVal(it.first, false) },
+    )
+
+    val FILTER_LIST get() = AnimeFilterList(
+        SortFilter(),
+        AnimeFilter.Separator(),
+        GenreFilter(),
+        CountryFilter(),
+        SeasonFilter(),
+        YearFilter(),
+        TypeFilter(),
+        StatusFilter(),
+        LanguageFilter(),
+        RatingFilter(),
+    )
+
+    data class FilterSearchParams(
+        val sort: String = "",
+        val genre: String = "",
+        val country: String = "",
+        val season: String = "",
+        val year: String = "",
+        val type: String = "",
+        val status: String = "",
+        val language: String = "",
+        val rating: String = "",
+    )
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+
+        return FilterSearchParams(
+            filters.asQueryPart<SortFilter>(),
+            filters.parseCheckbox<GenreFilter>(NineAnimeFiltersData.GENRE, "genre"),
+            filters.parseCheckbox<CountryFilter>(NineAnimeFiltersData.COUNTRY, "country"),
+            filters.parseCheckbox<SeasonFilter>(NineAnimeFiltersData.SEASON, "season"),
+            filters.parseCheckbox<YearFilter>(NineAnimeFiltersData.YEAR, "year"),
+            filters.parseCheckbox<TypeFilter>(NineAnimeFiltersData.TYPE, "type"),
+            filters.parseCheckbox<StatusFilter>(NineAnimeFiltersData.STATUS, "status"),
+            filters.parseCheckbox<LanguageFilter>(NineAnimeFiltersData.LANGUAGE, "language"),
+            filters.parseCheckbox<RatingFilter>(NineAnimeFiltersData.RATING, "rating"),
+        )
+    }
+
+    private object NineAnimeFiltersData {
+        val SORT = arrayOf(
+            Pair("Most relevance", "most_relevance"),
+            Pair("Recently updated", "recently_updated"),
+            Pair("Recently added", "recently_added"),
+            Pair("Release date", "release_date"),
+            Pair("Trending", "trending"),
+            Pair("Name A-Z", "title_az"),
+            Pair("Scores", "scores"),
+            Pair("MAL scores", "mal_scores"),
+            Pair("Most watched", "most_watched"),
+            Pair("Most favourited", "most_favourited"),
+            Pair("Number of episodes", "number_of_episodes"),
+        )
+
+        val GENRE = arrayOf(
+            Pair("Action", "1"),
+            Pair("Adventure", "2"),
+            Pair("Avant Garde", "2262888"),
+            Pair("Boys Love", "2262603"),
+            Pair("Comedy", "4"),
+            Pair("Demons", "4424081"),
+            Pair("Drama", "7"),
+            Pair("Ecchi", "8"),
+            Pair("Fantasy", "9"),
+            Pair("Girls Love", "2263743"),
+            Pair("Gourmet", "2263289"),
+            Pair("Harem", "11"),
+            Pair("Horror", "14"),
+            Pair("Isekai", "3457284"),
+            Pair("Iyashikei", "4398552"),
+            Pair("Josei", "15"),
+            Pair("Kids", "16"),
+            Pair("Magic", "4424082"),
+            Pair("Mahou Shoujo", "3457321"),
+            Pair("Martial Arts", "18"),
+            Pair("Mecha", "19"),
+            Pair("Military", "20"),
+            Pair("Music", "21"),
+            Pair("Mystery", "22"),
+            Pair("Parody", "23"),
+            Pair("Psychological", "25"),
+            Pair("Reverse Harem", "4398403"),
+            Pair("Romance", "26"),
+            Pair("School", "28"),
+            Pair("Sci-Fi", "29"),
+            Pair("Seinen", "30"),
+            Pair("Shoujo", "31"),
+            Pair("Shounen", "33"),
+            Pair("Slice of Life", "35"),
+            Pair("Space", "36"),
+            Pair("Sports", "37"),
+            Pair("Super Power", "38"),
+            Pair("Supernatural", "39"),
+            Pair("Suspense", "2262590"),
+            Pair("Thriller", "40"),
+            Pair("Vampire", "41"),
+        )
+
+        val COUNTRY = arrayOf(
+            Pair("China", "120823"),
+            Pair("Japan", "120822"),
+        )
+
+        val SEASON = arrayOf(
+            Pair("Fall", "fall"),
+            Pair("Summer", "summer"),
+            Pair("Spring", "spring"),
+            Pair("Winter", "winter"),
+            Pair("Unknown", "unknown"),
+        )
+
+        val YEAR = arrayOf(
+            Pair("2024", "2024"),
+            Pair("2023", "2023"),
+            Pair("2022", "2022"),
+            Pair("2021", "2021"),
+            Pair("2020", "2020"),
+            Pair("2019", "2019"),
+            Pair("2018", "2018"),
+            Pair("2017", "2017"),
+            Pair("2016", "2016"),
+            Pair("2015", "2015"),
+            Pair("2014", "2014"),
+            Pair("2013", "2013"),
+            Pair("2012", "2012"),
+            Pair("2011", "2011"),
+            Pair("2010", "2010"),
+            Pair("2009", "2009"),
+            Pair("2008", "2008"),
+            Pair("2007", "2007"),
+            Pair("2006", "2006"),
+            Pair("2005", "2005"),
+            Pair("2004", "2004"),
+            Pair("2003", "2003"),
+            Pair("2000s", "2000s"),
+            Pair("1990s", "1990s"),
+            Pair("1980s", "1980s"),
+            Pair("1970s", "1970s"),
+            Pair("1960s", "1960s"),
+            Pair("1950s", "1950s"),
+            Pair("1940s", "1940s"),
+            Pair("1930s", "1930s"),
+            Pair("1920s", "1920s"),
+            Pair("1910s", "1910s"),
+        )
+
+        val TYPE = arrayOf(
+            Pair("Movie", "movie"),
+            Pair("TV", "tv"),
+            Pair("OVA", "ova"),
+            Pair("ONA", "ona"),
+            Pair("Special", "special"),
+            Pair("Music", "music"),
+        )
+
+        val STATUS = arrayOf(
+            Pair("Not Yet Aired", "info"),
+            Pair("Releasing", "releasing"),
+            Pair("Completed", "completed"),
+        )
+
+        val LANGUAGE = arrayOf(
+            Pair("Sub and Dub", "subdub"),
+            Pair("Sub", "sub"),
+            Pair("Dub", "dub"),
+        )
+
+        val RATING = arrayOf(
+            Pair("G - All Ages", "g"),
+            Pair("PG - Children", "pg"),
+            Pair("PG 13 - Teens 13 and Older", "pg_13"),
+            Pair("R - 17+, Violence & Profanity", "r"),
+            Pair("R+ - Profanity & Mild Nudity", "r+"),
+            Pair("Rx - Hentai", "rx"),
+        )
+    }
+}
diff --git a/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveUtils.kt b/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveUtils.kt
new file mode 100644
index 00000000..39cbf7ca
--- /dev/null
+++ b/src/en/nineanime/src/eu/kanade/tachiyomi/animeextension/en/nineanime/AniwaveUtils.kt
@@ -0,0 +1,117 @@
+package eu.kanade.tachiyomi.animeextension.en.nineanime
+
+import android.util.Base64
+import java.net.URLDecoder
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
+
+class AniwaveUtils {
+
+    fun vrfEncrypt(input: String): String {
+        var vrf = input
+        ORDER.sortedBy {
+            it.first
+        }.forEach { item ->
+            when (item.second) {
+                "exchange" -> vrf = exchange(vrf, item.third)
+                "rc4" -> vrf = rc4Encrypt(item.third.get(0), vrf)
+                "reverse" -> vrf = vrf.reversed()
+                "base64" -> vrf = Base64.encode(vrf.toByteArray(), Base64.URL_SAFE or Base64.NO_WRAP).toString(Charsets.UTF_8)
+                else -> {}
+            }
+        }
+
+        return java.net.URLEncoder.encode(vrf, "utf-8")
+    }
+
+    fun vrfDecrypt(input: String): String {
+        var vrf = input
+        ORDER.sortedByDescending {
+            it.first
+        }.forEach { item ->
+            when (item.second) {
+                "exchange" -> vrf = exchange(vrf, item.third.reversed())
+                "rc4" -> vrf = rc4Decrypt(item.third.get(0), vrf)
+                "reverse" -> vrf = vrf.reversed()
+                "base64" -> vrf = Base64.decode(vrf, Base64.URL_SAFE).toString(Charsets.UTF_8)
+                else -> {}
+            }
+        }
+
+        return URLDecoder.decode(vrf, "utf-8")
+    }
+
+    private fun rc4Encrypt(key: String, input: String): String {
+        val rc4Key = SecretKeySpec(key.toByteArray(), "RC4")
+        val cipher = Cipher.getInstance("RC4")
+        cipher.init(Cipher.DECRYPT_MODE, rc4Key, cipher.parameters)
+
+        var output = cipher.doFinal(input.toByteArray())
+        output = Base64.encode(output, Base64.URL_SAFE or Base64.NO_WRAP)
+        return output.toString(Charsets.UTF_8)
+    }
+
+    private fun rc4Decrypt(key: String, input: String): String {
+        var vrf = input.toByteArray()
+        vrf = Base64.decode(vrf, Base64.URL_SAFE)
+
+        val rc4Key = SecretKeySpec(key.toByteArray(), "RC4")
+        val cipher = Cipher.getInstance("RC4")
+        cipher.init(Cipher.DECRYPT_MODE, rc4Key, cipher.parameters)
+        vrf = cipher.doFinal(vrf)
+        return vrf.toString(Charsets.UTF_8)
+    }
+
+    private fun exchange(input: String, keys: List<String>): String {
+        val key1 = keys.get(0)
+        val key2 = keys.get(1)
+        return input.map { i ->
+            val index = key1.indexOf(i)
+            if (index != -1) {
+                key2[index]
+            } else {
+                i
+            }
+        }.joinToString("")
+    }
+
+    private fun rot13(vrf: ByteArray): ByteArray {
+        for (i in vrf.indices) {
+            val byte = vrf[i]
+            if (byte in 'A'.code..'Z'.code) {
+                vrf[i] = ((byte - 'A'.code + 13) % 26 + 'A'.code).toByte()
+            } else if (byte in 'a'.code..'z'.code) {
+                vrf[i] = ((byte - 'a'.code + 13) % 26 + 'a'.code).toByte()
+            }
+        }
+        return vrf
+    }
+
+    private fun vrfShift(vrf: ByteArray): ByteArray {
+        for (i in vrf.indices) {
+            val shift = arrayOf(-2, -4, -5, 6, 2, -3, 3, 6)[i % 8]
+            vrf[i] = vrf[i].plus(shift).toByte()
+        }
+        return vrf
+    }
+
+    companion object {
+        private val EXCHANGE_KEY_1 = listOf("AP6GeR8H0lwUz1", "UAz8Gwl10P6ReH")
+        private val KEY_1 = "ItFKjuWokn4ZpB"
+        private val KEY_2 = "fOyt97QWFB3"
+        private val EXCHANGE_KEY_2 = listOf("1majSlPQd2M5", "da1l2jSmP5QM")
+        private val EXCHANGE_KEY_3 = listOf("CPYvHj09Au3", "0jHA9CPYu3v")
+        private val KEY_3 = "736y1uTJpBLUX"
+
+        private val ORDER = listOf(
+            Triple(1, "exchange", EXCHANGE_KEY_1),
+            Triple(2, "rc4", listOf(KEY_1)),
+            Triple(3, "rc4", listOf(KEY_2)),
+            Triple(4, "exchange", EXCHANGE_KEY_2),
+            Triple(5, "exchange", EXCHANGE_KEY_3),
+            Triple(5, "reverse", emptyList()),
+            Triple(6, "rc4", listOf(KEY_3)),
+            Triple(7, "base64", emptyList()),
+        )
+    }
+}
diff --git a/src/es/doramasyt/build.gradle b/src/es/doramasyt/build.gradle
index 5423041d..f73ca3a5 100644
--- a/src/es/doramasyt/build.gradle
+++ b/src/es/doramasyt/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Doramasyt'
     extClass = '.Doramasyt'
-    extVersionCode = 13
+    extVersionCode = 14
 }
 
 apply from: "$rootDir/common.gradle"
@@ -10,4 +10,9 @@ dependencies {
     implementation(project(':lib:uqload-extractor'))
     implementation(project(':lib:streamtape-extractor'))
     implementation(project(':lib:okru-extractor'))
+    implementation(project(':lib:voe-extractor'))
+    implementation(project(':lib:filemoon-extractor'))
+    implementation(project(':lib:streamwish-extractor'))
+    implementation(project(':lib:dood-extractor'))
+    implementation(project(':lib:mixdrop-extractor'))
 }
diff --git a/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/Doramasyt.kt b/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/Doramasyt.kt
index d3774bc6..762c2f86 100644
--- a/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/Doramasyt.kt
+++ b/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/Doramasyt.kt
@@ -2,34 +2,41 @@ package eu.kanade.tachiyomi.animeextension.es.doramasyt
 
 import android.app.Application
 import android.content.SharedPreferences
-import android.util.Log
+import android.util.Base64
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animeextension.es.doramasyt.extractors.SolidFilesExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
 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.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
+import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
+import eu.kanade.tachiyomi.lib.mixdropextractor.MixDropExtractor
 import eu.kanade.tachiyomi.lib.okruextractor.OkruExtractor
 import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
+import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.uqloadextractor.UqloadExtractor
+import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
+import eu.kanade.tachiyomi.util.parseAs
+import okhttp3.FormBody
 import okhttp3.Request
 import okhttp3.Response
-import org.jsoup.nodes.Document
 import org.jsoup.nodes.Element
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
+import kotlin.math.ceil
 
-class Doramasyt : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
+class Doramasyt : ConfigurableAnimeSource, AnimeHttpSource() {
 
     override val name = "Doramasyt"
 
-    override val baseUrl = "https://doramasyt.com"
+    override val baseUrl = "https://www.doramasyt.com"
 
     override val lang = "es"
 
@@ -39,241 +46,203 @@ class Doramasyt : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
     }
 
-    override fun popularAnimeSelector(): String = "div.col-lg-2.col-md-4.col-6 div.animes"
+    companion object {
+        private const val PREF_QUALITY_KEY = "preferred_quality"
+        private const val PREF_QUALITY_DEFAULT = "1080"
+        private val QUALITY_LIST = arrayOf("1080", "720", "480", "360")
 
-    override fun popularAnimeRequest(page: Int): Request = GET("https://doramasyt.com/doramas/?p=$page")
-
-    override fun popularAnimeFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.setUrlWithoutDomain(
-            element.select("div.anithumb a").attr("href"),
+        private const val PREF_SERVER_KEY = "preferred_server"
+        private const val PREF_SERVER_DEFAULT = "Filemoon"
+        private val SERVER_LIST = arrayOf(
+            "Voe",
+            "StreamWish",
+            "Okru",
+            "Upload",
+            "FileLions",
+            "Filemoon",
+            "DoodStream",
+            "MixDrop",
+            "Streamtape",
         )
-        anime.title = element.select("div.animedtls p").text()
-        anime.thumbnail_url = element.select(" div.anithumb a img").attr("src")
-        anime.description = element.select("div.animedtls p").text()
-        return anime
     }
 
-    override fun popularAnimeNextPageSelector(): String = "ul.pagination li:last-child a"
+    override fun animeDetailsParse(response: Response): SAnime {
+        val document = response.asJsoup()
+        val animeDetails = SAnime.create().apply {
+            title = document.selectFirst(".flex-column h1.text-capitalize")?.text() ?: ""
+            description = document.selectFirst(".h-100 .mb-3 p")?.text()
+            genre = document.select(".lh-lg span").joinToString { it.text() }
+            thumbnail_url = document.selectFirst(".gap-3 img")?.getImageUrl()
+            status = document.select(".lh-sm .ms-2").eachText().let { items ->
+                when {
+                    items.any { it.contains("Finalizado") } -> SAnime.COMPLETED
+                    items.any { it.contains("Estreno") } -> SAnime.ONGOING
+                    else -> SAnime.UNKNOWN
+                }
+            }
+        }
+        return animeDetails
+    }
+
+    override fun popularAnimeRequest(page: Int) = GET("$baseUrl/doramas?p=$page", headers)
+
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        val document = response.asJsoup()
+        val elements = document.select(".ficha_efecto a")
+        val nextPage = document.select(".pagination [rel=\"next\"]").any()
+        val animeList = elements.map { element ->
+            SAnime.create().apply {
+                title = element.selectFirst(".title_cap")!!.text()
+                thumbnail_url = element.selectFirst("img")?.getImageUrl()
+                setUrlWithoutDomain(element.attr("abs:href"))
+            }
+        }
+        return AnimesPage(animeList, nextPage)
+    }
+
+    override fun latestUpdatesParse(response: Response) = popularAnimeParse(response)
+
+    override fun latestUpdatesRequest(page: Int) = GET("$baseUrl/emision?p=$page", headers)
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val params = DoramasytFilters.getSearchParameters(filters)
+        return when {
+            query.isNotBlank() -> GET("$baseUrl/buscar?q=$query", headers)
+            params.filter.isNotBlank() -> GET("$baseUrl/doramas${params.getQuery()}&p=$page", headers)
+            else -> popularAnimeRequest(page)
+        }
+    }
+
+    override fun searchAnimeParse(response: Response) = popularAnimeParse(response)
 
     override fun episodeListParse(response: Response): List<SEpisode> {
-        return super.episodeListParse(response).reversed()
+        val document = response.asJsoup()
+        val token = document.select("meta[name='csrf-token']").attr("content")
+        val capListLink = document.select(".caplist").attr("data-ajax")
+        val referer = document.location()
+
+        val detail = getEpisodeDetails(capListLink, token, referer)
+        val total = detail.eps.size
+        val perPage = detail.perpage ?: return emptyList()
+        val pages = (total / perPage).ceilPage()
+
+        return (1..pages).parallelCatchingFlatMapBlocking {
+            getEpisodePage(detail.paginateUrl ?: "", it, token, referer).caps.mapIndexed { idx, ep ->
+                val episodeNumber = (ep.episodio ?: (idx + 1))
+                SEpisode.create().apply {
+                    name = "Capítulo $episodeNumber"
+                    episode_number = episodeNumber.toFloat()
+                    setUrlWithoutDomain(ep.url ?: "")
+                }
+            }
+        }.reversed()
     }
 
-    override fun episodeListSelector(): String = "div.mainrowdiv.pagesdiv div.jpage div.col-item"
+    private fun getEpisodeDetails(capListLink: String, token: String, referer: String): EpisodesDto {
+        val formBody = FormBody.Builder().add("_token", token).build()
+        val request = Request.Builder()
+            .url(capListLink)
+            .post(formBody)
+            .header("accept", "application/json, text/javascript, */*; q=0.01")
+            .header("accept-language", "es-419,es;q=0.8")
+            .header("content-type", "application/x-www-form-urlencoded; charset=UTF-8")
+            .header("origin", baseUrl)
+            .header("referer", referer)
+            .header("x-requested-with", "XMLHttpRequest")
+            .build()
 
-    override fun episodeFromElement(element: Element): SEpisode {
-        val episode = SEpisode.create()
-        val epNum = getNumberFromEpsString(element.select("a div.flimss div.dtlsflim p").text())
-        Log.i("bruh ep", element.select("a").attr("href"))
-        val formatedEp = when {
-            epNum.isNotEmpty() -> epNum.toFloatOrNull() ?: 1F
-            else -> 1F
-        }
-        episode.setUrlWithoutDomain(element.select("a").attr("href"))
-        episode.episode_number = formatedEp
-        episode.name = "Episodio $formatedEp"
-
-        return episode
+        return client.newCall(request).execute().parseAs<EpisodesDto>()
     }
 
-    private fun getNumberFromEpsString(epsStr: String): String {
-        return epsStr.filter { it.isDigit() }
+    private fun getEpisodePage(paginateUrl: String, page: Int, token: String, referer: String): EpisodeInfoDto {
+        val formBodyEp = FormBody.Builder()
+            .add("_token", token)
+            .add("p", "$page")
+            .build()
+        val requestEp = Request.Builder()
+            .url(paginateUrl)
+            .post(formBodyEp)
+            .header("accept", "application/json, text/javascript, */*; q=0.01")
+            .header("accept-language", "es-419,es;q=0.8")
+            .header("content-type", "application/x-www-form-urlencoded; charset=UTF-8")
+            .header("origin", baseUrl)
+            .header("referer", referer)
+            .header("x-requested-with", "XMLHttpRequest")
+            .build()
+
+        return client.newCall(requestEp).execute().parseAs<EpisodeInfoDto>()
     }
 
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
-        val videoList = mutableListOf<Video>()
-        document.select("div.playermain ul.dropcaps li#play-video a.cap").forEach { players ->
-            val server = players.text()
-            val urlEncoded = players.attr("data-player")
-            val byte = android.util.Base64.decode(urlEncoded, android.util.Base64.DEFAULT)
-            val url = String(byte, charset("UTF-8")).substringAfter("?url=")
-            if (server.contains("streamtape")) {
-                val video = StreamTapeExtractor(client).videoFromUrl(url)
-                if (video != null) {
-                    videoList.add(video)
-                }
-            }
-            if (server.contains("ok")) {
-                val videos = OkruExtractor(client).videosFromUrl(url)
-                videoList.addAll(videos)
-            }
-            if (server.contains("zeus")) {
-                val videos = SolidFilesExtractor(client).videosFromUrl(url)
-                videoList.addAll(videos)
-            }
-            if (server.contains("uqload") || server.contains("upload")) {
-                videoList.addAll(UqloadExtractor(client).videosFromUrl(url))
-            }
-        }
-        return videoList
+        return document.select("[data-player]")
+            .map { String(Base64.decode(it.attr("data-player"), Base64.DEFAULT)) }
+            .parallelCatchingFlatMapBlocking { serverVideoResolver(it) }
     }
 
-    override fun videoListSelector() = throw UnsupportedOperationException()
+    override fun getFilterList(): AnimeFilterList = DoramasytFilters.FILTER_LIST
 
-    override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
+    private val voeExtractor by lazy { VoeExtractor(client) }
+    private val streamwishExtractor by lazy { StreamWishExtractor(client, headers) }
+    private val filemoonExtractor by lazy { FilemoonExtractor(client) }
+    private val mixdropExtractor by lazy { MixDropExtractor(client) }
+    private val doodExtractor by lazy { DoodExtractor(client) }
+    private val streamTapeExtractor by lazy { StreamTapeExtractor(client) }
+    private val uqloadExtractor by lazy { UqloadExtractor(client) }
+    private val okruExtractor by lazy { OkruExtractor(client) }
 
-    override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
+    private fun serverVideoResolver(url: String): List<Video> {
+        val embedUrl = url.lowercase()
+        return when {
+            embedUrl.contains("voe") -> voeExtractor.videosFromUrl(url)
+            embedUrl.contains("uqload") -> uqloadExtractor.videosFromUrl(url)
+            embedUrl.contains("ok.ru") || embedUrl.contains("okru") -> okruExtractor.videosFromUrl(url)
+            embedUrl.contains("filemoon") || embedUrl.contains("moonplayer") -> filemoonExtractor.videosFromUrl(url, prefix = "Filemoon:")
+            embedUrl.contains("wishembed") || embedUrl.contains("streamwish") || embedUrl.contains("strwish") || embedUrl.contains("wish") || embedUrl.contains("wishfast") -> streamwishExtractor.videosFromUrl(url, videoNameGen = { "StreamWish:$it" })
+            embedUrl.contains("streamtape") || embedUrl.contains("stp") || embedUrl.contains("stape") -> streamTapeExtractor.videosFromUrl(url)
+            embedUrl.contains("doodstream") || embedUrl.contains("dood.") || embedUrl.contains("ds2play") || embedUrl.contains("doods.") -> doodExtractor.videosFromUrl(url, "DoodStream", false)
+            embedUrl.contains("filelions") || embedUrl.contains("lion") -> streamwishExtractor.videosFromUrl(url, videoNameGen = { "FileLions:$it" })
+            embedUrl.contains("mix") -> mixdropExtractor.videosFromUrl(url)
+            else -> emptyList()
+        }
+    }
 
     override fun List<Video>.sort(): List<Video> {
-        return try {
-            val videoSorted = this.sortedWith(
-                compareBy<Video> { it.quality.replace("[0-9]".toRegex(), "") }.thenByDescending { getNumberFromString(it.quality) },
-            ).toTypedArray()
-            val userPreferredQuality = preferences.getString("preferred_quality", "Okru:720p")
-            val preferredIdx = videoSorted.indexOfFirst { x -> x.quality == userPreferredQuality }
-            if (preferredIdx != -1) {
-                videoSorted.drop(preferredIdx + 1)
-                videoSorted[0] = videoSorted[preferredIdx]
-            }
-            videoSorted.toList()
-        } catch (e: Exception) {
-            this
-        }
+        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
+        val server = preferences.getString(PREF_SERVER_KEY, PREF_SERVER_DEFAULT)!!
+        return this.sortedWith(
+            compareBy(
+                { it.quality.contains(server, true) },
+                { it.quality.contains(quality) },
+                { Regex("""(\d+)p""").find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
+            ),
+        ).reversed()
     }
 
-    private fun getNumberFromString(epsStr: String): String {
-        return epsStr.filter { it.isDigit() }.ifEmpty { "0" }
-    }
-
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val filterList = if (filters.isEmpty()) getFilterList() else filters
-        val genreFilter = filterList.find { it is GenreFilter } as GenreFilter
-
+    private fun Element.getImageUrl(): String? {
         return when {
-            query.isNotBlank() -> GET("$baseUrl/buscar?q=$query&p=$page", headers)
-            genreFilter.state != 0 -> GET("$baseUrl/doramas?categoria=false&genero=${genreFilter.toUriPart()}&fecha=false&letra=false&p=$page")
-            else -> GET("$baseUrl/doramas/?p=$page")
+            isValidUrl("data-src") -> attr("abs:data-src")
+            isValidUrl("data-lazy-src") -> attr("abs:data-lazy-src")
+            isValidUrl("srcset") -> attr("abs:srcset").substringBefore(" ")
+            isValidUrl("src") -> attr("abs:src")
+            else -> ""
         }
     }
 
-    override fun searchAnimeFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.setUrlWithoutDomain(
-            element.selectFirst("a")!!.attr("href"),
-        )
-        anime.title = element.select("div.animedtls p").text()
-        anime.thumbnail_url = element.select("a img").attr("src")
-        anime.description = element.select("div.animedtls p").text()
-        return anime
+    private fun Element.isValidUrl(attrName: String): Boolean {
+        if (!hasAttr(attrName)) return false
+        return !attr(attrName).contains("anime.png")
     }
 
-    override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
-
-    override fun searchAnimeSelector(): String = popularAnimeSelector()
-
-    override fun animeDetailsParse(document: Document): SAnime {
-        val anime = SAnime.create()
-        // anime.thumbnail_url = document.selectFirst("div.herohead div.heroheadmain")!!.attr("style").substringAfter(",url(").substringBefore(") no-repeat;")
-        val sub = document.selectFirst("div.herohead div.heroheadmain strong")!!.text()
-        val title = document.selectFirst("div.herohead div.heroheadmain h1")!!.text().trim()
-        anime.title = title + if (sub.isNotEmpty()) " ($sub)" else ""
-        anime.description = document.selectFirst("div.herohead div.heroheadmain div.flimdtls p.textComplete")!!
-            .text().removeSurrounding("\"").replace("Ver menos", "")
-        anime.genre = document.select("div.herohead div.heroheadmain div.writersdiv div.nobel h6 a").joinToString { it.text() }
-        anime.status = parseStatus(document.select("div.herohead div.heroheadmain div.writersdiv div.state h6").text())
-        return anime
-    }
-
-    private fun parseStatus(statusString: String): Int {
-        return when {
-            statusString.contains("Estreno") -> SAnime.ONGOING
-            statusString.contains("Finalizado") -> SAnime.COMPLETED
-            else -> SAnime.UNKNOWN
-        }
-    }
-
-    override fun latestUpdatesNextPageSelector() = "" // popularAnimeNextPageSelector()
-
-    override fun latestUpdatesFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.setUrlWithoutDomain(
-            element.selectFirst("a")!!.attr("href"),
-        )
-        anime.title = element.selectFirst("a div.chapter p")!!.text()
-        anime.thumbnail_url = element.select("a div.chapter img").attr("src")
-        anime.description = element.select("div.animedtls p").text()
-        return anime
-    }
-
-    override fun latestUpdatesRequest(page: Int) = GET(baseUrl)
-
-    override fun latestUpdatesSelector() = "div.heroarea div.heromain div.chapters div.row div.chaps" // popularAnimeSelector()
-
-    override fun getFilterList(): AnimeFilterList = AnimeFilterList(
-        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
-        GenreFilter(),
-    )
-
-    private class GenreFilter : UriPartFilter(
-        "Generos",
-        arrayOf(
-            Pair("<selecionar>", "false"),
-            Pair("Acción", "accion"),
-            Pair("Amistad", "amistad"),
-            Pair("Artes marciales", "artes-marciales"),
-            Pair("Aventuras", "aventuras"),
-            Pair("Bélico", "belico"),
-            Pair("C-Drama", "c-drama"),
-            Pair("Ciencia Ficción", "ciencia-ficcion"),
-            Pair("Comedia", "comedia"),
-            Pair("Comida", "comida"),
-            Pair("Crimen ", "crimen"),
-            Pair("Deporte", "deporte"),
-            Pair("Documental", "documental"),
-            Pair("Drama", "drama"),
-            Pair("Escolar", "escolar"),
-            Pair("Familiar", "familiar"),
-            Pair("Fantasia", "fantasia"),
-            Pair("Histórico", "historico"),
-            Pair("HK-Drama", "hk-drama"),
-            Pair("Horror", "horror"),
-            Pair("Idols", "idols"),
-            Pair("J-Drama", "j-drama"),
-            Pair("Juvenil", "juvenil"),
-            Pair("K-Drama", "k-drama"),
-            Pair("Legal", "legal"),
-            Pair("Médico", "medico"),
-            Pair("Melodrama", "melodrama"),
-            Pair("Militar", "militar"),
-            Pair("Misterio", "misterio"),
-            Pair("Musical", "musical"),
-            Pair("Negocios", "negocios"),
-            Pair("Policial", "policial"),
-            Pair("Política", "politica"),
-            Pair("Psicológico", "psicologico"),
-            Pair("Reality Show", "reality-show"),
-            Pair("Recuentos de la vida", "recuentos-de-la-vida"),
-            Pair("Romance", "romance"),
-            Pair("Sobrenatural", "sobrenatural"),
-            Pair("Supervivencia", "supervivencia"),
-            Pair("Suspenso", "suspenso"),
-            Pair("Thai-Drama", "thai-drama"),
-            Pair("Thriller", "thriller"),
-            Pair("Time Travel", "time-travel"),
-            Pair("TW-Drama", "tw-drama"),
-            Pair("Yaoi", "yaoi"),
-            Pair("Yuri", "yuri"),
-        ),
-    )
-
-    private open class UriPartFilter(displayName: String, val vals: Array<Pair<String, String>>) :
-        AnimeFilter.Select<String>(displayName, vals.map { it.first }.toTypedArray()) {
-        fun toUriPart() = vals[state].second
-    }
+    private fun Double.ceilPage(): Int = if (this % 1 == 0.0) this.toInt() else ceil(this).toInt()
 
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
-        val qualities = arrayOf(
-            "Okru:1080p", "Okru:720p", "Okru:480p", "Okru:360p", "Okru:240p", "Okru:144p", // Okru
-            "Uqload", "SolidFiles", "StreamTape", // video servers without resolution
-        )
-        val videoQualityPref = ListPreference(screen.context).apply {
-            key = "preferred_quality"
-            title = "Preferred quality"
-            entries = qualities
-            entryValues = qualities
-            setDefaultValue("Okru:720p")
+        ListPreference(screen.context).apply {
+            key = PREF_SERVER_KEY
+            title = "Preferred server"
+            entries = SERVER_LIST
+            entryValues = SERVER_LIST
+            setDefaultValue(PREF_SERVER_DEFAULT)
             summary = "%s"
 
             setOnPreferenceChangeListener { _, newValue ->
@@ -282,7 +251,22 @@ class Doramasyt : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
                 val entry = entryValues[index] as String
                 preferences.edit().putString(key, entry).commit()
             }
-        }
-        screen.addPreference(videoQualityPref)
+        }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = PREF_QUALITY_KEY
+            title = "Preferred quality"
+            entries = QUALITY_LIST
+            entryValues = QUALITY_LIST
+            setDefaultValue(PREF_QUALITY_DEFAULT)
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }.also(screen::addPreference)
     }
 }
diff --git a/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/DoramasytDto.kt b/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/DoramasytDto.kt
new file mode 100644
index 00000000..3cba8883
--- /dev/null
+++ b/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/DoramasytDto.kt
@@ -0,0 +1,29 @@
+package eu.kanade.tachiyomi.animeextension.es.doramasyt
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class EpisodesDto(
+    @SerialName("paginate_url") var paginateUrl: String? = null,
+    @SerialName("perpage") var perpage: Double? = null,
+    @SerialName("eps") var eps: ArrayList<Eps> = arrayListOf(),
+)
+
+@Serializable
+data class Eps(
+    @SerialName("num") var num: Int? = null,
+)
+
+@Serializable
+data class EpisodeInfoDto(
+    @SerialName("default") var default: String? = null,
+    @SerialName("caps") var caps: ArrayList<Caps> = arrayListOf(),
+)
+
+@Serializable
+data class Caps(
+    @SerialName("episodio") var episodio: Int? = null,
+    @SerialName("url") var url: String? = null,
+    @SerialName("thumb") var thumb: String? = null,
+)
diff --git a/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/DoramasytFilters.kt b/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/DoramasytFilters.kt
new file mode 100644
index 00000000..87d9641f
--- /dev/null
+++ b/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/DoramasytFilters.kt
@@ -0,0 +1,117 @@
+package eu.kanade.tachiyomi.animeextension.es.doramasyt
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+
+object DoramasytFilters {
+    open class QueryPartFilter(displayName: String, val vals: Array<Pair<String, String>>) : AnimeFilter.Select<String>(
+        displayName,
+        vals.map { it.first }.toTypedArray(),
+    ) {
+        fun toQueryPart(name: String) = vals[state].second.takeIf { it.isNotEmpty() }?.let { "&$name=${vals[state].second}" } ?: run { "" }
+    }
+
+    private inline fun <reified R> AnimeFilterList.asQueryPart(name: String): String {
+        return (this.getFirst<R>() as QueryPartFilter).toQueryPart(name)
+    }
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R {
+        return this.filterIsInstance<R>().first()
+    }
+
+    private fun String.changePrefix() = this.takeIf { it.startsWith("&") }?.let { this.replaceFirst("&", "?") } ?: run { this }
+
+    data class FilterSearchParams(val filter: String = "") {
+        fun getQuery() = filter.changePrefix()
+    }
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+        return FilterSearchParams(
+            filters.asQueryPart<CategoriesFilter>("categoria") +
+                filters.asQueryPart<GenresFilter>("genero") +
+                filters.asQueryPart<YearsFilter>("fecha") +
+                filters.asQueryPart<LettersFilter>("letra"),
+        )
+    }
+
+    val FILTER_LIST get() = AnimeFilterList(
+        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
+        CategoriesFilter(),
+        GenresFilter(),
+        YearsFilter(),
+        LettersFilter(),
+    )
+
+    class CategoriesFilter : QueryPartFilter("Categoría", DoramasytFiltersData.CATEGORIES)
+
+    class GenresFilter : QueryPartFilter("Género", DoramasytFiltersData.GENRES)
+
+    class YearsFilter : QueryPartFilter("Año", DoramasytFiltersData.YEARS)
+
+    class LettersFilter : QueryPartFilter("Letra", DoramasytFiltersData.LETTER)
+
+    private object DoramasytFiltersData {
+        val CATEGORIES = arrayOf(
+            Pair("<Selecionar>", ""),
+            Pair("Dorama", "dorama"),
+            Pair("Live Action", "live-action"),
+            Pair("Pelicula", "pelicula"),
+            Pair("Series Turcas", "serie-turcas"),
+        )
+
+        val YEARS = arrayOf(Pair("<Seleccionar>", "")) + (1982..2024).map { Pair("$it", "$it") }.reversed().toTypedArray()
+
+        val LETTER = arrayOf(Pair("<Seleccionar>", "")) + ('A'..'Z').map { Pair("$it", "$it") }.toTypedArray()
+
+        val GENRES = arrayOf(
+            Pair("<Selecionar>", ""),
+            Pair("Policial", "policial"),
+            Pair("Romance", "romance"),
+            Pair("Comedia", "comedia"),
+            Pair("Escolar", "escolar"),
+            Pair("Acción", "accion"),
+            Pair("Thriller", "thriller"),
+            Pair("Drama", "drama"),
+            Pair("Misterio", "misterio"),
+            Pair("Fantasia", "fantasia"),
+            Pair("Histórico", "historico"),
+            Pair("Bélico", "belico"),
+            Pair("Militar", "militar"),
+            Pair("Médico", "medico"),
+            Pair("Ciencia Ficción", "ciencia-ficcion"),
+            Pair("Sobrenatural", "sobrenatural"),
+            Pair("Horror", "horror"),
+            Pair("Política", "politica"),
+            Pair("Familiar", "familiar"),
+            Pair("Melodrama", "melodrama"),
+            Pair("Deporte", "deporte"),
+            Pair("Comida", "comida"),
+            Pair("Supervivencia", "supervivencia"),
+            Pair("Aventuras", "aventuras"),
+            Pair("Artes marciales", "artes-marciales"),
+            Pair("Recuentos de la vida", "recuentos-de-la-vida"),
+            Pair("Amistad", "amistad"),
+            Pair("Psicológico", "psicologico"),
+            Pair("Yuri", "yuri"),
+            Pair("K-Drama", "k-drama"),
+            Pair("J-Drama", "j-drama"),
+            Pair("C-Drama", "c-drama"),
+            Pair("HK-Drama", "hk-drama"),
+            Pair("TW-Drama", "tw-drama"),
+            Pair("Thai-Drama", "thai-drama"),
+            Pair("Idols", "idols"),
+            Pair("Suspenso", "suspenso"),
+            Pair("Negocios", "negocios"),
+            Pair("Time Travel", "time-travel"),
+            Pair("Crimen ", "crimen"),
+            Pair("Yaoi", "yaoi"),
+            Pair("Legal", "legal"),
+            Pair("Juvenil", "juvenil"),
+            Pair("Musical", "musical"),
+            Pair("Reality Show", "reality-show"),
+            Pair("Documental", "documental"),
+            Pair("Turcas", "turcas"),
+        )
+    }
+}
diff --git a/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/extractors/SolidFilesExtractor.kt b/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/extractors/SolidFilesExtractor.kt
deleted file mode 100644
index ccb634e6..00000000
--- a/src/es/doramasyt/src/eu/kanade/tachiyomi/animeextension/es/doramasyt/extractors/SolidFilesExtractor.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.es.doramasyt.extractors
-
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.OkHttpClient
-
-class SolidFilesExtractor(private val client: OkHttpClient) {
-    fun videosFromUrl(url: String, prefix: String = ""): List<Video> {
-        val videoList = mutableListOf<Video>()
-        return try {
-            val document = client.newCall(GET(url)).execute().asJsoup()
-            document.select("script").forEach { script ->
-                if (script.data().contains("\"downloadUrl\":")) {
-                    val data = script.data().substringAfter("\"downloadUrl\":").substringBefore(",")
-                    val url = data.replace("\"", "")
-                    val videoUrl = url
-                    val quality = prefix + "SolidFiles"
-                    videoList.add(Video(videoUrl, quality, videoUrl))
-                }
-            }
-            videoList
-        } catch (e: Exception) {
-            videoList
-        }
-    }
-}
diff --git a/src/es/monoschinos/build.gradle b/src/es/monoschinos/build.gradle
index 4cd9d9bf..a43225a7 100644
--- a/src/es/monoschinos/build.gradle
+++ b/src/es/monoschinos/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'MonosChinos'
     extClass = '.MonosChinos'
-    extVersionCode = 27
+    extVersionCode = 28
 }
 
 apply from: "$rootDir/common.gradle"
@@ -12,4 +12,8 @@ dependencies {
     implementation(project(':lib:okru-extractor'))
     implementation(project(':lib:streamtape-extractor'))
     implementation(project(':lib:filemoon-extractor'))
+    implementation(project(':lib:voe-extractor'))
+    implementation(project(':lib:streamwish-extractor'))
+    implementation(project(':lib:mixdrop-extractor'))
+    implementation(project(':lib:dood-extractor'))
 }
\ No newline at end of file
diff --git a/src/es/monoschinos/res/mipmap-hdpi/ic_launcher.png b/src/es/monoschinos/res/mipmap-hdpi/ic_launcher.png
index 4252a48a..397648b7 100644
Binary files a/src/es/monoschinos/res/mipmap-hdpi/ic_launcher.png and b/src/es/monoschinos/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/es/monoschinos/res/mipmap-mdpi/ic_launcher.png b/src/es/monoschinos/res/mipmap-mdpi/ic_launcher.png
index 4252a48a..d11cb6bc 100644
Binary files a/src/es/monoschinos/res/mipmap-mdpi/ic_launcher.png and b/src/es/monoschinos/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/es/monoschinos/res/mipmap-xhdpi/ic_launcher.png b/src/es/monoschinos/res/mipmap-xhdpi/ic_launcher.png
index 4252a48a..1f22941b 100644
Binary files a/src/es/monoschinos/res/mipmap-xhdpi/ic_launcher.png and b/src/es/monoschinos/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/es/monoschinos/res/mipmap-xxhdpi/ic_launcher.png b/src/es/monoschinos/res/mipmap-xxhdpi/ic_launcher.png
index 4252a48a..efd76e33 100644
Binary files a/src/es/monoschinos/res/mipmap-xxhdpi/ic_launcher.png and b/src/es/monoschinos/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/es/monoschinos/res/mipmap-xxxhdpi/ic_launcher.png b/src/es/monoschinos/res/mipmap-xxxhdpi/ic_launcher.png
index 4252a48a..49650bfb 100644
Binary files a/src/es/monoschinos/res/mipmap-xxxhdpi/ic_launcher.png and b/src/es/monoschinos/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinos.kt b/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinos.kt
index d93f7744..9adcbbcf 100644
--- a/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinos.kt
+++ b/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinos.kt
@@ -5,275 +5,250 @@ import android.content.SharedPreferences
 import android.util.Base64
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animeextension.es.monoschinos.extractors.SolidFilesExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
 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.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
 import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
+import eu.kanade.tachiyomi.lib.mixdropextractor.MixDropExtractor
 import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
 import eu.kanade.tachiyomi.lib.okruextractor.OkruExtractor
 import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
+import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.uqloadextractor.UqloadExtractor
+import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
+import eu.kanade.tachiyomi.util.parseAs
+import okhttp3.FormBody
 import okhttp3.Request
 import okhttp3.Response
-import org.jsoup.nodes.Document
 import org.jsoup.nodes.Element
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
+import kotlin.math.ceil
 
-class MonosChinos : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
+class MonosChinos : ConfigurableAnimeSource, AnimeHttpSource() {
 
     override val name = "MonosChinos"
 
     override val baseUrl = "https://monoschinos2.com"
 
+    override val id = 6957694006954649296
+
     override val lang = "es"
 
-    override val supportsLatest = false
+    override val supportsLatest = true
 
     private val preferences: SharedPreferences by lazy {
         Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
     }
 
-    override fun popularAnimeSelector(): String = "div.heromain div.row div.col-md-4"
+    companion object {
+        private const val PREF_QUALITY_KEY = "preferred_quality"
+        private const val PREF_QUALITY_DEFAULT = "1080"
+        private val QUALITY_LIST = arrayOf("1080", "720", "480", "360")
 
-    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/animes?p=$page")
+        private const val PREF_SERVER_KEY = "preferred_server"
+        private const val PREF_SERVER_DEFAULT = "Filemoon"
+        private val SERVER_LIST = arrayOf(
+            "Voe",
+            "StreamWish",
+            "Okru",
+            "Upload",
+            "FileLions",
+            "Filemoon",
+            "DoodStream",
+            "MixDrop",
+            "Streamtape",
+            "Mp4Upload",
+        )
+    }
 
-    override fun popularAnimeFromElement(element: Element): SAnime {
-        val thumbDiv = element.select("a div.series div.seriesimg img")
-        return SAnime.create().apply {
-            setUrlWithoutDomain(element.select("a").attr("href"))
-            title = element.select("a div.series div.seriesdetails h3").text()
-            thumbnail_url = if (thumbDiv.attr("src").contains("/public/img")) {
-                thumbDiv.attr("data-src")
-            } else {
-                thumbDiv.attr("src")
+    override fun animeDetailsParse(response: Response): SAnime {
+        val document = response.asJsoup()
+        val animeDetails = SAnime.create().apply {
+            title = document.selectFirst(".flex-column h1.text-capitalize")?.text() ?: ""
+            description = document.selectFirst(".h-100 .mb-3 p")?.text()
+            genre = document.select(".lh-lg span").joinToString { it.text() }
+            thumbnail_url = document.selectFirst(".gap-3 img")?.getImageUrl()
+            status = document.select(".lh-sm .ms-2").eachText().let { items ->
+                when {
+                    items.any { it.contains("Finalizado") } -> SAnime.COMPLETED
+                    items.any { it.contains("Estreno") } -> SAnime.ONGOING
+                    else -> SAnime.UNKNOWN
+                }
             }
         }
+        return animeDetails
+    }
+
+    override fun popularAnimeRequest(page: Int) = GET("$baseUrl/animes?p=$page", headers)
+
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        val document = response.asJsoup()
+        val elements = document.select(".ficha_efecto a")
+        val nextPage = document.select(".pagination [rel=\"next\"]").any()
+        val animeList = elements.map { element ->
+            SAnime.create().apply {
+                title = element.selectFirst(".title_cap")!!.text()
+                thumbnail_url = element.selectFirst("img")?.getImageUrl()
+                setUrlWithoutDomain(element.attr("abs:href"))
+            }
+        }
+        return AnimesPage(animeList, nextPage)
+    }
+
+    override fun latestUpdatesParse(response: Response) = popularAnimeParse(response)
+
+    override fun latestUpdatesRequest(page: Int) = GET("$baseUrl/emision?p=$page", headers)
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val params = MonosChinosFilters.getSearchParameters(filters)
+        return when {
+            query.isNotBlank() -> GET("$baseUrl/buscar?q=$query", headers)
+            params.filter.isNotBlank() -> GET("$baseUrl/animes${params.getQuery()}&p=$page", headers)
+            else -> popularAnimeRequest(page)
+        }
     }
 
-    override fun popularAnimeNextPageSelector(): String = "li.page-item a.page-link"
+    override fun searchAnimeParse(response: Response) = popularAnimeParse(response)
 
     override fun episodeListParse(response: Response): List<SEpisode> {
-        val jsoup = response.asJsoup()
-        val animeId = response.request.url.pathSegments.last().replace("-sub-espanol", "").replace("-080p", "-1080p")
-        return jsoup.select("div.col-item").map { it ->
-            val epNum = it.attr("data-episode")
-            SEpisode.create().apply {
-                episode_number = epNum.toFloat()
-                name = "Episodio $epNum"
-                url = "/ver/$animeId-episodio-$epNum"
+        val document = response.asJsoup()
+        val token = document.select("meta[name='csrf-token']").attr("content")
+        val capListLink = document.select(".caplist").attr("data-ajax")
+        val referer = document.location()
+
+        val detail = getEpisodeDetails(capListLink, token, referer)
+        val total = detail.eps.size
+        val perPage = detail.perpage ?: return emptyList()
+        val pages = (total / perPage).ceilPage()
+
+        return (1..pages).parallelCatchingFlatMapBlocking {
+            getEpisodePage(detail.paginateUrl ?: "", it, token, referer).caps.mapIndexed { idx, ep ->
+                val episodeNumber = (ep.episodio ?: (idx + 1))
+                SEpisode.create().apply {
+                    name = "Capítulo $episodeNumber"
+                    episode_number = episodeNumber.toFloat()
+                    setUrlWithoutDomain(ep.url ?: "")
+                }
             }
         }.reversed()
     }
 
-    override fun episodeListSelector() = throw UnsupportedOperationException()
+    private fun getEpisodeDetails(capListLink: String, token: String, referer: String): EpisodesDto {
+        val formBody = FormBody.Builder().add("_token", token).build()
+        val request = Request.Builder()
+            .url(capListLink)
+            .post(formBody)
+            .header("accept", "application/json, text/javascript, */*; q=0.01")
+            .header("accept-language", "es-419,es;q=0.8")
+            .header("content-type", "application/x-www-form-urlencoded; charset=UTF-8")
+            .header("origin", baseUrl)
+            .header("referer", referer)
+            .header("x-requested-with", "XMLHttpRequest")
+            .build()
 
-    override fun episodeFromElement(element: Element) = throw UnsupportedOperationException()
+        return client.newCall(request).execute().parseAs<EpisodesDto>()
+    }
+
+    private fun getEpisodePage(paginateUrl: String, page: Int, token: String, referer: String): EpisodeInfoDto {
+        val formBodyEp = FormBody.Builder()
+            .add("_token", token)
+            .add("p", "$page")
+            .build()
+        val requestEp = Request.Builder()
+            .url(paginateUrl)
+            .post(formBodyEp)
+            .header("accept", "application/json, text/javascript, */*; q=0.01")
+            .header("accept-language", "es-419,es;q=0.8")
+            .header("content-type", "application/x-www-form-urlencoded; charset=UTF-8")
+            .header("origin", baseUrl)
+            .header("referer", referer)
+            .header("x-requested-with", "XMLHttpRequest")
+            .build()
+
+        return client.newCall(requestEp).execute().parseAs<EpisodeInfoDto>()
+    }
 
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
-        val videoList = mutableListOf<Video>()
-        document.select("div.heroarea div.row div.col-md-12 ul.dropcaps li").forEach { it ->
-            // val server = it.select("a").text()
-            val urlBase64 = it.select("a").attr("data-player")
-            val url = Base64.decode(urlBase64, Base64.DEFAULT).toString(Charsets.UTF_8).substringAfter("=")
-            when {
-                url.contains("ok") -> if (!url.contains("streamcherry")) videoList.addAll(OkruExtractor(client).videosFromUrl(url))
-                url.contains("solidfiles") -> videoList.addAll(SolidFilesExtractor(client).videosFromUrl(url))
-                url.contains("uqload") -> {
-                    videoList.addAll(UqloadExtractor(client).videosFromUrl(url))
-                }
-                url.contains("mp4upload") -> {
-                    val videos = Mp4uploadExtractor(client).videosFromUrl(url, headers)
-                    videoList.addAll(videos)
-                }
-                url.contains("streamtape") -> {
-                    val videos = StreamTapeExtractor(client).videosFromUrl(url)
-                    videoList.addAll(videos)
-                }
-                url.contains("filemoon") -> {
-                    val videos = FilemoonExtractor(client).videosFromUrl(url)
-                    videoList.addAll(videos)
-                }
-            }
-        }
-
-        return videoList.filter { video -> video.url.contains("http") }
+        return document.select("[data-player]")
+            .map { String(Base64.decode(it.attr("data-player"), Base64.DEFAULT)) }
+            .parallelCatchingFlatMapBlocking { serverVideoResolver(it) }
     }
 
-    override fun videoListSelector() = throw UnsupportedOperationException()
+    override fun getFilterList(): AnimeFilterList = MonosChinosFilters.FILTER_LIST
 
-    override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
+    private val voeExtractor by lazy { VoeExtractor(client) }
+    private val streamwishExtractor by lazy { StreamWishExtractor(client, headers) }
+    private val filemoonExtractor by lazy { FilemoonExtractor(client) }
+    private val mixdropExtractor by lazy { MixDropExtractor(client) }
+    private val doodExtractor by lazy { DoodExtractor(client) }
+    private val streamTapeExtractor by lazy { StreamTapeExtractor(client) }
+    private val uqloadExtractor by lazy { UqloadExtractor(client) }
+    private val okruExtractor by lazy { OkruExtractor(client) }
+    private val mp4uploadExtractor by lazy { Mp4uploadExtractor(client) }
 
-    override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
+    private fun serverVideoResolver(url: String): List<Video> {
+        val embedUrl = url.lowercase()
+        return when {
+            embedUrl.contains("voe") -> voeExtractor.videosFromUrl(url)
+            embedUrl.contains("uqload") -> uqloadExtractor.videosFromUrl(url)
+            embedUrl.contains("ok.ru") || embedUrl.contains("okru") -> okruExtractor.videosFromUrl(url)
+            embedUrl.contains("filemoon") || embedUrl.contains("moonplayer") -> filemoonExtractor.videosFromUrl(url, prefix = "Filemoon:")
+            embedUrl.contains("wishembed") || embedUrl.contains("streamwish") || embedUrl.contains("strwish") || embedUrl.contains("wish") || embedUrl.contains("wishfast") -> streamwishExtractor.videosFromUrl(url, videoNameGen = { "StreamWish:$it" })
+            embedUrl.contains("streamtape") || embedUrl.contains("stp") || embedUrl.contains("stape") -> streamTapeExtractor.videosFromUrl(url)
+            embedUrl.contains("doodstream") || embedUrl.contains("dood.") || embedUrl.contains("ds2play") || embedUrl.contains("doods.") -> doodExtractor.videosFromUrl(url, "DoodStream", false)
+            embedUrl.contains("filelions") || embedUrl.contains("lion") -> streamwishExtractor.videosFromUrl(url, videoNameGen = { "FileLions:$it" })
+            embedUrl.contains("mp4upload") || embedUrl.contains("mp4") -> mp4uploadExtractor.videosFromUrl(url, headers)
+            embedUrl.contains("mix") -> mixdropExtractor.videosFromUrl(url)
+            else -> emptyList()
+        }
+    }
 
     override fun List<Video>.sort(): List<Video> {
-        return try {
-            val videoSorted = this.sortedWith(
-                compareBy<Video> { it.quality.replace("[0-9]".toRegex(), "") }.thenByDescending { getNumberFromString(it.quality) },
-            ).toTypedArray()
-            val userPreferredQuality = preferences.getString("preferred_quality", "Okru:720p")
-            val preferredIdx = videoSorted.indexOfFirst { x -> x.quality == userPreferredQuality }
-            if (preferredIdx != -1) {
-                videoSorted.drop(preferredIdx + 1)
-                videoSorted[0] = videoSorted[preferredIdx]
-            }
-            videoSorted.toList()
-        } catch (e: Exception) {
-            this
-        }
+        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
+        val server = preferences.getString(PREF_SERVER_KEY, PREF_SERVER_DEFAULT)!!
+        return this.sortedWith(
+            compareBy(
+                { it.quality.contains(server, true) },
+                { it.quality.contains(quality) },
+                { Regex("""(\d+)p""").find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
+            ),
+        ).reversed()
     }
 
-    private fun getNumberFromString(epsStr: String): String {
-        return epsStr.filter { it.isDigit() }.ifEmpty { "0" }
-    }
-
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val genreFilter = filters.filterIsInstance<GenreFilter>().firstOrNull() ?: GenreFilter()
-        val yearFilter = try {
-            (filters.find { it is YearFilter } as YearFilter).state.toInt()
-        } catch (e: Exception) {
-            "false"
-        }
-        val letterFilter = try {
-            (filters.find { it is LetterFilter } as LetterFilter).state.first().uppercase()
-        } catch (e: Exception) {
-            "false"
-        }
-
+    private fun Element.getImageUrl(): String? {
         return when {
-            query.isNotBlank() -> GET("$baseUrl/buscar?q=$query&p=$page")
-            else -> GET("$baseUrl/animes?categoria=false&genero=${genreFilter.toUriPart()}&fecha=$yearFilter&letra=$letterFilter&p=$page")
+            isValidUrl("data-src") -> attr("abs:data-src")
+            isValidUrl("data-lazy-src") -> attr("abs:data-lazy-src")
+            isValidUrl("srcset") -> attr("abs:srcset").substringBefore(" ")
+            isValidUrl("src") -> attr("abs:src")
+            else -> ""
         }
     }
 
-    override fun searchAnimeFromElement(element: Element): SAnime {
-        return popularAnimeFromElement(element)
+    private fun Element.isValidUrl(attrName: String): Boolean {
+        if (!hasAttr(attrName)) return false
+        return !attr(attrName).contains("anime.png")
     }
 
-    override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
-
-    override fun searchAnimeSelector(): String = popularAnimeSelector()
-
-    override fun animeDetailsParse(document: Document): SAnime {
-        return SAnime.create().apply {
-            thumbnail_url = document.selectFirst("div.chapterpic img")!!.attr("src")
-            title = document.selectFirst("div.chapterdetails h1")!!.text()
-            description = document.selectFirst("p.textShort")!!.ownText()
-            genre = document.select("ol.breadcrumb li.breadcrumb-item a").joinToString { it.text() }
-            status = parseStatus(document.select("div.butns button.btn1").text())
-        }
-    }
-
-    private fun parseStatus(statusString: String): Int {
-        return when {
-            statusString.contains("Estreno") -> SAnime.ONGOING
-            statusString.contains("Finalizado") -> SAnime.COMPLETED
-            else -> SAnime.UNKNOWN
-        }
-    }
-
-    override fun latestUpdatesNextPageSelector() = throw UnsupportedOperationException()
-
-    override fun latestUpdatesFromElement(element: Element) = throw UnsupportedOperationException()
-
-    override fun latestUpdatesRequest(page: Int) = throw UnsupportedOperationException()
-
-    override fun latestUpdatesSelector() = throw UnsupportedOperationException()
-
-    override fun getFilterList(): AnimeFilterList = AnimeFilterList(
-        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
-        GenreFilter(),
-        AnimeFilter.Separator(),
-        YearFilter(),
-        LetterFilter(),
-    )
-
-    private class YearFilter : AnimeFilter.Text("Año", "2022")
-    private class LetterFilter : AnimeFilter.Text("Letra", "")
-
-    private class GenreFilter : UriPartFilter(
-        "Generos",
-        arrayOf(
-            Pair("<selecionar>", ""),
-            Pair("Latino", "latino"),
-            Pair("Castellano", "castellano"),
-            Pair("Acción", "acción"),
-            Pair("Aventura", "aventura"),
-            Pair("Carreras", "carreras"),
-            Pair("Comedia", "comedia"),
-            Pair("Cyberpunk", "cyberpunk"),
-            Pair("Deportes", "deportes"),
-            Pair("Drama", "drama"),
-            Pair("Ecchi", "ecchi"),
-            Pair("Escolares", "escolares"),
-            Pair("Fantasía", "fantasía"),
-            Pair("Gore", "gore"),
-            Pair("Harem", "harem"),
-            Pair("Horror", "horror"),
-            Pair("Josei", "josei"),
-            Pair("Lucha", "lucha"),
-            Pair("Magia", "magia"),
-            Pair("Josei", "josei"),
-            Pair("Mecha", "mecha"),
-            Pair("Militar", "militar"),
-            Pair("Misterio", "misterio"),
-            Pair("Música", "música"),
-            Pair("Parodias", "parodias"),
-            Pair("Psicológico", "psicológico"),
-            Pair("Recuerdos de la vida", "recuerdos-de-la-vida"),
-            Pair("Seinen", "seinen"),
-            Pair("Shojo", "shojo"),
-            Pair("Shonen", "shonen"),
-            Pair("Sobrenatural", "sobrenatural"),
-            Pair("Vampiros", "vampiros"),
-            Pair("Yaoi", "yaoi"),
-            Pair("Yuri", "yuri"),
-            Pair("Espacial", "espacial"),
-            Pair("Histórico", "histórico"),
-            Pair("Samurai", "samurai"),
-            Pair("Artes Marciales", "artes-marciales"),
-            Pair("Demonios", "demonios"),
-            Pair("Romance", "romance"),
-            Pair("Policía", " policía"),
-            Pair("Historia paralela", "historia-paralela"),
-            Pair("Aenime", "aenime"),
-            Pair("Donghua", "donghua"),
-            Pair("Blu-ray", "blu-ray"),
-            Pair("Monogatari", "monogatari"),
-        ),
-    )
-
-    private open class UriPartFilter(displayName: String, val vals: Array<Pair<String, String>>) :
-        AnimeFilter.Select<String>(displayName, vals.map { it.first }.toTypedArray()) {
-        fun toUriPart() = vals[state].second
-    }
+    private fun Double.ceilPage(): Int = if (this % 1 == 0.0) this.toInt() else ceil(this).toInt()
 
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
-        val qualities = arrayOf(
-            "Okru:1080p",
-            "Okru:720p",
-            "Okru:480p",
-            "Okru:360p",
-            "Okru:240p", // Okru
-            "SolidFiles",
-            "Upload", // video servers without resolution
-            "StreamTape",
-            "FileMoon",
-        )
-        val videoQualityPref = ListPreference(screen.context).apply {
-            key = "preferred_quality"
-            title = "Preferred quality"
-            entries = qualities
-            entryValues = qualities
-            setDefaultValue("Okru:720p")
+        ListPreference(screen.context).apply {
+            key = PREF_SERVER_KEY
+            title = "Preferred server"
+            entries = SERVER_LIST
+            entryValues = SERVER_LIST
+            setDefaultValue(PREF_SERVER_DEFAULT)
             summary = "%s"
 
             setOnPreferenceChangeListener { _, newValue ->
@@ -282,7 +257,22 @@ class MonosChinos : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
                 val entry = entryValues[index] as String
                 preferences.edit().putString(key, entry).commit()
             }
-        }
-        screen.addPreference(videoQualityPref)
+        }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = PREF_QUALITY_KEY
+            title = "Preferred quality"
+            entries = QUALITY_LIST
+            entryValues = QUALITY_LIST
+            setDefaultValue(PREF_QUALITY_DEFAULT)
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                val index = findIndexOfValue(selected)
+                val entry = entryValues[index] as String
+                preferences.edit().putString(key, entry).commit()
+            }
+        }.also(screen::addPreference)
     }
 }
diff --git a/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinosDto.kt b/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinosDto.kt
new file mode 100644
index 00000000..34e673f9
--- /dev/null
+++ b/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinosDto.kt
@@ -0,0 +1,29 @@
+package eu.kanade.tachiyomi.animeextension.es.monoschinos
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class EpisodesDto(
+    @SerialName("paginate_url") var paginateUrl: String? = null,
+    @SerialName("perpage") var perpage: Double? = null,
+    @SerialName("eps") var eps: ArrayList<Eps> = arrayListOf(),
+)
+
+@Serializable
+data class Eps(
+    @SerialName("num") var num: Int? = null,
+)
+
+@Serializable
+data class EpisodeInfoDto(
+    @SerialName("default") var default: String? = null,
+    @SerialName("caps") var caps: ArrayList<Caps> = arrayListOf(),
+)
+
+@Serializable
+data class Caps(
+    @SerialName("episodio") var episodio: Int? = null,
+    @SerialName("url") var url: String? = null,
+    @SerialName("thumb") var thumb: String? = null,
+)
diff --git a/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinosFilters.kt b/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinosFilters.kt
new file mode 100644
index 00000000..3fba586b
--- /dev/null
+++ b/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/MonosChinosFilters.kt
@@ -0,0 +1,139 @@
+package eu.kanade.tachiyomi.animeextension.es.monoschinos
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import java.util.Calendar
+
+object MonosChinosFilters {
+    open class QueryPartFilter(displayName: String, val vals: Array<Pair<String, String>>) : AnimeFilter.Select<String>(
+        displayName,
+        vals.map { it.first }.toTypedArray(),
+    ) {
+        fun toQueryPart(name: String) = vals[state].second.takeIf { it.isNotEmpty() }?.let { "&$name=${vals[state].second}" } ?: run { "" }
+    }
+
+    open class CheckBoxFilterList(name: String, values: List<CheckBox>) : AnimeFilter.Group<AnimeFilter.CheckBox>(name, values)
+
+    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
+
+    private inline fun <reified R> AnimeFilterList.parseCheckbox(
+        options: Array<Pair<String, String>>,
+        name: String,
+    ): String {
+        return (this.getFirst<R>() as CheckBoxFilterList).state
+            .mapNotNull { checkbox ->
+                if (checkbox.state) {
+                    options.find { it.first == checkbox.name }!!.second
+                } else {
+                    null
+                }
+            }.joinToString(",").let {
+                if (it.isBlank()) {
+                    ""
+                } else {
+                    "&$name=$it"
+                }
+            }
+    }
+
+    private inline fun <reified R> AnimeFilterList.asQueryPart(name: String): String {
+        return (this.getFirst<R>() as QueryPartFilter).toQueryPart(name)
+    }
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R {
+        return this.filterIsInstance<R>().first()
+    }
+
+    private fun String.changePrefix() = this.takeIf { it.startsWith("&") }?.let { this.replaceFirst("&", "?") } ?: run { this }
+
+    data class FilterSearchParams(val filter: String = "") {
+        fun getQuery() = filter.changePrefix()
+    }
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+        return FilterSearchParams(
+            filters.parseCheckbox<GenresFilter>(DoramasytFiltersData.GENRES, "genero") +
+                filters.parseCheckbox<TypesFilter>(DoramasytFiltersData.TYPES, "tipo") +
+                filters.asQueryPart<YearsFilter>("fecha") +
+                filters.asQueryPart<LettersFilter>("letra"),
+        )
+    }
+
+    val FILTER_LIST get() = AnimeFilterList(
+        AnimeFilter.Header("La busqueda por texto ignora el filtro"),
+        GenresFilter(),
+        TypesFilter(),
+        YearsFilter(),
+        LettersFilter(),
+    )
+
+    class GenresFilter : CheckBoxFilterList("Género", DoramasytFiltersData.GENRES.map { CheckBoxVal(it.first, false) })
+
+    class TypesFilter : CheckBoxFilterList("Tipo", DoramasytFiltersData.TYPES.map { CheckBoxVal(it.first, false) })
+
+    class YearsFilter : QueryPartFilter("Año", DoramasytFiltersData.YEARS)
+
+    class LettersFilter : QueryPartFilter("Letra", DoramasytFiltersData.LETTER)
+
+    private object DoramasytFiltersData {
+        val TYPES = arrayOf(
+            Pair("<Selecionar>", ""),
+            Pair("Pelicula", "pelicula"),
+            Pair("Anime", "anime"),
+        )
+
+        val YEARS = arrayOf(Pair("<Seleccionar>", "")) + (1982..Calendar.getInstance().get(Calendar.YEAR)).map { Pair("$it", "$it") }.reversed().toTypedArray()
+
+        val LETTER = arrayOf(Pair("<Seleccionar>", "")) + ('A'..'Z').map { Pair("$it", "$it") }.toTypedArray()
+
+        val GENRES = arrayOf(
+            Pair("<Selecionar>", ""),
+            Pair("Acción", "accion"),
+            Pair("Aventura", "aventura"),
+            Pair("Carreras", "carreras"),
+            Pair("Ciencia Ficción", "ciencia-ficcion"),
+            Pair("Comedia", "comedia"),
+            Pair("Cyberpunk", "cyberpunk"),
+            Pair("Deportes", "deportes"),
+            Pair("Drama", "drama"),
+            Pair("Ecchi", "ecchi"),
+            Pair("Escolares", "escolares"),
+            Pair("Fantasía", "fantasia"),
+            Pair("Gore", "gore"),
+            Pair("Harem", "harem"),
+            Pair("Horror", "horror"),
+            Pair("Josei", "josei"),
+            Pair("Lucha", "lucha"),
+            Pair("Magia", "magia"),
+            Pair("Mecha", "mecha"),
+            Pair("Militar", "militar"),
+            Pair("Misterio", "misterio"),
+            Pair("Música", "musica"),
+            Pair("Parodias", "parodias"),
+            Pair("Psicológico", "psicologico"),
+            Pair("Recuerdos de la vida", "recuerdos-de-la-vida"),
+            Pair("Seinen", "seinen"),
+            Pair("Shojo", "shojo"),
+            Pair("Shonen", "shonen"),
+            Pair("Sobrenatural", "sobrenatural"),
+            Pair("Vampiros", "vampiros"),
+            Pair("Yaoi", "yaoi"),
+            Pair("Yuri", "yuri"),
+            Pair("Latino", "latino"),
+            Pair("Espacial", "espacial"),
+            Pair("Histórico", "historico"),
+            Pair("Samurai", "samurai"),
+            Pair("Artes Marciales", "artes-marciales"),
+            Pair("Demonios", "demonios"),
+            Pair("Romance", "romance"),
+            Pair("Dementia", "dementia"),
+            Pair(" Policía", "policia"),
+            Pair("Castellano", "castellano"),
+            Pair("Historia paralela", "historia-paralela"),
+            Pair("Aenime", "aenime"),
+            Pair("Blu-ray", "blu-ray"),
+            Pair("Monogatari", "monogatari"),
+        )
+    }
+}
diff --git a/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/extractors/SolidFilesExtractor.kt b/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/extractors/SolidFilesExtractor.kt
deleted file mode 100644
index 45f37e7d..00000000
--- a/src/es/monoschinos/src/eu/kanade/tachiyomi/animeextension/es/monoschinos/extractors/SolidFilesExtractor.kt
+++ /dev/null
@@ -1,27 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.es.monoschinos.extractors
-
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.OkHttpClient
-
-class SolidFilesExtractor(private val client: OkHttpClient) {
-    fun videosFromUrl(url: String, prefix: String = ""): List<Video> {
-        val videoList = mutableListOf<Video>()
-        return try {
-            val document = client.newCall(GET(url)).execute().asJsoup()
-            document.select("script").forEach { script ->
-                if (script.data().contains("\"downloadUrl\":")) {
-                    val data = script.data().substringAfter("\"downloadUrl\":").substringBefore(",")
-                    val url = data.replace("\"", "")
-                    val videoUrl = url
-                    val quality = prefix + "SolidFiles"
-                    videoList.add(Video(videoUrl, quality, videoUrl))
-                }
-            }
-            videoList
-        } catch (e: Exception) {
-            videoList
-        }
-    }
-}