diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 0000000..5bb86c7
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,57 @@
+name: Gradle CI
+
+on:
+  push:
+    branches:
+      - '**'
+    paths-ignore:
+      - 'README.md'
+      - 'LICENSE'
+      - '.gitignore'
+  pull_request:
+    branches:
+      - '**'
+    paths-ignore:
+      - 'README.md'
+      - 'LICENSE'
+      - '.gitignore'
+  workflow_dispatch:
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, windows-latest ]
+    runs-on: ${{ matrix.os }}
+    name: Build with gradle
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Set up Java 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: 17
+          distribution: temurin
+      - name: Set up Java 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: 21
+          distribution: temurin
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+            ./.gradle/loom-cache
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Grant execute permission for gradlew
+        if: ${{ runner.os != 'Windows' }}
+        run: chmod +x ./gradlew
+      - name: Build with Gradle
+        run: ./gradlew build --no-daemon
+      - uses: actions/upload-artifact@v4
+        with:
+          name: artifact-${{ matrix.os }}
+          path: |
+            **/build/libs/
\ No newline at end of file
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 0000000..e17c074
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,44 @@
+name: Publish Release
+
+on:
+  push:
+    branches:
+      - '*/prod'
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Publish with gradle
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Set up Java 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: 17
+          distribution: temurin
+      - name: Set up Java 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: 21
+          distribution: temurin
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+            ./.gradle/loom-cache
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+      - name: Publish
+        run: ./gradlew publish publishMods
+        env:
+          CURSEFORGE_TOKEN: ${{secrets.CURSEFORGE}}
+          MODRINTH_TOKEN: ${{secrets.MODRINTH}}
+          GH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+          DISCORD_WEBHOOK: ${{secrets.DISCORD_WEBHOOK}}
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..77f4cee
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,44 @@
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+run
+logs
+
+### IntelliJ IDEA ###
+.idea/
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Kotlin ###
+.kotlin
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..66ed69a
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,7 @@
+# Beta 1.2
+
+## What’s New
+- **Supports Minecraft 1.20.1 → 1.21.8**
+- **Works on NeoForge and Fabric** (Forge coming later)
+- **Rewritten in Kotlin** for smoother performance and fewer bugs
+- **Built‑in widget system** for better stability without extra libraries 
\ No newline at end of file
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..f51db25
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 CalculatorsTeam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..54fb894
--- /dev/null
+++ b/README.md
@@ -0,0 +1,63 @@
+# DynamicPack
+A mod that will monitor the current version of your resource pack and download automatically!
+
+![https://img.shields.io/badge/Enviroment-Client-purple](https://img.shields.io/badge/Enviroment-Client-purple)  
+[![Static Badge](https://img.shields.io/badge/Github-gray?logo=github)
+](https://github.com/CalculatorsTeam/DynamicPack)
+
+[![Java CI with Gradle](https://github.com/CalculatorsTeamAdamCalculator/DynamicPack/actions/workflows/gradle.yml/badge.svg)](https://github.com/AdamCalculator/DynamicPack/actions/workflows/gradle.yml)
+
+[![Banner](https://api.mcbanners.com/banner/saved/wveMrFfPsqwXbV.png)](https://modrinth.com/mod/dynamicpack)
+
+## Documentation
+[**Available here**](https://github.com/CalculatorsTeam/DynamicPack/wiki)
+
+## Packs using it mod
+* [Better Tables](https://modrinth.com/resourcepack/bettertables)
+* [CursedEveryday (github)](https://github.com/AdamCalculator/CursedEveryday/releases/tag/day4)
+* [ModsRU](https://modrinth.com/resourcepack/mods-ru)
+* [zelda-music](https://modrinth.com/resourcepack/zelda-music)
+* [PawTotems (smp) (github)](https://github.com/1NFERR/PawTotems/)
+* [SPPack (smp) (github)](https://github.com/aladairmaxwell/SP)
+* [Essentially Tweaked](https://modrinth.com/resourcepack/essentially-tweaked)
+* [Vanilla Leaves](https://modrinth.com/resourcepack/vanilla-leaves)
+
+## Plans
+The mod is planned to support **any bootloader** and any version, but I don't have enough time right now. **I'm always happy to see new contributors!**
+
+## How it works
+Resource pack developers need to create a `dynamicmcpack.json` file inside the resource pack, which will save some information, and the mod will update when the game starts if resource pack files are required.
+
+## For users
+Install and it will automatically update supported resource packs.
+
+⚠️ Since the mod is being actively developed, it is not yet possible to check resource packs for updates, but this will be added in the future.
+
+
+## For developers
+If you want your package to update itself from **Modrinth**, you need to add the `dynamicmcpack.json` file to the following content:
+```json5
+{
+    "current": {
+      "version_number": "7.1" // version of the current pack
+    },
+    "remote": {
+      "game_version": "1.21.1", // game version
+      "modrinth_project_id": "better-leaves", // your project identifier
+      "type": "modrinth"
+    },
+    "formatVersion": 1
+}
+```
+**⚠️⚠️⚠️ JSON Specification not support //comments! Delete it before use.**
+
+You can validate your JSON [here](https://jsonformatter.curiousconcept.com/#)
+
+
+For other features (dynamic repos) visit [github wiki!](https://github.com/CalculatorsTeam/DynamicPack/wiki)
+
+
+## Donate
+The project is completely free and open under the MIT licence. You can help original author by donating ❤️
+
+**Bitcoin:** `bc1qpc0q9ym7rnfatdh43c4jyf68znj8x2jae5j4cz`
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 0000000..7bf9fdd
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,289 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import java.util.Locale
+
+plugins {
+    id("dev.kikugie.stonecutter")
+    id("dev.isxander.modstitch.base")
+    id("dev.isxander.modstitch.publishing")
+    kotlin("jvm")
+    `maven-publish`
+}
+
+// ========== Versions & Project Info ==========
+val mcVersion: String by project
+val versionWithoutMC = property("modVersion")!!.toString()
+
+val isDev = resolveProp("isDev")
+val isAlpha = "-a" in versionWithoutMC
+val isBeta = "-b" in versionWithoutMC
+
+val isFabric = modstitch.isLoom
+val isNeoforge = modstitch.isModDevGradleRegular
+val isForge = modstitch.isModDevGradleLegacy
+val isForgeLike = modstitch.isModDevGradle
+
+val loader = when {
+    isFabric -> "fabric"
+    isNeoforge -> "neoforge"
+    isForge -> "forge"
+    else -> error("Unknown loader")
+}
+
+val javaTargetVersion = if (stonecutter.eval(mcVersion, ">1.20.4")) 21 else 17
+val resolvedModId = resolveProp("modId") ?: error("modId is required")
+val gitHash = gitHash()
+
+// ========== ModStitch Setup ==========
+modstitch {
+    minecraftVersion = mcVersion
+    javaVersion = javaTargetVersion
+
+    if (!isForge) {
+        unitTesting()
+    }
+
+    kotlin {
+        jvmToolchain(javaVersion.get())
+        compilerOptions.jvmTarget.set(JvmTarget.fromTarget(javaVersion.get().toString()))
+    }
+
+    parchment {
+        mappingsVersion = resolveProp("parchment.version")
+        minecraftVersion = resolveProp("parchment.minecraft")
+    }
+
+    metadata {
+        modId = resolvedModId
+        modName = resolveProp("modName")
+        modVersion = "$versionWithoutMC${if (isAlpha || isBeta) "." else "+"}${stonecutter.current.project}${if (isDev?.lowercase(Locale.getDefault()) == "true" || isDev == "1") "-DEV-$gitHash" else ""}"
+        modGroup = resolveProp("modGroup")
+        modDescription = resolveProp("modDescription")
+        modLicense = resolveProp("modLicense")
+        modAuthor = resolveProp("modAuthor")
+
+        replacementProperties.put(
+            "pack_format", when (mcVersion) {
+                "1.19.2" -> 9
+                "1.20.1" -> 15
+                "1.21.1" -> 34
+                "1.21.3" -> 57
+                "1.21.4" -> 61
+                "1.21.5" -> 71
+                "1.21.8" -> 81
+                else -> throw IllegalArgumentException("Please store the resource pack version for $mcVersion in build.gradle.kts! https://minecraft.wiki/w/Pack_format")
+            }.toString()
+        )
+
+        replacementProperties.put("gitHead", gitHash)
+
+        // replacementProperties DSL
+        fun setReplace(key: String, property: String) {
+            resolveProp(property)?.let { replacementProperties.put(key, it) }
+        }
+
+        setReplace("github", "githubProject")
+        setReplace("mc", "meta.mcDep")
+        setReplace("fabricLoader", "deps.fabricLoader")
+        setReplace("fabricLangKotlin", "deps.fabricLangKotlin")
+        setReplace("fapi", "deps.fabricApi")
+    }
+
+    loom {
+        resolveProp("deps.fabricLoader")?.let { fabricLoaderVersion = it }
+    }
+
+    moddevgradle {
+        resolveProp("deps.neoforge")?.let { neoForgeVersion = it }
+        resolveProp("deps.forge")?.let { forgeVersion = it }
+        defaultRuns()
+
+        configureNeoForge {
+            runs.all {
+                jvmArguments.add("-Dmixin.debug.export=true")
+            }
+        }
+
+        modstitch.onEnable {
+            tasks.named("createMinecraftArtifacts") {
+                dependsOn("stonecutterGenerate")
+            }
+        }
+    }
+
+    mixin {
+        addMixinsToModManifest = true
+        configs.register(resolvedModId)
+    }
+}
+
+// ========== Stonecutter ==========
+stonecutter {
+    constants {
+        put("fabric", isFabric)
+        put("neoforge", isNeoforge)
+        put("forge", isForge)
+        put("forgelike", isForgeLike)
+    }
+
+    dependencies {
+        put("fapi", resolveProp("deps.fabricApi") ?: "0.0.0")
+    }
+}
+
+// ========== Dependencies ==========
+dependencies {
+    if (isFabric) {
+        modstitchModImplementation("net.fabricmc.fabric-api:fabric-api:${resolveProp("deps.fabricApi")}")
+        modstitchModImplementation("net.fabricmc:fabric-language-kotlin:${resolveProp("deps.fabricLangKotlin")}")
+
+        modstitchModImplementation("com.terraformersmc:modmenu:${resolveProp("deps.modmenu")}")
+    }
+
+    if (isNeoforge) {
+        modstitchModRuntimeOnly("thedarkcolour:kotlinforforge-neoforge:${resolveProp("deps.kotlinForForge")}")
+    }
+
+    if (isForge) {
+        modstitchModRuntimeOnly("thedarkcolour:kotlinforforge:${resolveProp("deps.kotlinForForge")}")
+        compileOnly("org.jetbrains:annotations:20.1.0")
+    }
+
+    modstitchModApi("dev.isxander:yet-another-config-lib:${resolveProp("deps.yacl")}") {
+        exclude(group = "thedarkcolour")
+    }
+}
+
+msPublishing {
+    maven {
+        repositories {
+            mavenLocal()
+        }
+    }
+
+    fun versionList(prop: String) = findProperty(prop)?.toString()
+        ?.split(',')
+        ?.map { it.trim() }
+        ?: emptyList()
+
+    val stableMCVersions = versionList("pub.stableMC")
+
+    mpp {
+        displayName.set("$versionWithoutMC for $loader $mcVersion")
+
+        changelog.set(
+            file("CHANGELOG.md")
+                .takeIf { it.exists() }
+                ?.readText()
+        )
+
+        type = when {
+            isAlpha -> ALPHA
+            isBeta -> BETA
+            else -> STABLE
+        }
+
+        modLoaders.add(loader)
+
+        val modrinthId: String by project
+        if (modrinthId.isNotBlank() && hasProperty("MODRINTH_TOKEN")) {
+            modrinth {
+                projectId.set(modrinthId)
+                accessToken.set(findProperty("MODRINTH_TOKEN")?.toString())
+                minecraftVersions.addAll(stableMCVersions)
+                minecraftVersions.addAll(versionList("pub.modrinthMC"))
+
+                if (isFabric) {
+                    requires { slug.set("fabric-language-kotlin") }
+                }
+                if (isForgeLike) {
+                    requires { slug.set("kotlin-for-forge") }
+                }
+                optional { slug.set("yacl") }
+            }
+        }
+
+        val curseforgeId: String by project
+        if (curseforgeId.isNotBlank() && hasProperty("CURSEFORGE_TOKEN")) {
+            curseforge {
+                projectId = curseforgeId
+                projectSlug = findProperty("curseforgeSlug")?.toString() ?: error("curseforgeSlug property not found")
+                accessToken = findProperty("CURSEFORGE_TOKEN")?.toString()
+                minecraftVersions.addAll(stableMCVersions)
+                minecraftVersions.addAll(versionList("pub.curseMC"))
+
+                if (isFabric) {
+                    requires { slug.set("fabric-language-kotlin") }
+                }
+                if (isForgeLike) {
+                    requires { slug.set("kotlin-for-forge") }
+                }
+                optional { slug.set("yacl") }
+            }
+        }
+
+        val githubProject: String by project
+        if (githubProject.isNotBlank() && hasProperty("GH_TOKEN")) {
+            github {
+                repository.set(githubProject)
+                accessToken.set(findProperty("GH_TOKEN")?.toString())
+                commitish.set(gitBranch())
+            }
+        }
+
+        if (hasProperty("DISCORD_WEBHOOK")) {
+            discord {
+                username.set("DynamicPack Updates")
+                webhookUrl.set(findProperty("DISCORD_WEBHOOK")?.toString())
+                content.set(changelog)
+            }
+        }
+
+        dryRun = true
+    }
+}
+
+// ========== Tasks ==========
+tasks {
+    withType<KotlinCompile>().configureEach {
+        compilerOptions {
+            jvmTarget = modstitch.javaVersion.map { JvmTarget.fromTarget(it.toString()) }
+        }
+        dependsOn("stonecutterGenerate")
+    }
+
+    named("generateModMetadata") {
+        dependsOn("stonecutterGenerate")
+    }
+
+    if (isForge) {
+        named<Test>("test") {
+            enabled = false
+        }
+    }
+}
+
+// ========== Helpers ==========
+fun resolveProp(property: String): String? =
+    System.getenv(property)?.takeIf { it.isNotBlank() }
+        ?: findProperty(property)?.toString()?.takeIf { it.isNotBlank() }
+
+fun gitHash(): String {
+    val process = ProcessBuilder("git", "rev-parse", "--short", "HEAD")
+        .redirectErrorStream(true) // combine stdout + stderr
+        .start()
+
+    val text = process.inputStream.bufferedReader().use { it.readText() }
+
+    return text.trim()
+}
+
+fun gitBranch(): String {
+    val process = ProcessBuilder("git", "rev-parse", "--abbrev-ref", "HEAD")
+        .redirectErrorStream(true) // объединяем stdout и stderr
+        .start()
+
+    val text = process.inputStream.bufferedReader().use { it.readText() }
+
+    return text.trim()
+}
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..e8eac9f
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,19 @@
+isDev=false
+modId=dynamicpack
+modName=DynamicPack
+modDescription=Adds auto-update support for resource packs
+modLicense=MIT
+modAuthor=AdamCalculator, Riflusso
+modGroup=com.calculatorsteam
+modVersion=1.2-b
+
+modrinthId=IT6fZgjc
+curseforgeSlug=dynamicpack
+curseforgeId=1356312
+githubProject=CalculatorsTeam/DynamicPack
+
+deps.fabricLoader=0.17.2
+deps.fabricLangKotlin=1.13.6+kotlin.2.2.20
+
+org.gradle.jvmargs=-Xmx4G
+org.gradle.parallel=true
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..1b33c55
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..2e11132
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.1.0-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000..23d15a9
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH="\\\"\\\""
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..db3a6ac
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/modstitch.accesswidener b/modstitch.accesswidener
new file mode 100644
index 0000000..cf997b3
--- /dev/null
+++ b/modstitch.accesswidener
@@ -0,0 +1,3 @@
+accessWidener	v1	named
+accessible method net/minecraft/client/gui/components/AbstractSelectionList getRowTop (I)I
+accessible class net/minecraft/server/packs/FilePackResources$SharedZipFileAccess
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 0000000..288a065
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,35 @@
+pluginManagement {
+    repositories {
+        mavenCentral()
+        gradlePluginPortal()
+        maven("https://maven.fabricmc.net/")
+        maven("https://maven.architectury.dev")
+        maven("https://maven.neoforged.net/releases/")
+        maven("https://maven.minecraftforge.net/")
+        maven("https://maven.kikugie.dev/releases")
+        maven("https://maven.kikugie.dev/snapshots")
+        maven("https://maven.isxander.dev/releases")
+    }
+}
+
+plugins {
+    id("dev.kikugie.stonecutter") version "0.7.10"
+}
+
+stonecutter {
+    kotlinController = true
+    centralScript = "build.gradle.kts"
+
+    create(rootProject) {
+        fun mc(mcVersion: String, name: String = mcVersion, loaders: Iterable<String>) =
+            loaders.forEach { version("$name-$it", mcVersion) }
+
+        mc("1.20.1", loaders = listOf("fabric"))
+        mc("1.21.1", loaders = listOf("fabric", "neoforge"))
+        mc("1.21.3", loaders = listOf("fabric", "neoforge"))
+        mc("1.21.4", loaders = listOf("fabric", "neoforge"))
+        mc("1.21.5", loaders = listOf("fabric", "neoforge"))
+        mc("1.21.8", loaders = listOf("fabric", "neoforge"))
+    }
+}
+rootProject.name = "DynamicPack"
\ No newline at end of file
diff --git a/src/main/java/com/calculatorsteam/dynamicpack/accessor/FilePackResourcesAccessor.java b/src/main/java/com/calculatorsteam/dynamicpack/accessor/FilePackResourcesAccessor.java
new file mode 100644
index 0000000..b34202c
--- /dev/null
+++ b/src/main/java/com/calculatorsteam/dynamicpack/accessor/FilePackResourcesAccessor.java
@@ -0,0 +1,9 @@
+package com.calculatorsteam.dynamicpack.accessor;
+
+import java.io.File;
+
+public interface FilePackResourcesAccessor {
+    boolean dynamicpack$isClosed();
+    File dynamicpack$getFile();
+    void dynamicpack$close();
+}
\ No newline at end of file
diff --git a/src/main/java/com/calculatorsteam/dynamicpack/mixins/FilePackResourcesMixin.java b/src/main/java/com/calculatorsteam/dynamicpack/mixins/FilePackResourcesMixin.java
new file mode 100644
index 0000000..7676b35
--- /dev/null
+++ b/src/main/java/com/calculatorsteam/dynamicpack/mixins/FilePackResourcesMixin.java
@@ -0,0 +1,58 @@
+package com.calculatorsteam.dynamicpack.mixins;
+
+import com.calculatorsteam.dynamicpack.accessor.FilePackResourcesAccessor;
+import com.calculatorsteam.dynamicpack.util.LockUtils;
+import net.minecraft.server.packs.FilePackResources;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.io.File;
+import java.util.zip.ZipFile;
+
+@Mixin(FilePackResources./*? if >=1.21 {*/SharedZipFileAccess./*?}*/class)
+public abstract class FilePackResourcesMixin implements FilePackResourcesAccessor {
+
+    @Unique private boolean dynamicpack$opened;
+
+    @Shadow public abstract void close();
+
+    @Shadow @Final
+    //? if < 1.21
+    /*private*/
+    File file;
+
+    @Inject(at = @At("RETURN"), method = "getOrCreateZipFile")
+    public void dynamicpack$return$getOrCreateZipFile(CallbackInfoReturnable<ZipFile> cir) {
+        ZipFile ret = cir.getReturnValue();
+        if (ret != null) {
+            dynamicpack$opened = true; // теперь действительно открыт
+            LockUtils.addFileToOpened(this);
+        }
+    }
+
+    @Inject(at = @At("RETURN"), method = "close")
+    public void dynamicpack$return$close(CallbackInfo ci) {
+        dynamicpack$opened = false;
+    }
+
+    @Override
+    public boolean dynamicpack$isClosed() {
+        return !dynamicpack$opened;
+    }
+
+    @Override
+    public File dynamicpack$getFile() {
+        return file;
+    }
+
+    @Override
+    public void dynamicpack$close() {
+        close();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/calculatorsteam/dynamicpack/mixins/MinecraftClientMixin.java b/src/main/java/com/calculatorsteam/dynamicpack/mixins/MinecraftClientMixin.java
new file mode 100644
index 0000000..05f3923
--- /dev/null
+++ b/src/main/java/com/calculatorsteam/dynamicpack/mixins/MinecraftClientMixin.java
@@ -0,0 +1,18 @@
+package com.calculatorsteam.dynamicpack.mixins;
+
+import com.calculatorsteam.dynamicpack.client.PackMixinHelper;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.main.GameConfig;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+
+@Mixin(Minecraft.class)
+public abstract class MinecraftClientMixin {
+    @Inject(at = @At("RETURN"), method = "<init>")
+    private void dynamicpack$initCheck(GameConfig args, CallbackInfo ci) {
+        PackMixinHelper.minecraftInitReturned();
+    }
+}
diff --git a/src/main/java/com/calculatorsteam/dynamicpack/mixins/PackRepositoryMixin.java b/src/main/java/com/calculatorsteam/dynamicpack/mixins/PackRepositoryMixin.java
new file mode 100644
index 0000000..957b5c2
--- /dev/null
+++ b/src/main/java/com/calculatorsteam/dynamicpack/mixins/PackRepositoryMixin.java
@@ -0,0 +1,61 @@
+package com.calculatorsteam.dynamicpack.mixins;
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod;
+import com.calculatorsteam.dynamicpack.client.GameStartSyncing;
+import com.calculatorsteam.dynamicpack.platform.VersionFunctions;
+import com.calculatorsteam.dynamicpack.util.log.Out;
+import com.mojang.blaze3d.systems.RenderSystem;
+import net.minecraft.client.Minecraft;
+import net.minecraft.server.packs.repository.PackRepository;
+import org.lwjgl.glfw.GLFW;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(PackRepository.class)
+public class PackRepositoryMixin {
+
+    /**
+     * For freeze resource pack loading (only in game starting) until DynamicPack update it
+     */
+    @Inject(at = @At("HEAD"), method = "reload")
+    private void dynamicpack$reload(CallbackInfo ci) {
+        // do nothing if minecraft initialized
+        if (DynamicPackMod.getInstance().isMinecraftInitialized()) {
+            return;
+        }
+
+        Minecraft client = Minecraft.getInstance();
+        GameStartSyncing syncing = DynamicPackMod.getGameStartSyncing();
+        if (!syncing.isLockSupported()) {
+            return;
+        }
+
+        if (syncing.getLockResourcesLoading()) {
+            syncing.startGameLocking();
+            while (!client.getWindow().shouldClose() && syncing.getLockResourcesLoading()) {
+                if (!syncing.lockedTick()) {
+                    break;
+                }
+
+                try {
+                    VersionFunctions.applyModelViewMatrix();
+                    VersionFunctions.clearColor(0.074f + (((float)syncing.getPercentage() / 100f)), 0.04f, (float) (0.24f + (Math.sin(System.currentTimeMillis() / 300f) / 2)), 1f);
+                    VersionFunctions.clear(16640);
+                    GLFW.glfwSwapBuffers(client.getWindow().getWindow());
+
+                } catch (Exception e) {
+                    Out.error("Error while manipulations with OpenGL", e);
+                }
+
+                try {
+                    Thread.sleep(50);
+                } catch (InterruptedException ignored) {
+                }
+            }
+            syncing.endGameLocking();
+        }
+    }
+}
+
diff --git a/src/main/java/com/calculatorsteam/dynamicpack/mixins/ResourcePackEntryMixin.java b/src/main/java/com/calculatorsteam/dynamicpack/mixins/ResourcePackEntryMixin.java
new file mode 100644
index 0000000..8cde469
--- /dev/null
+++ b/src/main/java/com/calculatorsteam/dynamicpack/mixins/ResourcePackEntryMixin.java
@@ -0,0 +1,96 @@
+package com.calculatorsteam.dynamicpack.mixins;
+
+import com.calculatorsteam.dynamicpack.client.gui.widget.DynamicPackResourcePackEntryWidget;
+import com.calculatorsteam.dynamicpack.client.gui.widget.ResourcePackEntryWidget;
+import com.calculatorsteam.dynamicpack.platform.VersionFunctions;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.packs.TransferableSelectionList;
+import net.minecraft.client.gui.screens.packs.PackSelectionModel;
+import net.minecraft.resources.ResourceLocation;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(TransferableSelectionList.PackEntry.class)
+public abstract class ResourcePackEntryMixin {
+
+    @Shadow
+    protected abstract boolean showHoverOverlay();
+
+    @Shadow
+    @Final
+    private PackSelectionModel.Entry pack;
+    @Shadow
+    @Final
+    private TransferableSelectionList parent;
+
+    @Unique
+    int dynamicpack$selected = -1;
+    @Unique
+    private Boolean fold;
+    @Unique
+    int dynamicpack$foldTicks = 0;
+    @Unique
+    private static final int maxFoldTicks = 10;
+    @Unique
+    private static final ResourcePackEntryWidget DYNAMIC_WIDGET = new DynamicPackResourcePackEntryWidget();
+
+    @Inject(at = @At("TAIL"),
+            method = "render(Lnet/minecraft/client/gui/GuiGraphics;IIIIIIIZF)V")
+    private void render(GuiGraphics context, int index, int y, int x, int entryWidth, int entryHeight,
+                        int mouseX, int mouseY, boolean hovered, float tickDelta, CallbackInfo info) {
+        int prevMargin = 0;
+        /*? if >=1.21 {*/
+        int deltaX = 3 + (VersionFunctions.maxScrollAmount(parent) > 0 ? 7 : 0);
+        /*?} else {*/
+        /*int deltaX = 8 + (parent.getMaxScroll() > 0 ? 7 : 0);
+        *//*?}*/
+        boolean selectable = showHoverOverlay();
+        dynamicpack$selected = -1;
+        if (dynamicpack$foldTicks == maxFoldTicks) {
+            /*? if >=1.21 {*/
+            VersionFunctions.blitSprite(context, ResourceLocation.withDefaultNamespace("transferable_list/unselect"),
+                    x + entryWidth - 16 - deltaX, y + entryWidth / 20 - 16, 16, 32);
+            /*?} else {*/
+            /*context.blit(new ResourceLocation("textures/gui/resource_packs.png"),
+                    x + entryWidth - 16 - deltaX, y + entryWidth / 20 - 16, 32.0F, 0.0F, 16, 32, 256, 256);
+            *//*?}*/
+        } else {
+            ResourcePackEntryWidget widget = DYNAMIC_WIDGET;
+            if (widget.isVisible(pack, selectable)) {
+                deltaX += Math.max(prevMargin, widget.getXMargin(pack));
+                int width = widget.getWidth(pack);
+                int height = widget.getHeight(pack, entryHeight);
+                int entryX = x + entryWidth - (deltaX + width) * (maxFoldTicks - dynamicpack$foldTicks) / maxFoldTicks;
+                int entryY = y + widget.getY(pack, entryHeight);
+                deltaX += width;
+                boolean widgetHovered = mouseX <= entryX + width && mouseX >= entryX &&
+                        mouseY <= entryY + height && mouseY >= entryY;
+                widget.render(pack, context, entryX, entryY, widgetHovered, tickDelta);
+                if (widgetHovered) dynamicpack$selected = 0; // фиксированный индекс
+                prevMargin = widget.getXMargin(pack);
+            }
+        }
+        if (fold == null) fold = deltaX > 48;
+        if (!fold) return;
+        int mouseRange = Math.max(10, deltaX) + 40;
+        if (mouseX >= x + entryWidth - mouseRange && mouseX <= x + entryWidth &&
+                mouseY <= y + entryHeight && mouseY >= y)
+            dynamicpack$foldTicks = Math.max(dynamicpack$foldTicks - 1, 0);
+        else
+            dynamicpack$foldTicks = Math.min(dynamicpack$foldTicks + 1, maxFoldTicks);
+    }
+
+    @Inject(method = "mouseClicked(DDI)Z", at = @At("RETURN"), cancellable = true)
+    private void dynamicpack$afterMouseClicked(double mouseX, double mouseY, int button, CallbackInfoReturnable<Boolean> cir) {
+        if (dynamicpack$selected != -1) {
+            cir.setReturnValue(false);
+            DYNAMIC_WIDGET.onClick(pack);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/calculatorsteam/dynamicpack/mixins/ResourcePackScreenMixin.java b/src/main/java/com/calculatorsteam/dynamicpack/mixins/ResourcePackScreenMixin.java
new file mode 100644
index 0000000..2f0f7c4
--- /dev/null
+++ b/src/main/java/com/calculatorsteam/dynamicpack/mixins/ResourcePackScreenMixin.java
@@ -0,0 +1,20 @@
+package com.calculatorsteam.dynamicpack.mixins;
+
+import com.calculatorsteam.dynamicpack.client.PackMixinHelper;
+import net.minecraft.client.gui.screens.packs.PackSelectionScreen;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(PackSelectionScreen.class)
+public class ResourcePackScreenMixin {
+    /**
+     * For auto-rescan packs
+     */
+    @Inject(at = @At("RETURN"), method = "populateLists")
+    private void dynamicpack$updatePackLists(CallbackInfo ci) {
+        PackMixinHelper.updatePacksMinecraftRequest();
+    }
+}
+
diff --git a/src/main/java/com/calculatorsteam/dynamicpack/mixins/TitleScreenMixin.java b/src/main/java/com/calculatorsteam/dynamicpack/mixins/TitleScreenMixin.java
new file mode 100644
index 0000000..7a39d15
--- /dev/null
+++ b/src/main/java/com/calculatorsteam/dynamicpack/mixins/TitleScreenMixin.java
@@ -0,0 +1,25 @@
+package com.calculatorsteam.dynamicpack.mixins;
+
+import com.calculatorsteam.dynamicpack.Constants;
+import net.minecraft.ChatFormatting;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.TitleScreen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.util.Mth;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(TitleScreen.class)
+public class TitleScreenMixin {
+    @Inject(at = @At("TAIL"), method = "render")
+    public void dynamicpack$render(GuiGraphics guiGraphics, int i, int j, float f, CallbackInfo ci) {
+        if (Constants.DEBUG) {
+            int k = Mth.ceil(Math.abs(Math.sin(((double) System.currentTimeMillis()) / 350d)) * 255.0f) << 24;
+            guiGraphics.drawString(Minecraft.getInstance().font, Component.literal("DynamicPack mod is DEBUG").withStyle(ChatFormatting.BOLD).append(Component.literal(" use a release version for stable behavior").withStyle(ChatFormatting.YELLOW)), 2, guiGraphics.guiHeight() - 20, 0xFF2222 | k);
+        }
+    }
+}
+
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/Constants.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/Constants.kt
new file mode 100644
index 0000000..3d5fe84
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/Constants.kt
@@ -0,0 +1,163 @@
+package com.calculatorsteam.dynamicpack
+
+import com.calculatorsteam.dynamicpack.util.log.Out
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import java.io.IOException
+import java.net.URI
+import java.net.URISyntaxException
+
+object Constants {
+    // DISABLE ALL DEBUG IN OFFICIAL RELEASES
+    const val DEBUG: Boolean = false // Don't forget to disable in release
+    const val DEBUG_ALLOW_UNSECURE: Boolean = false
+    @JvmField var DEBUG_LOGS: Boolean = false
+
+    const val VERSION_BUILD: Long = 50
+    const val VERSION_NAME_MOD: String = "1.2"
+    /*? if >=1.21.6 {*/
+    const val VERSION_NAME_BRANCH: String = "mc1.21.8"
+    /*?} else if >=1.21.5 {*/
+    /*const val VERSION_NAME_BRANCH: String = "mc1.21.5"
+    *//*?} else if >=1.21.4 {*/
+    /*const val VERSION_NAME_BRANCH: String = "mc1.21.4"
+    *//*?} else if >=1.21.2 {*/
+    /*const val VERSION_NAME_BRANCH: String = "mc1.21.3"
+    *//*?} else if >=1.21 {*/
+    /*const val VERSION_NAME_BRANCH: String = "mc1.21.1"
+    *//*?} else if >=1.20 {*/
+    /*const val VERSION_NAME_BRANCH: String = "mc1.20.1"
+    *//*?}*/
+    val VERSION_NAME: String = "$VERSION_NAME_MOD+$VERSION_NAME_BRANCH${if (DEBUG) "-debug" else ""}"
+    const val MOD_ID: String = "dynamicpack"
+
+    // NOTE: for increase contact to mod developer.
+    val DYNAMIC_PACK_HTTPS_FILE_SIZE_LIMIT: Long = megabyte(8)   // 8 MB
+    val MODRINTH_HTTPS_FILE_SIZE_LIMIT: Long = megabyte(1024)    // 1 GB
+    val MOD_MODTINTH_API_LIMIT: Long = megabyte(8)               // 8 MB
+    val GZIP_LIMIT: Long = megabyte(50)                         // 50 MB
+    val MOD_FILES_LIMIT: Long = megabyte(8)
+    const val MODRINTH_URL: String = "https://modrinth.com/mod/dynamicpack"
+    val NETWORK_STAT_RESET_LIMIT: Long = megabyte(3)
+
+    // Settings
+    const val MAX_ATTEMPTS_TO_DOWNLOAD_FILE: Int = 3
+    const val TEMP_DIR_NAME: String = "dynamicpack_f02ffd55_cd44_458a_8d58_e31b11313a53"
+    @JvmField var URLS_BUFFER_SIZE: Int = 1024
+
+    // const
+    const val HTTP_MINIMAL_HEADER_SIZE: Long = 24
+    const val CLIENT_FILE: String = "dynamicmcpack.json"
+    const val MINECRAFT_META: String = "pack.mcmeta"
+    val UNKNOWN_PACK_MCMETA: String = """
+        {
+          "pack": {
+            "pack_format": 17,
+            "description": "Unknown DynamicPack resource-pack..."
+          }
+        }
+    """.trimIndent()
+
+    @JvmField val GSON: Gson = GsonBuilder().setPrettyPrinting().create()
+
+    // --- Hosts ---
+    private val ALLOWED_HOSTS: MutableSet<String> = buildSet {
+        add("modrinth.com")
+        add("github.com")
+        add("github.io")
+        add("githubusercontent.com") // better use github pages
+        if (isLocalHostAllowed()) {
+            add("localhost")
+        }
+    }.toMutableSet()
+
+    /**
+     * API FOR MODPACKERS etc all-in-one packs
+     * @param host host to add.
+     * @param requester any object. It is recommended that .toString explicitly give out your name.
+     */
+    @Throws(Exception::class)
+    internal fun addAllowedHosts(host: String?, requester: Any?) {
+        if (host == null || requester == null) {
+            Out.securityWarning("Try to add allowed hosts is failed: null host or requester")
+            throw Exception("Try to add allowed hosts is failed: null host or requester")
+        }
+
+        Out.securityWarning("==== SECURITY WARNING ====")
+        Out.securityWarning("# The DynamicPack mod limits the hosts it can interact with.")
+        Out.securityWarning("# But a certain requester allowed the mod another host to interact with")
+        Out.securityWarning("# ")
+        Out.securityWarning("# Host: $host")
+        Out.securityWarning("# Requester: $requester")
+        Out.securityWarning("# StackTrace:")
+        Out.securityStackTrace()
+        Out.securityWarning("# ")
+        Out.securityWarning("===========================")
+
+        ALLOWED_HOSTS += host
+    }
+
+    @Throws(URISyntaxException::class)
+    fun getUrlHost(url: String): String? = URI(url).host
+
+    @Throws(IOException::class)
+    fun isUrlHostTrusted(url: String): Boolean {
+        return try {
+            val host = getUrlHost(url) ?: return false
+            when {
+                host in ALLOWED_HOSTS -> true
+                ALLOWED_HOSTS.any { host.endsWith(".$it") } -> true
+                else -> {
+                    Out.warn("Check trusted(false): $host")
+                    false
+                }
+            }
+        } catch (e: Exception) {
+            throw IOException("Error while check url for trust", e)
+        }
+    }
+
+    fun megabyte(mb: Long): Long = 1024L * 1024L * mb
+
+    fun speedToString(bytesPerSec: Long): String = when {
+        bytesPerSec >= 1024 * 1024 -> "${bytesPerSec / 1024 / 1024} MiB/s"
+        bytesPerSec >= 1024        -> "${bytesPerSec / 1024} KiB/s"
+        else                       -> "$bytesPerSec B/s"
+    }
+
+    fun secondsToString(s: Long): String = when {
+        s > 3600 -> "${s / 3600}h"
+        s > 60   -> "${s / 60}m"
+        else     -> "${s}s"
+    }
+
+    fun isBlockAllNotTrustedNetworks(): Boolean = true
+
+    // TRUE FOR ALL PUBLIC VERSION!!!!!!
+    // false is equal not safe!1!!!
+    fun isRelease(): Boolean = !DEBUG
+
+    // localhost allowed RELEASE=false
+    fun isLocalHostAllowed(): Boolean = DEBUG_ALLOW_UNSECURE
+
+    // file_debug_only:// allowed RELEASE=false
+    fun isFileDebugSchemeAllowed(): Boolean = DEBUG_ALLOW_UNSECURE
+
+    // http:// allowed RELEASE=false
+    fun isHTTPTrafficAllowed(): Boolean = false
+
+    fun debugNetwork(bytesRead: Int, total: Long) {
+        if (isRelease()) return
+        if (true) return  // Забавная проверка :) оставим семантику как есть.
+
+        try {
+            Thread.sleep(200)
+        } catch (e: InterruptedException) {
+            throw RuntimeException(e)
+        }
+    }
+
+    fun isDebugLogs(): Boolean = DEBUG_LOGS
+
+    fun isDebugMessageOnWorldJoin(): Boolean = DEBUG
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/DynamicPackMod.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/DynamicPackMod.kt
new file mode 100644
index 0000000..48a376b
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/DynamicPackMod.kt
@@ -0,0 +1,130 @@
+package com.calculatorsteam.dynamicpack
+
+import com.calculatorsteam.dynamicpack.client.GameStartSyncing
+import com.calculatorsteam.dynamicpack.client.config.Config
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.pack.Remote
+import com.calculatorsteam.dynamicpack.util.enums.Loader
+import com.calculatorsteam.dynamicpack.util.log.Out
+import org.jetbrains.annotations.ApiStatus
+import java.io.File
+import java.nio.charset.StandardCharsets
+import java.nio.file.Files
+
+/**
+ * Base mod entry, singleton instance kept in [instance].
+ */
+abstract class DynamicPackMod protected constructor() {
+
+    private lateinit var loader: Loader
+    private lateinit var gameDir: File          // .minecraft
+    private lateinit var configDir: File        // *gamedir*/config/dynamicpack
+    private lateinit var configFile: File       // *configDir*/config.json
+    private var _config: Config? = null
+    private lateinit var packsContainer: PacksContainer
+    private lateinit var gameStartSyncing: GameStartSyncing
+    private var minecraftInitialized: Boolean = false
+
+    companion object {
+        private var INSTANCE: DynamicPackMod? = null
+
+        @JvmStatic
+        val instance: DynamicPackMod
+            get() = INSTANCE ?: throw IllegalStateException("Mod not initialized")
+
+        @JvmStatic
+        val config: Config
+            get() = instance._config ?: error("Config not initialized!")
+
+        @JvmStatic
+        @ApiStatus.AvailableSince("1.0.30")
+        @Throws(Exception::class)
+        fun addAllowedHosts(host: String, requester: Any) {
+            Constants.addAllowedHosts(host, requester)
+        }
+
+        @JvmStatic
+        fun isNameIsDynamic(name: String): Boolean =
+            instance.packsContainer.getByFileName(name.removePrefix("file/")) != null
+
+        @JvmStatic
+        fun getDynamicPackByMinecraftName(name: String): DynamicResourcePack? {
+            return instance.packsContainer.getByFileName(name.removePrefix("file/"))
+        }
+
+        @JvmStatic
+        fun isResourcePackActive(pack: DynamicResourcePack): Boolean {
+            val optionsFile = File(instance.gameDir, "options.txt")
+            val lines: List<String> = try {
+                Files.readAllLines(optionsFile.toPath(), StandardCharsets.UTF_8)
+            } catch (e: Exception) {
+                Out.println("options.txt not exists or failed to parse.. isResourcePackActive => false.")
+                return false
+            }
+
+            return lines.any { line ->
+                line.startsWith("resourcePacks:") && line.contains(pack.minecraftId)
+            }
+        }
+
+        @JvmStatic val gameDir: File get() = instance.gameDir
+        @JvmStatic val packsContainer: PacksContainer get() = instance.packsContainer
+        @JvmStatic val loader: Loader get() = instance.loader
+        @JvmStatic val gameStartSyncing: GameStartSyncing get() = instance.gameStartSyncing
+        @JvmStatic val configDir: File get() = instance.configDir
+        @JvmStatic val configFile: File get() = instance.configFile
+    }
+
+    protected var manuallySyncThreadCounter: Int = 0
+
+    /**
+     * Основная инициализация мода.
+     */
+    open fun init(gameDir: File, loader: Loader) {
+        if (INSTANCE != null) throw RuntimeException("Already initialized!")
+        INSTANCE = this
+        this.gameDir = gameDir
+        this.loader = loader
+
+        // *gamedir*/resourcepacks
+        val resourcePacks = File(gameDir, "resourcepacks")
+        resourcePacks.mkdirs()
+
+        this.configDir = File(gameDir, "config/dynamicpack").apply { mkdirs() }
+        this.configFile = File(configDir, "config.json")
+
+        // Передаём путь внутрь Config перед загрузкой!
+        Config.fileRef = this.configFile
+        val loadedConfig = Config.load()
+        this._config = loadedConfig
+
+        Remote.initRemoteTypes()
+        Out.init()
+        Out.println("Mod version: ${Constants.VERSION_NAME} build: ${Constants.VERSION_BUILD}")
+
+        this.packsContainer = PacksContainer(resourcePacks)
+        this.packsContainer.rescan()
+        this.gameStartSyncing = GameStartSyncing()
+
+        if (loadedConfig.isAutoUpdateAtLaunch()) {
+            this.gameStartSyncing.start()
+        }
+    }
+
+    // == ABSTRACT API ==
+    abstract fun isModExists(id: String): Boolean
+    /** Manually re-sync all supported packs */
+    abstract fun startManuallySync()
+    abstract fun startManuallySync(pack: DynamicResourcePack)
+    abstract fun needResourcesReload()
+    abstract fun getCurrentGameVersion(): String
+    @Throws(Exception::class)
+    abstract fun checkResourcePackMetaValid(s: String): Boolean
+    // == END ABSTRACT ==
+
+    fun minecraftInitialized() {
+        this.minecraftInitialized = true
+    }
+
+    fun isMinecraftInitialized(): Boolean = minecraftInitialized
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/InputValidator.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/InputValidator.kt
new file mode 100644
index 0000000..b4f1ca0
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/InputValidator.kt
@@ -0,0 +1,109 @@
+package com.calculatorsteam.dynamicpack
+
+import com.calculatorsteam.dynamicpack.util.log.Out
+import java.net.URISyntaxException
+import java.nio.charset.StandardCharsets
+import java.util.regex.Pattern
+
+/**
+ * Validates for [user/resourcepack-creator] input values
+ */
+object InputValidator {
+    private val CONTENT_ID_PATTERN: Pattern = Pattern.compile("^[a-z0-9_:-]{2,128}$")
+    private val PATH_PATTERN: Pattern = Pattern.compile("^[A-Za-z0-9_./() +-]{0,255}$")
+    private val URL_PATTERN: Pattern = Pattern.compile(
+        "(https?://)?(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{2,256}\\.[a-z]{2,6}\\b([-a-zA-Z0-9@:%_\\+.~#?&//=]*)"
+    )
+
+    /**
+     * dynamic content id valid?
+     */
+    @JvmStatic
+    fun isDynamicContentIdValid(contentId: String?): Boolean =
+        contentId != null && CONTENT_ID_PATTERN.matcher(contentId).matches()
+
+    /**
+     * Throw if content id invalid
+     */
+    @JvmStatic
+    fun throwIsContentIdInvalid(contentId: String?) {
+        if (!isDynamicContentIdValid(contentId)) {
+            throw RuntimeException("Id of content is not valid: ${safeOutput(contentId ?: "<null>")}")
+        }
+    }
+
+    /**
+     * Is dynamic_repo content name valid?
+     */
+    @JvmStatic
+    fun isDynamicContentNameValid(contentName: String?): Boolean =
+        contentName?.trim()?.let {
+            it.length < 64 && it.isNotEmpty() &&
+                    !it.contains("\n") && !it.contains("\r") && !it.contains("\b")
+        } ?: false
+
+    /**
+     * Dynamic pack name valid?
+     */
+    @JvmStatic
+    fun isDynamicPackNameValid(name: String?): Boolean =
+        name?.trim()?.let {
+            it.length < 64 && it.isNotEmpty() &&
+                    !it.contains("\n") && !it.contains("\r") && !it.contains("\b")
+        } ?: false
+
+    /**
+     * Throw if local path invalid
+     */
+    @JvmStatic
+    fun throwIsPathInvalid(path: String?) {
+        if (path == null) {
+            throw SecurityException("Null path", NullPointerException("path to valid is null"))
+        }
+
+        val trim = path.trim()
+        if (trim.length < 2 || !PATH_PATTERN.matcher(path).matches()) {
+            val safe = path.toByteArray(StandardCharsets.US_ASCII).toString(StandardCharsets.US_ASCII)
+            throw SecurityException("Not valid path: $safe")
+        }
+    }
+
+    /**
+     * Is URL valid?
+     */
+    @JvmStatic
+    fun isUrlValid(url: String): Boolean {
+        try {
+            if (Constants.isLocalHostAllowed() && Constants.getUrlHost(url) == "localhost") {
+                Out.warn("isUrlValid return true for localhost! Behavior only when isLocalHostAllowed()=true")
+                return true
+            }
+        } catch (_: URISyntaxException) { }
+        return URL_PATTERN.matcher(url).matches()
+    }
+
+    /**
+     * Throw if url invalid
+     */
+    @JvmStatic
+    fun throwIsUrlInvalid(url: String?) {
+        if (url == null) {
+            throw SecurityException("null", NullPointerException("url to valid is null"))
+        }
+        if (!isUrlValid(url)) {
+            throw SecurityException("Not valid url: ${safeOutput(url)}")
+        }
+    }
+
+    /**
+     * SHA1 valid?
+     */
+    @JvmStatic
+    fun isHashValid(hash: String?): Boolean =
+        hash != null && hash.length == 40 && !hash.contains(" ")
+
+    private fun safeOutput(s: String): String {
+        val short = if (s.length >= 100) s.take(100) else s
+        return short.toByteArray(StandardCharsets.US_ASCII).toString(StandardCharsets.US_ASCII)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/PacksContainer.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/PacksContainer.kt
new file mode 100644
index 0000000..4930b94
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/PacksContainer.kt
@@ -0,0 +1,103 @@
+package com.calculatorsteam.dynamicpack
+
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.util.JsonUtil
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optInt
+import com.calculatorsteam.dynamicpack.util.PackUtil
+import com.calculatorsteam.dynamicpack.util.PathUtil
+import com.calculatorsteam.dynamicpack.util.log.Out
+import com.calculatorsteam.dynamicpack.util.exception.FailedOpenPackFileSystemException
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+
+/**
+ * Container for supported packs
+ */
+class PacksContainer(private val directoryToCheck: File) {
+
+    private var rescanPacksBlocked: Boolean = false
+    private var isPacksScanning: Boolean = false
+
+    /** Current dynamic packs by filename */
+    private val packs: MutableMap<String, DynamicResourcePack> = mutableMapOf()
+
+    fun lockRescan() {
+        rescanPacksBlocked = true
+    }
+
+    fun unlockRescan() {
+        rescanPacksBlocked = false
+    }
+
+    fun rescan() {
+        if (isPacksScanning) {
+            Out.warn("Already in scanning!")
+            return
+        }
+        if (rescanPacksBlocked) {
+            Out.warn("Rescan blocked! maybe currently syncing")
+            return
+        }
+
+        isPacksScanning = true
+        val forDelete = packs.keys.toMutableList()
+
+        PathUtil.listFiles(directoryToCheck)?.forEach { packFile ->
+            val currentDynamicPack = DynamicPackMod.getDynamicPackByMinecraftName("file/${packFile.name}")
+            if (currentDynamicPack?.isSyncing == true) {
+                Out.warn("WARNING: Found a pack that is now synchronizing. skipping this pack")
+                return@forEach
+            }
+
+            try {
+                PackUtil.openPackFileSystem(packFile) { packPath ->
+                    val clientFile = packPath.resolve(Constants.CLIENT_FILE)
+                    if (Files.exists(clientFile)) {
+                        Out.println("+ Pack ${packFile.name} supported by mod!")
+                        processPack(packFile, clientFile)
+                        forDelete.remove(packFile.name)
+                    } else {
+                        Out.println("- Pack ${packFile.name} not supported by mod.")
+                    }
+                }
+            } catch (e: Exception) {
+                if (e is FailedOpenPackFileSystemException) {
+                    Out.warn("Error while processing pack ${packFile.name}: ${e.message}")
+                } else {
+                    Out.error("Error while processing pack: ${packFile.name}", e)
+                }
+            }
+        }
+
+        forDelete.forEach { s ->
+            Out.println("Pack $s no longer exist or no longer support DynamicPack!")
+            packs.remove(s)
+        }
+
+        isPacksScanning = false
+    }
+
+    @Throws(Exception::class)
+    private fun processPack(location: File, clientFile: Path) {
+        val json = JsonUtil.readJson(clientFile)
+        val formatVersion = json.optInt("formatVersion")
+        val oldestPack = packs[location.name]
+
+        if (formatVersion == 1) {
+            val pack = DynamicResourcePack(location, json).apply {
+                if (oldestPack != null) {
+                    flashback(oldestPack)
+                }
+            }
+            packs[location.name] = pack
+        } else {
+            throw RuntimeException("Unsupported formatVersion for pack ${location.name}: $formatVersion")
+        }
+    }
+
+    val packsArray: Array<DynamicResourcePack>
+        get() = packs.values.toTypedArray()
+
+    fun getByFileName(filename: String): DynamicResourcePack? = packs[filename]
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/DynamicPackModBase.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/DynamicPackModBase.kt
new file mode 100644
index 0000000..ff323af
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/DynamicPackModBase.kt
@@ -0,0 +1,152 @@
+package com.calculatorsteam.dynamicpack.client
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.platform.VersionFunctions
+import com.calculatorsteam.dynamicpack.util.status.StatusChecker
+import com.calculatorsteam.dynamicpack.sync.SyncThread
+import com.calculatorsteam.dynamicpack.util.log.Out
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import com.google.gson.internal.LazilyParsedNumber
+import net.minecraft.ChatFormatting
+import net.minecraft.SharedConstants
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.components.toasts.SystemToast
+import net.minecraft.client.player.LocalPlayer
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.Style
+import net.minecraft.util.GsonHelper
+import java.net.URI
+
+/**
+ * Base impl for DynamicPack mod (minecraft logic)
+ * <pre>
+ * == inheritance tree ==
+ * DynamicPackMod - mod-related logic
+ * | DynamicPackModBase - minecraft-related logic
+ * . | fabric impl...
+ * . | forge impl...
+ * . | ...
+ * </pre>
+ */
+abstract class DynamicPackModBase : DynamicPackMod() {
+
+    private var toast: SystemToast? = null
+    private var toastUpdated: Long = 0
+
+    fun setToastContent(title: Component, text: Component) {
+        if (!isMinecraftInitialized()) return
+
+        val now = System.currentTimeMillis()
+        if (toast == null || (now - toastUpdated > 5000)) {
+            val toastManager = VersionFunctions.getToastManager()
+            toast = SystemToast(
+                VersionFunctions.getSystemToastId(),
+                title,
+                text
+            ).also { toastManager.addToast(it) }
+        } else {
+            toast?.reset(title, text)
+        }
+        toastUpdated = now
+    }
+
+    private fun createDownloadComponent(): Component =
+        Component.translatable("dynamicpack.status_checker.download")
+            .withStyle(
+                Style.EMPTY
+                    .withHoverEvent(
+                        VersionFunctions.getHoverEventShowText(
+                            Component.translatable(
+                                "dynamicpack.status_checker.download.hover",
+                                Component.literal(Constants.MODRINTH_URL)
+                                    .withStyle(ChatFormatting.UNDERLINE, ChatFormatting.AQUA)
+                            )
+                        )
+                    )
+                    .withClickEvent(
+                        VersionFunctions.getClickEventOpenUrl(Constants.MODRINTH_URL)
+                    )
+            )
+            .withStyle(ChatFormatting.YELLOW, ChatFormatting.UNDERLINE)
+
+    fun onWorldJoinForUpdateChecks(player: LocalPlayer?) {
+        if (Constants.isDebugMessageOnWorldJoin()) {
+            VersionFunctions.displayClientMessage(
+                player,
+                Component.literal("Debug message on world join")
+                    .withStyle(ChatFormatting.GREEN)
+            )
+        }
+        when {
+            player == null -> Out.warn("player == null on world join")
+            !StatusChecker.isSafe() -> {
+                VersionFunctions.displayClientMessage(
+                    player,
+                    Component.translatable(
+                        "dynamicpack.status_checker.not_safe",
+                        createDownloadComponent()
+                    )
+                )
+                setToastContent(
+                    Component.translatable("dynamicpack.status_checker.not_safe.toast.title"),
+                    Component.translatable("dynamicpack.status_checker.not_safe.toast.description")
+                )
+            }
+            !StatusChecker.isFormatActual() -> VersionFunctions.displayClientMessage(
+                player,
+                Component.translatable(
+                    "dynamicpack.status_checker.format_not_actual",
+                    createDownloadComponent()
+                )
+            )
+
+            StatusChecker.isModUpdateAvailable() ->
+                Out.println("DynamicPack mod update available: ${Constants.MODRINTH_URL}")
+
+            !StatusChecker.isChecked() ->
+                Out.warn("StatusChecker isChecked = false :(")
+
+            else -> Out.println("Mod in actual state in current time!")
+        }
+    }
+
+    override fun startManuallySync() {
+        SyncThread("SyncThread-${manuallySyncThreadCounter++}").start()
+    }
+
+    override fun startManuallySync(pack: DynamicResourcePack) {
+        SyncThread("SyncThread-${manuallySyncThreadCounter++}", pack).start()
+    }
+
+    override fun getCurrentGameVersion(): String {
+        SharedConstants.tryDetectVersion()
+        return VersionFunctions.versionName(SharedConstants.getCurrentVersion())
+    }
+
+    override fun checkResourcePackMetaValid(s: String): Boolean {
+        val pack: JsonObject = GsonHelper.parse(s).getAsJsonObject("pack")
+        if (pack["pack_format"].asNumber is LazilyParsedNumber) {
+            (pack["pack_format"].asNumber as LazilyParsedNumber).toInt()
+        }
+        val description: JsonElement = pack["description"]
+        if (description.isJsonNull) {
+            throw NullPointerException("description is null in pack.mcmeta")
+        }
+        return true
+    }
+
+    override fun needResourcesReload() {
+        val client = Minecraft.getInstance()
+        if (client != null && client.level == null) {
+            client.execute { client.reloadResourcePacks() }
+        } else {
+            setToastContent(
+                Component.translatable("dynamicpack.toast.needReload"),
+                Component.translatable("dynamicpack.toast.needReload.description")
+            )
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/GameStartSyncing.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/GameStartSyncing.kt
new file mode 100644
index 0000000..ad30ae8
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/GameStartSyncing.kt
@@ -0,0 +1,150 @@
+package com.calculatorsteam.dynamicpack.client
+
+import com.calculatorsteam.dynamicpack.client.config.Config
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.util.status.StatusChecker
+import com.calculatorsteam.dynamicpack.sync.SyncBuilder
+import com.calculatorsteam.dynamicpack.sync.SyncProgress
+import com.calculatorsteam.dynamicpack.sync.SyncingTask
+import com.calculatorsteam.dynamicpack.util.log.LoopLog
+import com.calculatorsteam.dynamicpack.util.log.NetworkStat
+import com.calculatorsteam.dynamicpack.util.log.Out
+import java.nio.file.Path
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * Syncing on game launch
+ */
+class GameStartSyncing : Thread("GameStartSyncingThread") {
+
+    companion object {
+        private const val MAX_LOCK_MS = 1000 * 15
+    }
+
+    private var updateStartTime: Long = 0L   // thread started time ms
+    private var lockStartTime: Long = 0L     // lock started time ms
+
+    /** locking resources loading (firstly true!) */
+    var lockResourcesLoading: Boolean = true
+        private set
+
+    var syncBuilder: SyncBuilder? = null
+    val etaLoopLog = LoopLog(1.seconds)
+
+    init {
+        if (!Config.getInstance().isAutoUpdateAtLaunch()) {
+            Out.warn("Auto-update at launch disabled by config.")
+            unlock()
+        }
+    }
+
+    /**
+     * Starting syncing... (thread entrypoint)
+     */
+    override fun run() {
+        if (!Config.getInstance().isAutoUpdateAtLaunch()) {
+            Out.warn("Thread launched with isAutoUpdateAtLaunch=false; return")
+            return
+        }
+
+        updateStartTime = System.currentTimeMillis()
+        Out.debug("[GameStartSyncing] thread started")
+
+        SyncingTask.launchTaskAsSyncing {
+            try {
+                StatusChecker.check() // check status
+                SyncingTask.currentRootSyncBuilder = SyncingTask.rootSyncBuilder().also { builder ->
+                    syncBuilder = builder
+                    builder.init(ignoreCaches = false)
+
+                    if (builder.isUpdateAvailable) {
+                        val reloadRequired = builder.doUpdate(createSyncProgress())
+                        if (!lockResourcesLoading && reloadRequired) {
+                            DynamicPackMod.instance.needResourcesReload()
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                Out.error("Error while GameStartSyncing...", e)
+            } finally {
+                unlock() // unlock main thread!
+                SyncingTask.currentRootSyncBuilder = null
+            }
+        }
+    }
+
+    private fun createSyncProgress(): SyncProgress = object : SyncProgress {
+        override fun setPhase(phase: String) {
+            Out.debug("Phase: $phase")
+            SyncingTask.log(phase)
+        }
+
+        override fun downloading(name: String, percentage: Float) {
+            syncBuilder?.let { builder ->
+                val remainsBytes = builder.updateSize - builder.downloadedSize
+                val eta = NetworkStat.remainingETA(remainsBytes).also { SyncingTask.eta = it }
+
+                if (etaLoopLog.tick()) {
+                    Out.debug("(${SyncingTask.currentPackName}) ETA=${eta}s")
+                }
+
+                // if locked and updating > 3 seconds
+                if (updateTime > 3000 && isLocked()) {
+                    val shouldUnlock = eta * 1000 > (untilForceUnlock / 1.5f)
+                    if (shouldUnlock) {
+                        Out.debug("[GameStartSyncing] ETA ${eta}s. Unlocking main thread...")
+                        unlock()
+                    }
+                }
+            }
+        }
+
+        override fun deleted(name: Path) {
+            Out.debug("Deleted: $name")
+            SyncingTask.log("Delete: ${name.fileName}")
+        }
+    }
+
+    // если конфликт модов → переопределить
+    fun isLockSupported(): Boolean = true
+
+    fun lockedTick(): Boolean {
+        if (lockTime > MAX_LOCK_MS) {
+            Out.warn("Main thread unlocked forcibly because lock time >= 15s")
+            return false
+        }
+        return true
+    }
+
+    val lockTime: Long
+        get() = System.currentTimeMillis() - lockStartTime
+
+    val updateTime: Long
+        get() = System.currentTimeMillis() - updateStartTime
+
+    val untilForceUnlock: Long
+        get() = MAX_LOCK_MS - lockTime
+
+    fun endGameLocking() {
+        Out.println("Main thread locked for ${lockTime / 1000} seconds")
+    }
+
+    fun startGameLocking() {
+        Out.println("Main thread locked by DynamicPack for updating resource packs...")
+        lockStartTime = System.currentTimeMillis()
+    }
+
+    fun isLockStarted(): Boolean = lockStartTime != 0L
+    fun isLocked(): Boolean = isLockStarted() && lockResourcesLoading
+
+    private fun unlock() {
+        lockResourcesLoading = false
+    }
+
+    val percentage: Double
+        get() = syncBuilder?.let { b ->
+            if (b.downloadedSize > 0)
+                (b.downloadedSize.toDouble() / b.updateSize.toDouble()) * 100.0
+            else 0.0
+        } ?: 0.0
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/PackMixinHelper.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/PackMixinHelper.kt
new file mode 100644
index 0000000..b980982
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/PackMixinHelper.kt
@@ -0,0 +1,19 @@
+package com.calculatorsteam.dynamicpack.client
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+
+/**
+ * Helper for mixin hooks into Minecraft lifecycle.
+ */
+object PackMixinHelper {
+
+    @JvmStatic
+    fun minecraftInitReturned() {
+        DynamicPackMod.instance.minecraftInitialized()
+    }
+
+    @JvmStatic
+    fun updatePacksMinecraftRequest() {
+        DynamicPackMod.packsContainer.rescan()
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/Config.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/Config.kt
new file mode 100644
index 0000000..8259005
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/Config.kt
@@ -0,0 +1,151 @@
+package com.calculatorsteam.dynamicpack.client.config
+
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.DynamicRepoSyncBuilder
+import com.calculatorsteam.dynamicpack.util.PathUtil
+import com.calculatorsteam.dynamicpack.util.log.FileLog
+import com.calculatorsteam.dynamicpack.util.log.Out
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardOpenOption
+
+/**
+ * Global config for DynamicPack.
+ */
+class Config private constructor() {
+
+    @Transient
+    private var def: Boolean = false
+
+    private var formatVersion: Int = 1 // do not touch
+
+    private var networkBufferSize: Int = 1024
+    fun getNetworkBufferSize(): Int = networkBufferSize
+    fun setNetworkBufferSize(value: Int) {
+        networkBufferSize = value
+        updateStaticVariables(this)
+    }
+
+    private var networkMultithreadDownloadThreads: Int = 12
+    fun getNetworkMultithreadDownloadThreads(): Int = networkMultithreadDownloadThreads
+    fun setNetworkMultithreadDownloadThreads(value: Int) {
+        networkMultithreadDownloadThreads = value
+        updateStaticVariables(this)
+    }
+
+    private var logAllFilesChanges: Boolean = false
+    fun isLogAllFilesChanges(): Boolean = logAllFilesChanges
+    fun setLogAllFilesChanges(value: Boolean) {
+        logAllFilesChanges = value
+        updateStaticVariables(this)
+    }
+
+    private var autoUpdateAtLaunch: Boolean = true
+    fun isAutoUpdateAtLaunch(): Boolean = autoUpdateAtLaunch
+    fun setAutoUpdateAtLaunch(value: Boolean) {
+        autoUpdateAtLaunch = value
+    }
+
+    private var updateOnlyEnabledPacks: Boolean = true
+    fun isUpdateOnlyEnabledPacks(): Boolean = updateOnlyEnabledPacks
+    fun setUpdateOnlyEnabledPacks(value: Boolean) {
+        updateOnlyEnabledPacks = value
+    }
+
+    private var debugIgnoreHiddenFlagInContents: Boolean = false
+    fun dynamicRepoIsIgnoreHiddenContentFlag(): Boolean = debugIgnoreHiddenFlagInContents
+    fun setDebugIgnoreHiddenFlagInContents(value: Boolean) {
+        debugIgnoreHiddenFlagInContents = value
+    }
+
+    private var debugLogs: Boolean = false
+    fun isDebugLogs(): Boolean = debugLogs
+    fun setDebugLogs(value: Boolean) {
+        debugLogs = value
+    }
+
+    private fun checkAndValidateConfig() {
+        var save = false
+
+        if (networkBufferSize < 256) {
+            networkBufferSize = 256
+            save = true
+            Out.warn("Config invalid 'networkBufferSize'. Sets to $networkBufferSize")
+        }
+
+        if (networkMultithreadDownloadThreads !in 1..<256) {
+            networkMultithreadDownloadThreads = 8
+            save = true
+            Out.warn("Config invalid 'networkMultithreadDownloadThreads'. Sets to $networkMultithreadDownloadThreads")
+        }
+
+        if (save) save()
+    }
+
+    fun save() {
+        if (def) throw RuntimeException("Can't save a DEF config!")
+        try {
+            val json = Constants.GSON.toJson(this)
+            val file: Path = fileRef!!.toPath()
+            PathUtil.delete(file)
+            PathUtil.createDirsToFile(file)
+            PathUtil.createFile(file)
+            Files.writeString(file, json, StandardOpenOption.WRITE)
+        } catch (e: Exception) {
+            Out.error("Config save failed :(", e)
+        }
+    }
+
+    companion object {
+        @JvmField val DEF: Config = createDefConfig()
+        private var instance: Config? = null
+        internal var fileRef: File? = null
+
+        private fun createDefConfig(): Config {
+            val cfg = Config()
+            cfg.def = true
+            return cfg
+        }
+
+        @JvmStatic
+        fun load(): Config {
+            if (instance != null) throw RuntimeException("Config already loaded")
+
+            val file = fileRef ?: throw RuntimeException("Config.fileRef not set before load()!")
+
+            if (!file.exists()) {
+                val cfg = Config()
+                updateStaticVariables(cfg)
+                instance = cfg
+                return cfg
+            }
+
+            return try {
+                val config = Constants.GSON.fromJson(
+                    PathUtil.readString(file.toPath()), Config::class.java
+                )
+                updateStaticVariables(config)
+                instance = config
+                config
+            } catch (e: Exception) {
+                Out.error("Config load failed (return default config)", e)
+                val fallback = Config()
+                updateStaticVariables(fallback)
+                instance = fallback
+                fallback
+            }
+        }
+
+        private fun updateStaticVariables(config: Config) {
+            config.checkAndValidateConfig()
+            Constants.URLS_BUFFER_SIZE = config.networkBufferSize
+            Constants.DEBUG_LOGS = config.debugLogs
+            DynamicRepoSyncBuilder.DOWNLOAD_THREADS_COUNT = config.networkMultithreadDownloadThreads
+            FileLog.logAllChanges = config.logAllFilesChanges
+        }
+
+        @JvmStatic
+        fun getInstance(): Config = instance ?: throw IllegalStateException("Config not initialized!")
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/ConfigScreenBuilder.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/ConfigScreenBuilder.kt
new file mode 100644
index 0000000..ab8dfaa
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/ConfigScreenBuilder.kt
@@ -0,0 +1,168 @@
+package com.calculatorsteam.dynamicpack.client.config
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.sync.SyncingTask
+import dev.isxander.yacl3.api.*
+import dev.isxander.yacl3.api.controller.BooleanControllerBuilder
+import dev.isxander.yacl3.api.controller.IntegerSliderControllerBuilder
+import dev.isxander.yacl3.api.controller.TickBoxControllerBuilder
+import dev.isxander.yacl3.gui.YACLScreen
+import dev.isxander.yacl3.gui.controllers.slider.IntegerSliderController
+import net.minecraft.ChatFormatting
+import net.minecraft.client.gui.screens.Screen
+import net.minecraft.network.chat.Component
+
+object ConfigScreenBuilder {
+    @JvmStatic
+    fun create(parent: Screen): Screen {
+        val config = YetAnotherConfigLib.createBuilder()
+            .title(Component.literal("DynamicPack"))
+            .category(buildGeneralCategory())
+            .category(buildNetworkCategory())
+            .category(buildDebugCategory())
+            .save { DynamicPackMod.config.save() }
+            .build()
+
+        return YACLScreen(config, parent)
+    }
+
+    private fun buildGeneralCategory(): ConfigCategory =
+        ConfigCategory.createBuilder()
+            .name(Component.translatable("dynamicpack.screen.config.category.general"))
+            .group(
+                OptionGroup.createBuilder()
+                    .option(
+                        Option.createBuilder<Boolean>()
+                            .name(Component.translatable("dynamicpack.screen.config.category.general.isAutoUpdateAtLaunch"))
+                            .binding(
+                                Config.DEF.isAutoUpdateAtLaunch(),
+                                { DynamicPackMod.config.isAutoUpdateAtLaunch() },
+                                { DynamicPackMod.config.setAutoUpdateAtLaunch(it) }
+                            )
+                            .controller { BooleanControllerBuilder.create(it).yesNoFormatter() }
+                            .build()
+                    )
+                    .option(
+                        Option.createBuilder<Boolean>()
+                            .name(Component.translatable("dynamicpack.screen.config.category.general.updateOnlyEnabledPacks"))
+                            .binding(
+                                Config.DEF.isUpdateOnlyEnabledPacks(),
+                                { DynamicPackMod.config.isUpdateOnlyEnabledPacks() },
+                                { DynamicPackMod.config.setUpdateOnlyEnabledPacks(it) }
+                            )
+                            .controller { BooleanControllerBuilder.create(it).yesNoFormatter() }
+                            .build()
+                    )
+                    .build()
+            )
+            .build()
+
+    private fun buildDebugCategory(): ConfigCategory =
+        ConfigCategory.createBuilder()
+            .name(Component.translatable("dynamicpack.screen.config.category.debug"))
+            .tooltip(Component.translatable("dynamicpack.screen.config.category.debug.description").withStyle(ChatFormatting.RED))
+            .group(
+                OptionGroup.createBuilder()
+                    .name(Component.literal("Calculator's category ^_^"))
+                    .option(
+                        Option.createBuilder<Boolean>()
+                            .name(Component.translatable("dynamicpack.screen.config.category.debug.logAllFilesChanges"))
+                            .binding(
+                                Config.DEF.isLogAllFilesChanges(),
+                                { DynamicPackMod.config.isLogAllFilesChanges() },
+                                { DynamicPackMod.config.setLogAllFilesChanges(it) }
+                            )
+                            .controller(TickBoxControllerBuilder::create)
+                            .build()
+                    )
+                    .option(
+                        Option.createBuilder<Boolean>()
+                            .name(Component.translatable("dynamicpack.screen.config.category.debug.ignoreHidden"))
+                            .binding(
+                                Config.DEF.dynamicRepoIsIgnoreHiddenContentFlag(),
+                                { DynamicPackMod.config.dynamicRepoIsIgnoreHiddenContentFlag() },
+                                { DynamicPackMod.config.setDebugIgnoreHiddenFlagInContents(it) }
+                            )
+                            .controller(TickBoxControllerBuilder::create)
+                            .build()
+                    )
+                    .option(
+                        Option.createBuilder<Boolean>()
+                            .name(Component.literal("INTERRUPT UPDATING"))
+                            .description(OptionDescription.of(Component.literal("EXPERIMENTAL FUNCTIONAL")))
+                            .binding(object : Binding<Boolean> {
+                                override fun setValue(value: Boolean) {
+                                    SyncingTask.currentRootSyncBuilder?.interrupt()
+                                }
+                                override fun getValue(): Boolean = false
+                                override fun defaultValue(): Boolean = false
+                            })
+                            .controller(TickBoxControllerBuilder::create)
+                            .build()
+                    )
+                    .build()
+            )
+            .build()
+
+    private fun buildNetworkCategory(): ConfigCategory =
+        ConfigCategory.createBuilder()
+            .name(Component.translatable("dynamicpack.screen.config.category.network"))
+            .tooltip(Component.translatable("dynamicpack.screen.config.category.network.tooltip"))
+            .group(
+                OptionGroup.createBuilder()
+                    .name(Component.translatable("dynamicpack.screen.config.category.network.group.name"))
+                    .description(OptionDescription.of(Component.translatable("dynamicpack.screen.config.category.network.group.description")))
+                    .option(
+                        Option.createBuilder<Int>()
+                            .name(Component.translatable("dynamicpack.screen.config.category.network.bufferSize.name"))
+                            .binding(
+                                Config.DEF.getNetworkBufferSize(),
+                                { DynamicPackMod.config.getNetworkBufferSize() },
+                                { DynamicPackMod.config.setNetworkBufferSize(it) }
+                            )
+                            .controller {
+                                IntegerSliderControllerBuilder.create(it)
+                                    .step(256)
+                                    .range(256, 8192)
+                            }
+                            .build()
+                    )
+                    .option(
+                        Option.createBuilder<Int>()
+                            .name(Component.translatable("dynamicpack.screen.config.category.network.multithread.threads.name"))
+                            .binding(
+                                Config.DEF.getNetworkMultithreadDownloadThreads(),
+                                { DynamicPackMod.config.getNetworkMultithreadDownloadThreads() },
+                                { DynamicPackMod.config.setNetworkMultithreadDownloadThreads(it) }
+                            )
+                            .controller { integerOption ->
+                                IntegerSliderControllerBuilder.create(integerOption)
+                                    .step(1)
+                                    .formatValue { value ->
+                                        when {
+                                            value >= 255 -> Component.literal("^_^ ")
+                                                .withStyle(ChatFormatting.STRIKETHROUGH, ChatFormatting.GOLD)
+                                                .append(Component.literal(value.toString()).withStyle(ChatFormatting.RESET, ChatFormatting.BOLD, ChatFormatting.GOLD))
+                                            value > 80 -> Component.literal("X_X ")
+                                                .withStyle(ChatFormatting.DARK_RED)
+                                                .append(Component.literal(value.toString()).withStyle(ChatFormatting.BOLD, ChatFormatting.DARK_RED))
+                                            value > 64 -> Component.literal("X_0 ")
+                                                .withStyle(ChatFormatting.DARK_RED)
+                                                .append(Component.literal(value.toString()).withStyle(ChatFormatting.BOLD))
+                                            value > 32 -> Component.literal("0_0 ")
+                                                .withStyle(ChatFormatting.RED)
+                                                .append(Component.literal(value.toString()).withStyle(ChatFormatting.BOLD))
+                                            value > 16 -> Component.literal("OwO ")
+                                                .withStyle(ChatFormatting.YELLOW)
+                                                .append(Component.literal(value.toString()).withStyle(ChatFormatting.BOLD))
+                                            else -> IntegerSliderController.DEFAULT_FORMATTER.apply(value)
+                                        }
+                                    }
+                                    .range(1, 255)
+                            }
+                            .build()
+                    )
+                    .build()
+            )
+            .build()
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/NoYACLScreen.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/NoYACLScreen.kt
new file mode 100644
index 0000000..fd21425
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/config/NoYACLScreen.kt
@@ -0,0 +1,108 @@
+package com.calculatorsteam.dynamicpack.client.config;
+
+import com.calculatorsteam.dynamicpack.platform.VersionFunctions
+import net.minecraft.ChatFormatting
+import net.minecraft.Util
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.Button
+import net.minecraft.client.gui.screens.Screen
+import net.minecraft.network.chat.ClickEvent
+import net.minecraft.network.chat.CommonComponents
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.Style
+import net.minecraft.util.FormattedCharSequence
+import net.minecraft.util.Mth
+import java.net.URI
+
+/**
+ * Screen displayed if YACL (YetAnotherConfigLib) is not found.
+ */
+open class NoYACLScreen(private val parent: Screen) : Screen(Component.translatable("dynamicpack.screen.config.no_yacl.title")) {
+
+    private val titleSequence: FormattedCharSequence =
+        Component.translatable("dynamicpack.screen.config.no_yacl.title")
+            .withStyle(ChatFormatting.BOLD)
+            .visualOrderText
+
+    private val unwrappedText: Component =
+        Component.translatable(
+            "dynamicpack.screen.config.no_yacl.description",
+            Component.literal("YetAnotherConfigLib").withStyle {
+                it.withClickEvent(VersionFunctions.getClickEventOpenUrl("https://modrinth.com/mod/yacl"))
+                    .applyFormats(ChatFormatting.BLUE, ChatFormatting.UNDERLINE)
+            },
+        )
+
+    private lateinit var wrappedText: List<FormattedCharSequence>
+
+    override fun init() {
+        wrappedText = font.split(unwrappedText, width - 50)
+
+        addRenderableWidget(
+            VersionFunctions.createButton<Button>(
+                CommonComponents.GUI_BACK,
+                {
+                    minecraft?.setScreen(parent)
+                },
+                150, 20,
+                (width - 150) / 2,
+                Mth.clamp(90 + wrappedText.size * 9 + 12, height / 6 + 96, height - 24)
+            )
+        )
+    }
+
+    override fun render(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
+        /*? if >=1.21 {*/
+        super.render(context, mouseX, mouseY, delta)
+        /*?} else {*/
+        /*VersionFunctions.renderBackground(this, context, mouseX, mouseY, delta);
+        *//*?}*/
+
+        context.drawCenteredString(font, titleSequence, width / 2, 70, -1)
+
+        var y = 90
+        for (line in wrappedText) {
+            context.drawCenteredString(font, line, width / 2, y, -1)
+            y += font.lineHeight
+        }
+        //? if < 1.21
+        /*super.render(context, mouseX, mouseY, delta)*/
+    }
+
+    override fun mouseClicked(mouseX: Double, mouseY: Double, button: Int): Boolean {
+        if (super.mouseClicked(mouseX, mouseY, button)) {
+            return true
+        }
+
+        val style = getStyle(mouseX.toInt(), mouseY.toInt()) ?: return false
+
+        if (minecraft?.player == null) {
+            val click = style.clickEvent ?: return false
+            /*? if >=1.21.5 {*/
+            if (click is ClickEvent.OpenUrl) {
+                Util.getPlatform().openUri(click.uri)
+            }
+            /*?} else {*/
+            /*if (click.action == ClickEvent.Action.OPEN_URL) {
+                Util.getPlatform().openUri(URI(click.value))
+            }
+            *//*?}*/
+        } else {
+            return handleComponentClicked(style)
+        }
+
+        return false
+    }
+
+    protected fun getStyle(mouseX: Int, mouseY: Int): Style? {
+        val y = mouseY - 90
+        val line = y / font.lineHeight
+
+        if (y < 0 || line !in wrappedText.indices) return null
+        val text = wrappedText[line]
+
+        val x = mouseX - (width / 2 - font.width(text) / 2)
+        return font.splitter.componentStyleAtWidth(text, x)
+
+    }
+}
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/ContentsList.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/ContentsList.kt
new file mode 100644
index 0000000..af7b570
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/ContentsList.kt
@@ -0,0 +1,181 @@
+package com.calculatorsteam.dynamicpack.client.gui
+
+import com.calculatorsteam.dynamicpack.client.config.Config
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.BaseContent
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.BaseEnum
+import com.calculatorsteam.dynamicpack.platform.VersionFunctions
+import com.calculatorsteam.dynamicpack.util.enums.OverrideType
+import com.calculatorsteam.dynamicpack.util.log.Out
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.Button
+import net.minecraft.client.gui.components.ContainerObjectSelectionList
+import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.client.gui.components.events.GuiEventListener
+import net.minecraft.client.gui.narration.NarratableEntry
+import net.minecraft.network.chat.Component
+
+/**
+ * List widget for showing contents (BaseContent and BaseEnum entries).
+ */
+class ContentsList(
+    private val parent: ContentsScreen,
+    minecraft: Minecraft
+) : ContainerObjectSelectionList<ContentsList.ContentEntry>(minecraft, parent.width, parent.height/*? if >=1.20.4 {*/- 52, 20,/*?} else {*//*, 20, parent.height - 32,*//*?}*/40) {
+
+    init {
+        // contents
+        for (knownContent in parent.baseContents) {
+            if (knownContent.hidden && !Config.getInstance().dynamicRepoIsIgnoreHiddenContentFlag()) {
+                continue
+            }
+            addEntry(BaseContentEntry(knownContent))
+        }
+        // enums
+        for (anEnum in parent.baseEnum) {
+            addEntry(EnumContentEntry(anEnum))
+        }
+    }
+    /*? if >=1.21.4 {*/
+    override fun scrollBarX(): Int = super.scrollBarX() + 15
+    /*?} else {*/
+    /*override fun getScrollbarPosition(): Int = super.getScrollbarPosition() + 15
+    *//*?}*/
+    override fun getRowWidth(): Int = super.getRowWidth() + 32
+
+    fun refreshAll() {
+        children().forEach { it.refresh() }
+    }
+
+    /**
+     * Row with BaseContent
+     */
+    inner class BaseContentEntry(private val content: BaseContent) : ContentEntry() {
+        init {
+            stateButton = createStateButton()
+            stateButton.active = !content.required
+            if (!stateButton.active) {
+                VersionFunctions.setTooltip(stateButton, Tooltip.create(
+                    Component.translatable("dynamicpack.screen.pack_contents.state.tooltip_disabled")
+                ))
+            }
+        }
+
+        private fun createStateButton(): Button =
+            Button.builder(
+                Component.translatable("dynamicpack.screen.pack_contents.state", currentState())
+            ) { clicked() }
+                .bounds(0, 0, 140, 20)
+                .build()
+
+        private fun clicked() {
+            try {
+                content.nextOverride(parent.baseContents)
+            } catch (e: Exception) {
+                Out.error("Error while content.nextOverride() in gui", e)
+            }
+            parent.onAfterChange()
+            refreshAll()
+        }
+
+        override fun refresh() {
+            stateButton.message =
+                Component.translatable("dynamicpack.screen.pack_contents.state", currentState())
+        }
+
+        private fun currentState(): Component {
+            val key = when (content.overrideType) {
+                OverrideType.TRUE -> "dynamicpack.screen.pack_contents.state.true"
+                OverrideType.FALSE -> "dynamicpack.screen.pack_contents.state.false"
+                OverrideType.NOT_SET ->
+                    if (content.defaultState)
+                        "dynamicpack.screen.pack_contents.state.default.true"
+                    else
+                        "dynamicpack.screen.pack_contents.state.default.false"
+            }
+            return Component.translatable(key)
+        }
+
+        override fun render(
+            context: GuiGraphics,
+            index: Int,
+            y: Int,
+            x: Int,
+            entryWidth: Int,
+            entryHeight: Int,
+            mouseX: Int,
+            mouseY: Int,
+            hovered: Boolean,
+            tickDelta: Float
+        ) {
+            val txt = content.name ?: content.id
+            val text = Component.literal(txt)
+            context.drawString(this@ContentsList.minecraft.font, text, x - 50, y + 10, -1, false)
+            stateButton.x = x + entryWidth - 140
+            stateButton.y = y
+            stateButton.render(context, mouseX, mouseY, tickDelta)
+        }
+    }
+
+    /**
+     * Row with BaseEnum
+     */
+    inner class EnumContentEntry(private val baseEnum: BaseEnum) : ContentEntry() {
+        init {
+            stateButton = createStateButton()
+        }
+
+        private fun createStateButton(): Button =
+            Button.builder(currentState()) { clicked() }
+                .bounds(0, 0, 140, 20)
+                .build()
+
+        private fun clicked() {
+            try {
+                baseEnum.applyNext(parent.baseContents)
+            } catch (e: Exception) {
+                Out.error("Error while applyNext (gui)", e)
+            }
+            parent.onAfterChange()
+            refreshAll()
+        }
+
+        override fun refresh() {
+            stateButton.message = currentState()
+        }
+
+        private fun currentState(): Component =
+            Component.literal(baseEnum.getCurrentState(parent.baseContents))
+
+        override fun render(
+            context: GuiGraphics,
+            index: Int,
+            y: Int,
+            x: Int,
+            entryWidth: Int,
+            entryHeight: Int,
+            mouseX: Int,
+            mouseY: Int,
+            hovered: Boolean,
+            tickDelta: Float
+        ) {
+            val txt = baseEnum.name ?: baseEnum.id
+            val text = Component.literal(txt)
+            context.drawString(this@ContentsList.minecraft.font, text, x - 50, y + 10, -1, false)
+            stateButton.x = x + entryWidth - 140
+            stateButton.y = y
+            stateButton.render(context, mouseX, mouseY, tickDelta)
+        }
+    }
+
+    /**
+     * Base row type
+     */
+    abstract inner class ContentEntry : Entry<ContentEntry>() {
+        protected lateinit var stateButton: Button
+        abstract fun refresh()
+
+        override fun children(): List<GuiEventListener> = listOf(stateButton)
+        override fun narratables(): List<NarratableEntry> = listOf(stateButton)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/ContentsScreen.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/ContentsScreen.kt
new file mode 100644
index 0000000..c23e0fa
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/ContentsScreen.kt
@@ -0,0 +1,140 @@
+package com.calculatorsteam.dynamicpack.client.gui
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.util.enums.OverrideType
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.BaseContent
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.BaseEnum
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.DynamicRepoPreferences
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.DynamicRepoRemote
+import com.calculatorsteam.dynamicpack.platform.VersionFunctions
+import net.minecraft.ChatFormatting
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.Button
+import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.client.gui.screens.Screen
+import net.minecraft.network.chat.CommonComponents
+import net.minecraft.network.chat.Component
+
+class ContentsScreen(
+    private val parent: Screen,
+    private val pack: DynamicResourcePack
+) : Screen(Component.translatable("dynamicpack.screen.pack_contents.title")) {
+
+    private val preferences: DynamicRepoPreferences
+    private val onPackReSync: (DynamicResourcePack) -> Unit = { VersionFunctions.runAtUI { this.onClose() } }
+    private lateinit var contentsList: ContentsList
+    private var syncOnExit = false
+    private lateinit var doneButton: Button
+    private lateinit var resetButton: Button
+
+    protected val contentIdsAssociation = hashMapOf<String, BaseContent>()
+    protected val preChangeStates = linkedMapOf<BaseContent, OverrideType>()
+    protected val enums = linkedSetOf<BaseEnum>()
+
+    init {
+        this.minecraft = Minecraft.getInstance()
+        this.pack.addDestroyListener(onPackReSync)
+        this.preferences = (pack.getRemote() as DynamicRepoRemote).preferences
+
+        preferences.getKnownContents().forEach { knownContent ->
+            contentIdsAssociation[knownContent.id] = knownContent
+            preChangeStates[knownContent] = knownContent.overrideType
+        }
+        enums.addAll(preferences.getKnownEnums())
+    }
+
+    fun isChanges(): Boolean =
+        preChangeStates.any { (content, override) -> override != content.overrideType }
+
+    fun reset() {
+        preChangeStates.forEach { (content, overrideType) ->
+            content.setOverrideType(overrideType, baseContents)
+        }
+        contentsList.refreshAll()
+        onAfterChange()
+    }
+
+    fun onAfterChange() {
+        this.syncOnExit = isChanges()
+        updateDoneButton()
+    }
+
+    override fun onClose() {
+        applyChanges()
+        Minecraft.getInstance().setScreen(this.parent)
+        pack.removeDestroyListener(onPackReSync)
+        if (syncOnExit) {
+            DynamicPackMod.instance.startManuallySync(pack)
+        }
+    }
+
+    private fun applyChanges() {
+        preChangeStates.keys.forEach { baseContent ->
+            preferences.setContentOverride(baseContent, baseContent.overrideType)
+        }
+        pack.saveClientFile()
+    }
+
+    override fun shouldCloseOnEsc(): Boolean = !syncOnExit
+
+    override fun render(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
+        /*? if >=1.21 {*/
+        super.render(context, mouseX, mouseY, delta)
+        /*?} else {*/
+        /*VersionFunctions.renderBackground(this, context, mouseX, mouseY, delta);
+        *//*?}*/
+        contentsList.render(context, mouseX, mouseY, delta)
+        VersionFunctions.drawCenteredString(context, this.font, this.title, this.width / 2, 8, -1)
+        //? if < 1.21
+        /*super.render(context, mouseX, mouseY, delta)*/
+    }
+
+    override fun init() {
+        super.init()
+        this.contentsList = ContentsList(this, this.minecraft!!)
+        this.addWidget(contentsList)
+
+        this.addRenderableWidget(
+            VersionFunctions.createButton<Button>(
+                CommonComponents.GUI_DONE,
+                { this.onClose() },
+                150, 20,
+                this.width / 2 + 4, this.height - 26
+            ).also { doneButton = it }
+        )
+        this.addRenderableWidget(
+            VersionFunctions.createButton<Button>(
+                Component.translatable("controls.reset"),
+                { this.reset() },
+                150, 20,
+                this.width / 2 - 154, this.height - 26
+            ).also { resetButton = it }
+        )
+        updateDoneButton()
+    }
+
+    private fun updateDoneButton() {
+        if (syncOnExit) {
+            doneButton.message = Component.translatable("dynamicpack.screen.pack_contents.apply")
+                .withStyle(ChatFormatting.BOLD, ChatFormatting.GOLD)
+            VersionFunctions.setTooltip(doneButton, Tooltip.create(
+                Component.translatable("dynamicpack.screen.pack_contents.apply.tooltip")
+            ))
+        } else {
+            doneButton.message = CommonComponents.GUI_DONE
+            VersionFunctions.setTooltip(doneButton, null)
+        }
+        resetButton.visible = syncOnExit
+    }
+
+    val baseContents: Array<BaseContent>
+        get() = preChangeStates.keys.toTypedArray()
+
+    val baseEnum: Array<BaseEnum>
+        get() = enums.toTypedArray()
+
+    fun getById(id: String): BaseContent? =
+        contentIdsAssociation[id]
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/DynamicPackScreen.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/DynamicPackScreen.kt
new file mode 100644
index 0000000..e897c12
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/DynamicPackScreen.kt
@@ -0,0 +1,218 @@
+package com.calculatorsteam.dynamicpack.client.gui
+
+import com.calculatorsteam.dynamicpack.client.config.Config
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.DynamicRepoRemote
+import com.calculatorsteam.dynamicpack.platform.VersionFunctions
+import com.calculatorsteam.dynamicpack.sync.SyncingTask
+import com.calculatorsteam.dynamicpack.util.log.NetworkStat
+import com.calculatorsteam.dynamicpack.util.exception.TranslatableException
+import net.minecraft.ChatFormatting
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.Button
+import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.client.gui.screens.Screen
+import net.minecraft.network.chat.CommonComponents
+import net.minecraft.network.chat.Component
+import java.awt.Color
+import java.text.DateFormat
+import java.util.Date
+import kotlin.math.sin
+
+class DynamicPackScreen(
+    private val parent: Screen?,
+    private var pack: DynamicResourcePack
+) : Screen(Component.literal(pack.name).withStyle(ChatFormatting.BOLD)) {
+
+    private val destroyListener: (DynamicResourcePack) -> Unit = { setPack(it) }
+    private lateinit var syncButton: Button
+    private lateinit var contentsButton: Button
+    private lateinit var syncButtonThis: Button
+    private lateinit var syncButtonAll: Button
+
+    init {
+        this.minecraft = Minecraft.getInstance()
+        setPack(pack)
+    }
+
+    private fun setPack(pack: DynamicResourcePack) {
+        this.pack.removeDestroyListener(destroyListener)
+        this.pack = pack
+        pack.addDestroyListener(destroyListener)
+    }
+
+    override fun render(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
+        /*? if >=1.21 {*/
+        super.render(context, mouseX, mouseY, delta)
+        /*?} else {*/
+        /*VersionFunctions.renderBackground(this, context, mouseX, mouseY, delta);
+        *//*?}*/
+
+        syncButton.active = !SyncingTask.isSyncing()
+        contentsButton.active = !SyncingTask.isSyncing()
+
+        if (SyncingTask.isSyncing()) {
+            hideSyncSpecButtons()
+        }
+
+        val h = 20
+        VersionFunctions.drawString(context, this.font, this.title, 20, 8, -1)
+        VersionFunctions.drawWrappedString(
+            context,
+            Component.translatable("dynamicpack.screen.pack.description").getString(999),
+            20, 20 + h,
+            width - 125, 2,
+            -11141291
+        )
+        VersionFunctions.drawString(
+            context, this.font,
+            Component.translatable("dynamicpack.screen.pack.remote_type", pack.getRemoteType()),
+            20, 40 + h, -1
+        )
+
+        if (SyncingTask.isSyncing()) {
+            VersionFunctions.drawWrappedString(
+                context,
+                SyncingTask.getLogs(),
+                20, 78 + 30 + h,
+                500, 99,
+                -3355444
+            )
+
+            val asciiPercentage = StringBuilder()
+            var percentage = 0
+            try {
+                val builder = SyncingTask.currentRootSyncBuilder
+                val down = builder?.downloadedSize ?: 0
+                val total = builder?.updateSize ?: 0
+                percentage = if (total > 0) ((down.toFloat() / total) * 100).toInt() else 0
+
+                repeat(25) { i ->
+                    val filled = percentage / 4
+                    asciiPercentage.append(if (i >= filled) "_" else "#")
+                }
+            } catch (_: Exception) {
+            }
+            VersionFunctions.drawWrappedString(
+                context,
+                Component.translatable(
+                    "dynamicpack.screen.pack.updateStat",
+                    Constants.speedToString(NetworkStat.getSpeed()),
+                    Constants.secondsToString(SyncingTask.eta),
+                    percentage,
+                    "[$asciiPercentage]"
+                ).getString(512),
+                20, 52 + h,
+                width, 3,
+                Color.getHSBColor(
+                    sin(System.currentTimeMillis() / 1850.0).toFloat(),
+                    0.6f, 0.6f
+                ).rgb
+            )
+        } else {
+            val latestUpdated = pack.getLatestUpdated()
+            if (latestUpdated > 0) {
+                val date = Date(latestUpdated * 1000)
+                val string = DateFormat.getDateTimeInstance().format(date)
+                VersionFunctions.drawString(
+                    context,
+                    this.font,
+                    Component.translatable("dynamicpack.screen.pack.latestUpdated", string),
+                    20, 52 + h, -1
+                )
+            }
+
+            val exception = pack.getLatestException()
+            if (exception != null) {
+                VersionFunctions.drawWrappedString(
+                    context,
+                    Component.translatable(
+                        "dynamicpack.screen.pack.latestException",
+                        TranslatableException.getComponentFromException(exception)
+                    ).getString(512),
+                    20, 82 + h,
+                    width - 40, 4,
+                    -56798
+                )
+            }
+        }
+
+        //? if < 1.21
+        /*super.render(context, mouseX, mouseY, delta)*/
+    }
+
+    private fun hideSyncSpecButtons() {
+        syncButtonThis.visible = false
+        syncButtonAll.visible = false
+    }
+
+    override fun init() {
+        addRenderableWidget(
+            VersionFunctions.createButton<Button>(
+                Component.translatable("dynamicpack.screen.pack.manually_sync"),
+                {
+                    syncButtonThis.visible = !syncButtonThis.visible
+                    syncButtonAll.visible = !syncButtonAll.visible
+                },
+                100, 20, width - 120, 10
+            ).also { syncButton = it }
+        )
+
+        addRenderableWidget(
+            VersionFunctions.createButton<Button>(
+                Component.translatable("dynamicpack.screen.pack.manually_sync.this"),
+                {
+                    DynamicPackMod.instance.startManuallySync(pack)
+                    hideSyncSpecButtons()
+                },
+                48, 20, width - 120, 35
+            ).also { syncButtonThis = it }
+        )
+
+        addRenderableWidget(
+            VersionFunctions.createButton<Button>(
+                Component.translatable("dynamicpack.screen.pack.manually_sync.all"),
+                {
+                    DynamicPackMod.instance.startManuallySync()
+                    hideSyncSpecButtons()
+                },
+                48, 20, width - 66, 35
+            ).also { syncButtonAll = it }
+        )
+
+        if (!DynamicPackMod.isResourcePackActive(pack) && Config.getInstance().isUpdateOnlyEnabledPacks()) {
+            VersionFunctions.setTooltip(syncButtonAll, Tooltip.create(
+                Component.translatable(
+                    "dynamicpack.screen.pack.manually_sync.all.warningNotInclude"
+                ).withStyle(ChatFormatting.RED)
+            ))
+        }
+
+        hideSyncSpecButtons()
+
+        addRenderableWidget(
+            VersionFunctions.createButton<Button>(
+                CommonComponents.GUI_DONE,
+                { this.onClose() },
+                150, 20, this.width / 2 + 4, this.height - 26
+            )
+        )
+
+        addRenderableWidget(
+            VersionFunctions.createButton<Button>(
+                Component.translatable("dynamicpack.screen.pack.dynamic.contents"),
+                { Minecraft.getInstance().setScreen(ContentsScreen(this, pack)) },
+                150, 20, this.width / 2 - 154, this.height - 26
+            ).also { contentsButton = it }
+        )
+        contentsButton.visible = pack.getRemote() is DynamicRepoRemote
+    }
+
+    override fun onClose() {
+        Minecraft.getInstance().setScreen(parent)
+        pack.removeDestroyListener(destroyListener)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/widget/DynamicPackResourcePackEntryWidget.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/widget/DynamicPackResourcePackEntryWidget.kt
new file mode 100644
index 0000000..8b7b7fd
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/widget/DynamicPackResourcePackEntryWidget.kt
@@ -0,0 +1,81 @@
+package com.calculatorsteam.dynamicpack.client.gui.widget
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.client.gui.DynamicPackScreen
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.platform.VersionFunctions
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.screens.packs.PackSelectionModel
+import net.minecraft.resources.ResourceLocation
+import kotlin.math.cos
+import kotlin.math.sin
+
+/**
+ * Widget for displaying the status of DynamicPack in the resource pack selection menu.
+ */
+class DynamicPackResourcePackEntryWidget : ResourcePackEntryWidget {
+    override fun isVisible(pack: PackSelectionModel.Entry, selectable: Boolean): Boolean =
+        getDynamicPackFromArgs(pack) != null
+
+    override fun render(
+        pack: PackSelectionModel.Entry,
+        context: GuiGraphics,
+        x: Int,
+        y: Int,
+        hovered: Boolean,
+        tickDelta: Float
+    ) {
+        getDynamicPackFromArgs(pack)?.let { drawTexture(context, it, x, y, hovered) }
+    }
+
+    override fun getWidth(pack: PackSelectionModel.Entry): Int = 16
+    override fun getHeight(pack: PackSelectionModel.Entry, rowHeight: Int): Int = 16
+    override fun getY(pack: PackSelectionModel.Entry, rowHeight: Int): Int = 16
+    override fun getXMargin(pack: PackSelectionModel.Entry): Int = 2
+
+    override fun onClick(pack: PackSelectionModel.Entry) {
+        getDynamicPackFromArgs(pack)?.let { openPackScreen(it) }
+    }
+
+    private fun getDynamicPackFromArgs(entry: PackSelectionModel.Entry): DynamicResourcePack? =
+        DynamicPackMod.getDynamicPackByMinecraftName(entry.id)
+
+    companion object {
+        private val BUTTON_TEXTURE = ResourceLocation.tryBuild("dynamicpack", "select_button.png")
+        private val BUTTON_WARNING_TEXTURE = ResourceLocation.tryBuild("dynamicpack", "select_button_warning.png")
+        private val BUTTON_SYNCING_TEXTURE = ResourceLocation.tryBuild("dynamicpack", "select_button_syncing.png")
+
+        fun drawTexture(context: GuiGraphics, pack: DynamicResourcePack, x: Int, y: Int, hovered: Boolean) {
+            val latestException = pack.getLatestException()
+            when {
+                pack.isSyncing -> {
+                    VersionFunctions.drawTexture(context, BUTTON_TEXTURE, x, y, 0f, if (hovered) 16f else 0f,
+                        16, 16, 16, 32)
+
+                    val alpha = System.currentTimeMillis() / 200.0
+                    val xShift = (sin(alpha) * 6.9).toInt()
+                    val yShift = (cos(alpha) * 6.9).toInt()
+
+                    VersionFunctions.drawTexture(context, BUTTON_SYNCING_TEXTURE,
+                        x + xShift + 6, y + yShift + 6,
+                        0f, if (hovered) 16f else 0f,
+                        4, 4, 16, 32)
+                }
+                latestException != null -> {
+                    VersionFunctions.drawTexture(context, BUTTON_WARNING_TEXTURE, x, y, 0f,
+                        if (hovered) 16f else 0f, 16, 16, 16, 32)
+                }
+                else -> {
+                    VersionFunctions.drawTexture(context, BUTTON_TEXTURE, x, y, 0f,
+                        if (hovered) 16f else 0f, 16, 16, 16, 32)
+                }
+            }
+        }
+
+        fun openPackScreen(pack: DynamicResourcePack) {
+            val mc = Minecraft.getInstance()
+            mc.setScreen(DynamicPackScreen(mc.screen, pack))
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/widget/ResourcePackEntryWidget.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/widget/ResourcePackEntryWidget.kt
new file mode 100644
index 0000000..90c72ef
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/client/gui/widget/ResourcePackEntryWidget.kt
@@ -0,0 +1,26 @@
+package com.calculatorsteam.dynamicpack.client.gui.widget
+
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.screens.packs.PackSelectionModel
+
+/**
+ * Represents an additional widget inserted on the right-hand side of a resource pack entry
+ * (in the resource pack or data pack screen).
+ */
+interface ResourcePackEntryWidget {
+    fun isVisible(pack: PackSelectionModel.Entry, selectable: Boolean): Boolean = true
+    fun getWidth(pack: PackSelectionModel.Entry): Int
+    fun getHeight(pack: PackSelectionModel.Entry, rowHeight: Int): Int
+    fun getY(pack: PackSelectionModel.Entry, rowHeight: Int): Int =
+        (rowHeight - getHeight(pack, rowHeight)) / 2
+    fun getXMargin(pack: PackSelectionModel.Entry): Int = 7
+    fun render(
+        pack: PackSelectionModel.Entry,
+        context: GuiGraphics,
+        x: Int,
+        y: Int,
+        hovered: Boolean,
+        tickDelta: Float
+    )
+    fun onClick(pack: PackSelectionModel.Entry)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/AbstractPack.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/AbstractPack.kt
new file mode 100644
index 0000000..d47b139
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/AbstractPack.kt
@@ -0,0 +1,8 @@
+package com.calculatorsteam.dynamicpack.pack
+
+/**
+ * Base contract for packs.
+ */
+interface AbstractPack {
+    val isSyncing: Boolean
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/DynamicResourcePack.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/DynamicResourcePack.kt
new file mode 100644
index 0000000..e4e5066
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/DynamicResourcePack.kt
@@ -0,0 +1,254 @@
+package com.calculatorsteam.dynamicpack.pack
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.sync.SyncBuilder
+import com.calculatorsteam.dynamicpack.sync.SyncProgress
+import com.calculatorsteam.dynamicpack.sync.SyncingTask
+import com.calculatorsteam.dynamicpack.util.*
+import com.calculatorsteam.dynamicpack.util.LockUtils
+import com.calculatorsteam.dynamicpack.util.log.Out
+import com.calculatorsteam.dynamicpack.util.status.StatusChecker
+import com.google.gson.JsonObject
+import java.io.File
+import java.io.IOException
+import java.nio.file.Path
+
+class DynamicResourcePack(
+    private val location: File, // in resourcepack dir
+    private val cachedJson: JsonObject // json of dynamicmcpack.json
+) : AbstractPack {
+
+    private val remote: Remote
+    private val remoteTypeStr: String
+
+    private var cachedUpdateAvailable: Boolean = false
+    private var latestException: Exception? = null
+    private val destroyListeners = mutableListOf<(DynamicResourcePack) -> Unit>()
+
+    private var _isSyncing: Boolean = false
+    private var destroyed: Boolean = false
+    private var activeSyncBuilder: SyncBuilder? = null
+
+    init {
+        try {
+            val remoteJson = cachedJson.getAsJsonObject("remote")
+            remoteTypeStr = remoteJson.getAsJsonPrimitive("type").asString
+
+            remote = Remote.REMOTES[remoteTypeStr]?.invoke()
+                ?: throw RuntimeException("Unknown remote type: $remoteTypeStr")
+
+            remote.init(this, remoteJson)
+        } catch (e: Exception) {
+            throw RuntimeException("Failed to parse 'remote' block", e)
+        }
+    }
+
+    override val isSyncing: Boolean get() = _isSyncing
+
+    /**
+     * Return pack SyncBuilder with wrapped throws
+     */
+    fun syncBuilder(): SyncBuilder = object : SyncBuilder {
+        private var builder: SyncBuilder? = null
+        private var notUpdate = false
+
+        private fun wrapThrowable(funBlock: () -> Unit) {
+            wrapThrowableRet({ funBlock(); null }, null)
+        }
+
+        private fun <T> wrapThrowableRet(funBlock: () -> T, def: T): T {
+            return try {
+                funBlock()
+            } catch (e: Exception) {
+                _isSyncing = false
+                setLatestException(e)
+                notUpdate = true
+                error("Error while doUpdate (or init) SyncBuilder", e)
+                def
+            }
+        }
+
+        override fun init(ignoreCaches: Boolean) {
+            _isSyncing = true
+            activeSyncBuilder = this
+            wrapThrowable {
+                checkNetwork()
+                builder = remote.syncBuilder().apply { init(ignoreCaches) }
+            }
+            _isSyncing = false
+            activeSyncBuilder = null
+        }
+
+        override val downloadedSize: Long
+            get() = if (notUpdate) 0 else wrapThrowableRet({ builder?.downloadedSize ?: -1L }, -1L)
+
+        override val isUpdateAvailable: Boolean
+            get() = if (notUpdate) false else wrapThrowableRet({ builder?.isUpdateAvailable ?: false }, false)
+
+        override val updateSize: Long
+            get() = if (notUpdate) 0 else wrapThrowableRet({ builder?.updateSize ?: -1L }, -1L)
+
+        override fun doUpdate(progress: SyncProgress): Boolean {
+            if (notUpdate) return false
+
+            SyncingTask.currentPackName = name
+            return wrapThrowableRet({
+                activeSyncBuilder = this
+                _isSyncing = true
+                val b = builder?.doUpdate(progress) ?: false
+                try {
+                    validateSafePackMinecraftMeta()
+                    setLatestException(null)
+                } catch (e2: Exception) {
+                    error("Error while check safe pack meta", e2)
+                    setLatestException(e2)
+                } finally {
+                    _isSyncing = false
+                    activeSyncBuilder = null
+                }
+                b
+            }, false)
+        }
+
+        override fun interrupt() {
+            builder?.interrupt()
+        }
+    }
+
+    fun saveClientFile() {
+        try {
+            PackUtil.openPackFileSystem(location, LockUtils.createFileFinalizer(location)) {
+                saveClientFile(it)
+            }
+        } catch (e: Exception) {
+            throw RuntimeException("saveClientFile failed.", e)
+        }
+    }
+
+    fun saveClientFile(packRoot: Path) {
+        PathUtil.nioWriteText(
+            packRoot.resolve(Constants.CLIENT_FILE),
+            JsonUtil.toString(packJson)
+        )
+    }
+
+    fun isNetworkBlocked(): Boolean = StatusChecker.isBlockUpdating(remoteTypeStr)
+
+    private fun checkNetwork() {
+        if (isNetworkBlocked()) {
+            throw SecurityException("Network is blocked for remote_type=$remoteTypeStr current version of mod not safe. Update mod!")
+        }
+    }
+
+    fun isZip(): Boolean =
+        !location.isDirectory && location.name.lowercase().endsWith(".zip")
+
+    fun isDestroyed(): Boolean = destroyed
+
+    fun getRemote(): Remote = remote
+    fun getLocation(): File = location
+    val name: String get() = location.name
+    val minecraftId: String get() = "file/${location.name}"
+    val packJson: JsonObject get() = cachedJson
+    val currentJson: JsonObject get() = cachedJson.getAsJsonObject("current")
+    fun getRemoteType(): String = remoteTypeStr
+
+    fun setLatestException(e: Exception?) {
+        debug("latestException=$e")
+        latestException = e
+    }
+
+    fun getLatestException(): Exception? = latestException
+
+    fun getLatestUpdated(): Long {
+        return try {
+            cachedJson.getAsJsonObject("current").get("latest_updated").asLong
+        } catch (e: Exception) {
+            -1
+        }
+    }
+
+    fun updateJsonLatestUpdate() {
+        cachedJson.getAsJsonObject("current")
+            .addProperty("latest_updated", System.currentTimeMillis() / 1000)
+    }
+
+    @Throws(IOException::class)
+    fun checkIsUpdateAvailable(): Boolean {
+        checkNetwork()
+        return remote.checkUpdateAvailable().also { cachedUpdateAvailable = it }
+    }
+
+    fun getCachedUpdateAvailableStatus(): Boolean = cachedUpdateAvailable
+
+    @Throws(Exception::class)
+    private fun validateSafePackMinecraftMeta() {
+        PackUtil.openPackFileSystem(location) { path ->
+            val mcmeta = path.resolve(Constants.MINECRAFT_META)
+            var safe = PathUtil.isPathFileExists(mcmeta)
+            if (safe) {
+                safe = try {
+                    checkMinecraftMetaIsValid(PathUtil.readString(mcmeta))
+                } catch (_: IOException) {
+                    false
+                }
+            }
+            if (!safe) {
+                PathUtil.nioWriteText(mcmeta, Constants.UNKNOWN_PACK_MCMETA)
+            }
+        }
+    }
+
+    private fun checkMinecraftMetaIsValid(s: String): Boolean {
+        return try {
+            DynamicPackMod.instance.checkResourcePackMetaValid(s)
+        } catch (e: Exception) {
+            error("Error while check meta valid.", e)
+            false
+        }
+    }
+
+    fun addDestroyListener(runnable: (DynamicResourcePack) -> Unit) {
+        destroyListeners += runnable
+    }
+
+    fun removeDestroyListener(runnable: (DynamicResourcePack) -> Unit) {
+        destroyListeners -= runnable
+    }
+
+    fun flashback(oldestPack: DynamicResourcePack?) {
+        if (oldestPack == null) return
+        oldestPack.markAsDestroyed(this)
+
+        if (latestException == null) {
+            latestException = oldestPack.latestException
+        }
+    }
+
+    private fun markAsDestroyed(heirPack: DynamicResourcePack) {
+        destroyListeners.toTypedArray().forEach { it(heirPack) }
+        destroyListeners.clear()
+        destroyed = true
+    }
+
+    private fun interrupt() {
+        activeSyncBuilder?.interrupt()
+    }
+
+    fun debug(s: String) {
+        Out.debug("{$name} $s")
+    }
+
+    fun error(s: String, e: Throwable) {
+        Out.error("{$name} $s", e)
+    }
+
+    fun warn(s: String) {
+        Out.warn("{$name} $s")
+    }
+
+    fun println(s: String) {
+        Out.println("{$name} $s")
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/ModrinthRemote.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/ModrinthRemote.kt
new file mode 100644
index 0000000..767a757
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/ModrinthRemote.kt
@@ -0,0 +1,230 @@
+package com.calculatorsteam.dynamicpack.pack
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.sync.SyncBuilder
+import com.calculatorsteam.dynamicpack.sync.SyncProgress
+import com.calculatorsteam.dynamicpack.util.*
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getBoolean
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getInt
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getJsonArray
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getString
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optString
+import com.calculatorsteam.dynamicpack.util.LockUtils
+import com.calculatorsteam.dynamicpack.util.exception.TranslatableException
+import com.google.gson.JsonObject
+import java.io.File
+import java.io.IOException
+import java.util.NoSuchElementException
+
+/**
+ * Remote for remote.type = "modrinth"
+ */
+class ModrinthRemote : Remote() {
+    private lateinit var parent: DynamicResourcePack
+    private lateinit var cachedCurrentJson: JsonObject
+    private lateinit var projectId: String
+    private lateinit var gameVersion: String
+    private var usesCurrentGameVersion: Boolean = false
+    private var noSpecifyGameVersion: Boolean = false
+
+    override fun init(pack: DynamicResourcePack, remote: JsonObject) {
+        parent = pack
+        cachedCurrentJson = pack.currentJson
+
+        projectId = if (remote.has("project_id"))
+            remote.getString("project_id")
+        else
+            remote.getString("modrinth_project_id")
+
+        val ver = remote.optString("game_version", "no_specify") ?: "no_specify"
+        usesCurrentGameVersion = ver.equals("current", ignoreCase = true)
+        noSpecifyGameVersion = ver.equals("no_specify", ignoreCase = true)
+        gameVersion = if (usesCurrentGameVersion)
+            DynamicPackMod.instance.getCurrentGameVersion()
+        else ver
+    }
+
+    override fun syncBuilder(): SyncBuilder = object : SyncBuilder {
+        private var urlsController: UrlsController? = null
+        private lateinit var latest: LatestModrinthVersion
+        private var latestJson: JsonObject? = null
+        private var isUpdateAvailableCache: Boolean? = null
+        private var downloaded: Long = 0
+        private var updateSizeBytes: Long = 0
+
+        override val downloadedSize: Long
+            get() = downloaded
+
+        override val isUpdateAvailable: Boolean
+            get() {
+                isUpdateAvailableCache?.let { return it }
+                val b = _isUpdateAvailable(latestJson)
+                isUpdateAvailableCache = b
+                return b
+            }
+
+        override val updateSize: Long
+            get() = updateSizeBytes
+
+        @Throws(Exception::class)
+        override fun init(ignoreCaches: Boolean) {
+            latestJson = parseModrinthLatestVersionJson()
+            latest = LatestModrinthVersion.ofJson(latestJson!!)
+            if (isUpdateAvailable) {
+                updateSizeBytes = latest.size.toLong()
+            }
+        }
+
+        @Throws(Exception::class)
+        override fun doUpdate(progress: SyncProgress): Boolean {
+            if (!isUpdateAvailable) {
+                warn("Call doUpdate in modrinth-remote when update not available")
+                return false
+            }
+
+            progress.setPhase("Downloading resourcepack from modrinth")
+            val fileName = latest.url.substringAfterLast('/')
+            var tempFile: File? = null
+            var attempts = Constants.MAX_ATTEMPTS_TO_DOWNLOAD_FILE
+
+            while (attempts > 0) {
+                tempFile = Urls.downloadFileToTemp(
+                    latest.url, "dynamicpack_modrinth", ".zip",
+                    Constants.MODRINTH_HTTPS_FILE_SIZE_LIMIT,
+                    object : UrlsController() {
+                        override fun onUpdate(it: UrlsController) {
+                            progress.downloading(fileName, it.getPercentage())
+                            downloaded = it.getLatest()
+                        }
+                    }.also { urlsController = it }
+                )
+                if (urlsController?.isInterrupted() == true) return false
+                if (Hashes.sha1sum(tempFile) == latest.fileHash) break
+
+                progress.setPhase("Failed. Downloading again...")
+                attempts--
+            }
+            if (attempts == 0) {
+                progress.setPhase("Fatal error.")
+                throw RuntimeException("Failed to download correct file from modrinth.")
+            }
+
+            progress.setPhase("Updating metadata...")
+            cachedCurrentJson.addProperty("version", latest.id)
+            cachedCurrentJson.remove("version_number")
+            parent.updateJsonLatestUpdate()
+
+            // save client json to temp file
+            PackUtil.openPackFileSystem(tempFile) { parent.saveClientFile(it) }
+
+            if (parent.isZip()) {
+                progress.setPhase("Unlocking file.")
+                LockUtils.closeFile(parent.getLocation())
+
+                progress.setPhase("Move files...")
+                PathUtil.moveFile(tempFile, parent.getLocation())
+            } else {
+                progress.setPhase("Extracting files...")
+                PathUtil.recursiveDeleteDirectory(parent.getLocation())
+                PathUtil.unzip(tempFile, parent.getLocation())
+                PathUtil.delete(tempFile?.toPath())
+            }
+
+            // save client json again
+            progress.setPhase("Saving dynamicmcpack.json")
+            parent.saveClientFile()
+            progress.setPhase("Success")
+            return true
+        }
+
+        override fun interrupt() {
+            urlsController?.interrupt()
+        }
+    }
+
+    fun getCurrentUnique(): String =
+        cachedCurrentJson.optString("version", "") ?: ""
+
+    fun getCurrentVersionNumber(): String =
+        cachedCurrentJson.optString("version_number", "") ?: ""
+
+    fun getApiVersionsUrl(): String =
+        "https://api.modrinth.com/v2/project/$projectId/version"
+
+    fun getProjectId(): String = projectId
+    fun isUsesCurrentGameVersion(): Boolean = usesCurrentGameVersion
+
+    @Throws(IOException::class)
+    fun parseModrinthLatestVersionJson(): JsonObject {
+        val content = Urls.parseTextContent(getApiVersionsUrl(), Constants.MOD_MODTINTH_API_LIMIT)
+            ?: throw IOException("Failed to fetch Modrinth API response")
+        val versions = JsonUtil.arrayFromString(content)
+        for (o in versions) {
+            val version = o.asJsonObject
+            if (noSpecifyGameVersion) return version
+
+            val gameVersions = version.getAsJsonArray("game_versions")
+            val supportGameVersion = gameVersions
+                .map { it.asString }
+                .any { it == gameVersion }
+            if (supportGameVersion) return version
+        }
+        throw TranslatableException(
+            "Could not find the latest version on modrinth with suitable parameters",
+            "dynamicpack.exceptions.pack.remote.modrinth.not_found_latest_version"
+        )
+    }
+
+    @Throws(IOException::class)
+    override fun checkUpdateAvailable(): Boolean {
+        val latest = parseModrinthLatestVersionJson()
+        return _isUpdateAvailable(latest)
+    }
+
+    private fun _isUpdateAvailable(latest: JsonObject?): Boolean {
+        if (latest == null) {
+            warn("Latest version not available for this game_version")
+            return false
+        }
+        if (latest.optString("version_number", "") == getCurrentVersionNumber()) {
+            debug("Version number equal. Update not available")
+            return false
+        }
+        val id = latest.getString("id")
+        debug("Version remote.id=$id; current=${getCurrentUnique()}")
+        return getCurrentUnique() != id
+    }
+
+    /**
+     * Data-object for version in Modrinth API. Uses only for latest version.
+     */
+    data class LatestModrinthVersion(
+        val id: String,
+        val versionNumber: String,
+        val url: String,
+        val fileHash: String,
+        val size: Int
+    ) {
+        companion object {
+            fun ofJson(latest: JsonObject): LatestModrinthVersion {
+                val latestId = latest.getString("id")
+                val latestVersionNumber = latest.getString("version_number")
+                val files = latest.getAsJsonArray("files")
+                for (element in files) {
+                    val file = element.asJsonObject
+                    if (file.getAsJsonPrimitive("primary").asBoolean) {
+                        val url = file.getAsJsonPrimitive("url").asString
+                        val size = file.getAsJsonPrimitive("size").asInt
+                        val hash = file.getAsJsonObject("hashes").getAsJsonPrimitive("sha1").asString
+                        return LatestModrinthVersion(latestId, latestVersionNumber, url, hash, size)
+                    }
+                }
+                throw NoSuchElementException("File json-object with primary=true not found... Modrinth API???")
+            }
+        }
+    }
+
+    fun debug(s: String) = parent.debug(s)
+    fun warn(s: String) = parent.warn(s)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/Remote.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/Remote.kt
new file mode 100644
index 0000000..0b4d55c
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/Remote.kt
@@ -0,0 +1,45 @@
+package com.calculatorsteam.dynamicpack.pack
+
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.DynamicRepoRemote
+import com.calculatorsteam.dynamicpack.sync.SyncBuilder
+import com.google.gson.JsonObject
+import org.jetbrains.annotations.ApiStatus
+import java.io.IOException
+
+/**
+ * Abstract remote of pack
+ */
+abstract class Remote {
+
+    /**
+     * Init this remote object and associate with pack
+     * @param pack parent
+     * @param remote root.remote
+     */
+    abstract fun init(pack: DynamicResourcePack, remote: JsonObject)
+
+    abstract fun syncBuilder(): SyncBuilder
+
+    @Throws(IOException::class)
+    abstract fun checkUpdateAvailable(): Boolean
+
+    @ApiStatus.OverrideOnly
+    open fun interrupt() {
+        // default empty implementation
+    }
+
+    companion object {
+        private var initialized = false
+
+        @JvmField
+        val REMOTES: MutableMap<String, () -> Remote> = HashMap()
+
+        @JvmStatic
+        fun initRemoteTypes() {
+            if (initialized) return
+            initialized = true
+            REMOTES["modrinth"] = { ModrinthRemote() }
+            REMOTES["dynamic_repo"] = { DynamicRepoRemote() }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/BaseContent.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/BaseContent.kt
new file mode 100644
index 0000000..a680892
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/BaseContent.kt
@@ -0,0 +1,63 @@
+package com.calculatorsteam.dynamicpack.pack.dynamicrepo
+
+import com.calculatorsteam.dynamicpack.util.enums.OverrideType
+
+/**
+ * Base content description in DynamicRepoRemote.
+ *
+ * BREAKING CHANGES:
+ * since 1.0.31 ignoring [required] key.
+ */
+class BaseContent(
+    val parentRemote: DynamicRepoRemote,
+    val id: String,
+    val required: Boolean,
+    var overrideType: OverrideType,
+    val name: String?,
+    private val defaultStatus: Boolean,
+    val hidden: Boolean,
+    val exclude: Set<String>
+) {
+
+    /**
+     * Switch override value to next state.
+     */
+    fun nextOverride(baseContents: Array<BaseContent>) {
+        setOverrideType(overrideType.next(), baseContents)
+    }
+
+    /**
+     * Set override value and enforce exclusions.
+     */
+    fun setOverrideType(override: OverrideType, baseContents: Array<BaseContent>) {
+        overrideType = override
+        val status = state
+
+        if (status) {
+            exclude.forEach { excludeId ->
+                val byId = findById(baseContents, excludeId)
+                    ?: throw NullPointerException("Content with id=$excludeId not found")
+
+                if (byId.required) {
+                    throw RuntimeException("Exclude a required not allowed!")
+                }
+                if (byId.state) {
+                    byId.setOverrideType(OverrideType.FALSE, baseContents)
+                }
+            }
+        }
+    }
+
+    /** Current effective state */
+    private val state: Boolean
+        get() = overrideType.asBoolean(required || defaultStatus)
+
+    val defaultState: Boolean
+        get() = defaultStatus
+
+    companion object {
+        @JvmStatic
+        fun findById(contents: Array<BaseContent>, findId: String): BaseContent? =
+            contents.firstOrNull { it.id.equals(findId, ignoreCase = true) }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/BaseEnum.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/BaseEnum.kt
new file mode 100644
index 0000000..1fbeaff
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/BaseEnum.kt
@@ -0,0 +1,95 @@
+package com.calculatorsteam.dynamicpack.pack.dynamicrepo
+
+import com.calculatorsteam.dynamicpack.util.enums.OverrideType
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getBoolean
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getString
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optString
+import com.google.gson.JsonObject
+
+/**
+ * Representation of an "enum" in dynamic repo remote.
+ */
+class BaseEnum private constructor(
+    val id: String,
+    val name: String,
+    private val elements: LinkedHashMap<String, Element>
+) {
+
+    companion object {
+        fun ofJson(json: JsonObject): BaseEnum {
+            val id = json.getString("id")
+            val name = json.optString("name", "Unknown") ?: "Unknown"
+
+            val enumJson = json.getAsJsonObject("enum")
+            val elements = LinkedHashMap<String, Element>()
+
+            for (key in enumJson.keySet()) {
+                val element = Element.ofJson(enumJson.getAsJsonObject(key))
+                elements[key] = element
+            }
+
+            return BaseEnum(id, name, elements)
+        }
+    }
+
+    /** Returns the display name of the current state */
+    fun getCurrentState(contents: Array<BaseContent>): String =
+        getCurrentElement(contents)?.name ?: "Unknown"
+
+    /** Returns the current matching element if any */
+    fun getCurrentElement(contents: Array<BaseContent>): Element? {
+        return elements.values.firstOrNull { element ->
+            element.contents.all { (contentId, requiredBool) ->
+                val baseContent = BaseContent.findById(contents, contentId)
+                baseContent?.overrideType?.asBoolean(baseContent.defaultState) == requiredBool
+            }
+        }
+    }
+
+    /**
+     * Cycle to next element, apply its overrides.
+     */
+    @Throws(Exception::class)
+    fun applyNext(contents: Array<BaseContent>) {
+        val current = getCurrentElement(contents)
+        val values = elements.values.toList()
+
+        val next = if (current == null) {
+            values.firstOrNull()
+        } else {
+            val index = values.indexOf(current)
+            if (index == -1) values.firstOrNull()
+            else values[(index + 1) % values.size]
+        }
+
+        next?.apply(contents)
+    }
+
+    data class Element(
+        val name: String,
+        val contents: Map<String, Boolean>
+    ) {
+        companion object {
+            fun ofJson(json: JsonObject): Element {
+                val name = json.getString("name")
+                val contents = mutableMapOf<String, Boolean>()
+
+                val jsonContents = json.getAsJsonObject("contents")
+                for (contentId in jsonContents.keySet()) {
+                    val bool = jsonContents.getBoolean(contentId)
+                    contents[contentId] = bool
+                }
+                return Element(name, contents)
+            }
+        }
+
+        @Throws(Exception::class)
+        fun apply(contentsArray: Array<BaseContent>) {
+            contents.forEach { (contentId, bool) ->
+                val base = BaseContent.findById(contentsArray, contentId)
+                    ?: throw RuntimeException("Content with id=$contentId not found")
+                base.setOverrideType(OverrideType.ofBoolean(bool), contentsArray)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicFile.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicFile.kt
new file mode 100644
index 0000000..2c5a7a4
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicFile.kt
@@ -0,0 +1,26 @@
+package com.calculatorsteam.dynamicpack.pack.dynamicrepo
+
+import java.nio.file.Path
+
+/**
+ * File descriptor in DynamicRepo.
+ *
+ * @param size size from remote! May be Int.MAX_VALUE if remote deprecated!
+ */
+data class DynamicFile(
+    val url: String,
+    val path: String,
+    val size: Int,
+    val hash: String,
+    var downloadedPath: Path? = null
+) {
+    override fun toString(): String = buildString {
+        append("DynamicFile(")
+        append("url=").append(url)
+        append(", path=").append(path)
+        append(", size=").append(size)
+        append(", hash=").append(hash)
+        append(", tempPath=").append(downloadedPath)
+        append(")")
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoPreferences.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoPreferences.kt
new file mode 100644
index 0000000..a1cab8e
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoPreferences.kt
@@ -0,0 +1,232 @@
+package com.calculatorsteam.dynamicpack.pack.dynamicrepo
+
+import com.calculatorsteam.dynamicpack.InputValidator
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.util.enums.OverrideType
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getBoolean
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getJsonArray
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getString
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optBoolean
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optString
+import com.calculatorsteam.dynamicpack.util.log.Out
+import com.google.gson.JsonArray
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+
+class DynamicRepoPreferences(
+    private val pack: DynamicResourcePack,
+    private val remote: DynamicRepoRemote
+) {
+    // if key exists, value used for override content. If content is required it ignored...
+    private val contentOverrides = mutableMapOf<String, Boolean>()
+
+    private val cachedRemoteJson: JsonObject = remote.cachedRemote
+    private val cachedCurrentJson: JsonObject = remote.cachedCurrent
+
+    init {
+        recalculateContentOverrideFromJson()
+    }
+
+    /**
+     * Update this.contentOverrides from cachedRemoteJson
+     */
+    private fun recalculateContentOverrideFromJson() {
+        contentOverrides.clear()
+        if (cachedRemoteJson.has("content_override")) {
+            val j = cachedRemoteJson.getAsJsonObject("content_override")
+            j.keySet().forEach { key ->
+                contentOverrides[key] = j.getBoolean(key)
+            }
+            if (j.size() == 0) cachedCurrentJson.remove("content_override")
+        }
+    }
+
+    fun notifyNewRemoteJson(repoJson: JsonObject) {
+        val contents = repoJson.getJsonArray("contents") ?: JsonArray()
+        val guis = repoJson.getJsonArray("gui")
+
+        if (guis == null) {
+            Out.debug("Repo not using 'gui' features.")
+        }
+
+        updateKnownContents(contents)
+        updateKnownGuis(guis)
+    }
+
+    private fun updateKnownGuis(guis: JsonArray?) {
+        if (guis != null) {
+            validateGuis(guis)
+            cachedCurrentJson.add("known_guis", guis)
+        } else cachedCurrentJson.remove("known_guis")
+    }
+
+    private fun validateGuis(guis: JsonArray) {
+        for (_gui in guis) {
+            val gui = _gui.asJsonObject
+            val type = gui.getString("type")
+            val id = gui.getString("id")
+
+            InputValidator.throwIsContentIdInvalid(id)
+            InputValidator.throwIsContentIdInvalid(type)
+
+            if (type.equals("enum", ignoreCase = true)) {
+                val enums = gui.getAsJsonObject("enum")
+                enums.keySet().forEach { key ->
+                    InputValidator.throwIsContentIdInvalid(key)
+                    val anEnum = enums.getAsJsonObject(key)
+
+                    if (!InputValidator.isDynamicPackNameValid(anEnum.getString("name"))) {
+                        throw RuntimeException("Name of enum element invalid :( enumKey=$key")
+                    }
+
+                    val contents = anEnum.getAsJsonObject("contents")
+                    contents.keySet().forEach { contentId ->
+                        // call get for validate is boolean
+                        contents.get(contentId).asBoolean
+
+                        val found = BaseContent.findById(getKnownContents(), contentId)
+                        requireNotNull(found) { "Content from enum not found :(" }
+
+                        if (found.required) {
+                            throw RuntimeException("Override 'required':true content in enum not allowed!")
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private fun getContentJsonById(contents: JsonArray, findId: String): JsonObject? {
+        Out.debug("getContentJsonById findId=$findId")
+        return contents.firstOrNull {
+            it.asJsonObject.getString("id").equals(findId, ignoreCase = true)
+        }?.asJsonObject
+    }
+
+    private fun updateKnownContents(contents: JsonArray) {
+        val knownContents = JsonObject()
+        for (contentElem in contents) {
+            val jsonObject = contentElem.asJsonObject
+            val id = jsonObject.getString("id")
+            val required = jsonObject.optBoolean("required", false)
+
+            if (required) setContentOverride(id, OverrideType.NOT_SET)
+
+            val excludeContent = parseContentList(jsonObject, "exclude_content")
+
+            excludeContent.forEach { s ->
+                val cont = getContentJsonById(contents, s)
+                    ?: throw RuntimeException("exclude_content contains id not found content :(")
+                if (cont.optBoolean("required", false)) {
+                    throw RuntimeException("Exclude required content not allowed!")
+                }
+            }
+            if (excludeContent.contains(id)) {
+                throw RuntimeException("Self id in exclude list. Not allowed!")
+            }
+
+            val newJsonObject = jsonObject.deepCopy().apply { remove("id") }
+            knownContents.add(id, newJsonObject)
+        }
+        cachedCurrentJson.add("known_contents", knownContents)
+    }
+
+    /** Is content active by overrides (only settings) */
+    fun isContentActive(id: String, def: Boolean): Boolean {
+        return contentOverrides[id] ?: def
+    }
+
+    fun getKnownContents(): Array<BaseContent> {
+        return try {
+            if (cachedCurrentJson.has("known_contents")) {
+                val known = cachedCurrentJson.getAsJsonObject("known_contents")
+                val list = mutableListOf<BaseContent>()
+                known.keySet().forEach { contentId ->
+                    val content = known.getAsJsonObject(contentId)
+                    val required = content.optBoolean("required", false)
+                    val defaultValue = content.optBoolean("default_active", true)
+                    val hidden = content.optBoolean("hidden", false)
+                    val name = content.optString("name", null)
+                    val resultOverride =
+                        if (required) OverrideType.TRUE else getCurrentOverrideStatus(contentId)
+                    val exclude = parseContentList(content, "exclude_content")
+
+                    list += BaseContent(remote, contentId, required, resultOverride, name, defaultValue, hidden, exclude)
+                }
+                list.toTypedArray()
+            } else emptyArray()
+        } catch (e: Exception) {
+            pack.setLatestException(e)
+            Out.error("Error while getKnownContents()", e)
+            emptyArray()
+        }
+    }
+
+    private fun parseContentList(content: JsonObject, key: String): Set<String> {
+        val set = mutableSetOf<String>()
+        if (content.has(key)) {
+            val element = content.get(key)
+            if (element.isJsonArray) {
+                element.asJsonArray.forEach { jsonElement ->
+                    val str = jsonElement.asString
+                    if (!set.add(str)) throw RuntimeException("$key: duplicated!")
+                }
+            } else if (element.isJsonPrimitive) {
+                set.add(element.asString)
+            }
+        }
+        return set
+    }
+
+    private fun getCurrentOverrideStatus(contentId: String): OverrideType {
+        return contentOverrides[contentId]?.let { OverrideType.ofBoolean(it) } ?: OverrideType.NOT_SET
+    }
+
+    fun setContentOverride(content: BaseContent, overrideType: OverrideType) {
+        val effective = if (content.required) OverrideType.NOT_SET else overrideType
+        setContentOverride(content.id, effective)
+    }
+
+    fun setContentOverride(id: String, overrideType: OverrideType) {
+        Out.debug("setContentOverride: $id: $overrideType")
+        val override: JsonObject? = if (cachedRemoteJson.has("content_override")) {
+            cachedRemoteJson.getAsJsonObject("content_override")
+        } else if (overrideType != OverrideType.NOT_SET) {
+            JsonObject()
+        } else null
+
+        if (override != null) {
+            if (overrideType == OverrideType.NOT_SET) {
+                override.remove(id)
+            } else {
+                override.addProperty(id, overrideType.asBoolean())
+            }
+            if (override.keySet().isEmpty()) {
+                cachedRemoteJson.remove("content_override")
+            } else if (!cachedRemoteJson.has("content_override")) {
+                cachedRemoteJson.add("content_override", override)
+            }
+        }
+        recalculateContentOverrideFromJson()
+    }
+
+    fun getKnownEnums(): Array<BaseEnum> {
+        return try {
+            if (cachedCurrentJson.has("known_guis")) {
+                val known = cachedCurrentJson.getAsJsonArray("known_guis")
+                val enums = mutableListOf<BaseEnum>()
+                known.forEach { elem ->
+                    val jsonEnum = elem.asJsonObject
+                    // type must be enum
+                    if (!jsonEnum.getString("type").equals("enum", ignoreCase = true)) return@forEach
+                    enums += BaseEnum.ofJson(jsonEnum)
+                }
+                enums.toTypedArray()
+            } else emptyArray()
+        } catch (e: Exception) {
+            pack.setLatestException(e)
+            Out.error("Error while getKnownEnums()", e)
+            emptyArray()
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoRemote.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoRemote.kt
new file mode 100644
index 0000000..4b67518
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoRemote.kt
@@ -0,0 +1,79 @@
+package com.calculatorsteam.dynamicpack.pack.dynamicrepo
+
+import com.calculatorsteam.dynamicpack.InputValidator
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.pack.Remote
+import com.calculatorsteam.dynamicpack.sync.SyncBuilder
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getString
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optLong
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optBoolean
+import com.calculatorsteam.dynamicpack.util.Urls
+import com.google.gson.JsonObject
+import java.io.IOException
+
+/**
+ * Remote for type = dynamic_repo
+ */
+class DynamicRepoRemote : Remote() {
+
+    companion object {
+        const val REPO_JSON = "dynamicmcpack.repo.json"
+        const val REPO_BUILD = "dynamicmcpack.repo.build"
+    }
+
+    lateinit var parent: DynamicResourcePack
+        private set
+
+    private lateinit var cachedCurrentJson: JsonObject
+    private lateinit var cachedRemoteJson: JsonObject
+    lateinit var url: String
+        private set
+    lateinit var buildUrl: String
+        private set
+    lateinit var packUrl: String
+        private set
+    lateinit var preferences: DynamicRepoPreferences
+        private set
+
+    override fun init(pack: DynamicResourcePack, remote: JsonObject) {
+        parent = pack
+        cachedRemoteJson = remote
+        cachedCurrentJson = pack.currentJson
+
+        url = remote.getString("url")
+        InputValidator.throwIsUrlInvalid(url)
+
+        buildUrl = "$url/$REPO_BUILD"
+        packUrl = "$url/$REPO_JSON"
+
+        preferences = DynamicRepoPreferences(pack, this)
+
+        val signNoRequired = remote.optBoolean("sign_no_required", false)
+        if (signNoRequired == remote.has("public_key")) {
+            throw RuntimeException("Please add sign_no_required=true")
+        }
+    }
+
+    override fun syncBuilder(): SyncBuilder = DynamicRepoSyncBuilder(parent, this)
+
+    @Throws(IOException::class)
+    override fun checkUpdateAvailable(): Boolean {
+        val content = Urls.parseTextContent(buildUrl, 64)?.trim()
+            ?: throw IOException("Empty response from $buildUrl")
+        return currentBuild != content.toLong()
+    }
+
+    val currentBuild: Long
+        get() = cachedCurrentJson.optLong("build", -1)
+
+    val cachedCurrent: JsonObject
+        get() = cachedCurrentJson
+
+    val cachedRemote: JsonObject
+        get() = cachedRemoteJson
+
+    fun notifyNewRemoteJson(repoJson: JsonObject) {
+        val copy = repoJson.deepCopy()
+        preferences.notifyNewRemoteJson(copy)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoSyncBuilder.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoSyncBuilder.kt
new file mode 100644
index 0000000..8c6b572
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/pack/dynamicrepo/DynamicRepoSyncBuilder.kt
@@ -0,0 +1,378 @@
+package com.calculatorsteam.dynamicpack.pack.dynamicrepo
+
+import com.calculatorsteam.dynamicpack.InputValidator
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.sync.SyncBuilder
+import com.calculatorsteam.dynamicpack.sync.SyncProgress
+import com.calculatorsteam.dynamicpack.util.*
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getLong
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getString
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optBoolean
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optInt
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optLong
+import com.calculatorsteam.dynamicpack.util.JsonUtil.optString
+import com.calculatorsteam.dynamicpack.util.LockUtils
+import com.calculatorsteam.dynamicpack.util.log.NetworkStat
+import com.google.gson.JsonArray
+import com.google.gson.JsonObject
+import java.io.File
+import java.nio.charset.StandardCharsets
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardCopyOption
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+import java.util.concurrent.ThreadFactory
+
+class DynamicRepoSyncBuilder(
+    private val pack: DynamicResourcePack,
+    private val remote: DynamicRepoRemote
+) : SyncBuilder {
+
+    private val oldestFilesList = mutableSetOf<String>()
+    private var doNotDeleteOldestFiles = false
+    private val dynamicFiles = mutableMapOf<String, DynamicFile>()
+
+    private var updateAvailable: Boolean = false
+    private var _updateSize: Long = 0
+    private var _downloadedSize: Long = 0
+    private lateinit var repoJson: JsonObject
+
+    private var reloadRequired: Boolean = false
+    private var interrupted: Boolean = false
+
+    override fun init(ignoreCaches: Boolean) {
+        updateAvailable = ignoreCaches || remote.checkUpdateAvailable()
+        if (updateAvailable) {
+            val packUrlContent = Urls.parseTextContent(
+                remote.packUrl,
+                Constants.MOD_FILES_LIMIT,
+                object : UrlsController() {
+                    override fun isInterrupted() = interrupted
+                }
+            )?.trim() ?: throw RuntimeException("Empty repo response")
+
+            repoJson = JsonUtil.fromString(packUrlContent)
+
+            val formatVersion = repoJson.get("formatVersion").asLong
+            if (formatVersion != 1L) {
+                throw RuntimeException("Incompatible formatVersion: $formatVersion")
+            }
+
+            val minBuild = repoJson.optLong("minimal_mod_build", Constants.VERSION_BUILD)
+            if (minBuild > Constants.VERSION_BUILD) {
+                throw RuntimeException(
+                    "Incompatible DynamicPack Mod version: required $minBuild, current=${Constants.VERSION_BUILD}"
+                )
+            }
+
+            val remoteName = repoJson.getString("name")
+            if (!InputValidator.isDynamicPackNameValid(remoteName)) {
+                throw RuntimeException("Remote name not valid")
+            }
+
+            PackUtil.openPackFileSystem(pack.getLocation()) { fs ->
+                PathUtil.walkScan(oldestFilesList, fs)
+            }
+
+            try {
+                checkContents(repoJson.getAsJsonArray("contents"))
+                remote.notifyNewRemoteJson(repoJson)
+
+                calcActiveContents().forEach { processContentInit(it) }
+            } catch (e: Exception) {
+                doNotDeleteOldestFiles = true
+                throw e
+            }
+        }
+    }
+
+    private fun checkContents(contents: JsonArray) {
+        val ids = mutableSetOf<String>()
+        for (elem in contents) {
+            val obj = elem.asJsonObject
+            val id = obj.getString("id")
+            InputValidator.throwIsContentIdInvalid(id)
+            if (!ids.add(id)) {
+                throw RuntimeException("Duplicate content found: $id")
+            }
+        }
+    }
+
+    override val downloadedSize: Long
+        get() = _downloadedSize
+
+    override fun doUpdate(progress: SyncProgress): Boolean {
+        progress.setPhase("Opening a pack file-system")
+        PackUtil.openPackFileSystem(pack.getLocation(), LockUtils.createFileFinalizer(pack.getLocation())) { packFs ->
+            internalProcessDynamicFiles(progress, packFs)
+
+            if (!doNotDeleteOldestFiles && !interrupted) {
+                progress.setPhase("Deleting unnecessary files")
+                oldestFilesList.forEach { s ->
+                    val pathToFile = packFs.resolve(s)
+                    if (pathToFile.fileName.toString().equals(Constants.CLIENT_FILE, true)) return@forEach
+
+                    progress.deleted(pathToFile)
+                    PathUtil.nioSmartDelete(pathToFile)
+                    markReloadRequired(s)
+                }
+            }
+
+            progress.setPhase("Updating metadata...")
+            pack.packJson.getAsJsonObject("current")
+                .addProperty("build", repoJson.getLong("build"))
+            pack.updateJsonLatestUpdate()
+            pack.saveClientFile(packFs)
+        }
+        progress.setPhase("Success")
+        return reloadRequired
+    }
+
+    override fun interrupt() {
+        interrupted = true
+    }
+
+    override val isUpdateAvailable: Boolean
+        get() = updateAvailable
+
+    override val updateSize: Long
+        get() = _updateSize
+
+    private fun processContentInit(jsonContent: JsonObject) {
+        val id = jsonContent.getString("id")
+        InputValidator.throwIsContentIdInvalid(id)
+        var url = jsonContent.getString("url")
+        var urlCompressed = jsonContent.optString("url_compressed", null)
+        val compressSupported = urlCompressed != null
+        checkPathSafety(url)
+        val hash = jsonContent.getString("hash")
+
+        url = "${remote.url}/$url"
+        if (compressSupported) {
+            checkPathSafety(urlCompressed)
+            urlCompressed = "${remote.url}/$urlCompressed"
+        }
+
+        val content = if (compressSupported) {
+            Urls.parseTextGZippedContent(urlCompressed!!, Constants.GZIP_LIMIT, null)
+        } else {
+            Urls.parseTextContent(url, Constants.MOD_FILES_LIMIT, null)
+        } ?: throw RuntimeException("Can't load content $url")
+
+        val receivedHash = Hashes.sha1sum(content.toByteArray(StandardCharsets.UTF_8))
+        if (hash != receivedHash) {
+            throw SecurityException("Hash mismatch for content $url")
+        }
+
+        val jsonContentD2 = JsonUtil.fromString(content)
+        PackUtil.openPackFileSystem(remote.parent.getLocation(), LockUtils.createFileFinalizer(pack.getLocation())) { packFs ->
+            val formatVersion = jsonContentD2.getLong("formatVersion")
+            if (formatVersion != 1L) throw RuntimeException("Incompatible formatVersion=$formatVersion")
+
+            val c = jsonContentD2.getAsJsonObject("content")
+            val parentPath = c.optString("parent", "") ?: ""
+            val rem = c.optString("remote_parent", "") ?: ""
+            val files = c.getAsJsonObject("files")
+
+            var processedFiles = 0
+            for (fileEntry in files.keySet()) {
+                if (interrupted) return@openPackFileSystem
+                var pathValidated = false
+                try {
+                    val relPath = getAndCheckPath(parentPath, fileEntry)
+                    InputValidator.throwIsPathInvalid(relPath)
+                    pathValidated = true
+                    val filePath = packFs.resolve(relPath)
+
+                    if (filePath.fileName.toString().contains(Constants.CLIENT_FILE)) {
+                        warn("File ${Constants.CLIENT_FILE} can't be updated remotely!")
+                        continue
+                    }
+
+                    val fileRemoteUrl = getUrlFromPathAndCheck(rem, relPath)
+                    val fileExtra = files.getAsJsonObject(fileEntry)
+                    val fileHash = fileExtra.getString("hash")
+                    val fileSize = fileExtra.optInt("size", Int.MAX_VALUE)
+
+                    if (!InputValidator.isHashValid(fileHash)) {
+                        warn("Hash not valid for file: $relPath")
+                        continue
+                    }
+
+                    oldestFilesList.remove(relPath)
+
+                    var isNeedOverwrite = !Files.exists(filePath) ||
+                            Hashes.sha1sum(filePath) != fileHash
+
+                    if (dynamicFiles.containsKey(relPath)) {
+                        warn("File duplicates across contents: $relPath")
+                        _updateSize -= dynamicFiles[relPath]!!.size.toLong()
+                        isNeedOverwrite = true
+                    }
+
+                    if (isNeedOverwrite) {
+                        val dyn = DynamicFile(fileRemoteUrl, relPath, fileSize, fileHash)
+                        _updateSize += fileSize.toLong()
+                        dynamicFiles[relPath] = dyn
+                    }
+
+                    processedFiles++
+                } catch (e: Exception) {
+                    val errorFile = if (pathValidated) fileEntry else "(failed to validate)"
+                    error("Error while process file $errorFile", e)
+                }
+            }
+            println("Total initialized files in content '$id': $processedFiles")
+        }
+    }
+
+    private fun internalProcessDynamicFiles(progress: SyncProgress, packFs: Path) {
+        debug("internalProcessDynamicFiles begin")
+        NetworkStat.speedMultiplier = DOWNLOAD_THREADS_COUNT.toLong()
+        val tempPath: Path? = if (pack.isZip()) {
+            val tmp = File(System.getProperty("java.io.tmpdir") + File.separator + Constants.TEMP_DIR_NAME, pack.name).toPath()
+            if (!Files.exists(tmp)) {
+                PathUtil.createDirsToFile(tmp)
+                Files.createDirectory(tmp)
+            }
+            tmp
+        } else null
+
+        val executor = getExecutor()
+        CompletableFuture.supplyAsync({ dynamicFiles.values }, executor)
+            .thenCompose { files ->
+                val futs = files.map { file ->
+                    CompletableFuture.supplyAsync({
+                        if (interrupted) throw InterruptedException("Interrupted")
+                        downloadFile(tempPath ?: packFs, file, progress)
+                        file
+                    }, executor).exceptionally {
+                        error("Error while download a file", it)
+                        null
+                    }
+                }
+                CompletableFuture.allOf(*futs.toTypedArray())
+                    .thenApply { futs.mapNotNull { it.join() } }
+            }.whenComplete { files, th ->
+                if (interrupted) return@whenComplete
+                if (th == null) {
+                    files.forEach { file ->
+                        if (file.downloadedPath == null) {
+                            warn("Downloaded file with null path: $file")
+                            return@forEach
+                        }
+                        markReloadRequired(file)
+                        if (tempPath != null) {
+                            try {
+                                val dest = packFs.resolve(file.path)
+                                val src = file.downloadedPath!!
+                                PathUtil.createDirsToFile(dest)
+                                Files.move(src, dest, StandardCopyOption.REPLACE_EXISTING)
+                                PathUtil.nioSmartDelete(src)
+                            } catch (e: Exception) {
+                                error("Error while moving file ${file.path}", e)
+                            }
+                        }
+                    }
+                } else throw RuntimeException(th)
+            }.join()
+        NetworkStat.speedMultiplier = 1
+        debug("internalProcessDynamicFiles end")
+    }
+
+    private fun downloadFile(rootPath: Path, dynamicFile: DynamicFile, progress: SyncProgress) {
+        val filePath = rootPath.resolve(dynamicFile.path)
+        if (filePath.fileName.toString().contains(Constants.CLIENT_FILE)) {
+            warn("File ${Constants.CLIENT_FILE} can't be updated remotely!")
+            return
+        }
+        if (PathUtil.isPathFileExists(filePath)) {
+            if (Hashes.sha1sum(filePath).equals(dynamicFile.hash, true)) {
+                warn("File ${dynamicFile.path} skipped: already exists with same hash")
+                dynamicFile.downloadedPath = filePath
+                _downloadedSize += Files.size(filePath)
+                return
+            }
+        }
+        PackUtil.downloadPackFile(dynamicFile.url, filePath, dynamicFile.hash, object : UrlsController() {
+            private var fileSize: Long = 0
+            override fun onUpdate(it: UrlsController) {
+                progress.downloading(filePath.fileName.toString(), it.getPercentage())
+                _downloadedSize -= fileSize
+                fileSize = it.getLatest()
+                _downloadedSize += fileSize
+            }
+            override fun isInterrupted() = interrupted
+        })
+        if (interrupted) {
+            progress.setPhase("Interrupted")
+            return
+        }
+        dynamicFile.downloadedPath = filePath
+        progress.setPhase("File ${dynamicFile.path} downloaded!")
+    }
+
+    private fun getExecutor(): ExecutorService {
+        val execNum = executorCounter++
+        return Executors.newFixedThreadPool(DOWNLOAD_THREADS_COUNT, object : ThreadFactory {
+            private var count = 1
+            override fun newThread(r: Runnable) = Thread(r, "DownloadWorker$execNum-${count++}")
+        })
+    }
+
+    private fun getUrlFromPathAndCheck(remoteParent: String, path: String): String {
+        checkPathSafety(remoteParent)
+        return if (remoteParent.isEmpty()) "${remote.url}/$path"
+        else "${remote.url}/$remoteParent/$path"
+    }
+
+    companion object {
+        var DOWNLOAD_THREADS_COUNT = 8
+        private var executorCounter = 0
+
+        @JvmStatic
+        fun getAndCheckPath(parent: String, path: String): String {
+            checkPathSafety(path)
+            checkPathSafety(parent)
+            return if (parent.isEmpty()) path else "$parent/$path"
+        }
+
+        @JvmStatic
+        fun checkPathSafety(s: String) {
+            if (arrayOf("://", "..", "  ", ".exe", ":", ".jar").any { s.contains(it) }) {
+                throw SecurityException("This path not safe: $s")
+            }
+        }
+    }
+
+    private fun calcActiveContents(): List<JsonObject> {
+        val active = mutableListOf<JsonObject>()
+        val arr = repoJson.getAsJsonArray("contents")
+        for (content in arr) {
+            val obj = content.asJsonObject
+            val id = obj.getString("id")
+            InputValidator.throwIsContentIdInvalid(id)
+            val defaultActive = obj.optBoolean("default_active", true)
+            val required = obj.optBoolean("required", false)
+            if (required || remote.preferences.isContentActive(id, defaultActive)) {
+                active.add(obj)
+            }
+        }
+        return active
+    }
+
+    fun isReloadRequired() = reloadRequired
+
+    private fun markReloadRequired(obj: Any) {
+        if (!reloadRequired) debug("Now reload is required because $obj")
+        reloadRequired = true
+    }
+
+    private fun debug(s: String) = pack.debug(s)
+    private fun error(s: String, e: Throwable) = pack.error(s, e)
+    private fun warn(s: String) = pack.warn(s)
+    private fun println(s: String) = pack.println(s)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/PlatformEntrypoint.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/PlatformEntrypoint.kt
new file mode 100644
index 0000000..e6a034e
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/PlatformEntrypoint.kt
@@ -0,0 +1,128 @@
+package com.calculatorsteam.dynamicpack.platform
+
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.client.DynamicPackModBase
+import com.calculatorsteam.dynamicpack.client.config.ConfigScreenBuilder
+import com.calculatorsteam.dynamicpack.client.config.NoYACLScreen
+import com.calculatorsteam.dynamicpack.util.enums.Loader
+import com.calculatorsteam.dynamicpack.util.log.Out
+import net.minecraft.client.player.LocalPlayer
+/*? if fabric {*/
+import com.calculatorsteam.dynamicpack.platform.fabric.FabricDynamicPreLaunch
+import net.fabricmc.api.ClientModInitializer
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents
+import net.fabricmc.fabric.api.networking.v1.PacketSender
+import net.minecraft.client.Minecraft
+import net.minecraft.client.multiplayer.ClientPacketListener
+
+class PlatformEntrypoint : ClientModInitializer {
+    override fun onInitializeClient() {
+        ClientPlayConnectionEvents.JOIN.register { clientPacketListener: ClientPacketListener, packetSender: PacketSender, minecraft: Minecraft ->
+            FabricDynamicPreLaunch.getInstance().onWorldJoinForUpdateChecks(Minecraft.getInstance().player)
+        }
+    }
+}
+/*?} elif neoforge {*/
+/*import net.neoforged.api.distmarker.Dist
+import net.neoforged.fml.ModList
+import net.neoforged.fml.ModLoadingContext
+import net.neoforged.fml.common.Mod
+import net.neoforged.fml.loading.FMLPaths
+import net.neoforged.neoforge.client.gui.IConfigScreenFactory
+
+@Mod(Constants.MOD_ID, dist = [Dist.CLIENT])
+class PlatformEntrypoint : DynamicPackModBase() {
+
+    init {
+        instance = this
+
+        val gameDir = FMLPaths.GAMEDIR.get().toFile()
+        init(gameDir, Loader.NEO_FORGE)
+
+        Out.println("DynamicPack loaded. Hello NeoForge world!")
+
+        ModList.get().getModContainerById(Constants.MOD_ID).ifPresent { container ->
+            val meta = container.modInfo
+            val gitHash = meta.modProperties[Constants.MOD_ID + ":buildGitHash"]
+            gitHash.let { Out.println("Build git hash: $it") }
+        }
+
+        ModLoadingContext.get().registerExtensionPoint(
+            IConfigScreenFactory::class.java
+        ) {
+            IConfigScreenFactory { _, parent ->
+                if (DynamicPackMod.instance.isModExists("yet_another_config_lib_v3")) {
+                    ConfigScreenBuilder.create(parent)
+                } else {
+                    NoYACLScreen(parent)
+                }
+            }
+        }
+    }
+
+    override fun isModExists(id: String): Boolean =
+        ModList.get().isLoaded(id)
+
+    fun onWorldJoin(localPlayer: LocalPlayer) {
+        onWorldJoinForUpdateChecks(localPlayer)
+    }
+
+    companion object {
+        @JvmStatic
+        lateinit var instance: PlatformEntrypoint
+            private set
+    }
+}
+*//*?} elif forge {*/
+/*import net.minecraftforge.client.ConfigScreenHandler
+import net.minecraftforge.fml.ModList
+import net.minecraftforge.fml.ModLoadingContext
+import net.minecraftforge.fml.common.Mod
+import net.minecraftforge.fml.loading.FMLPaths
+
+@Mod(Constants.MOD_ID)
+class PlatformEntrypoint() : DynamicPackModBase() {
+
+    init {
+        instance = this
+
+        val gameDir = FMLPaths.GAMEDIR.get().toFile()
+        init(gameDir, Loader.FORGE)
+
+        Out.println("DynamicPack loaded. Hello Forge world!")
+
+        ModList.get().getModContainerById(Constants.MOD_ID).ifPresent { container ->
+            val meta = container.modInfo
+            val gitHash = meta.modProperties[Constants.MOD_ID + ":buildGitHash"]
+            gitHash.let { Out.println("Build git hash: $it") }
+        }
+
+        ModLoadingContext.get().registerExtensionPoint(
+            ConfigScreenHandler.ConfigScreenFactory::class.java
+        ) {
+            ConfigScreenHandler.ConfigScreenFactory { _, parent ->
+                if (DynamicPackMod.instance.isModExists("yet_another_config_lib_v3")) {
+                    ConfigScreenBuilder.create(parent)
+                } else {
+                    NoYACLScreen(parent)
+                }
+            }
+        }
+    }
+
+    override fun isModExists(id: String): Boolean =
+        ModList.get().isLoaded(id)
+
+    fun onWorldJoin(localPlayer: LocalPlayer) {
+        onWorldJoinForUpdateChecks(localPlayer)
+    }
+
+    companion object {
+        @JvmStatic
+        lateinit var instance: PlatformEntrypoint
+            private set
+    }
+}
+*//*?}*/
+
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/VersionFunctions.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/VersionFunctions.kt
new file mode 100644
index 0000000..df8486a
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/VersionFunctions.kt
@@ -0,0 +1,236 @@
+package com.calculatorsteam.dynamicpack.platform
+
+import com.mojang.blaze3d.systems.RenderSystem
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.Font
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.Button
+import net.minecraft.client.gui.components.Renderable
+import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.client.gui.components.events.GuiEventListener
+import net.minecraft.client.gui.narration.NarratableEntry
+import net.minecraft.client.gui.screens.Screen
+import net.minecraft.client.gui.screens.packs.TransferableSelectionList
+import net.minecraft.client.player.LocalPlayer
+import net.minecraft.locale.Language
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.FormattedText
+import net.minecraft.network.chat.Style
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.util.FormattedCharSequence
+import java.net.URI
+
+object VersionFunctions {
+    private val client: Minecraft = Minecraft.getInstance()
+
+    /**
+     * Creates a vanilla Button with proper generics
+     */
+    @Suppress("UNCHECKED_CAST")
+    fun <T> createButton(
+        text: Component,
+        press: () -> Unit,
+        w: Int, h: Int,
+        x: Int, y: Int
+    ): T where T : GuiEventListener, T : Renderable, T : NarratableEntry {
+        return Button.builder(text) { press.invoke() }
+            .size(w, h)
+            .pos(x, y)
+            .build() as T
+    }
+
+    /**
+     * Rewritten from ModMenu (MIT).
+     * Draw wrapped string with maximum lines.
+     */
+    fun drawWrappedString(
+        matrices: GuiGraphics,
+        stringIn: String,
+        x: Int, y: Int,
+        wrapWidth: Int,
+        lines: Int,
+        color: Int
+    ) {
+        var string = stringIn
+        while (string.endsWith("\n")) {
+            string = string.removeSuffix("\n")
+        }
+        val strings: List<FormattedText> = client.font.splitter.splitLines(Component.literal(string), wrapWidth, Style.EMPTY)
+        for (i in strings.indices) {
+            if (i >= lines) break
+            var renderable: FormattedText = strings[i]
+            if (i == lines - 1 && strings.size > lines) {
+                renderable = FormattedText.composite(renderable, FormattedText.of("..."))
+            }
+            val line: FormattedCharSequence = Language.getInstance().getVisualOrder(renderable)
+            var x1 = x
+            if (client.font.isBidirectional) {
+                val width = client.font.width(line)
+                x1 += (wrapWidth - width)
+            }
+            matrices.drawString(client.font, line, x1, y + i * client.font.lineHeight, color, false)
+        }
+    }
+
+    fun runAtUI(task: () -> Unit) {
+        client.execute(task)
+    }
+
+    fun drawTexture(
+        context: GuiGraphics,
+        texture: ResourceLocation?,
+        x: Int, y: Int,
+        u: Float, v: Float,
+        width: Int, height: Int,
+        textureWidth: Int, textureHeight: Int
+    ) {
+        /*? if >=1.21.6 {*/
+        if (texture != null) {
+            RenderSystem.setShaderTexture(0, Minecraft.getInstance().textureManager.getTexture(texture).textureView);
+            context.blit(net.minecraft.client.renderer.RenderPipelines.GUI_TEXTURED, texture, x, y, u,  v, width, height, textureWidth, textureHeight)
+        }
+        /*?} else if >=1.21.5 {*/
+        /*if (texture != null) {
+            RenderSystem.setShaderTexture(0, Minecraft.getInstance().getTextureManager().getTexture(texture).getTexture());
+            context.blit(net.minecraft.client.renderer.RenderType::guiTextured, texture, x, y, u,  v, width, height, textureWidth, textureHeight)
+        }
+        *//*?} else if >=1.21.2 {*/
+        /*if (texture != null) {
+            RenderSystem.setShaderTexture(0, texture)
+            context.blit(net.minecraft.client.renderer.RenderType::guiTextured, texture, x, y, u,  v, width, height, textureWidth, textureHeight)
+        }
+        *//*?} else {*/
+        /*if (texture != null) {
+            RenderSystem.setShaderTexture(0, texture)
+            context.blit(texture, x, y, 1, u, v, width, height, textureWidth, textureHeight)
+        }
+        *//*?}*/
+    }
+
+    fun renderBackground(screen: Screen, context: Any, mouseX: Int, mouseY: Int, delta: Float) {
+        /*? if >=1.21 {*/
+        screen.renderBackground(context as GuiGraphics, mouseX, mouseY, delta)
+        /*?} else {*/
+        /*screen.renderBackground(context as GuiGraphics)
+        *//*?}*/
+    }
+
+    fun drawString(context: Any, font: Font, component: Component, x: Int, y: Int, color: Int) {
+        (context as GuiGraphics).drawString(font, component, x, y, color)
+    }
+
+    fun drawCenteredString(context: Any, font: Font, title: Component, x: Int, y: Int, color: Int) {
+        (context as GuiGraphics).drawCenteredString(font, title, x, y, color)
+    }
+
+    @JvmStatic
+    fun blitSprite(context: Any, sprite: ResourceLocation , x: Int, y: Int, width: Int, height: Int) {
+        /*? if >=1.21.6 {*/
+        (context as GuiGraphics).blitSprite(net.minecraft.client.renderer.RenderPipelines.GUI_TEXTURED, sprite, x, y, width, height)
+        /*?} else if >=1.21.2 {*/
+        /*(context as GuiGraphics).blitSprite(net.minecraft.client.renderer.RenderType::guiTextured, sprite, x, y, width, height)
+        *//*?} else if >=1.21 {*/
+        /*(context as GuiGraphics).blitSprite(sprite, x, y, width, height)
+        *//*?}*/
+    }
+
+    fun displayClientMessage(player: LocalPlayer?, chatComponent: Component) {
+        /*? if >=1.21.2 {*/
+        player?.displayClientMessage(chatComponent, false)
+        /*?} else {*/
+        /*player?.sendSystemMessage(chatComponent)
+        *//*?}*/
+    }
+
+    fun setTooltip(button: Button, tooltip: Tooltip?) {
+        /*? if >=1.21.6 {*/
+        button.setTooltip(tooltip)
+        /*?} else {*/
+        /*button.tooltip = tooltip
+        *//*?}*/
+    }
+
+    fun versionName(version: net.minecraft.WorldVersion): String {
+        /*? if >=1.21.6 {*/
+        return version.name()
+        /*?} else {*/
+        /*return version.name
+        *//*?}*/
+    }
+
+    fun versionString(): String {
+        return "1.21.8"
+    }
+
+    fun getToastManager():
+        /*? if >=1.21.2 {*/
+            net.minecraft.client.gui.components.toasts.ToastManager {
+        return client.toastManager
+        /*?} else {*/
+            /*net.minecraft.client.gui.components.toasts.ToastComponent {
+        return client.toasts
+        *//*?}*/
+    }
+
+    fun getSystemToastId():
+        /*? if >=1.20.4 {*/
+            net.minecraft.client.gui.components.toasts.SystemToast.SystemToastId {
+        return net.minecraft.client.gui.components.toasts.SystemToast.SystemToastId(5000)
+        /*?} else {*/
+            /*net.minecraft.client.gui.components.toasts.SystemToast.SystemToastIds {
+        return net.minecraft.client.gui.components.toasts.SystemToast.SystemToastIds.NARRATOR_TOGGLE
+        *//*?}*/
+    }
+
+    fun getHoverEventShowText(component: Component): net.minecraft.network.chat.HoverEvent {
+        /*? if >=1.21.5 {*/
+        return net.minecraft.network.chat.HoverEvent.ShowText(component)
+        /*?} else {*/
+        /*return net.minecraft.network.chat.HoverEvent(net.minecraft.network.chat.HoverEvent.Action.SHOW_TEXT, component)
+        *//*?}*/
+    }
+
+    fun getClickEventOpenUrl(url: String): net.minecraft.network.chat.ClickEvent {
+        /*? if >=1.21.5 {*/
+        return net.minecraft.network.chat.ClickEvent.OpenUrl(URI.create(url))
+        /*?} else {*/
+        /*return net.minecraft.network.chat.ClickEvent(net.minecraft.network.chat.ClickEvent.Action.OPEN_URL, url)
+        *//*?}*/
+    }
+
+    @JvmStatic
+    fun maxScrollAmount(parent: TransferableSelectionList): Int {
+        /*? if >=1.21.4 {*/
+        return parent.maxScrollAmount()
+        /*?} else {*/
+        /*return parent.getMaxScroll()
+        *//*?}*/
+    }
+
+    @JvmStatic
+    fun applyModelViewMatrix() {
+        /*? if <1.21.2 {*/
+        /*RenderSystem.applyModelViewMatrix();
+        *//*?}*/
+    }
+
+    @JvmStatic
+    fun clear(int: Int) {
+        /*? if >=1.21.5 {*/
+        com.mojang.blaze3d.opengl.GlStateManager._clear(int)
+        /*?} else if >=1.21.2 {*/
+        /*RenderSystem.clear(int);
+        *//*?} else {*/
+        /*RenderSystem.clear(16640, net.minecraft.client.Minecraft.ON_OSX);
+        *//*?}*/
+    }
+
+    @JvmStatic
+    fun clearColor(red: Float, green: Float, blue: Float, alpha: Float) {
+        /*? if >=1.21.5 {*/
+        org.lwjgl.opengl.GL11.glClearColor(red, green, blue, alpha)
+        /*?} else {*/
+        /*RenderSystem.clearColor(red, green, blue, alpha)
+        *//*?}*/
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/fabric/FabricDynamicPreLaunch.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/fabric/FabricDynamicPreLaunch.kt
new file mode 100644
index 0000000..4272567
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/fabric/FabricDynamicPreLaunch.kt
@@ -0,0 +1,40 @@
+/*? if fabric {*/
+package com.calculatorsteam.dynamicpack.platform.fabric
+
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.client.DynamicPackModBase
+import com.calculatorsteam.dynamicpack.util.enums.Loader
+import com.calculatorsteam.dynamicpack.util.log.Out
+import net.fabricmc.loader.api.FabricLoader
+import net.fabricmc.loader.api.entrypoint.PreLaunchEntrypoint
+
+/**
+ * Fabric impl for DynamicPack mod
+ */
+class FabricDynamicPreLaunch : DynamicPackModBase(), PreLaunchEntrypoint {
+
+    override fun onPreLaunch() {
+        instance = this
+        Out.println("DynamicPack loaded. Hello fabric world!")
+
+        val gameDir = FabricLoader.getInstance().gameDir.toFile()
+        init(gameDir, Loader.FABRIC)
+
+        val container = FabricLoader.getInstance().getModContainer(Constants.MOD_ID).get()
+        val buildHash = container.metadata.getCustomValue(Constants.MOD_ID + ":buildGitHash")?.asString
+        if (buildHash != null) {
+            Out.println("Build git hash: $buildHash")
+        }
+    }
+
+    override fun isModExists(id: String): Boolean =
+        FabricLoader.getInstance().isModLoaded(id)
+
+    companion object {
+        private var instance: FabricDynamicPreLaunch? = null
+        @JvmStatic
+        fun getInstance(): FabricDynamicPreLaunch =
+            instance ?: throw IllegalStateException("FabricDynamicPreLaunch not initialized yet")
+    }
+}
+/*?}*/
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/fabric/ModMenuIntegration.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/fabric/ModMenuIntegration.kt
new file mode 100644
index 0000000..5be8621
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/fabric/ModMenuIntegration.kt
@@ -0,0 +1,22 @@
+/*? if fabric {*/
+package com.calculatorsteam.dynamicpack.platform.fabric
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.client.config.ConfigScreenBuilder
+import com.calculatorsteam.dynamicpack.client.config.NoYACLScreen
+import com.terraformersmc.modmenu.api.ConfigScreenFactory
+import com.terraformersmc.modmenu.api.ModMenuApi
+import net.minecraft.client.gui.screens.Screen
+
+class ModMenuIntegration : ModMenuApi {
+    override fun getModConfigScreenFactory(): ConfigScreenFactory<Screen> {
+        return ConfigScreenFactory { parent ->
+            if (DynamicPackMod.instance.isModExists("yet_another_config_lib_v3")) {
+                ConfigScreenBuilder.create(parent)
+            } else {
+                NoYACLScreen(parent)
+            }
+        }
+    }
+}
+/*?}*/
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/forge/ForgeEvent.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/forge/ForgeEvent.kt
new file mode 100644
index 0000000..c7dca29
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/forge/ForgeEvent.kt
@@ -0,0 +1,20 @@
+/*? if forge {*/
+/*package com.calculatorsteam.dynamicpack.platform.forge
+
+import com.calculatorsteam.dynamicpack.platform.PlatformEntrypoint
+import net.minecraft.client.player.LocalPlayer
+import net.minecraftforge.event.entity.EntityJoinLevelEvent
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.common.Mod
+
+@Mod.EventBusSubscriber
+object ForgeEvent {
+
+    @SubscribeEvent
+    fun onJoin(event: EntityJoinLevelEvent) {
+        (event.entity as? LocalPlayer)?.let { player ->
+            PlatformEntrypoint.instance.onWorldJoin(player)
+        }
+    }
+}
+*//*?}*/
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/neoforge/NeoForgeEvent.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/neoforge/NeoForgeEvent.kt
new file mode 100644
index 0000000..27676c8
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/platform/neoforge/NeoForgeEvent.kt
@@ -0,0 +1,20 @@
+/*? if neoforge {*/
+/*package com.calculatorsteam.dynamicpack.platform.neoforge
+
+import com.calculatorsteam.dynamicpack.platform.PlatformEntrypoint
+import net.minecraft.client.player.LocalPlayer
+import net.neoforged.bus.api.SubscribeEvent
+import net.neoforged.fml.common.EventBusSubscriber
+import net.neoforged.neoforge.event.entity.EntityJoinLevelEvent
+
+@EventBusSubscriber
+object NeoForgeEvent {
+
+    @SubscribeEvent
+    fun onJoin(event: EntityJoinLevelEvent) {
+        (event.entity as? LocalPlayer)?.let { player ->
+            PlatformEntrypoint.instance.onWorldJoin(player)
+        }
+    }
+}
+*//*?}*/
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncBuilder.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncBuilder.kt
new file mode 100644
index 0000000..2f11e4b
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncBuilder.kt
@@ -0,0 +1,39 @@
+package com.calculatorsteam.dynamicpack.sync
+
+/**
+ * SyncBuilder
+ */
+interface SyncBuilder {
+    /**
+     * Initialize a SyncBuilder, cache updateAvailable status, update size, etc...
+     */
+    @Throws(Exception::class)
+    fun init(ignoreCaches: Boolean)
+
+    /**
+     * @return downloaded size
+     */
+    val downloadedSize: Long
+
+    /**
+     * @return cached in init() value
+     */
+    val isUpdateAvailable: Boolean
+
+    /**
+     * @return calculated and cached in init() value
+     */
+    val updateSize: Long
+
+    /**
+     * Update pack
+     * @return is needed a reload
+     */
+    @Throws(Exception::class)
+    fun doUpdate(progress: SyncProgress): Boolean
+
+    /**
+     * Stop update
+     */
+    fun interrupt()
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncProgress.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncProgress.kt
new file mode 100644
index 0000000..7d1a6da
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncProgress.kt
@@ -0,0 +1,23 @@
+package com.calculatorsteam.dynamicpack.sync
+
+import java.nio.file.Path
+
+/**
+ * Sync pack info interface.
+ */
+interface SyncProgress {
+    /**
+     * Set current phase for sync operation
+     */
+    fun setPhase(phase: String)
+
+    /**
+     * Called while downloading data
+     */
+    fun downloading(name: String, percentage: Float)
+
+    /**
+     * Called when a file is deleted
+     */
+    fun deleted(name: Path)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncThread.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncThread.kt
new file mode 100644
index 0000000..baac3af
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncThread.kt
@@ -0,0 +1,70 @@
+package com.calculatorsteam.dynamicpack.sync
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.util.log.LoopLog
+import com.calculatorsteam.dynamicpack.util.log.NetworkStat
+import com.calculatorsteam.dynamicpack.util.log.Out
+import java.nio.file.Path
+import kotlin.time.Duration.Companion.seconds
+
+class SyncThread @JvmOverloads constructor(
+    name: String,
+    private val packSpecify: DynamicResourcePack? = null
+) : Thread(name) {
+
+    private var syncBuilder: SyncBuilder? = null
+    private val etaLoopLog = LoopLog(1.seconds)
+
+    override fun run() {
+        Out.debug("[SyncThread] thread started")
+
+        if (SyncingTask.isSyncing()) {
+            Out.warn("Shutting down SyncThread because other thread already work")
+            return
+        }
+
+        SyncingTask.launchTaskAsSyncing {
+            try {
+                SyncingTask.currentRootSyncBuilder =
+                    (packSpecify?.syncBuilder() ?: SyncingTask.rootSyncBuilder())
+                        .also { syncBuilder = it }
+
+                syncBuilder?.init(true)
+
+                if (syncBuilder?.isUpdateAvailable == true) {
+                    val reloadRequired = syncBuilder!!.doUpdate(createSyncProgress())
+                    if (reloadRequired) {
+                        DynamicPackMod.instance.needResourcesReload()
+                    }
+                }
+            } catch (e: Exception) {
+                Out.error("Error while SyncThread...", e)
+            } finally {
+                SyncingTask.currentRootSyncBuilder = null
+            }
+        }
+    }
+
+    private fun createSyncProgress(): SyncProgress =
+        object : SyncProgress {
+            override fun setPhase(phase: String) {
+                Out.debug("Phase: $phase")
+                SyncingTask.log(phase)
+            }
+
+            override fun downloading(name: String, percentage: Float) {
+                val sb = syncBuilder ?: return
+                val remainsBytes = sb.updateSize - sb.downloadedSize
+                val eta = NetworkStat.remainingETA(remainsBytes).also { SyncingTask.eta = it }
+                if (etaLoopLog.tick()) {
+                    Out.debug("(${SyncingTask.currentPackName}) ETA=${eta}s")
+                }
+            }
+
+            override fun deleted(name: Path) {
+                Out.debug("Deleted: $name")
+                SyncingTask.log(name.fileName.toString())
+            }
+        }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncingTask.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncingTask.kt
new file mode 100644
index 0000000..a22fd37
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/sync/SyncingTask.kt
@@ -0,0 +1,140 @@
+package com.calculatorsteam.dynamicpack.sync
+
+import com.calculatorsteam.dynamicpack.client.config.Config
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.pack.DynamicResourcePack
+import com.calculatorsteam.dynamicpack.util.log.Out
+
+/**
+ * Sync task.
+ * Re-check all packs and update packs with update available
+ */
+object SyncingTask {
+    private var isSyncing: Boolean = false
+
+    private var syncingLog1: String = ""
+    private var syncingLog2: String = ""
+    private var syncingLog3: String = ""
+
+    @JvmField
+    var eta: Long = 0
+
+    /** used in future for interrupt() download. Sets by Thread */
+    @JvmField
+    var currentRootSyncBuilder: SyncBuilder? = null
+
+    @JvmField
+    var currentPackName: String? = null
+
+    /**
+     * @param runnable to run
+     * @throws RuntimeException if task already running (check isSyncing before call)
+     */
+    @JvmStatic
+    fun launchTaskAsSyncing(runnable: () -> Unit) {
+        if (isSyncing()) {
+            throw RuntimeException("Failed to launchTaskAsSyncing. Other task currently working...")
+        }
+
+        val packs = DynamicPackMod.packsContainer
+        setSyncing(true)
+        packs.lockRescan()
+
+        log("[SyncingTask] launchTaskAsSyncing start!")
+        runnable()
+        log("[SyncingTask] launchTaskAsSyncing end!")
+
+        setSyncing(false)
+        packs.unlockRescan()
+        currentPackName = null
+        currentRootSyncBuilder = null
+    }
+
+    @JvmStatic
+    fun log(s: String) {
+        Out.debug("[SyncingTask] log: $s")
+        syncingLog1 = syncingLog2
+        syncingLog2 = syncingLog3
+        syncingLog3 = s
+    }
+
+    @JvmStatic
+    fun clearLog() {
+        syncingLog3 = ""
+        syncingLog2 = ""
+        syncingLog1 = ""
+    }
+
+    @JvmStatic
+    fun getLogs(): String =
+        "$syncingLog1\n$syncingLog2\n$syncingLog3"
+
+    @JvmStatic
+    fun setSyncing(syncing: Boolean) {
+        isSyncing = syncing
+    }
+
+    @JvmStatic
+    fun isSyncing(): Boolean = isSyncing
+
+    @JvmStatic
+    fun rootSyncBuilder(): SyncBuilder =
+        object : SyncBuilder {
+            private val builders: MutableSet<SyncBuilder> = mutableSetOf()
+            private var updateAvailable: Boolean = false
+            private var totalSize: Long = 0
+            private var interrupted: Boolean = false
+
+            @Throws(Exception::class)
+            override fun init(ignoreCaches: Boolean) {
+                clearLog()
+
+                for (pack: DynamicResourcePack in DynamicPackMod.packsContainer.packsArray) {
+                    if (interrupted) return
+
+                    if (Config.getInstance().isUpdateOnlyEnabledPacks()) {
+                        val enabled = DynamicPackMod.isResourcePackActive(pack)
+                        if (!enabled) continue
+                    }
+
+                    val builder = pack.syncBuilder()
+                    builder.init(ignoreCaches)
+                    builders += builder
+
+                    totalSize += builder.updateSize
+                    if (builder.isUpdateAvailable) {
+                        updateAvailable = true
+                    }
+                }
+                Out.debug("[SyncingTask] rootSyncBuilder() totalSize=$totalSize updateAvailable=$updateAvailable")
+            }
+
+            override val isUpdateAvailable: Boolean
+                get() = updateAvailable
+
+            override val updateSize: Long
+                get() = totalSize
+
+            override val downloadedSize: Long
+                get() = builders.sumOf { it.downloadedSize }
+
+            @Throws(Exception::class)
+            override fun doUpdate(progress: SyncProgress): Boolean {
+                var reload = false
+                for (syncBuilder in builders) {
+                    if (interrupted) return false
+
+                    if (syncBuilder.isUpdateAvailable) {
+                        val rel = syncBuilder.doUpdate(progress)
+                        if (rel) reload = true
+                    }
+                }
+                return reload
+            }
+
+            override fun interrupt() {
+                interrupted = true
+                builders.forEach { it.interrupt() }
+            }
+        }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/Hashes.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/Hashes.kt
new file mode 100644
index 0000000..54a474b
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/Hashes.kt
@@ -0,0 +1,25 @@
+package com.calculatorsteam.dynamicpack.util
+
+import org.apache.commons.codec.digest.DigestUtils
+import java.io.File
+import java.io.IOException
+import java.io.InputStream
+import java.nio.file.Files
+import java.nio.file.Path
+
+object Hashes {
+    @JvmStatic
+    @Throws(IOException::class)
+    fun sha1sum(file: File): String = sha1sum(file.toPath())
+
+    @JvmStatic
+    @Throws(IOException::class)
+    fun sha1sum(path: Path): String = Files.newInputStream(path).use { DigestUtils.sha1Hex(it) }
+
+    @JvmStatic
+    @Throws(IOException::class)
+    fun sha1sum(inputStream: InputStream): String = inputStream.use { DigestUtils.sha1Hex(it) }
+
+    @JvmStatic
+    fun sha1sum(bytes: ByteArray): String = DigestUtils.sha1Hex(bytes)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/JsonUtil.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/JsonUtil.kt
new file mode 100644
index 0000000..1191f21
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/JsonUtil.kt
@@ -0,0 +1,74 @@
+package com.calculatorsteam.dynamicpack.util
+
+import com.calculatorsteam.dynamicpack.Constants
+import com.google.gson.JsonArray
+import com.google.gson.JsonObject
+import java.io.IOException
+import java.io.InputStream
+import java.nio.file.Path
+
+/**
+ * <h2>Preserving the psyche during migration from org.json to gson</h2>
+ * @author AdamCalculator
+ */
+object JsonUtil {
+    // --- GET ---
+    @JvmStatic
+    fun JsonObject.optInt(key: String, def: Int = 0): Int =
+        if (has(key)) getAsJsonPrimitive(key).asInt else def
+
+    @JvmStatic
+    fun JsonObject.getInt(key: String): Int =
+        getAsJsonPrimitive(key).asInt
+
+    @JvmStatic
+    fun JsonObject.optLong(key: String, def: Long = 0L): Long =
+        if (has(key)) getAsJsonPrimitive(key).asLong else def
+
+    @JvmStatic
+    fun JsonObject.getLong(key: String): Long =
+        getAsJsonPrimitive(key).asLong
+
+    @JvmStatic
+    fun JsonObject.getString(key: String): String =
+        getAsJsonPrimitive(key).asString
+
+    @JvmStatic
+    fun JsonObject.optString(key: String, def: String? = null): String? =
+        if (has(key)) getAsJsonPrimitive(key).asString else def
+
+    @JvmStatic
+    fun JsonObject.getJsonArray(key: String): JsonArray? =
+        if (has(key)) getAsJsonArray(key) else null
+
+    @JvmStatic
+    fun JsonObject.getBoolean(key: String): Boolean =
+        getAsJsonPrimitive(key).asBoolean
+
+    @JvmStatic
+    fun JsonObject.optBoolean(key: String, def: Boolean = false): Boolean =
+        if (has(key)) get(key).asBoolean else def
+
+    // --- CREATE ---
+    @JvmStatic
+    fun fromString(s: String): JsonObject =
+        Constants.GSON.fromJson(s, JsonObject::class.java)
+
+    @JvmStatic
+    @Throws(IOException::class)
+    fun readJson(inputStream: InputStream): JsonObject =
+        fromString(PathUtil.readString(inputStream))
+
+    @JvmStatic
+    @Throws(IOException::class)
+    fun readJson(path: Path): JsonObject =
+        fromString(PathUtil.readString(path))
+
+    @JvmStatic
+    fun arrayFromString(s: String): JsonArray =
+        Constants.GSON.fromJson(s, JsonArray::class.java)
+
+    @JvmStatic
+    fun toString(json: JsonObject): String =
+        Constants.GSON.toJson(json)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/LockUtil.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/LockUtil.kt
new file mode 100644
index 0000000..e94ae81
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/LockUtil.kt
@@ -0,0 +1,39 @@
+package com.calculatorsteam.dynamicpack.util
+
+import com.calculatorsteam.dynamicpack.accessor.FilePackResourcesAccessor
+import com.calculatorsteam.dynamicpack.util.log.Out
+import java.io.File
+
+/**
+ * Utils for file locked by other process (fixes crashes in Windows).
+ */
+object LockUtils {
+    private val openedZipFiles: MutableSet<FilePackResourcesAccessor> = mutableSetOf()
+
+    /**
+     * Create file finalizer Runnable
+     */
+    @JvmStatic
+    fun createFileFinalizer(file: File): Runnable = Runnable { closeFile(file) }
+
+    @JvmStatic
+    fun closeFile(file: File) {
+        Out.debug("[PackUtil] closeFile $file")
+
+        val toDelete = mutableSetOf<FilePackResourcesAccessor>()
+        // Перебор snapshot множества, чтобы безопасно удалять
+        for (openedZipFile in openedZipFiles.toTypedArray()) {
+            if (openedZipFile.`dynamicpack$getFile`().equals(file)) {
+                openedZipFile.`dynamicpack$close`()
+                toDelete += openedZipFile
+                Out.debug("[PackUtil] - $openedZipFile")
+            }
+        }
+        openedZipFiles.removeAll(toDelete)
+    }
+
+    @JvmStatic
+    fun addFileToOpened(resources: FilePackResourcesAccessor) {
+        openedZipFiles += resources
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/PackUtil.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/PackUtil.kt
new file mode 100644
index 0000000..b751a82
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/PackUtil.kt
@@ -0,0 +1,112 @@
+package com.calculatorsteam.dynamicpack.util
+
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.util.exception.FailedOpenPackFileSystemException
+import com.calculatorsteam.dynamicpack.util.log.FileLog
+import com.calculatorsteam.dynamicpack.util.log.Out
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.IOException
+import java.net.URI
+import java.nio.file.FileSystems
+import java.nio.file.Files
+import java.nio.file.Path
+
+/**
+ * Pack utilities: open ZIP or folder as FileSystem, download packs.
+ */
+object PackUtil {
+
+    /**
+     * Open file (or dir) as nio.Path.
+     *
+     * If exception in consumer → filesystem closed normally.
+     */
+    @JvmStatic
+    @Throws(Exception::class)
+    fun openPackFileSystem(
+        file: File?,                      // теперь nullable
+        preClose: Runnable? = null,
+        consumer: (Path) -> Unit
+    ) {
+        val realFile = file ?: throw FileNotFoundException("File is null")
+
+        if (!realFile.exists()) {
+            throw FileNotFoundException(realFile.canonicalPath)
+        }
+
+        when {
+            realFile.isDirectory -> {
+                consumer(realFile.toPath())
+            }
+
+            realFile.isFile && realFile.name.lowercase().endsWith(".zip") -> {
+                val env = mapOf("create" to "true")
+                val uri = URI.create("jar:" + realFile.toPath().toUri())
+
+                var caught: Exception? = null
+                FileSystems.newFileSystem(uri, env).use { fs ->
+                    try {
+                        consumer(fs.getPath(""))
+                    } catch (e: Exception) {
+                        caught = e
+                    } finally {
+                        preClose?.run()
+                    }
+                }
+                if (caught != null) throw caught
+            }
+
+            else -> throw FailedOpenPackFileSystemException(
+                "Failed to recognize pack filesystem: not dir or zip"
+            )
+        }
+    }
+
+    /**
+     * Download file for dynamic_repo.
+     * Retries on failure up to [Constants.MAX_ATTEMPTS_TO_DOWNLOAD_FILE].
+     *
+     * @throws IOException if latest attempt failed, rethrown.
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun downloadPackFile(url: String, path: Path?, hash: String, controller: UrlsController) {
+        val target = path ?: throw IOException("Path is null")
+        val maxAttempts = Constants.MAX_ATTEMPTS_TO_DOWNLOAD_FILE
+
+        repeat(maxAttempts) { attempt ->
+            try {
+                PathUtil.createDirsToFile(target)
+
+                if (Files.exists(target)) {
+                    PathUtil.delete(target)
+                }
+                PathUtil.createFile(target)
+
+                try {
+                    Urls._transferStreamsWithHash(
+                        hash,
+                        Urls._getInputStreamOfUrl(
+                            url,
+                            Constants.DYNAMIC_PACK_HTTPS_FILE_SIZE_LIMIT,
+                            controller
+                        ),
+                        Files.newOutputStream(target),
+                        controller
+                    )
+                    FileLog.writtenByUrl(target, url)
+                } catch (e: Exception) {
+                    throw RuntimeException(
+                        "File $target download error. From url: $url. Expected hash: $hash", e
+                    )
+                }
+                return // success → exit method
+
+            } catch (e: Exception) {
+                Out.error("downloadPackFile. Attempt=${attempt + 1}/$maxAttempts", e)
+                if (attempt == maxAttempts - 1) throw e
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/PathUtil.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/PathUtil.kt
new file mode 100644
index 0000000..b3a9431
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/PathUtil.kt
@@ -0,0 +1,174 @@
+package com.calculatorsteam.dynamicpack.util
+
+import com.calculatorsteam.dynamicpack.util.log.FileLog
+import org.apache.commons.io.FileUtils
+import java.io.File
+import java.io.IOException
+import java.io.InputStream
+import java.nio.charset.StandardCharsets
+import java.nio.file.*
+
+/**
+ * Utils for working with [Path] and [File].
+ */
+object PathUtil {
+
+    /** Delete path-file and log */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun delete(path: Path?) {
+        val p = path ?: return
+        if (Files.exists(p)) {
+            Files.delete(p)
+            FileLog.deleted(p)
+        }
+    }
+
+    /** Create path-file and log */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun createFile(path: Path?) {
+        val p = path ?: throw IOException("Path is null")
+        Files.createFile(p)
+        FileLog.created(p)
+    }
+
+    @JvmStatic
+    fun listFiles(file: File?): Array<File>? = file?.listFiles()
+
+    /** Move a file source to dest place */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun moveFile(source: File?, dest: File?) {
+        val s = source ?: throw IOException("Source file is null")
+        val d = dest ?: throw IOException("Destination file is null")
+        Files.move(s.toPath(), d.toPath(), StandardCopyOption.REPLACE_EXISTING)
+    }
+
+    /** Extract a zipFilePath to dir */
+    @JvmStatic
+    @Throws(Exception::class)
+    fun unzip(zipFilePath: File?, dir: File?) {
+        val z = zipFilePath ?: throw IOException("Zip file is null")
+        val d = dir ?: throw IOException("Destination dir is null")
+
+        PackUtil.openPackFileSystem(z) { zip ->
+            val buffer = mutableSetOf<String>()
+            walkScan(buffer, zip)
+            buffer.forEach { relative ->
+                val path = zip.resolve(relative)
+                val toPath = d.toPath().resolve(relative)
+                createDirsToFile(toPath)
+                Files.copy(path, toPath, StandardCopyOption.REPLACE_EXISTING)
+            }
+        }
+    }
+
+    /** Force delete a directory */
+    @JvmStatic
+    fun recursiveDeleteDirectory(file: File?) {
+        val f = file ?: return
+        try {
+            if (!f.isDirectory) throw RuntimeException("File not a directory.")
+            FileUtils.deleteDirectory(f)
+            FileLog.deleted(f.toPath())
+        } catch (e: IOException) {
+            throw RuntimeException("Exception while recursive delete dir $f", e)
+        }
+    }
+
+    private fun nioIsDirExistsAndEmpty(path: Path?): Boolean {
+        val p = path ?: return false
+        if (Files.isDirectory(p)) {
+            Files.list(p).use { return it.count() == 0L }
+        }
+        return false
+    }
+
+    /** Delete path and remove empty parent dirs */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun nioSmartDelete(toDel: Path?) {
+        val p = toDel ?: return
+        FileLog.deleted(p)
+        val par = p.parent
+        Files.deleteIfExists(p)
+        if (par != null && nioIsDirExistsAndEmpty(par)) {
+            nioSmartDelete(par)
+        }
+    }
+
+    /** Write a text to path */
+    @JvmStatic
+    fun nioWriteText(path: Path?, text: String) {
+        val p = path ?: throw IOException("Path is null")
+        try {
+            if (Files.exists(p) && !Files.isRegularFile(p)) {
+                throw SecurityException("Try to write text to a not regular file.")
+            }
+            Files.deleteIfExists(p)
+            Files.writeString(p, text, StandardOpenOption.CREATE, StandardOpenOption.WRITE)
+        } catch (e: IOException) {
+            throw RuntimeException("nioWriteText exception!", e)
+        }
+    }
+
+    /** Read text from file */
+    @JvmStatic
+    fun nioReadText(path: Path?): String {
+        val p = path ?: throw IOException("Path is null")
+        try {
+            if (!Files.exists(p) || Files.isDirectory(p)) {
+                throw RuntimeException("This is not a file. Not found or directory.")
+            }
+            return Files.readString(p)
+        } catch (e: IOException) {
+            throw RuntimeException("nioReadText exception!", e)
+        }
+    }
+
+    /** If paths parent not exists, create dirs to file */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun createDirsToFile(path: Path?) {
+        val p = path ?: return
+        val par = p.parent
+        if (par != null && !Files.exists(par)) {
+            Files.createDirectories(par)
+        }
+    }
+
+    /** Fill buffer with paths to all files (recursively). */
+    @JvmStatic
+    fun walkScan(buffer: MutableSet<String>, path: Path?) {
+        val p = path ?: return
+        try {
+            Files.walk(p, Int.MAX_VALUE).use { entries ->
+                entries.forEach { child ->
+                    if (!Files.isDirectory(child)) {
+                        buffer.add(p.relativize(child).toString())
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            throw RuntimeException("Exception while walkScan", e)
+        }
+    }
+
+    /** If path exists and is a file */
+    @JvmStatic
+    fun isPathFileExists(path: Path?): Boolean =
+        path != null && Files.exists(path) && !Files.isDirectory(path)
+
+    @JvmStatic
+    @Throws(IOException::class)
+    fun readString(inputStream: InputStream): String =
+        inputStream.readAllBytes().toString(StandardCharsets.UTF_8)
+
+    @JvmStatic
+    @Throws(IOException::class)
+    fun readString(path: Path?): String {
+        val p = path ?: throw IOException("Path is null")
+        return Files.readString(p, StandardCharsets.UTF_8)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/Urls.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/Urls.kt
new file mode 100644
index 0000000..760b451
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/Urls.kt
@@ -0,0 +1,220 @@
+package com.calculatorsteam.dynamicpack.util
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.InputValidator
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.util.log.NetworkStat
+import com.calculatorsteam.dynamicpack.util.log.Out
+import java.io.*
+import java.net.URI
+import java.net.URL
+import java.net.URLConnection
+import java.nio.charset.StandardCharsets
+import java.nio.file.Files
+import java.util.zip.GZIPInputStream
+
+/**
+ * Safe network utils
+ */
+object Urls {
+    @JvmStatic
+    fun isFileDebugSchemeAllowed(): Boolean = Constants.isFileDebugSchemeAllowed()
+
+    @JvmStatic
+    fun isHTTPTrafficAllowed(): Boolean = Constants.isHTTPTrafficAllowed()
+
+    /**
+     * Parse text content from URL (no progress).
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun parseTextContent(url: String, limit: Long): String? =
+        parseTextContent(url, limit, null)
+
+    /**
+     * Parse text content from url
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun parseTextContent(url: String, limit: Long, progress: UrlsController?): String? =
+        _parseTextFromStream(_getInputStreamOfUrl(url, limit, progress), progress)
+
+    /**
+     * Parse GZip compressed content from url
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun parseTextGZippedContent(url: String, limit: Long, progress: UrlsController?): String? =
+        _parseTextFromStream(GZIPInputStream(_getInputStreamOfUrl(url, limit, progress)), progress)
+
+    /**
+     * Create temp zipFile and download to it from url.
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun downloadFileToTemp(
+        url: String,
+        tmpPrefix: String,
+        tmpSuffix: String,
+        limit: Long,
+        controller: UrlsController?
+    ): File {
+        val file = File.createTempFile(tmpPrefix, tmpSuffix)
+        _getInputStreamOfUrl(url, limit, controller).use { input ->
+            Files.newOutputStream(file.toPath()).use { output ->
+                _transferStreams(input, output, controller)
+            }
+        }
+        return file
+    }
+
+    // --- Internal low-level helpers ---
+
+    @Throws(IOException::class)
+    internal fun _getInputStreamOfUrl(url: String, sizeLimit: Long, controller: UrlsController?): InputStream {
+        if (" " in url) throw IOException("URL can't contain spaces!")
+        InputValidator.throwIsUrlInvalid(url)
+
+        return when {
+            url.startsWith("file_debug_only://") -> {
+                if (!isFileDebugSchemeAllowed()) {
+                    throw RuntimeException("Not allowed scheme.")
+                }
+                val gameDir = DynamicPackMod.gameDir
+                val file = File(gameDir, url.removePrefix("file_debug_only://"))
+                FileInputStream(file)
+            }
+            url.startsWith("http://") -> {
+                if (!isHTTPTrafficAllowed()) {
+                    throw RuntimeException("HTTP (not secure) not allowed scheme.")
+                }
+                throwIsUrlNotTrust(url)
+                __unsafeInputStreamFromUrl(url, sizeLimit, controller)
+            }
+            url.startsWith("https://") -> {
+                throwIsUrlNotTrust(url)
+                __unsafeInputStreamFromUrl(url, sizeLimit, controller)
+            }
+            else -> throw RuntimeException("Unsupported scheme for url $url")
+        }
+    }
+
+    /**
+     * # Unsafe: returns stream with only sizeLimit check.
+     */
+    @Throws(IOException::class)
+    private fun __unsafeInputStreamFromUrl(
+        url: String,
+        sizeLimit: Long,
+        controller: UrlsController?
+    ): InputStream {
+        val metaSize = Constants.HTTP_MINIMAL_HEADER_SIZE + url.length
+        return NetworkStat.runNetworkTask(metaSize.toLong()) {
+            val connection: URLConnection = URI(url).toURL().openConnection()
+            val length = connection.contentLengthLong
+            if (length > sizeLimit) {
+                throw RuntimeException("File size exceeds $length bytes > limit $sizeLimit; url=$url")
+            }
+            controller?.updateMax(length)
+            connection.getInputStream()
+        }
+    }
+
+    @Throws(IOException::class)
+    internal fun _parseTextFromStream(stream: InputStream, controller: UrlsController?): String? =
+        stream.use { input ->
+            val out = ByteArrayOutputStream()
+            val buf = ByteArray(Constants.URLS_BUFFER_SIZE)
+            val isNetwork = isNetwork(input)
+
+            readLoop(input, buf, controller, isNetwork) { data, off, len ->
+                out.write(data, off, len)
+            }
+
+            out.toString(StandardCharsets.UTF_8)
+        }
+
+    /**
+     * Transfer streams and close all
+     */
+    @Throws(IOException::class)
+    private fun _transferStreams(inputStream: InputStream, outputStream: OutputStream, controller: UrlsController?) {
+        inputStream.use { inp ->
+            outputStream.use { outp ->
+                BufferedInputStream(inp).use { inBuf ->
+                    val buf = ByteArray(Constants.URLS_BUFFER_SIZE)
+                    val isNetwork = isNetwork(inp)
+
+                    readLoop(inBuf, buf, controller, isNetwork) { data, off, len ->
+                        outp.write(data, off, len)
+                    }
+                }
+            }
+        }
+    }
+
+    @Throws(IOException::class)
+    internal fun _transferStreamsWithHash(
+        hash: String,
+        inputStream: InputStream,
+        outputStream: OutputStream,
+        controller: UrlsController?
+    ) {
+        val buf = ByteArray(Constants.URLS_BUFFER_SIZE)
+        val isNetwork = isNetwork(inputStream)
+
+        val bytes = BufferedInputStream(inputStream).use { inBuf ->
+            val out = ByteArrayOutputStream()
+            readLoop(inBuf, buf, controller, isNetwork) { data, off, len ->
+                out.write(data, off, len)
+            }
+            out.toByteArray()
+        }
+
+        val calcHash = Hashes.sha1sum(bytes)
+        if (calcHash == hash) {
+            _transferStreams(ByteArrayInputStream(bytes), outputStream, null)
+        } else {
+            throw SecurityException("Hash mismatch: expected=$hash actual=$calcHash")
+        }
+    }
+
+    // --- Core loop to eliminate duplicates ---
+
+    private fun readLoop(
+        input: InputStream,
+        buf: ByteArray,
+        controller: UrlsController?,
+        isNetwork: Boolean,
+        onBytes: (data: ByteArray, offset: Int, length: Int) -> Unit
+    ): Long {
+        var total = 0L
+        var bytesRead: Int
+        while (true) {
+            if (UrlsController.isInterrupted(controller)) {
+                Out.debug("interrupted readLoop")
+                break
+            }
+            val start = System.currentTimeMillis()
+            bytesRead = input.read(buf)
+            if (bytesRead == -1) break
+            onBytes(buf, 0, bytesRead)
+            total += bytesRead
+            UrlsController.updateCurrent(controller, total)
+            if (isNetwork) {
+                Constants.debugNetwork(bytesRead, total)
+                NetworkStat.addLap(System.currentTimeMillis() - start, bytesRead.toLong())
+            }
+        }
+        return total
+    }
+
+    private fun isNetwork(isrc: InputStream): Boolean = isrc !is ByteArrayInputStream
+
+    @Throws(IOException::class)
+    private fun throwIsUrlNotTrust(url: String) {
+        if (!Constants.isUrlHostTrusted(url) && Constants.isBlockAllNotTrustedNetworks()) {
+            throw SecurityException("Url '$url' host is not trusted!")
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/UrlsController.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/UrlsController.kt
new file mode 100644
index 0000000..88dca7b
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/UrlsController.kt
@@ -0,0 +1,68 @@
+package com.calculatorsteam.dynamicpack.util
+
+import com.calculatorsteam.dynamicpack.util.log.NetworkStat
+import org.jetbrains.annotations.ApiStatus
+import java.util.function.LongConsumer
+
+open class UrlsController : LongConsumer {
+    companion object {
+        const val MAGIC_DEV_BY_ZERO = -1000f
+        const val MAGIC_OVERMAXING = 101f
+
+        @JvmStatic
+        fun isInterrupted(controller: UrlsController?): Boolean =
+            controller?.isInterrupted() == true
+
+        @JvmStatic
+        fun updateCurrent(controller: UrlsController?, current: Long) {
+            controller?.updateCurrent(current)
+        }
+    }
+
+    private var interrupted: Boolean = false
+    private var max: Long = 0
+    private var latest: Long = 0
+
+    fun updateCurrent(value: Long) {
+        latest = value
+        onUpdate(this)
+    }
+
+    fun updateMax(value: Long) {
+        max = value.coerceAtLeast(max)
+    }
+
+    /**
+     * @deprecated Override a LongConsumer for back compatibility
+     */
+    @Deprecated("Use updateCurrent/updateMax directly", ReplaceWith("updateCurrent(value)"))
+    override fun accept(value: Long) {
+        updateCurrent(value)
+        updateMax(value)
+    }
+
+    fun getPercentage(): Float = when {
+        max < latest -> MAGIC_OVERMAXING
+        max == 0L -> MAGIC_DEV_BY_ZERO
+        latest == max -> 100f
+        else -> (latest.toFloat() * 100f) / max.toFloat()
+    }
+
+    /**
+     * Remaining time in seconds
+     */
+    fun getRemaining(): Long = NetworkStat.remainingETA(max - latest)
+
+    fun getLatest(): Long = latest
+
+    open fun isInterrupted(): Boolean = false
+
+    fun interrupt() {
+        interrupted = false
+    }
+
+    @ApiStatus.OverrideOnly
+    open fun onUpdate(it: UrlsController) {
+        // override it in subclasses
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/enums/Loader.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/enums/Loader.kt
new file mode 100644
index 0000000..515c3aa
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/enums/Loader.kt
@@ -0,0 +1,8 @@
+package com.calculatorsteam.dynamicpack.util.enums
+
+enum class Loader {
+    UNKNOWN,
+    FABRIC,
+    FORGE,
+    NEO_FORGE;
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/enums/OverrideType.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/enums/OverrideType.kt
new file mode 100644
index 0000000..9b7d0bf
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/enums/OverrideType.kt
@@ -0,0 +1,39 @@
+package com.calculatorsteam.dynamicpack.util.enums
+
+/**
+ * Override state for pack configuration.
+ */
+enum class OverrideType {
+    TRUE,
+    FALSE,
+    NOT_SET;
+
+    fun next(): OverrideType = when (this) {
+        TRUE -> FALSE
+        FALSE -> NOT_SET
+        NOT_SET -> TRUE
+    }
+
+    /**
+     * Convert enum to boolean. Throws if value == NOT_SET.
+     */
+    fun asBoolean(): Boolean = when (this) {
+        TRUE -> true
+        FALSE -> false
+        NOT_SET -> throw UnsupportedOperationException("asBoolean() doesn't support for NOT_SET")
+    }
+
+    /**
+     * Convert enum to boolean with default if NOT_SET.
+     */
+    fun asBoolean(def: Boolean): Boolean = when (this) {
+        TRUE -> true
+        FALSE -> false
+        NOT_SET -> def
+    }
+
+    companion object {
+        @JvmStatic
+        fun ofBoolean(b: Boolean): OverrideType = if (b) TRUE else FALSE
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/exception/FailedOpenPackFileSystemException.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/exception/FailedOpenPackFileSystemException.kt
new file mode 100644
index 0000000..5c2b9de
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/exception/FailedOpenPackFileSystemException.kt
@@ -0,0 +1,11 @@
+package com.calculatorsteam.dynamicpack.util.exception
+
+/**
+ * Thrown when fail to open pack file system.
+ */
+class FailedOpenPackFileSystemException @JvmOverloads constructor(
+    message: String? = null,
+    cause: Throwable? = null,
+    enableSuppression: Boolean = false,
+    writableStackTrace: Boolean = true
+) : RuntimeException(message, cause, enableSuppression, writableStackTrace)
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/exception/TranslatableException.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/exception/TranslatableException.kt
new file mode 100644
index 0000000..fcd59a8
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/exception/TranslatableException.kt
@@ -0,0 +1,55 @@
+package com.calculatorsteam.dynamicpack.util.exception
+
+import net.minecraft.network.chat.Component
+
+/**
+ * Exception shows in GUI as translatable
+ */
+class TranslatableException : RuntimeException {
+
+    val key: String
+    val args: Array<out Any>
+
+    constructor(message: String?, key: String, vararg args: Any) : super(message) {
+        this.key = key
+        this.args = args
+    }
+
+    constructor(message: String?, cause: Throwable?, key: String, vararg args: Any) : super(message, cause) {
+        this.key = key
+        this.args = args
+    }
+
+    constructor(cause: Throwable?, key: String, vararg args: Any) : super(cause) {
+        this.key = key
+        this.args = args
+    }
+
+    constructor(
+        message: String?,
+        cause: Throwable?,
+        enableSuppression: Boolean,
+        writableStackTrace: Boolean,
+        key: String,
+        vararg args: Any
+    ) : super(message, cause, enableSuppression, writableStackTrace) {
+        this.key = key
+        this.args = args
+    }
+
+    companion object {
+        fun findComponentOnException(e: Throwable?): Component? {
+            if (e == null) return null
+            return if (e is TranslatableException) {
+                Component.translatable(e.key, *e.args)
+            } else if (e.cause != null) {
+                findComponentOnException(e.cause)
+            } else null
+        }
+
+        @JvmStatic
+        fun getComponentFromException(e: Throwable): Component {
+            return findComponentOnException(e) ?: Component.literal(e.message ?: "Unknown error")
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/FileLog.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/FileLog.kt
new file mode 100644
index 0000000..c9fa5e2
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/FileLog.kt
@@ -0,0 +1,31 @@
+package com.calculatorsteam.dynamicpack.util.log
+
+import java.nio.file.Path
+
+/**
+ * Notify this class about all changes in files by mod.
+ */
+object FileLog {
+    private const val PREFIX = "[FilesLog] "
+
+    @JvmField
+    var logAllChanges: Boolean = false
+
+    fun deleted(path: Path) {
+        if (logAllChanges) {
+            Out.debug("$PREFIX-deleted: $path")
+        }
+    }
+
+    fun created(path: Path) {
+        if (logAllChanges) {
+            Out.debug("$PREFIX+created: $path")
+        }
+    }
+
+    fun writtenByUrl(path: Path, url: String) {
+        if (logAllChanges) {
+            Out.debug("$PREFIX=written: ($url)-> $path")
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/LoopLog.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/LoopLog.kt
new file mode 100644
index 0000000..7b2ffc2
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/LoopLog.kt
@@ -0,0 +1,20 @@
+package com.calculatorsteam.dynamicpack.util.log
+
+import kotlin.time.Duration
+
+/**
+ * Millis timer based on [System.currentTimeMillis].
+ */
+class LoopLog(private val interval: Duration) {
+    private var latest: Long = 0
+
+    fun tick(): Boolean {
+        val current = System.currentTimeMillis()
+        return if (current - latest > interval.inWholeMilliseconds) {
+            latest = current
+            true
+        } else {
+            false
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/NetworkStat.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/NetworkStat.kt
new file mode 100644
index 0000000..5265def
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/NetworkStat.kt
@@ -0,0 +1,86 @@
+package com.calculatorsteam.dynamicpack.util.log
+
+import com.calculatorsteam.dynamicpack.Constants
+import java.io.IOException
+import kotlin.time.Duration.Companion.seconds
+
+/**
+ * Network statistics: speed, totals, ETA.
+ */
+object NetworkStat {
+    const val MAGIC_NO_STATISTIC: Long = -1
+
+    private val debugCallLoopLog = LoopLog(1.seconds)
+    private var millis: Long = 0
+    private var bytes: Long = 0
+
+    // used for multi-thread correction
+    @JvmField
+    var speedMultiplier: Long = 1 // костыль :-)
+
+    /**
+     * Run network task with counted bytes/time.
+     */
+    @Throws(IOException::class)
+    fun <R> runNetworkTask(bytes: Long, runnable: () -> R): R {
+        val start = System.currentTimeMillis()
+        var exception: IOException? = null
+        var result: R? = null
+        try {
+            result = runnable()
+        } catch (e: IOException) {
+            exception = e
+        }
+        val elapsed = System.currentTimeMillis() - start
+        addLap(elapsed, bytes)
+        if (exception != null) {
+            throw exception
+        }
+        return result ?: throw IllegalStateException("Runnable returned null")
+    }
+
+    /**
+     * @return speed in bytes/second
+     */
+    fun getSpeed(): Long {
+        if (millis < 1000 || bytes == 0L) return MAGIC_NO_STATISTIC
+        return (bytes / (millis / 1000f)).toLong() * speedMultiplier
+    }
+
+    /**
+     * Add a lap to statistic
+     */
+    fun addLap(elapsed: Long, bytesRead: Long) {
+        require(elapsed >= 0 && bytesRead >= 0) {
+            "elapsed and bytesRead can't be negative!"
+        }
+
+        if (bytes > Constants.NETWORK_STAT_RESET_LIMIT) {
+            bytes /= 3
+            millis /= 3
+            Out.debug("[NetworkStat] reset by divide all by 3")
+        }
+        millis += elapsed
+        bytes += bytesRead
+
+        debugCall()
+    }
+
+    /**
+     * ETA in seconds
+     */
+    fun remainingETA(bytes: Long): Long {
+        val speed = getSpeed()
+        if (speed <= 0) return MAGIC_NO_STATISTIC
+        return bytes / speed
+    }
+
+    private fun debugCall() {
+        if (Constants.DEBUG && debugCallLoopLog.tick()) {
+            Out.debug(
+                "[NetworkStat] speed: ${Constants.speedToString(getSpeed())}; " +
+                        "totalTime=$millis; totalBytes=$bytes"
+            )
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/Out.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/Out.kt
new file mode 100644
index 0000000..325d157
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/log/Out.kt
@@ -0,0 +1,102 @@
+package com.calculatorsteam.dynamicpack.util.log
+
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.util.enums.Loader
+import org.apache.logging.log4j.LogManager
+import org.apache.logging.log4j.Logger
+import java.io.FileNotFoundException
+import java.net.UnknownHostException
+
+/**
+ * Mod logger
+ */
+object Out {
+    private val LOGGER: Logger = LogManager.getLogger("dynamicpack")
+    private const val DEFAULT_PREFIX = "[DynamicPack] "
+
+    @JvmField var ENABLE: Boolean = true
+    @JvmField var USE_SOUT: Boolean = false
+    private var prefix: String = ""
+
+    @JvmStatic
+    fun println(o: Any?) {
+        if (!ENABLE) return
+        if (USE_SOUT) {
+            kotlin.io.println(prefix + o)
+        } else {
+            LOGGER.info("{}{}", prefix, o)
+        }
+    }
+
+    @JvmStatic
+    fun error(s: String, e: Throwable) {
+        if (!ENABLE) return
+        val stacktrace = isPrintErrorStackTrace(e)
+        if (USE_SOUT) {
+            System.err.println(prefix + s)
+            if (stacktrace) {
+                e.printStackTrace()
+            }
+        } else {
+            if (stacktrace) {
+                LOGGER.error("{}{}", prefix, s, e)
+            } else {
+                LOGGER.error("{}{}: {}", prefix, s, e.toString())
+            }
+        }
+    }
+
+    private fun isPrintErrorStackTrace(e: Throwable): Boolean =
+        e !is FileNotFoundException && e !is UnknownHostException
+
+    fun warn(s: String) {
+        if (!ENABLE) return
+        if (USE_SOUT) {
+            kotlin.io.println(prefix + "WARN: " + s)
+        } else {
+            LOGGER.warn("{}{}", prefix, s)
+        }
+    }
+
+    /**
+     * Always enable! Ignore enable/disable
+     */
+    fun securityWarning(s: String) {
+        if (USE_SOUT) {
+            kotlin.io.println("[DynamicPack] $s")
+            return
+        }
+        runCatching {
+            LOGGER.warn("[DynamicPack] {}", s)
+        }.onFailure {
+            kotlin.io.println("[DynamicPack] $s")
+        }
+    }
+
+    fun debug(s: String) {
+        if (Constants.isDebugLogs()) {
+            println("DEBUG: $s")
+        }
+    }
+
+    /**
+     * Always enable! Ignore enable/disable
+     */
+    fun securityStackTrace() {
+        if (USE_SOUT) {
+            kotlin.io.println("[DynamicPack] Stacktrace")
+            Throwable("StackTrace printer").printStackTrace()
+            return
+        }
+        LOGGER.error(
+            "[DynamicPack] No error. This is stacktrace printer",
+            Throwable("StackTrace printer")
+        )
+    }
+
+    fun init() {
+        if (Constants.isRelease()) {
+            prefix = DEFAULT_PREFIX
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/com/calculatorsteam/dynamicpack/util/status/StatusChecker.kt b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/status/StatusChecker.kt
new file mode 100644
index 0000000..4274b1b
--- /dev/null
+++ b/src/main/kotlin/com/calculatorsteam/dynamicpack/util/status/StatusChecker.kt
@@ -0,0 +1,70 @@
+package com.calculatorsteam.dynamicpack.util.status
+
+import com.calculatorsteam.dynamicpack.Constants
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.util.JsonUtil.getLong
+import com.calculatorsteam.dynamicpack.util.JsonUtil.fromString
+import com.calculatorsteam.dynamicpack.util.enums.Loader
+import com.calculatorsteam.dynamicpack.util.log.Out
+import com.calculatorsteam.dynamicpack.util.Urls
+import com.google.gson.JsonObject
+
+/**
+ * Check status from developer.
+ */
+object StatusChecker {
+    private const val URL = "https://calculatorsteam.github.io/DynamicPack/dynamicpack.status.v1.json"
+
+    private var isUpdateAvailable: Boolean = false
+    private var isFormatActual: Boolean = true
+    private var isSafe: Boolean = true
+    private var isChecked: Boolean = false
+
+    @JvmStatic
+    fun check() {
+        if (isChecked) return
+
+        Out.println("Checking status...")
+        try {
+            val s = Urls.parseTextContent(URL, 1024 * 512) ?: return
+            val j: JsonObject = fromString(s)
+            val platformKey = getLatestKeyForPlatform(DynamicPackMod.loader)
+            val lat = j.getAsJsonObject(platformKey)
+
+            isUpdateAvailable = lat.getLong("build") > Constants.VERSION_BUILD
+            isSafe = lat.getLong("safe") <= Constants.VERSION_BUILD
+            isFormatActual = lat.getLong("format") <= Constants.VERSION_BUILD
+
+            isChecked = true
+            Out.println(
+                "Status checked! platformKey=$platformKey, " +
+                        "isSafe=$isSafe, isFormatActual=$isFormatActual, isUpdateAvailable=$isUpdateAvailable"
+            )
+        } catch (e: Exception) {
+            Out.error("Error while checking status...", e)
+        }
+    }
+
+    private fun getLatestKeyForPlatform(loader: Loader?): String = when (loader) {
+        null, Loader.UNKNOWN -> "latest_version"
+        Loader.FABRIC -> "latest_version_fabric"
+        Loader.FORGE -> "latest_version_forge"
+        Loader.NEO_FORGE -> "latest_version_neoforge"
+    }
+
+    @JvmStatic
+    fun isBlockUpdating(remoteType: String): Boolean =
+        if (remoteType == "modrinth") false else !isSafe()
+
+    @JvmStatic
+    fun isModUpdateAvailable(): Boolean = isUpdateAvailable
+
+    @JvmStatic
+    fun isSafe(): Boolean = isSafe
+
+    @JvmStatic
+    fun isFormatActual(): Boolean = isFormatActual
+
+    @JvmStatic
+    fun isChecked(): Boolean = isChecked
+}
\ No newline at end of file
diff --git a/src/main/resources/assets/dynamicpack/lang/en_us.json b/src/main/resources/assets/dynamicpack/lang/en_us.json
new file mode 100644
index 0000000..c75468f
--- /dev/null
+++ b/src/main/resources/assets/dynamicpack/lang/en_us.json
@@ -0,0 +1,66 @@
+{
+  "dynamicpack.toast.needReload": "Packs updated!",
+  "dynamicpack.toast.needReload.description": "§6For reload: F3 + T",
+  "dynamicpack.toast.syncStarted": "Sync started",
+  "dynamicpack.toast.done": "§aSync is complete",
+  "dynamicpack.toast.pack.done.success.title": "Pack %s",
+  "dynamicpack.toast.pack.done.success.description": "Done!",
+  "dynamicpack.toast.pack.error.title": "Pack %s",
+  "dynamicpack.toast.pack.error.description": "§cError while sync...",
+  "dynamicpack.toast.pack.state.downloading.title": "Pack %s",
+  "dynamicpack.toast.pack.state.downloading.description": "[%s%%] %s",
+  "dynamicpack.toast.pack.state.deleting.title": "Pack %s",
+  "dynamicpack.toast.pack.state.deleting.description": "Delete %s",
+  "dynamicpack.toast.pack.state.unknown.title": "Pack %s",
+  "dynamicpack.toast.pack.state.unknown.description": "Processing...",
+  "dynamicpack.screen.pack.description": "§aThis resource pack support DynamicPack features!",
+  "dynamicpack.screen.pack.remote_type": "Remote type: %s",
+  "dynamicpack.screen.pack.latestUpdated": "Last updated: %s",
+  "dynamicpack.screen.pack.latestException": "Last error in this pack: %s\nSee logs for details...",
+  "dynamicpack.screen.pack.manually_sync": "Sync manually",
+  "dynamicpack.screen.pack.manually_sync.this": "[This]",
+  "dynamicpack.screen.pack.manually_sync.all": "[All]",
+  "dynamicpack.screen.pack.manually_sync.all.warningNotInclude": "Please note that this pack will not be updated when you click [All] button, since the configuration only enables updating of active packs, but this pack is not activated.",
+  "dynamicpack.screen.pack.dynamic.contents": "Contents...",
+  "dynamicpack.status_checker.not_safe": "Security update available for DynamicPack mod! This message should not be ignored, since the update has fixed possible vulnerabilities: %s",
+  "dynamicpack.status_checker.not_safe.toast.title": "DynamicPack",
+  "dynamicpack.status_checker.not_safe.toast.description": "Security update available",
+  "dynamicpack.status_checker.format_not_actual": "Dynamic pack format update available! Perhaps resource pack developers will use it, and then without updating the mod they will stop working: %s",
+  "dynamicpack.status_checker.download": "Download!",
+  "dynamicpack.status_checker.download.hover": "Click for go to %s",
+  "dynamicpack.exceptions.pack.remote.modrinth.not_found_latest_version": "Could not find the latest version on modrinth with suitable parameters",
+  "dynamicpack.screen.pack_contents.title": "Contents",
+  "dynamicpack.screen.pack_contents.apply": "Apply & ReSync",
+  "dynamicpack.screen.pack_contents.apply.tooltip": "§cAfter exiting, everything unnecessary will be deleted, and the missing will be downloaded!",
+  "dynamicpack.screen.pack_contents.state": "State: %s",
+  "dynamicpack.screen.pack_contents.state.tooltip_disabled": "This pack cannot be disabled. Because it's required for work",
+  "dynamicpack.screen.pack_contents.state.true": "§aEnabled",
+  "dynamicpack.screen.pack_contents.state.false": "§cDisabled",
+  "dynamicpack.screen.pack_contents.state.default.true": "Default §a(ON)",
+  "dynamicpack.screen.pack_contents.state.default.false": "Default §c(OFF)",
+  "dynamicpack.screen.pack.updateStat": "Speed: %s\nETA: %s\n%s%% %s",
+  "dynamicpack.screen.config.category.network": "Network",
+  "dynamicpack.screen.config.category.network.tooltip": "You can change this if you understand what you are doing",
+  "dynamicpack.screen.config.category.network.group.name": "Download",
+  "dynamicpack.screen.config.category.network.group.description": "",
+  "dynamicpack.screen.config.category.network.bufferSize.name": "Buffer size",
+  "dynamicpack.screen.config.category.network.bufferSize.description": "Files are downloaded in small parts. If you have high Internet speed, you can increase the size of the part to reduce CPU load. Please note that if you make the size larger than the average size of downloaded files, the buffer will be half empty most of the time, which means it will waste your RAM.",
+
+  "dynamicpack.screen.config.category.network.multithread.threads.name": "Number of threads",
+  "dynamicpack.screen.config.category.network.multithread.threads.description": "In resource packs like 'dynamic_repo' the mod uses multi-threaded downloading. This setting sets the number of threads.\n\nPlease note that values greater than 10 are not recommended, since the service from which files are downloaded may limit the maximum number of connections from one IP address.\n\nIf your Internet initializes the HTTPS connection very slowly, but downloading occurs faster, increasing this setting will give a noticeable boost.",
+
+  "dynamicpack.screen.config.category.general": "General",
+  "dynamicpack.screen.config.category.general.isAutoUpdateAtLaunch": "Auto-update when starting Minecraft",
+  "dynamicpack.screen.config.category.general.isAutoUpdateAtLaunch.description": "The mod in the background will launch an auto-update process for those resource packs that are outdated. (Recommended)",
+
+  "dynamicpack.screen.config.category.general.updateOnlyEnabledPacks": "Update only enabled packs",
+  "dynamicpack.screen.config.category.general.updateOnlyEnabledPacks.description": "Update only those packs that are activated in the game.",
+
+  "dynamicpack.screen.config.category.debug": "Debug",
+  "dynamicpack.screen.config.category.debug.description": "It is highly recommended not to touch anything in this tab.",
+  "dynamicpack.screen.config.category.debug.logAllFilesChanges": "Log all files changes",
+  "dynamicpack.screen.config.category.debug.ignoreHidden": "Ignore 'hidden' flag in contents",
+
+  "dynamicpack.screen.config.no_yacl.title": "YetAnotherConfigLib not installed!",
+  "dynamicpack.screen.config.no_yacl.description": "To configure DynamicPack using a GUI, you must install %s, this is the library used to make this functionality available."
+}
\ No newline at end of file
diff --git a/src/main/resources/assets/dynamicpack/lang/ru_ru.json b/src/main/resources/assets/dynamicpack/lang/ru_ru.json
new file mode 100644
index 0000000..2b37a54
--- /dev/null
+++ b/src/main/resources/assets/dynamicpack/lang/ru_ru.json
@@ -0,0 +1,67 @@
+{
+  "dynamicpack.toast.needReload": "Паки обновлены!",
+  "dynamicpack.toast.needReload.description": "§6Чтобы применить: F3 + T",
+  "dynamicpack.toast.syncStarted": "Процесс начат!",
+  "dynamicpack.toast.done": "§aУспешно!",
+  "dynamicpack.toast.pack.done.success.title": "Пак %s",
+  "dynamicpack.toast.pack.done.success.description": "Успешно!",
+  "dynamicpack.toast.pack.error.title": "Пак %s",
+  "dynamicpack.toast.pack.error.description": "§cОшибка...",
+  "dynamicpack.toast.pack.state.downloading.title": "Пак %s",
+  "dynamicpack.toast.pack.state.downloading.description": "[%s%%] %s",
+  "dynamicpack.toast.pack.state.deleting.title": "Пак %s",
+  "dynamicpack.toast.pack.state.deleting.description": "Удаление %s",
+  "dynamicpack.toast.pack.state.unknown.title": "Пак %s",
+  "dynamicpack.toast.pack.state.unknown.description": "Обработка...",
+  "dynamicpack.screen.pack.description": "§aЭтот ресурспак поддерживает возможности мода DynamicPack!",
+  "dynamicpack.screen.pack.remote_type": "Тип: %s",
+  "dynamicpack.screen.pack.latestUpdated": "Обновлён: %s",
+  "dynamicpack.screen.pack.latestException": "Последняя ошибка в паке: %s\nДля деталей смотрите логи",
+  "dynamicpack.screen.pack.manually_sync": "Синхр. вручную",
+  "dynamicpack.screen.pack.manually_sync.this": "[Этот]",
+  "dynamicpack.screen.pack.manually_sync.all": "[Все]",
+  "dynamicpack.screen.pack.manually_sync.all.warningNotInclude": "Учтите, этот пак не будет обновлён при нажатии этой кнопки поскольку в конфигурации включено обновление только включённых паков, но этот пак не включен.",
+  "dynamicpack.screen.pack.dynamic.contents": "Контенты...",
+  "dynamicpack.status_checker.not_safe": "Доступно обновление безопасности для мода DynamicPack! Это сообщение не стоит игнорировать, поскольку в обновлении были исправлены возможные уязвимости: %s",
+  "dynamicpack.status_checker.not_safe.toast.title": "DynamicPack",
+  "dynamicpack.status_checker.not_safe.toast.description": "Доступно обновление безопасности",
+  "dynamicpack.status_checker.format_not_actual": "Доступно обновление формата динамических паков! Возможно разработчики ресурспаков будут его использовать, и тогда без обновления мода они работать перестанут: %s",
+  "dynamicpack.status_checker.download": "Загрузить!",
+  "dynamicpack.status_checker.download.hover": "Нажмите чтобы перейти %s",
+  "dynamicpack.exceptions.pack.remote.modrinth.not_found_latest_version": "Не удалось найти последнюю версию на Modrinth с подходящими параметрами",
+  "dynamicpack.screen.pack_contents.title": "Параметры контентов",
+  "dynamicpack.screen.pack_contents.apply": "Применить",
+  "dynamicpack.screen.pack_contents.apply.tooltip": "§cПосле выхода всё ненужное будет удалено, а недостающее скачано!",
+  "dynamicpack.screen.pack_contents.state": "Режим: %s",
+  "dynamicpack.screen.pack_contents.state.tooltip_disabled": "Этот пак нельзя отключить. Он обязательный",
+  "dynamicpack.screen.pack_contents.state.true": "§aВключено",
+  "dynamicpack.screen.pack_contents.state.false": "§cОтключено",
+  "dynamicpack.screen.pack_contents.state.default.true": "По умолчанию §a(вкл)",
+  "dynamicpack.screen.pack_contents.state.default.false": "По умолчанию §c(выкл)",
+  "dynamicpack.screen.pack.updateStat": "Скорость: %s\nОсталось: %s\n%s%% %s",
+  "dynamicpack.screen.config.category.network": "Сеть",
+  "dynamicpack.screen.config.category.network.tooltip": "Вы можете поменять это если понимаете что делаете",
+  "dynamicpack.screen.config.category.network.group.name": "Скачивание",
+  "dynamicpack.screen.config.category.network.group.description": "",
+  "dynamicpack.screen.config.category.network.bufferSize.name": "Размер буффера",
+  "dynamicpack.screen.config.category.network.bufferSize.description": "Файлы загружаются небольшими частями. Если у вас высокая скорость интернета, вы можете увеличить размер части чтобы уменьшить нагрузку на процессор. Обратите внимание, что если вы сделаете размер больше среднего размера загружаемых файлов, большую часть времени буфер будет наполовину пуст, а это значит, что он будет тратить вашу оперативную память не эффективно.",
+
+  "dynamicpack.screen.config.category.network.multithread.threads.name": "Количество потоков",
+  "dynamicpack.screen.config.category.network.multithread.threads.description": "В ресурспаках типа 'dynamic_repo' мод применяет мнопоточное скачивание. Эта настройка устанавливает количество потоков.\n\nУчтите, значения больше 10 не рекомендуются, поскольку сервис откуда скачиваются файлы может ограничивать максимальное количество подключений с одного айпи адреса.\n\nЕсли ваш интернет очень медленно инициализирует HTTPS соединение, но скачивание происходит быстрее, повышение этой настройки даст ощутимый буст.",
+
+  "dynamicpack.screen.config.category.general": "Основное",
+  "dynamicpack.screen.config.category.general.isAutoUpdateAtLaunch": "Авто-обновление при запуске Minecraft",
+  "dynamicpack.screen.config.category.general.isAutoUpdateAtLaunch.description": "Мод в фоне будет запускать процесс авто-обновления для тех ресурспаков которые устарели. (Рекомендуется)",
+
+  "dynamicpack.screen.config.category.general.updateOnlyEnabledPacks": "Обновлять только актиные паки",
+  "dynamicpack.screen.config.category.general.updateOnlyEnabledPacks.description": "Обновлять только те паки, которые включены в игре.",
+
+
+  "dynamicpack.screen.config.category.debug": "Отладка",
+  "dynamicpack.screen.config.category.debug.description": "Очень не рекомендуется трогать что-либо в этой вкладке.",
+  "dynamicpack.screen.config.category.debug.logAllFilesChanges": "Логгировать все изменения файлов",
+  "dynamicpack.screen.config.category.debug.ignoreHidden": "Игнор флага 'hidden' в контентах",
+
+  "dynamicpack.screen.config.no_yacl.title": "YetAnotherConfigLib не установлен!",
+  "dynamicpack.screen.config.no_yacl.description": "Для настройки DynamicPack через графический интерфейс требуется мод %s - это библиотека, используемая для предоставленияя данной функции."
+}
\ No newline at end of file
diff --git a/src/main/resources/assets/dynamicpack/select_button.png b/src/main/resources/assets/dynamicpack/select_button.png
new file mode 100644
index 0000000..d3e8e08
Binary files /dev/null and b/src/main/resources/assets/dynamicpack/select_button.png differ
diff --git a/src/main/resources/assets/dynamicpack/select_button_syncing.png b/src/main/resources/assets/dynamicpack/select_button_syncing.png
new file mode 100644
index 0000000..6790eae
Binary files /dev/null and b/src/main/resources/assets/dynamicpack/select_button_syncing.png differ
diff --git a/src/main/resources/assets/dynamicpack/select_button_warning.png b/src/main/resources/assets/dynamicpack/select_button_warning.png
new file mode 100644
index 0000000..f538b3a
Binary files /dev/null and b/src/main/resources/assets/dynamicpack/select_button_warning.png differ
diff --git a/src/main/resources/dynamicpack.mixins.json b/src/main/resources/dynamicpack.mixins.json
new file mode 100644
index 0000000..f1b34ea
--- /dev/null
+++ b/src/main/resources/dynamicpack.mixins.json
@@ -0,0 +1,19 @@
+{
+  "required": true,
+  "package": "com.calculatorsteam.dynamicpack.mixins",
+  "compatibilityLevel": "JAVA_17",
+  "minVersion": "0.8",
+  "client": [
+    "MinecraftClientMixin",
+    "ResourcePackEntryMixin",
+    "ResourcePackScreenMixin",
+    "TitleScreenMixin"
+  ],
+  "mixins": [
+    "FilePackResourcesMixin",
+    "PackRepositoryMixin"
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}
\ No newline at end of file
diff --git a/src/main/resources/icon.png b/src/main/resources/icon.png
new file mode 100644
index 0000000..57f3f24
Binary files /dev/null and b/src/main/resources/icon.png differ
diff --git a/src/main/templates/META-INF/mods.toml b/src/main/templates/META-INF/mods.toml
new file mode 100644
index 0000000..37db9a9
--- /dev/null
+++ b/src/main/templates/META-INF/mods.toml
@@ -0,0 +1,30 @@
+modLoader = "kotlinforforge"
+loaderVersion = "[1,)"
+issueTrackerURL = "https://github.com/${github}/issues"
+license = "${mod_license}"
+
+[[mods]]
+modId = "${mod_id}"
+version = "${mod_version}"
+displayName = "${mod_name}"
+authors = "${mod_author}"
+description = '''
+${mod_description}
+'''
+logoFile = "icon.png"
+
+[["dependencies.${mod_id}"]]
+modId = "forge"
+mandatory = true
+ordering = "NONE"
+side = "BOTH"
+
+[["dependencies.${mod_id}"]]
+modId = "minecraft"
+mandatory = true
+versionRange = "${mc}"
+ordering = "NONE"
+side = "BOTH"
+
+[modproperties.${mod_id}]
+"${mod_id}:buildGitHash" = "${gitHead}"
\ No newline at end of file
diff --git a/src/main/templates/META-INF/neoforge.mods.toml b/src/main/templates/META-INF/neoforge.mods.toml
new file mode 100644
index 0000000..bf22678
--- /dev/null
+++ b/src/main/templates/META-INF/neoforge.mods.toml
@@ -0,0 +1,30 @@
+modLoader = "kotlinforforge"
+loaderVersion = "[1,)"
+issueTrackerURL = "https://github.com/${github}/issues"
+license = "${mod_license}"
+
+[[mods]]
+modId = "${mod_id}"
+version = "${mod_version}"
+displayName = "${mod_name}"
+authors = "${mod_author}"
+description = '''
+${mod_description}
+'''
+logoFile = "icon.png"
+
+[["dependencies.${mod_id}"]]
+modId = "neoforge"
+mandatory = true
+ordering = "NONE"
+side = "BOTH"
+
+[["dependencies.${mod_id}"]]
+modId = "minecraft"
+mandatory = true
+versionRange = "${mc}"
+ordering = "NONE"
+side = "BOTH"
+
+[modproperties.${mod_id}]
+"${mod_id}:buildGitHash" = "${gitHead}"
\ No newline at end of file
diff --git a/src/main/templates/fabric.mod.json b/src/main/templates/fabric.mod.json
new file mode 100644
index 0000000..b953f0f
--- /dev/null
+++ b/src/main/templates/fabric.mod.json
@@ -0,0 +1,39 @@
+{
+  "schemaVersion": 1,
+  "id": "${mod_id}",
+  "version": "${mod_version}",
+  "name": "${mod_name}",
+  "description": "${mod_description}",
+  "authors": [
+    "${mod_author}"
+  ],
+  "contact": {
+    "homepage": "https://example.com",
+    "issues": "https://github.com/${github}/issues",
+    "sources": "https://github.com/${github}"
+  },
+  "icon": "icon.png",
+  "license": "${mod_license}",
+  "environment": "*",
+  "depends": {
+    "fabric-api": ">=${fapi}",
+    "fabricloader": ">=${fabricLoader}",
+    "fabric-language-kotlin": ">=${fabricLangKotlin}",
+    "minecraft": "${mc}",
+    "java": ">=17"
+  },
+  "entrypoints": {
+    "preLaunch": [
+      "com.calculatorsteam.dynamicpack.platform.fabric.FabricDynamicPreLaunch"
+    ],
+    "client": [
+      "com.calculatorsteam.dynamicpack.platform.PlatformEntrypoint"
+    ],
+    "modmenu": [
+      "com.calculatorsteam.dynamicpack.platform.fabric.ModMenuIntegration"
+    ]
+  },
+  "custom": {
+    "${mod_id}:buildGitHash": "${gitHead}"
+  }
+}
\ No newline at end of file
diff --git a/src/main/templates/pack.mcmeta b/src/main/templates/pack.mcmeta
new file mode 100644
index 0000000..0387682
--- /dev/null
+++ b/src/main/templates/pack.mcmeta
@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "description": "${mod_description}",
+    "pack_format": ${pack_format}
+}
+}
\ No newline at end of file
diff --git a/src/test/kotlin/tests/InputValidatorTest.kt b/src/test/kotlin/tests/InputValidatorTest.kt
new file mode 100644
index 0000000..70564d8
--- /dev/null
+++ b/src/test/kotlin/tests/InputValidatorTest.kt
@@ -0,0 +1,87 @@
+/*? if !forge {*/
+package tests
+
+import com.calculatorsteam.dynamicpack.InputValidator
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+import java.util.*
+
+class InputValidatorTest {
+
+    @Test
+    fun testContentId() {
+        assertFalse(InputValidator.isDynamicContentIdValid(""))
+        assertFalse(InputValidator.isDynamicContentIdValid(" "))
+        assertFalse(InputValidator.isDynamicContentIdValid("  "))
+        assertFalse(InputValidator.isDynamicContentIdValid("   32"))
+        assertFalse(InputValidator.isDynamicContentIdValid("test\ntest"))
+
+        assertTrue(InputValidator.isDynamicContentIdValid("__"))
+        assertTrue(InputValidator.isDynamicContentIdValid("_-"))
+        assertTrue(InputValidator.isDynamicContentIdValid("pack:megapack"))
+        assertTrue(InputValidator.isDynamicContentIdValid("1234567890"))
+        assertTrue(InputValidator.isDynamicContentIdValid("01"))
+        assertTrue(InputValidator.isDynamicContentIdValid("test_pack"))
+        assertTrue(InputValidator.isDynamicContentIdValid("super:mega_puper:"))
+    }
+
+    @Test
+    fun testRemoteName() {
+        assertFalse(InputValidator.isDynamicPackNameValid("\n"))
+        assertTrue(InputValidator.isDynamicPackNameValid("__"))
+    }
+
+    @Test
+    fun testUrls() {
+        assertTrue(InputValidator.isUrlValid("https://google.com"))
+        assertTrue(InputValidator.isUrlValid("https://324234.github.io/"))
+        assertTrue(InputValidator.isUrlValid("https://32-4234.github.io/"))
+        assertTrue(InputValidator.isUrlValid("https://google.com/f"))
+        assertTrue(
+            InputValidator.isUrlValid(
+                "https://google.net/fi/1/%s_1234567890-+.json?x=81723731+343+1"
+            )
+        )
+        assertFalse(InputValidator.isUrlValid("https://google.com`"))
+        assertFalse(InputValidator.isUrlValid("https://google.com "))
+        assertFalse(InputValidator.isUrlValid("https://google.com /"))
+        assertFalse(InputValidator.isUrlValid("https://google.com*!@#$%^&*()"))
+    }
+
+    @Test
+    fun testPaths() {
+        // корректный кейс
+        InputValidator.throwIsPathInvalid("/file/p.txt")
+
+        // некорректные
+        assertThrows(SecurityException::class.java) { InputValidator.throwIsPathInvalid("") }
+        assertThrows(SecurityException::class.java) { InputValidator.throwIsPathInvalid(" ") }
+        assertThrows(SecurityException::class.java) { InputValidator.throwIsPathInvalid("!/file/p.txt") }
+        assertThrows(SecurityException::class.java) { InputValidator.throwIsPathInvalid(null) }
+        assertThrows(SecurityException::class.java) { InputValidator.throwIsPathInvalid("\$@#") }
+        assertThrows(SecurityException::class.java) { InputValidator.throwIsPathInvalid("!\"/file/p.txt") }
+        assertThrows(SecurityException::class.java) { InputValidator.throwIsPathInvalid("!/fil*&^%544e/p.txt") }
+
+        // случай с рандомными байтами
+        assertThrows(SecurityException::class.java) {
+            val b = ByteArray(128).apply { Random().nextBytes(this) }
+            InputValidator.throwIsPathInvalid(String(b))
+        }
+
+        try {
+            val b = ByteArray(128).apply { Random().nextBytes(this) }
+            InputValidator.throwIsPathInvalid(String(b))
+        } catch (e: Exception) {
+            println(e)
+        }
+
+        assertThrows(SecurityException::class.java) { InputValidator.throwIsPathInvalid("~") }
+
+        assertThrows(SecurityException::class.java) {
+            InputValidator.throwIsPathInvalid(
+                "()*)*&" + "Y".repeat(300) + ")()*)*&" + "Y".repeat(300)
+            )
+        }
+    }
+}
+/*?}*/
\ No newline at end of file
diff --git a/src/test/kotlin/tests/PackUtilTest.kt b/src/test/kotlin/tests/PackUtilTest.kt
new file mode 100644
index 0000000..252f27a
--- /dev/null
+++ b/src/test/kotlin/tests/PackUtilTest.kt
@@ -0,0 +1,38 @@
+/*? if !forge {*/
+package tests
+
+import com.calculatorsteam.dynamicpack.util.PackUtil
+import org.junit.jupiter.api.Test
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+
+class PackUtilTest {
+
+    private val projectRoot: File = File(System.getProperty("user.dir"))
+        .let { dir ->
+            generateSequence(dir) { it.parentFile }
+                .firstOrNull { File(it, "settings.gradle.kts").exists() }
+                ?: dir
+        }
+
+    private fun resourceFile(name: String): File =
+        File(projectRoot, "src/test/kotlin/tests_files/$name")
+
+    @Test
+    fun testDir() {
+        PackUtil.openPackFileSystem(resourceFile("filedir")) { path: Path ->
+            val resolve = path.resolve("file.txt")
+            println(Files.readString(resolve))
+        }
+    }
+
+    @Test
+    fun testZip() {
+        PackUtil.openPackFileSystem(resourceFile("filezip.zip")) { path: Path ->
+            val resolve = path.resolve("file.txt")
+            println(Files.readString(resolve))
+        }
+    }
+}
+/*?}*/
\ No newline at end of file
diff --git a/src/test/kotlin/tests/SecurityTrustedUrlsTest.kt b/src/test/kotlin/tests/SecurityTrustedUrlsTest.kt
new file mode 100644
index 0000000..a8e5962
--- /dev/null
+++ b/src/test/kotlin/tests/SecurityTrustedUrlsTest.kt
@@ -0,0 +1,41 @@
+/*? if !forge {*/
+package tests
+
+import com.calculatorsteam.dynamicpack.pack.dynamicrepo.DynamicRepoSyncBuilder
+import com.calculatorsteam.dynamicpack.util.log.Out
+import com.calculatorsteam.dynamicpack.util.Urls
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.Test
+
+class SecurityTrustedUrlsTest {
+
+    @Test
+    fun test() {
+        Out.USE_SOUT = true
+
+        assertThrows(Exception::class.java) {
+            Out.println(Urls.parseTextContent("https://google.com", 1732132132))
+        }
+        assertThrows(Exception::class.java) {
+            Urls.parseTextContent("https://modrinth.com.google.com", 1732132132)
+        }
+        assertThrows(Exception::class.java) {
+            Urls.parseTextContent("https://fakemodrinth.com.com", 1732132132)
+        }
+
+        assertDoesNotThrow {
+            DynamicRepoSyncBuilder.getAndCheckPath("assets", "minecraft/lang/en_us.json")
+            DynamicRepoSyncBuilder.getAndCheckPath("assets/", "minecraft/lang/en_us.json")
+            DynamicRepoSyncBuilder.getAndCheckPath("assets", "/minecraft/lang/en_us.json")
+            DynamicRepoSyncBuilder.getAndCheckPath("assets", "/minecraft/lang/en_us.json")
+            DynamicRepoSyncBuilder.getAndCheckPath("/assets/", "///minecraft/lang/en_us.json")
+        }
+
+        repeat(3) {
+            assertThrows(Exception::class.java) {
+                DynamicRepoSyncBuilder.getAndCheckPath("assets/../../../../", "minecraft/lang/en_us.json")
+            }
+        }
+    }
+}
+/*?}*/
\ No newline at end of file
diff --git a/src/test/kotlin/tests/UrlsTest.kt b/src/test/kotlin/tests/UrlsTest.kt
new file mode 100644
index 0000000..99f8e1e
--- /dev/null
+++ b/src/test/kotlin/tests/UrlsTest.kt
@@ -0,0 +1,27 @@
+/*? if !forge {*/
+package tests
+
+import com.calculatorsteam.dynamicpack.DynamicPackMod
+import com.calculatorsteam.dynamicpack.util.log.Out
+import com.calculatorsteam.dynamicpack.util.Urls
+import org.junit.jupiter.api.Test
+
+class UrlsTest {
+
+    @Test
+    fun valid() {
+        Out.USE_SOUT = true
+        DynamicPackMod.addAllowedHosts("ubuntu.com", this)
+
+        repeat(100) {
+            Urls.downloadFileToTemp(
+                "https://cdn.modrinth.com/data/UQBo9Yss/versions/fYk7cLrO/BetterTables.zip",
+                "test",
+                ".temp",
+                32_965_550_080L, // читается лучше с подчёркивателями
+                null
+            )
+        }
+    }
+}
+/*?}*/
\ No newline at end of file
diff --git a/src/test/kotlin/tests_files/filedir/file.txt b/src/test/kotlin/tests_files/filedir/file.txt
new file mode 100644
index 0000000..4ec056c
--- /dev/null
+++ b/src/test/kotlin/tests_files/filedir/file.txt
@@ -0,0 +1 @@
+this is file in dir!
\ No newline at end of file
diff --git a/src/test/kotlin/tests_files/filezip.zip b/src/test/kotlin/tests_files/filezip.zip
new file mode 100644
index 0000000..e8b3dc4
Binary files /dev/null and b/src/test/kotlin/tests_files/filezip.zip differ
diff --git a/stonecutter.gradle.kts b/stonecutter.gradle.kts
new file mode 100644
index 0000000..66c9ad1
--- /dev/null
+++ b/stonecutter.gradle.kts
@@ -0,0 +1,24 @@
+plugins {
+    base
+    kotlin("jvm") version "2.2.20" apply false
+
+    id("dev.kikugie.stonecutter")
+
+    val modstitchVersion = "0.7.0-unstable"
+    id("dev.isxander.modstitch.base") version modstitchVersion apply false
+    id("dev.isxander.modstitch.shadow") version modstitchVersion apply false
+    id("dev.isxander.modstitch.publishing") version modstitchVersion apply false
+}
+stonecutter active "1.21.8-fabric"
+
+allprojects {
+    repositories {
+        maven("https://maven.terraformersmc.com/")
+        maven("https://maven.isxander.dev/releases")
+        maven("https://maven.isxander.dev/snapshots")
+        exclusiveContent {
+            forRepository { maven("https://thedarkcolour.github.io/KotlinForForge/") }
+            filter { includeGroup("thedarkcolour") }
+        }
+    }
+}
\ No newline at end of file
diff --git a/versions/1.20.1-fabric/gradle.properties b/versions/1.20.1-fabric/gradle.properties
new file mode 100644
index 0000000..75189dc
--- /dev/null
+++ b/versions/1.20.1-fabric/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=loom
+
+mcVersion=1.20.1
+parchment.version=2023.09.03
+
+deps.fabricApi=0.92.6+1.20.1
+deps.modmenu=7.2.2
+deps.yacl=3.6.6+1.20.1-fabric
+
+meta.mcDep=~1.20 <1.20.2
+
+pub.stableMC=1.20,1.20.1
\ No newline at end of file
diff --git a/versions/1.20.1-forge/gradle.properties b/versions/1.20.1-forge/gradle.properties
new file mode 100644
index 0000000..5e68f27
--- /dev/null
+++ b/versions/1.20.1-forge/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=moddevgradle-legacy
+
+mcVersion=1.20.1
+parchment.version=2023.09.03
+
+deps.forge=1.20.1-47.4.0
+deps.kotlinForForge=4.11.0
+deps.yacl=3.6.6+1.20.1-forge
+
+meta.mcDep=[1.20,1.20.1]
+
+pub.stableMC=1.20,1.20.1
\ No newline at end of file
diff --git a/versions/1.21.1-fabric/gradle.properties b/versions/1.21.1-fabric/gradle.properties
new file mode 100644
index 0000000..6fb8d2c
--- /dev/null
+++ b/versions/1.21.1-fabric/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=loom
+
+mcVersion=1.21.1
+parchment.version=2024.11.17
+
+deps.fabricApi=0.116.6+1.21.1
+deps.modmenu=11.0.3
+deps.yacl=3.7.1+1.21.1-fabric
+
+meta.mcDep=~1.21 <1.21.2
+
+pub.stableMC=1.21,1.21.1
\ No newline at end of file
diff --git a/versions/1.21.1-neoforge/gradle.properties b/versions/1.21.1-neoforge/gradle.properties
new file mode 100644
index 0000000..f610620
--- /dev/null
+++ b/versions/1.21.1-neoforge/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=moddevgradle
+
+mcVersion=1.21.1
+parchment.version=2024.11.17
+
+deps.neoforge=21.1.209
+deps.kotlinForForge=5.10.0
+deps.yacl=3.7.1+1.21.1-neoforge
+
+meta.mcDep=[1.21,1.21.1]
+
+pub.stableMC=1.21,1.21.1
\ No newline at end of file
diff --git a/versions/1.21.3-fabric/gradle.properties b/versions/1.21.3-fabric/gradle.properties
new file mode 100644
index 0000000..dcc2cb6
--- /dev/null
+++ b/versions/1.21.3-fabric/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=loom
+
+mcVersion=1.21.3
+parchment.version=2024.12.07
+
+deps.fabricApi=0.114.1+1.21.3
+deps.modmenu=12.0.0
+deps.yacl=3.7.1+1.21.3-fabric
+
+meta.mcDep=~1.21.2 <1.21.4
+
+pub.stableMC=1.21.2,1.21.3
\ No newline at end of file
diff --git a/versions/1.21.3-neoforge/gradle.properties b/versions/1.21.3-neoforge/gradle.properties
new file mode 100644
index 0000000..28071be
--- /dev/null
+++ b/versions/1.21.3-neoforge/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=moddevgradle
+
+mcVersion=1.21.3
+parchment.version=2024.12.07
+
+deps.neoforge=21.3.93
+deps.kotlinForForge=5.10.0
+deps.yacl=3.7.1+1.21.3-neoforge
+
+meta.mcDep=[1.21.2,1.21.3]
+
+pub.stableMC=1.21.2,1.21.3
\ No newline at end of file
diff --git a/versions/1.21.4-fabric/gradle.properties b/versions/1.21.4-fabric/gradle.properties
new file mode 100644
index 0000000..56410e5
--- /dev/null
+++ b/versions/1.21.4-fabric/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=loom
+
+mcVersion=1.21.4
+parchment.version=2025.03.23
+
+deps.fabricApi=0.119.4+1.21.4
+deps.modmenu=13.0.3
+deps.yacl=3.7.1+1.21.4-fabric
+
+meta.mcDep=~1.21.4 <1.21.5
+
+pub.stableMC=1.21.4
\ No newline at end of file
diff --git a/versions/1.21.4-neoforge/gradle.properties b/versions/1.21.4-neoforge/gradle.properties
new file mode 100644
index 0000000..fb29ca7
--- /dev/null
+++ b/versions/1.21.4-neoforge/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=moddevgradle
+
+mcVersion=1.21.4
+parchment.version=2025.03.23
+
+deps.neoforge=21.4.154
+deps.kotlinForForge=5.10.0
+deps.yacl=3.7.1+1.21.4-neoforge
+
+meta.mcDep=[1.21.4]
+
+pub.stableMC=1.21.4
\ No newline at end of file
diff --git a/versions/1.21.5-fabric/gradle.properties b/versions/1.21.5-fabric/gradle.properties
new file mode 100644
index 0000000..28e899f
--- /dev/null
+++ b/versions/1.21.5-fabric/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=loom
+
+mcVersion=1.21.5
+parchment.version=2025.06.15
+
+deps.fabricApi=0.128.2+1.21.5
+deps.modmenu=14.0.0-rc.2
+deps.yacl=3.7.1+1.21.5-fabric
+
+meta.mcDep=~1.21.5 <1.21.6
+
+pub.stableMC=1.21.5
\ No newline at end of file
diff --git a/versions/1.21.5-neoforge/gradle.properties b/versions/1.21.5-neoforge/gradle.properties
new file mode 100644
index 0000000..d4dbdae
--- /dev/null
+++ b/versions/1.21.5-neoforge/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=moddevgradle
+
+mcVersion=1.21.5
+parchment.version=2025.06.15
+
+deps.neoforge=21.5.95
+deps.kotlinForForge=5.10.0
+deps.yacl=3.7.1+1.21.5-neoforge
+
+meta.mcDep=[1.21.5]
+
+pub.stableMC=1.21.5
\ No newline at end of file
diff --git a/versions/1.21.8-fabric/gradle.properties b/versions/1.21.8-fabric/gradle.properties
new file mode 100644
index 0000000..2caac64
--- /dev/null
+++ b/versions/1.21.8-fabric/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=loom
+
+mcVersion=1.21.8
+parchment.version=2025.09.14
+
+deps.fabricApi=0.133.4+1.21.8
+deps.modmenu=15.0.0
+deps.yacl=3.7.1+1.21.6-fabric
+
+meta.mcDep=~1.21.6 <1.21.9
+
+pub.stableMC=1.21.6,1.21.7,1.21.8
\ No newline at end of file
diff --git a/versions/1.21.8-neoforge/gradle.properties b/versions/1.21.8-neoforge/gradle.properties
new file mode 100644
index 0000000..43ee12a
--- /dev/null
+++ b/versions/1.21.8-neoforge/gradle.properties
@@ -0,0 +1,12 @@
+modstitch.platform=moddevgradle
+
+mcVersion=1.21.8
+parchment.version=2025.09.14
+
+deps.neoforge=21.8.47
+deps.kotlinForForge=5.10.0
+deps.yacl=3.7.1+1.21.6-neoforge
+
+meta.mcDep=[1.21.6,1.21.7,1.21.8]
+
+pub.stableMC=1.21.6,1.21.7,1.21.8
\ No newline at end of file