diff --git a/src/ru/animelib/build.gradle b/src/ru/animelib/build.gradle
new file mode 100644
index 000000000..79f45dd8d
--- /dev/null
+++ b/src/ru/animelib/build.gradle
@@ -0,0 +1,12 @@
+ext {
+    extName = 'Animelib'
+    extClass = '.Animelib'
+    extVersionCode = 1
+    isNsfw = true
+}
+
+apply from: "$rootDir/common.gradle"
+
+dependencies {
+    implementation project(':lib:playlist-utils')
+}
\ No newline at end of file
diff --git a/src/ru/animelib/res/mipmap-hdpi/ic_launcher.png b/src/ru/animelib/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 000000000..b3c00da43
Binary files /dev/null and b/src/ru/animelib/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/ru/animelib/res/mipmap-mdpi/ic_launcher.png b/src/ru/animelib/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 000000000..a92b0439c
Binary files /dev/null and b/src/ru/animelib/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/ru/animelib/res/mipmap-xhdpi/ic_launcher.png b/src/ru/animelib/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 000000000..1636c0daa
Binary files /dev/null and b/src/ru/animelib/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/ru/animelib/res/mipmap-xxhdpi/ic_launcher.png b/src/ru/animelib/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 000000000..1eb09e12d
Binary files /dev/null and b/src/ru/animelib/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/ru/animelib/res/mipmap-xxxhdpi/ic_launcher.png b/src/ru/animelib/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 000000000..3be7f05be
Binary files /dev/null and b/src/ru/animelib/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/Animelib.kt b/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/Animelib.kt
new file mode 100644
index 000000000..cec264b35
--- /dev/null
+++ b/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/Animelib.kt
@@ -0,0 +1,495 @@
+package eu.kanade.tachiyomi.animeextension.ru.animelib
+
+import android.app.Application
+import android.util.Base64
+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 app.cash.quickjs.QuickJs
+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.Track
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parseAs
+import okhttp3.FormBody
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.Request
+import okhttp3.Response
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.net.URLDecoder
+import java.text.SimpleDateFormat
+import java.util.Locale
+
+class Animelib : ConfigurableAnimeSource, AnimeHttpSource() {
+
+    override val name = "Animelib"
+
+    override val lang = "ru"
+
+    override val supportsLatest = true
+
+    private val domain = "anilib.me"
+    override val baseUrl = "https://$domain/ru"
+    private val apiUrl = "https://api.lib.social/api"
+
+    private val playlistUtils by lazy { PlaylistUtils(client, headers) }
+    private val dateFormatter by lazy { SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH) }
+
+    companion object {
+        private const val PREF_QUALITY_KEY = "pref_quality"
+        private val PREF_QUALITY_ENTRIES = arrayOf("360", "720", "1080", "2160")
+
+        private const val PREF_USE_MAX_QUALITY_KEY = "pref_use_max_quality"
+        private const val PREF_USE_MAX_QUALITY_DEFAULT = true
+
+        private const val PREF_SERVER_KEY = "pref_server"
+        private val PREF_SERVER_ENTRIES = arrayOf("Основной", "Резервный 1", "Резервный 2")
+
+        private const val PREF_DUB_TEAM_KEY = "prev_dub_team"
+
+        private const val PREF_IGNORE_SUBS_KEY = "pref_ignore_subs"
+        private const val PREF_IGNORE_SUBS_DEFAULT = true
+
+        private const val PREF_USE_KODIK_KEY = "pref_use_kodik"
+        private const val PREF_USE_KODIK_DEFAULT = true
+
+        private val ATOB_REGEX = Regex("atob\\([^\"]")
+    }
+
+    // =============================== Preference ===============================
+    private val preferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        ListPreference(screen.context).apply {
+            key = PREF_SERVER_KEY
+            title = "Предпочитаемый сервер плеера Animelib"
+            entries = PREF_SERVER_ENTRIES
+            entryValues = PREF_SERVER_ENTRIES
+            summary = "%s"
+            setDefaultValue(PREF_SERVER_ENTRIES[0])
+
+            setOnPreferenceChangeListener { _, newValue ->
+                preferences.edit().putString(key, newValue as String).commit()
+            }
+        }.also(screen::addPreference)
+
+        SwitchPreferenceCompat(screen.context).apply {
+            key = PREF_USE_MAX_QUALITY_KEY
+            title = "Использовать максимальное доступное качество"
+            summary = "Для каждой студии озвучки будет выбрано максимальное качество"
+            setDefaultValue(PREF_USE_MAX_QUALITY_DEFAULT)
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val value = newValue as Boolean
+
+                val text = if (value) {
+                    "Предпочитаемое качество пропадет после закрытия окна настроек"
+                } else {
+                    "Откройте настройки заново чтобы выбрать предпочитаемое качество"
+                }
+                Toast.makeText(screen.context, text, Toast.LENGTH_LONG).show()
+
+                preferences.edit().putBoolean(key, value).commit()
+            }
+        }.also(screen::addPreference)
+
+        if (!preferences.getBoolean(PREF_USE_MAX_QUALITY_KEY, true)) {
+            MultiSelectListPreference(screen.context).apply {
+                key = PREF_QUALITY_KEY
+                title = "Предпочитаемое качество"
+                entries = PREF_QUALITY_ENTRIES
+                entryValues = PREF_QUALITY_ENTRIES
+                summary = "При отсутствии нужного качества могут возникать ошибки!"
+                setDefaultValue(PREF_QUALITY_ENTRIES.toSet())
+
+                setOnPreferenceChangeListener { _, newValue ->
+                    @Suppress("UNCHECKED_CAST")
+                    preferences.edit().putStringSet(key, newValue as Set<String>).commit()
+                }
+            }.also(screen::addPreference)
+        }
+
+        SwitchPreferenceCompat(screen.context).apply {
+            key = PREF_USE_KODIK_KEY
+            title = "Включить парсинг видео из плеера Kodik"
+            summary = "Некоторые видео доступны только в нем, но он может работать нестабильно"
+            setDefaultValue(PREF_USE_KODIK_DEFAULT)
+
+            setOnPreferenceChangeListener { _, newValue ->
+                preferences.edit().putBoolean(key, newValue as Boolean).commit()
+            }
+        }.also(screen::addPreference)
+
+        SwitchPreferenceCompat(screen.context).apply {
+            key = PREF_IGNORE_SUBS_KEY
+            title = "Игнорировать субтитры"
+            summary = "Исключает видео с субтитрами"
+            setDefaultValue(PREF_IGNORE_SUBS_DEFAULT)
+
+            setOnPreferenceChangeListener { _, newValue ->
+                preferences.edit().putBoolean(key, newValue as Boolean).commit()
+            }
+        }.also(screen::addPreference)
+
+        EditTextPreference(screen.context).apply {
+            key = PREF_DUB_TEAM_KEY
+            title = "Предпочитаемые студии озвучки"
+            summary = "Список студий или ключевых слов через запятую (экспериментальная функция)"
+            setDefaultValue("")
+
+            setOnPreferenceChangeListener { _, newValue ->
+                preferences.edit().putString(key, newValue as String).commit()
+            }
+        }.also(screen::addPreference)
+    }
+
+    // =============================== Details ===============================
+    override fun animeDetailsRequest(anime: SAnime): Request {
+        val url = apiUrl.toHttpUrl().newBuilder()
+        url.addPathSegment("anime")
+        url.addPathSegment(anime.url)
+        url.addQueryParameter("fields[]", "genres")
+        url.addQueryParameter("fields[]", "summary")
+        url.addQueryParameter("fields[]", "authors")
+        url.addQueryParameter("fields[]", "publisher")
+        url.addQueryParameter("fields[]", "otherNames")
+        url.addQueryParameter("fields[]", "anime_status_id")
+
+        return GET(url.build())
+    }
+
+    override fun getAnimeUrl(anime: SAnime) = "$baseUrl/${anime.url}"
+
+    override fun animeDetailsParse(response: Response) = response.parseAs<AnimeInfo>().data.toSAnime()
+
+    // =============================== Episodes ===============================
+    override fun episodeListRequest(anime: SAnime): Request {
+        val url = apiUrl.toHttpUrl().newBuilder()
+        url.addPathSegment("episodes")
+        url.addQueryParameter("anime_id", anime.url)
+
+        return GET(url.build())
+    }
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val episodeList = response.parseAs<EpisodeList>()
+
+        return episodeList.data.map { it.toSEpisode() }.reversed()
+    }
+
+    // =============================== Video List ===============================
+    override fun videoListParse(response: Response): List<Video> {
+        val episodeData = response.parseAs<EpisodeVideoData>()
+        val videoServer = fetchPreferredVideoServer()
+        val teams = preferences.getString(PREF_DUB_TEAM_KEY, "")?.split(',')
+
+        val preferredTeams = episodeData.data.players?.filter { videoInfo ->
+            teams.isNullOrEmpty() || teams.any { videoInfo.team.name.contains(it.trim(), true) }
+        } ?: episodeData.data.players
+
+        val useMaxQuality = preferences.getBoolean(
+            PREF_USE_MAX_QUALITY_KEY,
+            PREF_USE_MAX_QUALITY_DEFAULT,
+        )
+        val videoInfoList = preferredTeams?.filter { videoInfo ->
+            val quality = bestQuality(videoInfo)
+            val noneBetter = preferredTeams.none {
+                bestQuality(it) > quality && it.team.name == videoInfo.team.name
+            }
+
+            noneBetter || !useMaxQuality
+        } ?: preferredTeams
+
+        val ignoreSubs = preferences.getBoolean(PREF_IGNORE_SUBS_KEY, PREF_IGNORE_SUBS_DEFAULT)
+        return videoInfoList?.flatMap { videoInfo ->
+            if (ignoreSubs && videoInfo.translationInfo.id == 1) {
+                return@flatMap emptyList()
+            }
+            val playerName = videoInfo.player.lowercase()
+            when (playerName) {
+                "kodik" -> kodikVideoLinks(videoInfo.src, videoInfo.team.name)
+                "animelib" -> animelibVideoLinks(videoInfo, videoServer)
+                else -> emptyList()
+            }
+        } ?: emptyList()
+    }
+
+    override fun videoListRequest(episode: SEpisode) = GET(episode.url)
+
+    // =============================== Latest ===============================
+    override fun latestUpdatesParse(response: Response) = popularAnimeParse(response)
+
+    override fun latestUpdatesRequest(page: Int): Request {
+        val url = apiUrl.toHttpUrl().newBuilder()
+        url.addPathSegment("anime")
+        url.addQueryParameter("page", page.toString())
+        url.addQueryParameter("site_id[]", "5")
+        url.addQueryParameter("links[]", "")
+        url.addQueryParameter("sort_by", "last_episode_at")
+
+        return GET(url.build())
+    }
+
+    // =============================== Popular ===============================
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        val animeList = response.parseAs<AnimeList>()
+
+        val hasNext = !animeList.links?.next.isNullOrEmpty()
+        val animes = animeList.data.map { it.toSAnime() }
+        return AnimesPage(animes, hasNext)
+    }
+
+    override fun popularAnimeRequest(page: Int): Request {
+        val url = apiUrl.toHttpUrl().newBuilder()
+        url.addPathSegment("anime")
+        url.addQueryParameter("page", page.toString())
+        url.addQueryParameter("site_id[]", "5")
+        url.addQueryParameter("links[]", "")
+
+        return GET(url.build())
+    }
+
+    // =============================== Search ===============================
+    override fun searchAnimeParse(response: Response) = popularAnimeParse(response)
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val searchParams = AnimelibFilters.getSearchParameters(filters)
+
+        val url = apiUrl.toHttpUrl().newBuilder()
+        url.addPathSegment("anime")
+        url.addQueryParameter("page", page.toString())
+        url.addQueryParameter("site_id[]", "5")
+        url.addQueryParameter("links[]", "")
+
+        searchParams.genres.include.forEach { url.addQueryParameter("genres[]", it) }
+        searchParams.genres.exclude.forEach { url.addQueryParameter("genres_exclude[]", it) }
+        searchParams.format.forEach { url.addQueryParameter("types[]", it) }
+        searchParams.pegi.forEach { url.addQueryParameter("caution[]", it) }
+        searchParams.ongoingStatus.forEach { url.addQueryParameter("status[]", it) }
+
+        url.addQueryParameter("sort_by", searchParams.sortOrder)
+        if (searchParams.sortDirection.isNotEmpty()) {
+            url.addQueryParameter("sort_type", searchParams.sortDirection)
+        }
+
+        url.addQueryParameter("q", query)
+
+        return GET(url.build())
+    }
+
+    override fun getFilterList() = AnimelibFilters.FILTER_LIST
+
+    // =============================== Utils ===============================
+    private fun fetchPreferredVideoServer(): String {
+        val url = apiUrl.toHttpUrl().newBuilder()
+        url.addPathSegment("constants")
+        url.addQueryParameter("fields[]", "videoServers")
+
+        val videoServerResponse = client.newCall(GET(url.build())).execute()
+        val videoServers = videoServerResponse.parseAs<VideoServerData>()
+
+        val serverPreference = preferences.getString(PREF_SERVER_KEY, PREF_SERVER_ENTRIES[0])
+        if (serverPreference.isNullOrEmpty()) {
+            return videoServers.data.videoServers[0].url
+        }
+
+        for (videoServer in videoServers.data.videoServers) {
+            if (videoServer.label == serverPreference) {
+                return videoServer.url
+            }
+        }
+
+        return videoServers.data.videoServers[0].url
+    }
+
+    private fun kodikVideoLinks(playerUrl: String?, teamName: String): List<Video> {
+        val useKodik = preferences.getBoolean(PREF_USE_KODIK_KEY, PREF_USE_KODIK_DEFAULT)
+        if (playerUrl.isNullOrEmpty() || !useKodik) {
+            return emptyList()
+        }
+
+        val kodikPage = "https:$playerUrl"
+        val headers = Headers.Builder()
+        headers.add("Referer", baseUrl)
+        val kodikPageResponse = client.newCall(GET(kodikPage, headers.build())).execute()
+
+        // Parse form parameters for video link request
+        val page = kodikPageResponse.asJsoup()
+        val urlParams = page.selectFirst("script:containsData($domain)")?.data()
+            ?: return emptyList()
+
+        val formData = urlParams.substringAfter("urlParams = '")
+            .substringBefore("'")
+            .parseAs<KodikForm>()
+
+        if (formData.dSign.isEmpty()) {
+            return emptyList()
+        }
+
+        val kodikDomain = formData.pd
+        val formBody = FormBody.Builder()
+        formBody.add("d", formData.d)
+        formBody.add("d_sign", URLDecoder.decode(formData.dSign, "utf-8"))
+        formBody.add("pd", formData.pd)
+        formBody.add("pd_sign", URLDecoder.decode(formData.pdSign, "utf-8"))
+        formBody.add("ref", URLDecoder.decode(formData.ref, "utf-8"))
+        formBody.add("ref_sign", URLDecoder.decode(formData.refSign, "utf-8"))
+
+        val urlParts = playerUrl.split('/')
+        formBody.add("type", urlParts[3])
+        formBody.add("id", urlParts[4])
+        formBody.add("hash", urlParts[5])
+
+        val videoInfoRequest = POST("https://$kodikDomain/ftor", body = formBody.build())
+        val videoInfoResponse = client.newCall(videoInfoRequest).execute()
+        val kodikData = videoInfoResponse.parseAs<KodikData>()
+
+        // Load js with encode algorithm and parse it
+        val scriptUrl = page.selectFirst("script[src*=player_single]")?.attr("abs:src")
+            ?: return emptyList()
+        val jsScript = client.newCall(GET(scriptUrl)).execute().body.string()
+        val atob = ATOB_REGEX.find(jsScript) ?: return emptyList()
+
+        var encodeScript = ""
+        val deque = ArrayDeque<Char>()
+        deque.addFirst('(')
+        for (i in atob.range.last..jsScript.length) {
+            val char = jsScript[i]
+            if (char in arrayOf('(', '{')) {
+                deque.addFirst(char)
+            } else if (char in arrayOf(')', '}')) {
+                if (deque.isNotEmpty()) {
+                    deque.removeFirst()
+                }
+            }
+
+            if (deque.isNotEmpty()) {
+                encodeScript += char
+            } else {
+                break
+            }
+        }
+
+        val useMaxQuality = preferences.getBoolean(
+            PREF_USE_MAX_QUALITY_KEY,
+            PREF_USE_MAX_QUALITY_DEFAULT,
+        )
+        val qualityPreference = preferences.getStringSet(PREF_QUALITY_KEY, emptySet())
+        val qualityList = if (useMaxQuality) {
+            listOf("720")
+        } else if (!qualityPreference.isNullOrEmpty()) {
+            qualityPreference.toList()
+        } else {
+            listOf("360", "480", "720")
+        }
+
+        val videoList = qualityList.flatMap { quality ->
+            val quickJs = QuickJs.create()
+            val videoInfo = when (quality) {
+                "360" -> kodikData.links.ugly[0].src
+                "480" -> kodikData.links.bad[0].src
+                "720" -> kodikData.links.good[0].src
+                else -> return@flatMap emptyList()
+            }
+
+            val base64Url = quickJs.use {
+                it.evaluate("t='$videoInfo'; $encodeScript")
+            }.toString()
+            val hlsUrl = Base64.decode(base64Url, Base64.DEFAULT).toString(Charsets.UTF_8)
+            playlistUtils.extractFromHls(
+                "https:$hlsUrl",
+                videoNameGen = { "$teamName (${quality}p Kodik)" },
+            )
+        }
+
+        return videoList
+    }
+
+    private fun animelibVideoLinks(videoInfo: VideoInfo, serverUrl: String): List<Video> {
+        if (videoInfo.video == null) {
+            return emptyList()
+        }
+
+        val subtitles = videoInfo.subtitles?.map {
+            val url = it.src
+            val lang = "${videoInfo.team.name} (${it.format})"
+            Track(url, lang)
+        } ?: emptyList()
+
+        val useMaxQuality = preferences.getBoolean(
+            PREF_USE_MAX_QUALITY_KEY,
+            PREF_USE_MAX_QUALITY_DEFAULT,
+        )
+        val maxQuality = bestQuality(videoInfo)
+        val qualityPreference = preferences.getStringSet(PREF_QUALITY_KEY, emptySet())
+
+        val videoList = videoInfo.video.quality.mapNotNull {
+            if (useMaxQuality && it.quality != maxQuality) {
+                return@mapNotNull null
+            } else if (!useMaxQuality && !qualityPreference.isNullOrEmpty()) {
+                if (!qualityPreference.contains(it.quality.toString())) {
+                    return@mapNotNull null
+                }
+            }
+
+            val url = "$serverUrl${it.href}"
+            val quality = "${videoInfo.team.name} (${it.quality}p Animelib)"
+            Video(url, quality, url, subtitleTracks = subtitles)
+        }
+
+        return videoList
+    }
+
+    private fun bestQuality(videoInfo: VideoInfo): Int {
+        return when (videoInfo.player.lowercase()) {
+            "animelib" -> videoInfo.video?.quality?.maxBy { it.quality }?.quality ?: 0
+            "kodik" -> 720
+            else -> 0
+        }
+    }
+
+    // =============================== Converters ===============================
+    private fun convertStatus(status: Int): Int {
+        return when (status) {
+            1 -> SAnime.ONGOING
+            2 -> SAnime.COMPLETED
+            4 -> SAnime.ON_HIATUS
+            5 -> SAnime.CANCELLED
+            else -> {
+                SAnime.UNKNOWN
+            }
+        }
+    }
+
+    private fun AnimeData.toSAnime() = SAnime.create().apply {
+        url = href
+        title = rusName
+        thumbnail_url = cover.thumbnail
+        description = summary
+        status = convertStatus(animeStatus.id)
+        author = publisher?.joinToString { it.name }
+        artist = authors?.joinToString { it.name }
+    }
+
+    private fun EpisodeInfo.toSEpisode() = SEpisode.create().apply {
+        url = "$apiUrl/episodes/$id"
+        name = "Сезон $season Серия $number $episodeName"
+        episode_number = number.toFloat()
+        date_upload = dateFormatter.parse(date)?.time ?: 0L
+    }
+}
diff --git a/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/AnimelibDto.kt b/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/AnimelibDto.kt
new file mode 100644
index 000000000..4a960b421
--- /dev/null
+++ b/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/AnimelibDto.kt
@@ -0,0 +1,179 @@
+package eu.kanade.tachiyomi.animeextension.ru.animelib
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class AnimeStatus(
+    val id: Int,
+)
+
+@Serializable
+data class CoverInfo(
+    val thumbnail: String,
+)
+
+@Serializable
+data class GenreInfo(
+    val id: Int,
+    val name: String,
+)
+
+@Serializable
+data class PublisherInfo(
+    val id: Int,
+    val name: String,
+)
+
+@Serializable
+data class AuthorInfo(
+    val id: Int,
+    val name: String,
+)
+
+@Serializable
+data class AnimeData(
+    val id: Int,
+    @SerialName("rus_name") val rusName: String,
+    @SerialName("slug_url") val href: String,
+    @SerialName("status") val animeStatus: AnimeStatus,
+    val cover: CoverInfo,
+
+    // Optional
+    @SerialName("is_licensed") val licensed: Boolean? = null,
+    val summary: String? = null,
+    val genres: List<GenreInfo>? = null,
+    val publisher: List<PublisherInfo>? = null,
+    val authors: List<AuthorInfo>? = null,
+)
+
+@Serializable
+data class PageMetaData(
+    val next: String? = null,
+)
+
+@Serializable
+data class AnimeList(
+    val data: List<AnimeData>,
+    val links: PageMetaData? = null,
+)
+
+@Serializable
+data class AnimeInfo(
+    val data: AnimeData,
+)
+
+// ============================== Episode ==============================
+@Serializable
+data class TeamInfo(
+    val id: Int,
+    val name: String,
+)
+
+@Serializable
+data class VideoQuality(
+    val href: String,
+    val quality: Int,
+)
+
+@Serializable
+data class VideoMetaData(
+    val id: Int,
+    val quality: List<VideoQuality>,
+)
+
+@Serializable
+data class TranslationInfo(
+    val id: Int,
+)
+
+@Serializable
+data class SubtitleInfo(
+    val id: Int,
+    val format: String,
+    val src: String,
+)
+
+@Serializable
+data class VideoInfo(
+    val id: Int,
+    val player: String,
+    val team: TeamInfo,
+
+    @SerialName("translation_type") val translationInfo: TranslationInfo,
+
+    // Kodik player
+    val src: String? = null,
+
+    // Animelib player
+    val video: VideoMetaData? = null,
+    val subtitles: List<SubtitleInfo>? = null,
+)
+
+@Serializable
+data class EpisodeInfo(
+    val id: Int,
+    @SerialName("name") val episodeName: String,
+    val number: String,
+    val season: String,
+    @SerialName("created_at") val date: String,
+
+    // Optional
+    val players: List<VideoInfo>? = null,
+)
+
+@Serializable
+data class EpisodeVideoData(
+    val data: EpisodeInfo,
+)
+
+@Serializable
+data class EpisodeList(
+    val data: List<EpisodeInfo>,
+)
+
+// ============================== VideoServer ==============================
+@Serializable
+data class VideoServerInfo(
+    val id: String,
+    val label: String,
+    val url: String,
+)
+
+@Serializable
+data class VideoServers(
+    val videoServers: List<VideoServerInfo>,
+)
+
+@Serializable
+data class VideoServerData(
+    val data: VideoServers,
+)
+
+// ============================== Kodik ==============================
+@Serializable
+data class KodikForm(
+    val d: String = "",
+    @SerialName("d_sign") val dSign: String = "",
+    val pd: String = "",
+    @SerialName("pd_sign") val pdSign: String = "",
+    val ref: String = "",
+    @SerialName("ref_sign") val refSign: String = "",
+)
+
+@Serializable
+data class KodikVideoInfo(
+    val src: String,
+)
+
+@Serializable
+data class KodikVideoQuality(
+    @SerialName("480") val bad: List<KodikVideoInfo>,
+    @SerialName("720") val good: List<KodikVideoInfo>,
+    @SerialName("360") val ugly: List<KodikVideoInfo>,
+)
+
+@Serializable
+data class KodikData(
+    val links: KodikVideoQuality,
+)
diff --git a/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/AnimelibFilters.kt b/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/AnimelibFilters.kt
new file mode 100644
index 000000000..fa9cde121
--- /dev/null
+++ b/src/ru/animelib/src/eu/kanade/tachiyomi/animeextension/ru/animelib/AnimelibFilters.kt
@@ -0,0 +1,192 @@
+package eu.kanade.tachiyomi.animeextension.ru.animelib
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+
+object AnimelibFilters {
+
+    open class TriStateFilterList(name: String, values: List<AnimeFilter.TriState>) : AnimeFilter.Group<AnimeFilter.TriState>(name, values)
+    class TriFilterVal(name: String) : AnimeFilter.TriState(name)
+
+    class GenresFilter : TriStateFilterList("Жанр", AnimelibFiltersData.GENRES.map { TriFilterVal(it.first) })
+
+    private inline fun <reified R> AnimeFilterList.getFirst(): R = first { it is R } as R
+
+    private inline fun <reified R> AnimeFilterList.parseTriFilter(options: Array<Pair<String, String>>): IncludeExcludeParams {
+        return (getFirst<R>() as TriStateFilterList).state
+            .filterNot { it.isIgnored() }
+            .map { filter -> filter.state to options.find { it.first == filter.name }!!.second }
+            .groupBy { it.first }
+            .let { dict ->
+                val included = dict[AnimeFilter.TriState.STATE_INCLUDE]?.map { it.second }.orEmpty()
+                val excluded = dict[AnimeFilter.TriState.STATE_EXCLUDE]?.map { it.second }.orEmpty()
+                IncludeExcludeParams(included, excluded)
+            }
+    }
+
+    open class CheckBoxFilterList(name: String, values: List<CheckBox>) : AnimeFilter.Group<AnimeFilter.CheckBox>(name, values)
+    class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
+
+    class FormatFilter : CheckBoxFilterList("Формат", AnimelibFiltersData.FORMATS.map { CheckBoxVal(it.first) })
+    class PegiFilter : CheckBoxFilterList("Возрастной рейтинг", AnimelibFiltersData.PEGI.map { CheckBoxVal(it.first) })
+    class OngoingFilter : CheckBoxFilterList("Статус тайтла", AnimelibFiltersData.ONGOING_STATUS.map { CheckBoxVal(it.first) })
+
+    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 }
+            .toList()
+    }
+
+    class SortFilter : AnimeFilter.Sort(
+        "Сортировать по",
+        AnimelibFiltersData.ORDERS.map { it.first }.toTypedArray(),
+        Selection(0, false),
+    )
+
+    val FILTER_LIST get() = AnimeFilterList(
+        GenresFilter(),
+
+        PegiFilter(),
+        FormatFilter(),
+        OngoingFilter(),
+
+        SortFilter(),
+    )
+
+    data class IncludeExcludeParams(
+        val include: List<String> = emptyList(),
+        var exclude: List<String> = emptyList(),
+    )
+
+    data class FilterSearchParams(
+        val genres: IncludeExcludeParams = IncludeExcludeParams(),
+        val format: List<String> = emptyList(),
+        val pegi: List<String> = emptyList(),
+        val ongoingStatus: List<String> = emptyList(),
+
+        val sortOrder: String = AnimelibFiltersData.ORDERS[0].second,
+        val sortDirection: String = "",
+    )
+
+    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
+        if (filters.isEmpty()) return FilterSearchParams()
+
+        val sortDirection = filters.getFirst<SortFilter>().state?.let {
+            if (it.ascending) "asc" else ""
+        } ?: ""
+
+        val sortOrder = filters.getFirst<SortFilter>().state?.let {
+            AnimelibFiltersData.ORDERS[it.index].second
+        } ?: ""
+
+        return FilterSearchParams(
+            filters.parseTriFilter<GenresFilter>(AnimelibFiltersData.GENRES),
+            filters.parseCheckbox<FormatFilter>(AnimelibFiltersData.FORMATS),
+            filters.parseCheckbox<PegiFilter>(AnimelibFiltersData.PEGI),
+            filters.parseCheckbox<OngoingFilter>(AnimelibFiltersData.ONGOING_STATUS),
+            sortOrder,
+            sortDirection,
+        )
+    }
+
+    private object AnimelibFiltersData {
+        val FORMATS = arrayOf(
+            Pair("TV сериалы", "16"),
+            Pair("Фильмы", "17"),
+            Pair("Короткометражное", "18"),
+            Pair("Спешл", "19"),
+            Pair("OVA", "20"),
+            Pair("ONA", "21"),
+            Pair("Клип", "22"),
+        )
+
+        val GENRES = arrayOf(
+            Pair("Арт", "32"),
+            Pair("Безумие", "91"),
+            Pair("Боевик", "34"),
+            Pair("Боевые искусства", "35"),
+            Pair("Вампиры", "36"),
+            Pair("Военное", "89"),
+            Pair("Гарем", "37"),
+            Pair("Гендерная интрига", "38"),
+            Pair("Героическое фэнтези", "39"),
+            Pair("Демоны", "81"),
+            Pair("Детектив", "40"),
+            Pair("Детское", "88"),
+            Pair("Дзёсэй", "41"),
+            Pair("Драма", "43"),
+            Pair("Игра", "44"),
+            Pair("Исекай", "79"),
+            Pair("История", "45"),
+            Pair("Киберпанк", "46"),
+            Pair("Кодомо", "76"),
+            Pair("Комедия", "47"),
+            Pair("Космос", "83"),
+            Pair("Магия", "85"),
+            Pair("Махо-сёдзё", "48"),
+            Pair("Машины", "90"),
+            Pair("Меха", "49"),
+            Pair("Мистика", "50"),
+            Pair("Музыка", "80"),
+            Pair("Научная фантастика", "51"),
+            Pair("Омегаверс", "77"),
+            Pair("Пародия", "86"),
+            Pair("Повседневность", "52"),
+            Pair("Полиция", "82"),
+            Pair("Постапокалиптика", "53"),
+            Pair("Приключения", "54"),
+            Pair("Психология", "55"),
+            Pair("Романтика", "56"),
+            Pair("Самурайский боевик", "57"),
+            Pair("Сверхъестественное", "58"),
+            Pair("Сёдзё", "59"),
+            Pair("Сёдзё-ай", "60"),
+            Pair("Сёнэн", "61"),
+            Pair("Сёнэн-ай", "62"),
+            Pair("Спорт", "63"),
+            Pair("Супер сила", "87"),
+            Pair("Сэйнэн", "64"),
+            Pair("Трагедия", "65"),
+            Pair("Триллер", "66"),
+            Pair("Ужасы", "67"),
+            Pair("Фантастика", "68"),
+            Pair("Фэнтези", "69"),
+            Pair("Хентай", "84"),
+            Pair("Школа", "70"),
+            Pair("Эротика", "71"),
+            Pair("Этти", "72"),
+            Pair("Юри", "73"),
+            Pair("Яой", "74"),
+        )
+
+        val PEGI = arrayOf(
+            Pair("Нет", "0"),
+            Pair("6+", "1"),
+            Pair("12+", "2"),
+            Pair("16+", "3"),
+            Pair("18+", "4"),
+            Pair("18+ (RX)", "5"),
+        )
+
+        val ONGOING_STATUS = arrayOf(
+            Pair("Онгоинг", "1"),
+            Pair("Завершён", "2"),
+            Pair("Анонс", "3"),
+            Pair("Приостановлен", "4"),
+            Pair("Выпуск прекращён", "5"),
+        )
+
+        val ORDERS = arrayOf(
+            Pair("Популярности", "rating_score"),
+            Pair("Рейтингу", "rate_avg"),
+            Pair("Просмотрам", "views"),
+            Pair("Количеству эпизодов", "episodes_count"),
+            Pair("Дате обновления", "last_episode_at"),
+            Pair("Дате добавления", "created_at"),
+            Pair("Названию (A-Z)", "name"),
+            Pair("Названию (А-Я)", "rus_name"),
+        )
+    }
+}