diff --git a/src/all/hikari/build.gradle b/src/all/hikari/build.gradle
index 9db96065..2e8afef6 100644
--- a/src/all/hikari/build.gradle
+++ b/src/all/hikari/build.gradle
@@ -1,14 +1,13 @@
 ext {
     extName = 'Hikari'
     extClass = '.Hikari'
-    extVersionCode = 12
+    extVersionCode = 11
 }
 
 apply from: "$rootDir/common.gradle"
 
 dependencies {
-    implementation(project(':lib:chillx-extractor'))
     implementation(project(':lib:filemoon-extractor'))
-    implementation(project(':lib:streamwish-extractor'))
     implementation(project(':lib:vidhide-extractor'))
+    implementation(project(':lib:chillx-extractor'))
 }
\ No newline at end of file
diff --git a/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Hikari.kt b/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Hikari.kt
index 0ccfb7d7..aa771c1f 100644
--- a/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Hikari.kt
+++ b/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Hikari.kt
@@ -14,7 +14,6 @@ import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
 import eu.kanade.tachiyomi.lib.chillxextractor.ChillxExtractor
 import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
-import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.vidhideextractor.VidHideExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
@@ -221,7 +220,6 @@ class Hikari : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
     private val filemoonExtractor by lazy { FilemoonExtractor(client) }
     private val vidHideExtractor by lazy { VidHideExtractor(client, headers) }
     private val chillxExtractor by lazy { ChillxExtractor(client, headers) }
-    private val streamwishExtractor by lazy { StreamWishExtractor(client, headers) }
     private val embedRegex = Regex("""getEmbed\(\s*(\d+)\s*,\s*(\d+)\s*,\s*'(\d+)'""")
 
     override fun videoListRequest(episode: SEpisode): Request {
@@ -330,19 +328,17 @@ class Hikari : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
             }.filter { it.first.isNotEmpty() }
         }
 
-        return sdEmbedUrls.parallelCatchingFlatMapBlocking {
+        val embedUrls = sdEmbedUrls.ifEmpty {
+            subEmbedUrls + dubEmbedUrls
+        }
+        return embedUrls.parallelCatchingFlatMapBlocking {
             getVideosFromEmbed(it.first, it.second)
-        }.ifEmpty {
-            (subEmbedUrls + dubEmbedUrls).parallelCatchingFlatMapBlocking {
-                getVideosFromEmbed(it.first, it.second)
-            }
         }
     }
 
     private fun getVideosFromEmbed(embedUrl: String, name: String): List<Video> = when {
         name.contains("vidhide", true) -> vidHideExtractor.videosFromUrl(embedUrl, videoNameGen = { s -> "$name - $s" })
         embedUrl.contains("filemoon", true) -> filemoonExtractor.videosFromUrl(embedUrl, prefix = "$name - ", headers = headers)
-        name.contains("streamwish", true) -> streamwishExtractor.videosFromUrl(embedUrl, prefix = "$name - ")
         else -> chillxExtractor.videoFromUrl(embedUrl, referer = baseUrl, prefix = "$name - ")
     }
 
diff --git a/src/en/aniplay/build.gradle b/src/en/aniplay/build.gradle
index 64c01315..e78b9bfe 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 = 7
+    overrideVersionCode = 6
 }
 
 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 40302b02..5c0b5c1e 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
@@ -17,6 +17,7 @@ import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
 import eu.kanade.tachiyomi.multisrc.anilist.AniListAnimeHttpSource
 import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.util.parallelFlatMap
+import eu.kanade.tachiyomi.util.parallelMap
 import eu.kanade.tachiyomi.util.parseAs
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.encodeToString
@@ -182,152 +183,99 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
             }
             ?: emptyList()
 
+        val headersWithAction =
+            headers.newBuilder()
+                // next.js stuff I guess
+                .add("Next-Action", getHeaderValue(baseHost, NEXT_ACTION_SOURCES_LIST))
+                .build()
+
         var timeouts = 0
         var maxTimeout = 0
-        val videos = extras.parallelFlatMap { extra ->
+        val episodeDataList = extras.parallelFlatMap { extra ->
             val languages = mutableListOf("sub").apply {
                 if (extra.hasDub) add("dub")
             }
-            languages.parallelFlatMap { language ->
+            languages.parallelMap { language ->
+                maxTimeout += 1
                 val epNum = if (extra.episodeNum == extra.episodeNum.toInt().toFloat()) {
-                    extra.episodeNum.toInt().toString()
+                    extra.episodeNum.toInt().toString() // If it has no fractional part, convert it to an integer
                 } else {
-                    extra.episodeNum.toString()
+                    extra.episodeNum.toString() // If it has a fractional part, leave it as a float
                 }
 
+                val requestBody = "[\"$animeId\",\"${extra.source}\",\"${extra.episodeId}\",\"$epNum\",\"$language\"]"
+                    .toRequestBody("application/json".toMediaType())
+
                 val params = mapOf(
                     "host" to extra.source,
                     "ep" to epNum,
                     "type" to language,
                 )
-
                 val builder = Uri.parse("$baseUrl/anime/watch/$animeId").buildUpon()
                 params.map { (k, v) -> builder.appendQueryParameter(k, v); }
-                val url = builder.build()
-
-                val headersWithAction =
-                    headers.newBuilder()
-                        .add("Next-Action", getHeaderValue(baseHost, NEXT_ACTION_SOURCES_LIST))
-                        .build()
-
-                val requestBody = "[\"$animeId\",\"${extra.source}\",\"${extra.episodeId}\",\"$epNum\",\"$language\"]"
-                    .toRequestBody("application/json".toMediaType())
-
-                val request = POST(url.toString(), headersWithAction, requestBody)
-
-                maxTimeout += 1
+                val url = builder.build().toString()
                 try {
-                    getVideos(extra, language, request)
-                } catch (e: java.net.SocketTimeoutException) {
-                    Log.e("AniPlay", "VideoList $url SocketTimeoutException", e)
-                    timeouts++
-                    emptyList()
-                } catch (e: IOException) {
-                    Log.e("AniPlay", "VideoList $url IOException", e)
-                    emptyList()
-                } catch (e: Exception) {
-                    Log.e("AniPlay", "VideoList $url Exception", e)
-                    emptyList()
-                }
-            }
-        }
+                    val request = POST(url, headersWithAction, requestBody)
+                    val response = client.newCall(request).execute()
 
-        if (videos.isEmpty() && timeouts != 0 && maxTimeout == timeouts) {
-            throw Exception("Timed out")
-        }
+                    val responseString = response.body.string()
+                    val sourcesString = extractSourcesList(responseString) ?: return@parallelMap null
+                    val data = sourcesString.parseAs<VideoSourceResponse>()
 
-        return videos.sort()
-    }
-
-    private fun getVideos(extra: EpisodeExtra, language: String, request: Request): List<Video> {
-        val response = client.newCall(request).execute()
-
-        val responseString = response.body.string()
-        val sourcesString = extractSourcesList(responseString) ?: return emptyList()
-        Log.i("AniPlay", "${extra.source} $language -> $sourcesString")
-
-        when (extra.source.lowercase()) {
-            "yuki" -> {
-                val data = sourcesString.parseAs<VideoSourceResponseYuki>()
-                return processEpisodeDataYuki(
-                    EpisodeDataYuki(
-                        source = extra.source,
-                        language = language,
-                        response = data,
-                    ),
-                )
-            }
-            else -> {
-                val data = sourcesString.parseAs<VideoSourceResponse>()
-                return processEpisodeData(
                     EpisodeData(
                         source = extra.source,
                         language = language,
                         response = data,
-                    ),
+                    )
+                } catch (e: java.net.SocketTimeoutException) {
+                    timeouts += 1
+                    null
+                } catch (e: IOException) {
+                    Log.w("AniPlay", "VideoList $url IOException", e)
+                    timeouts = -999
+                    null // Return null to be filtered out
+                } catch (e: Exception) {
+                    Log.w("AniPlay", "VideoList $url Exception", e)
+                    timeouts = -999
+                    null // Return null to be filtered out
+                }
+            }.filterNotNull() // Filter out null values due to errors
+        }
+
+        if (maxTimeout == timeouts && timeouts != 0) {
+            throw Exception("Timed out")
+        }
+
+        val videos = episodeDataList.flatMap { episodeData ->
+            val defaultSource = episodeData.response.sources?.firstOrNull {
+                it.quality in listOf("default", "auto")
+            } ?: return@flatMap emptyList()
+
+            val subtitles = episodeData.response.subtitles
+                ?.filter { it.lang != "Thumbnails" }
+                ?.map { Track(it.url, it.lang) }
+                ?: emptyList()
+
+            try {
+                playlistUtils.extractFromHls(
+                    playlistUrl = defaultSource.url,
+                    videoNameGen = { quality ->
+                        val serverName = getServerName(episodeData.source)
+                        val typeName = when {
+                            subtitles.isNotEmpty() -> "SoftSub"
+                            else -> getTypeName(episodeData.language)
+                        }
+                        "$serverName - $quality - $typeName"
+                    },
+                    subtitleList = subtitles,
                 )
+            } catch (e: Exception) {
+                Log.e("AniPlay", "extractFromHls Error: $e")
+                emptyList()
             }
         }
-    }
 
-    private fun processEpisodeDataYuki(episodeData: EpisodeDataYuki): List<Video> {
-        val defaultSource = episodeData.response.sources?.firstOrNull()
-
-        if (defaultSource == null) {
-            Log.e("AniPlay", "defaultSource is null (${episodeData.response})")
-            return emptyList()
-        }
-
-        val subtitles = episodeData.response.tracks
-            ?.filter { it.kind?.lowercase() == "captions" }
-            ?.map { Track(it.file, it.label ?: "Unknown") }
-            ?: emptyList()
-
-        val serverName = getServerName(episodeData.source)
-        val typeName = getTypeName(episodeData.language).let {
-            if (it == "Sub" && subtitles.isNotEmpty()) "SoftSub" else it
-        }
-
-        try {
-            return playlistUtils.extractFromHls(
-                playlistUrl = defaultSource.url,
-                videoNameGen = { quality -> "$serverName - $quality - $typeName" },
-                subtitleList = subtitles,
-            )
-        } catch (e: Exception) {
-            Log.e("AniPlay", "processEpisodeDataYuki extractFromHls Error (\"$serverName - $typeName\"): $e")
-        }
-
-        return emptyList()
-    }
-
-    private fun processEpisodeData(episodeData: EpisodeData): List<Video> {
-        val defaultSource = episodeData.response.sources?.firstOrNull {
-            it.quality in listOf("default", "auto")
-        } ?: return emptyList()
-
-        val subtitles = episodeData.response.subtitles
-            ?.filter { it.lang?.lowercase() != "thumbnails" }
-            ?.map { Track(it.url, it.lang ?: "Unk") }
-            ?: emptyList()
-
-        val serverName = getServerName(episodeData.source)
-        val typeName = when {
-            subtitles.isNotEmpty() -> "SoftSub"
-            else -> getTypeName(episodeData.language)
-        }
-
-        try {
-            return playlistUtils.extractFromHls(
-                playlistUrl = defaultSource.url,
-                videoNameGen = { quality -> "$serverName - $quality - $typeName" },
-                subtitleList = subtitles,
-            )
-        } catch (e: Exception) {
-            Log.e("AniPlay", "processEpisodeData extractFromHls Error (\"$serverName - $typeName\"): $e")
-        }
-
-        return emptyList()
+        return videos.sort()
     }
 
     override fun List<Video>.sort(): List<Video> {
@@ -483,7 +431,7 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
     }
 
     private fun getTypeName(value: String): String {
-        val index = PREF_TYPE_ENTRY_VALUES.indexOf(value.lowercase())
+        val index = PREF_TYPE_ENTRY_VALUES.indexOf(value)
         if (index == -1) {
             return "Other"
         }
@@ -508,8 +456,8 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         private const val PREF_DOMAIN_DEFAULT = "aniplaynow.live"
 
         private const val PREF_SERVER_KEY = "server"
-        private val PREF_SERVER_ENTRIES = arrayOf("Kuro", "Anya", "Yuki")
-        private val PREF_SERVER_ENTRY_VALUES = arrayOf("kuro", "anya", "yuki")
+        private val PREF_SERVER_ENTRIES = arrayOf("Kuro", "Yuki", "Yuno")
+        private val PREF_SERVER_ENTRY_VALUES = arrayOf("kuro", "yuki", "yuno")
         private const val PREF_SERVER_DEFAULT = "kuro"
 
         private const val PREF_QUALITY_KEY = "quality"
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 3024863f..d22ca43d 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
@@ -1,5 +1,6 @@
 package eu.kanade.tachiyomi.animeextension.en.aniplay
 
+import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
 @Serializable
@@ -21,6 +22,20 @@ data class EpisodeListResponse(
     )
 }
 
+@Serializable
+data class VideoSourceRequest(
+    val source: String,
+
+    @SerialName("episodeid")
+    val episodeId: String,
+
+    @SerialName("episodenum")
+    val episodeNum: String,
+
+    @SerialName("subtype")
+    val subType: String,
+)
+
 @Serializable
 data class VideoSourceResponse(
     val sources: List<Source>?,
@@ -29,35 +44,13 @@ data class VideoSourceResponse(
     @Serializable
     data class Source(
         val url: String,
-        val quality: String?,
+        val quality: String,
     )
 
     @Serializable
     data class Subtitle(
         val url: String,
-        val lang: String?,
-    )
-}
-
-@Serializable
-data class VideoSourceResponseYuki(
-    val sources: List<Source>?,
-    val tracks: List<Subtitle>?,
-    val anilistID: Int?,
-    val malID: Int?,
-) {
-    @Serializable
-    data class Source(
-        val url: String,
-        val type: String?,
-    )
-
-    @Serializable
-    data class Subtitle(
-        val file: String,
-        val label: String?,
-        val kind: String?,
-        val default: Boolean?,
+        val lang: String,
     )
 }
 
@@ -75,10 +68,3 @@ data class EpisodeData(
     val language: String,
     val response: VideoSourceResponse,
 )
-
-@Serializable
-data class EpisodeDataYuki(
-    val source: String,
-    val language: String,
-    val response: VideoSourceResponseYuki,
-)
diff --git a/src/pt/animesfoxbr/build.gradle b/src/pt/animesfoxbr/build.gradle
new file mode 100644
index 00000000..f7b79d18
--- /dev/null
+++ b/src/pt/animesfoxbr/build.gradle
@@ -0,0 +1,9 @@
+ext {
+    extName = 'AnimesFox BR'
+    extClass = '.AnimesFoxBR'
+    themePkg = 'dooplay'
+    baseUrl = 'https://animesfox.net'
+    overrideVersionCode = 2
+}
+
+apply from: "$rootDir/common.gradle"
\ No newline at end of file
diff --git a/src/pt/animesfoxbr/res/mipmap-hdpi/ic_launcher.png b/src/pt/animesfoxbr/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..c95b02dd
Binary files /dev/null and b/src/pt/animesfoxbr/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/pt/animesfoxbr/res/mipmap-mdpi/ic_launcher.png b/src/pt/animesfoxbr/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..9975416d
Binary files /dev/null and b/src/pt/animesfoxbr/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/pt/animesfoxbr/res/mipmap-xhdpi/ic_launcher.png b/src/pt/animesfoxbr/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..152d9d33
Binary files /dev/null and b/src/pt/animesfoxbr/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/pt/animesfoxbr/res/mipmap-xxhdpi/ic_launcher.png b/src/pt/animesfoxbr/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..78ce457d
Binary files /dev/null and b/src/pt/animesfoxbr/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/pt/animesfoxbr/res/mipmap-xxxhdpi/ic_launcher.png b/src/pt/animesfoxbr/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..e5be2b07
Binary files /dev/null and b/src/pt/animesfoxbr/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/pt/animesfoxbr/src/eu/kanade/tachiyomi/animeextension/pt/animesfoxbr/AnimesFoxBR.kt b/src/pt/animesfoxbr/src/eu/kanade/tachiyomi/animeextension/pt/animesfoxbr/AnimesFoxBR.kt
new file mode 100644
index 00000000..9856b75b
--- /dev/null
+++ b/src/pt/animesfoxbr/src/eu/kanade/tachiyomi/animeextension/pt/animesfoxbr/AnimesFoxBR.kt
@@ -0,0 +1,209 @@
+package eu.kanade.tachiyomi.animeextension.pt.animesfoxbr
+
+import android.util.Base64
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.multisrc.dooplay.DooPlay
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.FormBody
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+
+class AnimesFoxBR : DooPlay(
+    "pt-BR",
+    "AnimesFox BR",
+    "https://animesfox.net",
+) {
+    // ============================== Popular ===============================
+    // The site doesn't have a true popular anime tab,
+    // so we use the latest added anime page instead.
+    override fun popularAnimeRequest(page: Int) = GET("$baseUrl/animes/page/$page")
+
+    override fun popularAnimeSelector() = "div.clw div.b_flex > div > a"
+
+    override fun popularAnimeNextPageSelector() = "div.pagination i#nextpagination"
+
+    // ============================== Episodes ==============================
+    override fun episodeListSelector() = "div.se-a > div.anime_item > a"
+
+    override fun episodeFromElement(element: Element, seasonName: String) =
+        super.episodeFromElement(element, seasonName).apply {
+            name = name.substringBefore("- ")
+        }
+
+    // ============================ Video Links =============================
+    override val prefQualityValues = arrayOf("360p ~ SD", "720p ~ HD")
+    override val prefQualityEntries = prefQualityValues
+
+    override fun videoListParse(response: Response): List<Video> {
+        val doc = response.asJsoup()
+        return doc.select("ul#playeroptionsul li").mapNotNull {
+            val url = getPlayerUrl(it)
+            val language = it.selectFirst("span.title")?.text() ?: "Linguagem desconhecida"
+            when {
+                baseUrl in url -> extractVideos(url, language)
+                else -> null
+            }
+        }.flatten()
+    }
+
+    private fun extractVideos(url: String, language: String): List<Video> {
+        return client.newCall(GET(url, headers)).execute().let { response ->
+            response.body.string()
+                .substringAfter("sources:[")
+                .substringBefore("]")
+                .split("},")
+                .mapNotNull {
+                    val videoUrl = it.substringAfter("file: \"")
+                        .substringBefore('"')
+                        .ifBlank { return@mapNotNull null }
+                    val quality = it.substringAfter("label:\"").substringBefore('"')
+                    Video(videoUrl, "$language($quality)", videoUrl, headers = headers)
+                }
+        }
+    }
+
+    private fun getPlayerUrl(player: Element): String {
+        val body = FormBody.Builder()
+            .add("action", "doo_player_ajax")
+            .add("post", player.attr("data-post"))
+            .add("nume", player.attr("data-nume"))
+            .add("type", player.attr("data-type"))
+            .build()
+
+        return client.newCall(POST("$baseUrl/wp-admin/admin-ajax.php", headers, body))
+            .execute()
+            .let { response ->
+                response.body.string()
+                    .substringAfter("\"embed_url\":\"")
+                    .substringBefore("\",")
+                    .replace("\\", "")
+                    .let { url ->
+                        when {
+                            url.contains("token=") -> {
+                                url.substringAfter("token=")
+                                    .substringBefore("' ")
+                                    .let { Base64.decode(it, Base64.DEFAULT) }
+                                    .let(::String)
+                            }
+                            url.contains("iframe") -> {
+                                url.substringAfter("?link=").substringBefore("'")
+                            }
+                            else -> ""
+                        }
+                    }
+            }
+    }
+
+    // =============================== Search ===============================
+    override fun searchAnimeNextPageSelector() = "div.pagination > *:last-child:not(.current)"
+
+    // ============================== Filters ===============================
+    override fun genresListRequest() = GET("$baseUrl/categorias")
+
+    override fun genresListSelector() = "div.box_category > a"
+
+    override fun genresListParse(document: Document) =
+        super.genresListParse(document).map {
+            Pair(it.first.substringAfter(" "), it.second)
+        }.toTypedArray()
+
+    // =========================== Anime Details ============================
+    override fun animeDetailsParse(document: Document): SAnime {
+        val doc = getRealAnimeDoc(document)
+        return SAnime.create().apply {
+            setUrlWithoutDomain(doc.location())
+            thumbnail_url = doc.selectFirst("div.capa_poster img")!!.attr("src")
+            val container = doc.selectFirst("div.container_anime_r")!!
+            title = container.selectFirst("div > h1")!!.text().let {
+                when {
+                    "email protected" in it -> {
+                        val decoded = container.selectFirst("div > h1 > a")!!
+                            .attr("data-cfemail")
+                            .decodeEmail()
+                        it.replace("[email protected]", decoded)
+                    }
+                    else -> it
+                }
+            }
+            genre = container.select("div.btn_gen").eachText().joinToString()
+            description = buildString {
+                container.selectFirst("div.sinopse")?.let {
+                    append(it.text() + "\n\n")
+                }
+
+                container.selectFirst("div.container_anime_nome > h2")?.let {
+                    append("Nome alternativo: ${it.text()}\n")
+                }
+
+                container.select("div.container_anime_back").forEach {
+                    val infoType = it.selectFirst("div.info-nome")?.text() ?: return@forEach
+                    val infoData = it.selectFirst("span")?.text() ?: return@forEach
+                    append("$infoType: $infoData\n")
+                }
+            }
+        }
+    }
+
+    // =============================== Latest ===============================
+    override val latestUpdatesPath = "episodios"
+
+    override fun latestUpdatesSelector() = popularAnimeSelector()
+
+    override fun latestUpdatesNextPageSelector() = popularAnimeNextPageSelector()
+
+    // ============================== Settings ==============================
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        val videoLanguagePref = ListPreference(screen.context).apply {
+            key = PREF_LANGUAGE_KEY
+            title = PREF_LANGUAGE_TITLE
+            entries = PREF_LANGUAGE_ENTRIES
+            entryValues = PREF_LANGUAGE_VALUES
+            setDefaultValue(PREF_LANGUAGE_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()
+            }
+        }
+
+        screen.addPreference(videoLanguagePref)
+        super.setupPreferenceScreen(screen)
+    }
+
+    // ============================= Utilities ==============================
+    override val animeMenuSelector = "div.epsL i.material-icons:contains(library)"
+
+    private fun String.decodeEmail(): String {
+        val hex = chunked(2).map { it.toInt(16) }
+        return hex.drop(1).joinToString("") {
+            Char(it xor hex.first()).toString()
+        }
+    }
+
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString(videoSortPrefKey, videoSortPrefDefault)!!
+        val language = preferences.getString(PREF_LANGUAGE_KEY, PREF_LANGUAGE_DEFAULT)!!
+        return sortedWith(
+            compareBy(
+                { it.quality.lowercase().contains(quality.lowercase()) },
+                { it.quality.lowercase().contains(language.lowercase()) },
+            ),
+        ).reversed()
+    }
+
+    companion object {
+        private const val PREF_LANGUAGE_KEY = "preferred_language"
+        private const val PREF_LANGUAGE_DEFAULT = "Legendado"
+        private const val PREF_LANGUAGE_TITLE = "Língua preferida"
+        private val PREF_LANGUAGE_VALUES = arrayOf("Legendado", "Dublado")
+        private val PREF_LANGUAGE_ENTRIES = PREF_LANGUAGE_VALUES
+    }
+}
diff --git a/src/pt/otakuanimes/AndroidManifest.xml b/src/pt/otakuanimes/AndroidManifest.xml
new file mode 100644
index 00000000..b467aa92
--- /dev/null
+++ b/src/pt/otakuanimes/AndroidManifest.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application>
+        <activity
+            android:name=".pt.otakuanimes.OtakuAnimesUrlActivity"
+            android:excludeFromRecents="true"
+            android:exported="true"
+            android:theme="@android:style/Theme.NoDisplay">
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:host="otakuanimesscc.com"
+                    android:pathPattern="/..*"
+                    android:scheme="https" />
+                <data
+                    android:host="otakuanimesscc.com"
+                    android:pathPattern="/anime/..*"
+                    android:scheme="https" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
diff --git a/src/pt/otakuanimes/build.gradle b/src/pt/otakuanimes/build.gradle
new file mode 100644
index 00000000..6420730f
--- /dev/null
+++ b/src/pt/otakuanimes/build.gradle
@@ -0,0 +1,12 @@
+ext {
+    extName = 'OtakuAnimes'
+    extClass = '.OtakuAnimes'
+    extVersionCode = 2
+    isNsfw = true
+}
+
+apply from: "$rootDir/common.gradle"
+
+dependencies {
+    implementation(project(":lib:playlist-utils"))
+}
diff --git a/src/pt/otakuanimes/res/mipmap-hdpi/ic_launcher.png b/src/pt/otakuanimes/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..713c126d
Binary files /dev/null and b/src/pt/otakuanimes/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/pt/otakuanimes/res/mipmap-mdpi/ic_launcher.png b/src/pt/otakuanimes/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..ce60d541
Binary files /dev/null and b/src/pt/otakuanimes/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/pt/otakuanimes/res/mipmap-xhdpi/ic_launcher.png b/src/pt/otakuanimes/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..c507c31f
Binary files /dev/null and b/src/pt/otakuanimes/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/pt/otakuanimes/res/mipmap-xxhdpi/ic_launcher.png b/src/pt/otakuanimes/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..f9d9a728
Binary files /dev/null and b/src/pt/otakuanimes/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/pt/otakuanimes/res/mipmap-xxxhdpi/ic_launcher.png b/src/pt/otakuanimes/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..b10fec85
Binary files /dev/null and b/src/pt/otakuanimes/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/pt/otakuanimes/src/eu/kanade/tachiyomi/animeextension/pt/otakuanimes/OtakuAnimes.kt b/src/pt/otakuanimes/src/eu/kanade/tachiyomi/animeextension/pt/otakuanimes/OtakuAnimes.kt
new file mode 100644
index 00000000..cde366c7
--- /dev/null
+++ b/src/pt/otakuanimes/src/eu/kanade/tachiyomi/animeextension/pt/otakuanimes/OtakuAnimes.kt
@@ -0,0 +1,247 @@
+package eu.kanade.tachiyomi.animeextension.pt.otakuanimes
+
+import android.app.Application
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+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.lib.playlistutils.PlaylistUtils
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.awaitSuccess
+import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
+import okhttp3.HttpUrl.Companion.toHttpUrl
+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
+
+class OtakuAnimes : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
+
+    override val name = "Otaku Animes"
+
+    override val baseUrl = "https://otakuanimesscc.com"
+
+    override val lang = "pt-BR"
+
+    override val supportsLatest = true
+
+    private val preferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    override fun headersBuilder() = super.headersBuilder()
+        .add("Referer", baseUrl)
+        .add("Origin", baseUrl)
+
+    // ============================== Popular ===============================
+    override fun popularAnimeRequest(page: Int) = GET(baseUrl, headers)
+
+    override fun popularAnimeSelector() = "div.calendarioL div.ultAnisContainerItem > a"
+
+    override fun popularAnimeFromElement(element: Element) = SAnime.create().apply {
+        setUrlWithoutDomain(element.attr("href"))
+        title = element.selectFirst("div.aniNome")!!.text().trim()
+        thumbnail_url = element.selectFirst("img")?.getImageUrl()
+    }
+
+    override fun popularAnimeNextPageSelector() = null
+
+    // =============================== Latest ===============================
+    override fun latestUpdatesRequest(page: Int) =
+        GET("$baseUrl/lista-de-animes/page/$page", headers)
+
+    override fun latestUpdatesSelector() = "div.ultAnisContainer div.ultAnisContainerItem > a"
+
+    override fun latestUpdatesFromElement(element: Element) = popularAnimeFromElement(element)
+
+    override fun latestUpdatesNextPageSelector() = "div.paginacao a.next"
+
+    // =============================== Search ===============================
+    override suspend fun getSearchAnime(
+        page: Int,
+        query: String,
+        filters: AnimeFilterList,
+    ): AnimesPage {
+        return if (query.startsWith(PREFIX_SEARCH)) {
+            val path = query.removePrefix(PREFIX_SEARCH)
+            client.newCall(GET("$baseUrl/$path"))
+                .awaitSuccess()
+                .use(::searchAnimeByIdParse)
+        } else {
+            super.getSearchAnime(page, query, filters)
+        }
+    }
+
+    private fun searchAnimeByIdParse(response: Response): AnimesPage {
+        val details = animeDetailsParse(response).apply {
+            setUrlWithoutDomain(response.request.url.toString())
+            initialized = true
+        }
+
+        return AnimesPage(listOf(details), false)
+    }
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val url = "$baseUrl/page".toHttpUrl().newBuilder()
+            .addPathSegment(page.toString())
+            .addQueryParameter("s", query)
+            .build()
+
+        return GET(url, headers = headers)
+    }
+
+    override fun searchAnimeSelector() = "div.SectionBusca div.ultAnisContainerItem > a"
+
+    override fun searchAnimeFromElement(element: Element) = latestUpdatesFromElement(element)
+
+    override fun searchAnimeNextPageSelector() = latestUpdatesNextPageSelector()
+
+    // =========================== Anime Details ============================
+    override fun animeDetailsParse(document: Document): SAnime {
+        val doc = getRealDoc(document)
+
+        return SAnime.create().apply {
+            setUrlWithoutDomain(doc.location())
+            title = doc.selectFirst("div.animeFirstContainer h1")!!.text()
+            thumbnail_url = doc.selectFirst("div.animeCapa img")?.getImageUrl()
+            description = doc.selectFirst("div.animeSecondContainer > p")?.text()
+            genre = doc.select("ul.animeGen li").eachText()?.joinToString(", ")
+        }
+    }
+
+    // ============================== Episodes ==============================
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        return getRealDoc(response.asJsoup())
+            .select(episodeListSelector())
+            .map(::episodeFromElement)
+            .reversed()
+    }
+
+    override fun episodeListSelector() = "div.sectionEpiInAnime a"
+
+    override fun episodeFromElement(element: Element) = SEpisode.create().apply {
+        setUrlWithoutDomain(element.attr("href"))
+        element.text().let {
+            name = it.trim()
+            episode_number = name.substringAfterLast(" ").toFloatOrNull() ?: 1F
+        }
+    }
+
+    // ============================ Video Links =============================
+    override fun videoListParse(response: Response): List<Video> {
+        val document = response.asJsoup()
+
+        return document.select("#player iframe")
+            .parallelCatchingFlatMapBlocking {
+                getVideosFromURL(it.attr("src"))
+            }
+    }
+
+    private val playlistUtils by lazy { PlaylistUtils(client) }
+    private fun getVideosFromURL(url: String): List<Video> {
+        return when {
+            "playerhls" in url -> {
+                return client.newCall(GET(url, headers)).execute().body.string()
+                    .substringAfter("sources: [")
+                    .substringBefore("],").split("{").drop(1).map {
+                        val label = it.substringAfter("label: \"")
+                            .substringBefore('"')
+
+                        val playlistUrl = it.substringAfter("file: '")
+                            .substringBefore("'")
+                            .replace("\\", "")
+
+                        return playlistUtils.extractFromHls(
+                            playlistUrl,
+                            videoNameGen = { label },
+                        )
+                    }
+            }
+
+            else -> emptyList()
+        }
+    }
+
+    override fun videoListSelector(): String {
+        throw UnsupportedOperationException()
+    }
+
+    override fun videoFromElement(element: Element): Video {
+        throw UnsupportedOperationException()
+    }
+
+    override fun videoUrlParse(document: Document): String {
+        throw UnsupportedOperationException()
+    }
+
+    // ============================== Settings ==============================
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        ListPreference(screen.context).apply {
+            key = PREF_QUALITY_KEY
+            title = PREF_QUALITY_TITLE
+            entries = PREF_QUALITY_VALUES
+            entryValues = PREF_QUALITY_VALUES
+            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)
+    }
+
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
+        return sortedWith(
+            compareBy(
+                { it.quality.contains(quality) },
+                { REGEX_QUALITY.find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
+            ),
+        ).reversed()
+    }
+
+    // ============================= Utilities ==============================
+    private fun getRealDoc(document: Document): Document {
+        val menu = document.selectFirst("a.aniBack")
+        if (menu != null) {
+            val originalUrl = menu.parent()!!.attr("href")
+            val response = client.newCall(GET(originalUrl, headers)).execute()
+            return response.asJsoup()
+        }
+
+        return document
+    }
+
+    /**
+     * Tries to get the image url via various possible attributes.
+     * Taken from Tachiyomi's Madara multisrc.
+     */
+    protected open fun Element.getImageUrl(): String? {
+        return when {
+            hasAttr("data-src") -> attr("abs:data-src")
+            hasAttr("data-lazy-src") -> attr("abs:data-lazy-src")
+            hasAttr("srcset") -> attr("abs:srcset").substringBefore(" ")
+            else -> attr("abs:src")
+        }.substringBefore("?resize")
+    }
+
+    companion object {
+        const val PREFIX_SEARCH = "path:"
+        private val REGEX_QUALITY by lazy { Regex("""(\d+)p""") }
+
+        private const val PREF_QUALITY_KEY = "preferred_quality"
+        private const val PREF_QUALITY_TITLE = "Qualidade preferida"
+        private const val PREF_QUALITY_DEFAULT = "720p"
+        private val PREF_QUALITY_VALUES = arrayOf("360p", "720p", "1080p")
+    }
+}
diff --git a/src/pt/otakuanimes/src/eu/kanade/tachiyomi/animeextension/pt/otakuanimes/OtakuAnimesUrlActivity.kt b/src/pt/otakuanimes/src/eu/kanade/tachiyomi/animeextension/pt/otakuanimes/OtakuAnimesUrlActivity.kt
new file mode 100644
index 00000000..18c7da70
--- /dev/null
+++ b/src/pt/otakuanimes/src/eu/kanade/tachiyomi/animeextension/pt/otakuanimes/OtakuAnimesUrlActivity.kt
@@ -0,0 +1,46 @@
+package eu.kanade.tachiyomi.animeextension.pt.otakuanimes
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+import kotlin.system.exitProcess
+
+/**
+ * Springboard that accepts https://otakuanimesscc.com/a/<slug> and https://otakuanimesscc.com/<id> intents
+ * and redirects them to the main Aniyomi process.
+ */
+class OtakuAnimesUrlActivity : Activity() {
+
+    private val tag = javaClass.simpleName
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val pathSegments = intent?.data?.pathSegments
+        if (pathSegments != null && pathSegments.size > 0) {
+            val searchQuery = if (pathSegments.size > 1) {
+                "${pathSegments[0]}/${pathSegments[1]}"
+            } else {
+                pathSegments[0]
+            }
+
+            val mainIntent = Intent().apply {
+                action = "eu.kanade.tachiyomi.ANIMESEARCH"
+                putExtra("query", "${OtakuAnimes.PREFIX_SEARCH}$searchQuery")
+                putExtra("filter", packageName)
+            }
+
+            try {
+                startActivity(mainIntent)
+            } catch (e: ActivityNotFoundException) {
+                Log.e(tag, e.toString())
+            }
+        } else {
+            Log.e(tag, "could not parse uri from intent $intent")
+        }
+
+        finish()
+        exitProcess(0)
+    }
+}
diff --git a/src/pt/rinecloud/build.gradle b/src/pt/rinecloud/build.gradle
new file mode 100644
index 00000000..ceed6d7d
--- /dev/null
+++ b/src/pt/rinecloud/build.gradle
@@ -0,0 +1,14 @@
+ext {
+    extName = 'RineCloud'
+    extClass = '.RineCloud'
+    themePkg = 'animestream'
+    baseUrl = 'https://rine.cloud'
+    overrideVersionCode = 10
+}
+
+apply from: "$rootDir/common.gradle"
+
+dependencies {
+    implementation(project(":lib:unpacker"))
+    implementation(project(":lib:playlist-utils"))
+}
\ No newline at end of file
diff --git a/src/pt/rinecloud/res/mipmap-hdpi/ic_launcher.png b/src/pt/rinecloud/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..70eb09e4
Binary files /dev/null and b/src/pt/rinecloud/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/pt/rinecloud/res/mipmap-mdpi/ic_launcher.png b/src/pt/rinecloud/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..e1d85e25
Binary files /dev/null and b/src/pt/rinecloud/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/pt/rinecloud/res/mipmap-xhdpi/ic_launcher.png b/src/pt/rinecloud/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..60f8fe8d
Binary files /dev/null and b/src/pt/rinecloud/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/pt/rinecloud/res/mipmap-xxhdpi/ic_launcher.png b/src/pt/rinecloud/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..f75f379d
Binary files /dev/null and b/src/pt/rinecloud/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/pt/rinecloud/res/mipmap-xxxhdpi/ic_launcher.png b/src/pt/rinecloud/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..703f81f3
Binary files /dev/null and b/src/pt/rinecloud/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/pt/rinecloud/src/eu/kanade/tachiyomi/animeextension/pt/rinecloud/RineCloud.kt b/src/pt/rinecloud/src/eu/kanade/tachiyomi/animeextension/pt/rinecloud/RineCloud.kt
new file mode 100644
index 00000000..ef9f4386
--- /dev/null
+++ b/src/pt/rinecloud/src/eu/kanade/tachiyomi/animeextension/pt/rinecloud/RineCloud.kt
@@ -0,0 +1,25 @@
+package eu.kanade.tachiyomi.animeextension.pt.rinecloud
+
+import eu.kanade.tachiyomi.animeextension.pt.rinecloud.extractors.RineCloudExtractor
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.multisrc.animestream.AnimeStream
+
+class RineCloud : AnimeStream(
+    "pt-BR",
+    "RineCloud",
+    "https://rine.cloud",
+) {
+    override fun headersBuilder() = super.headersBuilder().add("Referer", baseUrl)
+
+    // ============================ Video Links =============================
+    override val prefQualityValues = arrayOf("1080p", "720p", "480p", "360p", "240p")
+    override val prefQualityEntries = prefQualityValues
+
+    private val rinecloudExtractor by lazy { RineCloudExtractor(client, headers) }
+    override fun getVideoList(url: String, name: String): List<Video> {
+        return when {
+            "rine.cloud" in url -> rinecloudExtractor.videosFromUrl(url)
+            else -> emptyList()
+        }
+    }
+}
diff --git a/src/pt/rinecloud/src/eu/kanade/tachiyomi/animeextension/pt/rinecloud/extractors/RineCloudExtractor.kt b/src/pt/rinecloud/src/eu/kanade/tachiyomi/animeextension/pt/rinecloud/extractors/RineCloudExtractor.kt
new file mode 100644
index 00000000..a5c313e7
--- /dev/null
+++ b/src/pt/rinecloud/src/eu/kanade/tachiyomi/animeextension/pt/rinecloud/extractors/RineCloudExtractor.kt
@@ -0,0 +1,47 @@
+package eu.kanade.tachiyomi.animeextension.pt.rinecloud.extractors
+
+import android.util.Base64
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
+import eu.kanade.tachiyomi.lib.unpacker.Unpacker
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+
+class RineCloudExtractor(private val client: OkHttpClient, private val headers: Headers) {
+    private val playlistUtils by lazy { PlaylistUtils(client, headers) }
+
+    fun videosFromUrl(url: String): List<Video> {
+        val playerDoc = client.newCall(GET(url, headers)).execute().asJsoup()
+        val encodedScript = playerDoc.selectFirst("script:containsData(JuicyCodes.Run)")
+            ?.data()
+
+        val script = if (encodedScript != null) {
+            val decodedData = encodedScript.substringAfter("(").substringBefore(")")
+                .split("+\"")
+                .joinToString("") { it.replace("\"", "") }
+                .let { Base64.decode(it, Base64.DEFAULT) }
+                .let(::String)
+            Unpacker.unpack(decodedData).ifEmpty { return emptyList() }
+        } else {
+            playerDoc.selectFirst("script:containsData(const player)")?.data()
+                ?: return emptyList()
+        }
+
+        return script.substringAfter("sources:").substringBefore("]")
+            .split("{")
+            .drop(1)
+            .flatMap {
+                val videoUrl = it.substringAfter("\"file\"").substringAfter('"').substringBefore('"')
+                val quality = it.substringAfter("\"label\"").substringAfter('"').substringBefore('"').ifBlank { "Unknown" }
+
+                when {
+                    arrayOf("googlevideo", ".mp4").any(videoUrl) -> listOf(Video(videoUrl, "Rinecloud - $quality", videoUrl, headers))
+                    else -> playlistUtils.extractFromHls(videoUrl, videoNameGen = { "Rinecloud - ${if (it == "Video") quality else it}" })
+                }
+            }
+    }
+
+    private fun Array<String>.any(url: String): Boolean = this.any { url.contains(it, ignoreCase = true) }
+}
diff --git a/src/pt/tomato/build.gradle b/src/pt/tomato/build.gradle
new file mode 100644
index 00000000..6b964445
--- /dev/null
+++ b/src/pt/tomato/build.gradle
@@ -0,0 +1,7 @@
+ext {
+    extName = 'Tomato'
+    extClass = '.Tomato'
+    extVersionCode = 1
+}
+
+apply from: "$rootDir/common.gradle"
diff --git a/src/pt/tomato/res/mipmap-hdpi/ic_launcher.png b/src/pt/tomato/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..a9e39ecc
Binary files /dev/null and b/src/pt/tomato/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/pt/tomato/res/mipmap-mdpi/ic_launcher.png b/src/pt/tomato/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..2adff7e0
Binary files /dev/null and b/src/pt/tomato/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/pt/tomato/res/mipmap-xhdpi/ic_launcher.png b/src/pt/tomato/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..31fa1a88
Binary files /dev/null and b/src/pt/tomato/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/pt/tomato/res/mipmap-xxhdpi/ic_launcher.png b/src/pt/tomato/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..cc673719
Binary files /dev/null and b/src/pt/tomato/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/pt/tomato/res/mipmap-xxxhdpi/ic_launcher.png b/src/pt/tomato/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..d2f201dc
Binary files /dev/null and b/src/pt/tomato/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/Tomato.kt b/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/Tomato.kt
new file mode 100644
index 00000000..a8b31601
--- /dev/null
+++ b/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/Tomato.kt
@@ -0,0 +1,336 @@
+package eu.kanade.tachiyomi.animeextension.pt.tomato
+
+import android.app.Application
+import android.util.Log
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animeextension.pt.tomato.dto.AnimeResultDto
+import eu.kanade.tachiyomi.animeextension.pt.tomato.dto.EpisodeInfoDto
+import eu.kanade.tachiyomi.animeextension.pt.tomato.dto.EpisodesResultDto
+import eu.kanade.tachiyomi.animeextension.pt.tomato.dto.SearchAnimeItemDto
+import eu.kanade.tachiyomi.animeextension.pt.tomato.dto.SearchResultDto
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+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.AnimeHttpSource
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.network.interceptor.rateLimitHost
+import eu.kanade.tachiyomi.util.parallelMapBlocking
+import eu.kanade.tachiyomi.util.parseAs
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.add
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.int
+import kotlinx.serialization.json.jsonArray
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.put
+import kotlinx.serialization.json.putJsonArray
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.Response
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import uy.kohesive.injekt.injectLazy
+import kotlin.time.Duration.Companion.seconds
+
+class Tomato : ConfigurableAnimeSource, AnimeHttpSource() {
+
+    override val name = "Tomato"
+
+    override val baseUrl = "https://beta-api.tomatoanimes.com"
+
+    override val lang = "pt-BR"
+
+    override val supportsLatest = true
+
+    private val preferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    private val json: Json by injectLazy()
+
+    override fun headersBuilder() = super.headersBuilder().add(
+        "Authorization",
+        "Bearer $TOKEN",
+    )
+
+    private val episodesClient by lazy {
+        client.newBuilder().rateLimitHost(baseUrl.toHttpUrl(), 1, 0.5.seconds).build()
+    }
+
+    // ============================== Popular ===============================
+    override fun popularAnimeRequest(page: Int) =
+        GET("$baseUrl/v2/animes/feed", headers = headers)
+
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        val responseJson = response.parseAs<JsonObject>()
+
+        val emAlta = responseJson["data"]?.jsonArray?.find {
+            it.jsonObject["title"]?.jsonPrimitive?.content?.contains("curtidos") == true
+        }
+
+        val animes = emAlta?.jsonObject?.get("data")?.jsonArray?.parallelMapBlocking {
+            animeFromId(it.jsonObject["anime_id"]!!.jsonPrimitive.int)
+        }
+            ?: emptyList<SAnime>()
+
+        return AnimesPage(animes, false)
+    }
+
+    // =============================== Latest ===============================
+    override fun latestUpdatesRequest(page: Int) =
+        GET("$baseUrl/v2/animes/feed", headers = headers)
+
+    override fun latestUpdatesParse(response: Response): AnimesPage {
+        val responseJson = response.parseAs<JsonObject>()
+
+        val emAlta = responseJson["data"]?.jsonArray?.find {
+            it.jsonObject["type"]!!.jsonPrimitive.int == 7
+        }
+
+        val animes = emAlta?.jsonObject?.get("data")?.jsonArray?.parallelMapBlocking {
+            animeFromId(it.jsonObject["ep_anime_id"]!!.jsonPrimitive.int)
+        }
+            ?: emptyList<SAnime>()
+
+        return AnimesPage(animes, false)
+    }
+
+    // =============================== Search ===============================
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val params = TomatoFilters.getSearchParameters(filters)
+
+        val data = buildJsonObject {
+            put("token", TOKEN)
+            put("search", query)
+            put("content_type", "anime")
+            put("page", page - 1)
+
+            if (params.genres.isNotEmpty()) {
+                putJsonArray("tags") {
+                    params.genres.forEach { add(it) }
+                }
+            }
+        }
+
+        val body = json.encodeToString(JsonObject.serializer(), data)
+            .toRequestBody("application/json".toMediaType())
+
+        return POST("$baseUrl/v2/content/search", headers = headers, body = body)
+    }
+
+    override fun searchAnimeParse(response: Response): AnimesPage {
+        val searchResult = response.parseAs<SearchResultDto>().result
+        val results = searchResult.map { it.toSAnime() }
+        return AnimesPage(results, false)
+    }
+
+    private fun SearchAnimeItemDto.toSAnime(): SAnime {
+        return SAnime.create().apply {
+            setUrlWithoutDomain("$baseUrl/v2/anime/$id")
+            title = name
+            thumbnail_url = image
+        }
+    }
+
+    override fun getFilterList() = TomatoFilters.FILTER_LIST
+
+    // =========================== Anime Details ============================
+    private fun animeFromId(id: Int): SAnime {
+        val response = client.newCall(
+            GET("$baseUrl/v2/anime/$id", headers = headers),
+        ).execute()
+
+        return animeDetailsParse(response)
+    }
+
+    override fun animeDetailsParse(response: Response): SAnime {
+        val anime = response.parseAs<AnimeResultDto>()
+        return SAnime.create().apply {
+            setUrlWithoutDomain("$baseUrl/v2/anime/${anime.animeDetails.animeId}")
+            title = anime.animeDetails.animeName
+            description = anime.animeDetails.animeDescription
+            genre = anime.animeDetails.animeGenre
+            thumbnail_url = anime.animeDetails.animeCoverUrl
+        }
+    }
+
+    // ============================== Episodes ==============================
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val anime = response.parseAs<AnimeResultDto>()
+
+        val seasons = anime.animeSeasons
+
+        val episodeList = mutableListOf<SEpisode>()
+
+        seasons.forEach { season ->
+            var nextPage = 0
+            do {
+                val data = buildJsonObject {
+                    put("token", TOKEN)
+                    put("page", nextPage)
+                    put("order", "ASC")
+                }
+
+                val body = json.encodeToString(JsonObject.serializer(), data)
+                    .toRequestBody("application/json".toMediaType())
+
+                val request = POST(
+                    "$baseUrl/season/${season.seasonId}/episodes",
+                    headers = headers,
+                    body = body,
+                )
+                val episodes =
+                    episodesClient.newCall(request).execute().parseAs<EpisodesResultDto>().data
+
+                episodes.forEach { episode ->
+                    val partName = "Temporada ${season.seasonNumber} x ${episode.epNumber}"
+                    val fullName = "$partName - ${episode.epName}"
+
+                    val prev = episodeList.find { it.name.contains(partName) }
+
+                    val newUrl = "&episode[${season.seasonDubbed}]=${episode.epId}"
+                    if (prev != null) {
+                        prev.url += newUrl
+                    } else {
+                        episodeList.add(
+                            SEpisode.create().apply {
+                                episode_number = episode.epNumber
+                                name = fullName
+                                url = "http://localhost?season=${season.seasonNumber}$newUrl"
+                            },
+                        )
+                    }
+                }
+
+                if (episodes.size == 25) nextPage += 1 else nextPage = -1
+            } while (nextPage != -1)
+        }
+
+        return episodeList.reversed()
+    }
+
+    // ============================ Video Links =============================
+    override suspend fun getVideoList(episode: SEpisode): List<Video> {
+        Log.d("fetchVideoList", episode.url)
+
+        val dubs = listOf(
+            Pair("Legendado", episode.url.toHttpUrl().queryParameter("episode[0]")),
+            Pair("Dublado", episode.url.toHttpUrl().queryParameter("episode[1]")),
+        )
+
+        val videos = mutableListOf<Video>()
+
+        dubs.forEach { dub ->
+            if (dub.second.isNullOrBlank()) {
+                return@forEach
+            }
+            val request =
+                GET("$baseUrl/v2/anime/episode/${dub.second}/stream", headers = headers)
+            val response = client.newCall(request).execute().parseAs<EpisodeInfoDto>()
+
+            if (response.streams.shd != null) {
+                videos.add(
+                    Video(
+                        response.streams.shd,
+                        "${dub.first} - 480p",
+                        videoUrl = response.streams.shd,
+                    ),
+                )
+            }
+            if (response.streams.mhd != null) {
+                videos.add(
+                    Video(
+                        response.streams.mhd,
+                        "${dub.first} - 720p",
+                        videoUrl = response.streams.mhd,
+                    ),
+                )
+            }
+            if (response.streams.fhd != null) {
+                videos.add(
+                    Video(
+                        response.streams.fhd,
+                        "${dub.first} - 1080p",
+                        videoUrl = response.streams.fhd,
+                    ),
+                )
+            }
+        }
+
+        return videos.sort()
+    }
+
+    // ============================== Settings ==============================
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        ListPreference(screen.context).apply {
+            key = PREF_QUALITY_KEY
+            title = PREF_QUALITY_TITLE
+            entries = PREF_QUALITY_ENTRIES
+            entryValues = PREF_QUALITY_ENTRIES
+            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_LANGUAGE_KEY
+            title = PREF_LANGUAGE_TITLE
+            entries = PREF_LANGUAGE_VALUES
+            entryValues = PREF_LANGUAGE_VALUES
+            setDefaultValue(PREF_LANGUAGE_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)
+    }
+
+    // ============================= Utilities ==============================
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
+        val lang = preferences.getString(PREF_LANGUAGE_KEY, PREF_LANGUAGE_DEFAULT)!!
+
+        return sortedWith(
+            compareByDescending<Video> { it.quality.contains(lang) }
+                .thenByDescending { it.quality.contains(quality) }
+                .thenByDescending {
+                    REGEX_QUALITY.find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0
+                },
+        )
+    }
+
+    companion object {
+        private val REGEX_QUALITY by lazy { Regex("""(\d+)p""") }
+        private val TOKEN =
+            "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6MTMxNjUzODQsInV1aWQiOiI4N2VmNmNmMC1jMjFkLTExZWYtODAxNS01NzNlMjdjNWU4ZGIiLCJpYXQiOjE3MzUwNjMwNTd9.5JMhTqBjs4A3VxrIjNQqpXtJGJ5y8MJt-ARvFrjcYUo"
+
+        private const val PREF_QUALITY_KEY = "preferred_quality"
+        private const val PREF_QUALITY_TITLE = "Qualidade preferida"
+        private const val PREF_QUALITY_DEFAULT = "1080p"
+        private val PREF_QUALITY_ENTRIES = arrayOf("480p", "720p", "1080p")
+
+        private const val PREF_LANGUAGE_KEY = "pref_language"
+        private const val PREF_LANGUAGE_DEFAULT = "Legendado"
+        private const val PREF_LANGUAGE_TITLE = "Língua/tipo preferido"
+        private val PREF_LANGUAGE_VALUES = arrayOf("Legendado", "Dublado")
+    }
+}
diff --git a/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/TomatoFilters.kt b/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/TomatoFilters.kt
new file mode 100644
index 00000000..b954db90
--- /dev/null
+++ b/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/TomatoFilters.kt
@@ -0,0 +1,79 @@
+package eu.kanade.tachiyomi.animeextension.pt.tomato
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+
+object TomatoFilters {
+    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.parseCheckbox(
+        options: Array<Pair<String, String>>,
+    ): List<String> {
+        return (getFirst<R>() as CheckBoxFilterList).state
+            .asSequence()
+            .filter { it.state }
+            .map { checkbox -> options.find { it.first == checkbox.name }!!.second }
+            .filter(String::isNotBlank)
+            .toList()
+    }
+
+    class GenresFilter : CheckBoxFilterList("Gêneros", TomatoFiltersData.GENRES_LIST)
+
+    val FILTER_LIST
+        get() = AnimeFilterList(
+            GenresFilter(),
+        )
+
+    data class FilterSearchParams(
+        val genres: List<String> = emptyList(),
+    )
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+
+        return FilterSearchParams(
+            filters.parseCheckbox<GenresFilter>(TomatoFiltersData.GENRES_LIST),
+        )
+    }
+
+    private object TomatoFiltersData {
+        private val SELECT = Pair("<Selecione>", "")
+
+        val GENRES_LIST = arrayOf(
+            Pair("Aventura", "Aventura"),
+            Pair("Ação", "Ação"),
+            Pair("Comédia", "Comédia"),
+            Pair("Dublado", "Dublado"),
+            Pair("Drama", "Drama"),
+            Pair("Escolar", "Escolar"),
+            Pair("Fantasia", "Fantasia"),
+            Pair("Romance", "Romance"),
+            Pair("Slice Of Life", "Slice Of Life"),
+            Pair("Sobrenatural", "Sobrenatural"),
+            Pair("Sci-Fi", "Sci-Fi"),
+            Pair("Shounen", "Shounen"),
+        )
+    }
+}
diff --git a/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/dto/TomatoDto.kt b/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/dto/TomatoDto.kt
new file mode 100644
index 00000000..731f20dc
--- /dev/null
+++ b/src/pt/tomato/src/eu/kanade/tachiyomi/animeextension/pt/tomato/dto/TomatoDto.kt
@@ -0,0 +1,78 @@
+package eu.kanade.tachiyomi.animeextension.pt.tomato.dto
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class SearchAnimeItemDto(
+    val id: Int,
+    val name: String,
+    val image: String,
+    val tags: String,
+)
+
+@Serializable
+data class SearchResultDto(
+    val result: List<SearchAnimeItemDto>,
+)
+
+@Serializable
+data class AnimeDetailsDto(
+    @SerialName("anime_id")
+    val animeId: Int,
+    @SerialName("anime_name")
+    val animeName: String,
+    @SerialName("anime_description")
+    val animeDescription: String,
+    @SerialName("anime_cover_url")
+    val animeCoverUrl: String,
+    @SerialName("anime_genre")
+    val animeGenre: String,
+)
+
+@Serializable
+data class AnimeSeasonDto(
+    @SerialName("season_id")
+    val seasonId: Int,
+    @SerialName("season_name")
+    val seasonName: String,
+    @SerialName("season_number")
+    val seasonNumber: Int,
+    @SerialName("season_dubbed")
+    val seasonDubbed: Int,
+)
+
+@Serializable
+data class AnimeResultDto(
+    @SerialName("anime_details")
+    val animeDetails: AnimeDetailsDto,
+    @SerialName("anime_seasons")
+    val animeSeasons: List<AnimeSeasonDto>,
+)
+
+@Serializable
+data class EpisodesItemDto(
+    @SerialName("ep_id")
+    val epId: Int,
+    @SerialName("ep_name")
+    val epName: String,
+    @SerialName("ep_number")
+    val epNumber: Float,
+)
+
+@Serializable
+data class EpisodesResultDto(
+    val data: List<EpisodesItemDto>,
+)
+
+@Serializable
+data class EpisodeStreamDto(
+    val shd: String?,
+    val mhd: String?,
+    val fhd: String?,
+)
+
+@Serializable
+data class EpisodeInfoDto(
+    val streams: EpisodeStreamDto,
+)