diff --git a/src/main/kotlin/buj/tl/IL.kt b/src/main/kotlin/buj/tl/IL.kt
new file mode 100644
index 0000000..5b8e59e
--- /dev/null
+++ b/src/main/kotlin/buj/tl/IL.kt
@@ -0,0 +1,6 @@
+package buj.tl
+
+interface IL<Self : IL<Self>> {
+    fun put(key: String, value: Script): Self
+    fun put(key: String, text: String): Self
+}
diff --git a/src/main/kotlin/buj/tl/ILVoidDone.kt b/src/main/kotlin/buj/tl/ILVoidDone.kt
new file mode 100644
index 0000000..9d561b3
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ILVoidDone.kt
@@ -0,0 +1,5 @@
+package buj.tl
+
+interface ILVoidDone<Self : ILVoidDone<Self>> : IL<Self> {
+    fun done(key: String)
+}
diff --git a/src/main/kotlin/buj/tl/IScript.kt b/src/main/kotlin/buj/tl/IScript.kt
new file mode 100644
index 0000000..79231f6
--- /dev/null
+++ b/src/main/kotlin/buj/tl/IScript.kt
@@ -0,0 +1,6 @@
+package buj.tl
+
+interface IScript {
+    fun append(ctx: LCtx, source: String, lang: String): String
+    fun debug(): String
+}
diff --git a/src/main/kotlin/buj/tl/ITranslationLocaleRegistry.kt b/src/main/kotlin/buj/tl/ITranslationLocaleRegistry.kt
new file mode 100644
index 0000000..1b21a97
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ITranslationLocaleRegistry.kt
@@ -0,0 +1,6 @@
+package buj.tl
+
+interface ITranslationLocaleRegistry {
+    fun register(loader: ClassLoader)
+    fun all(): List<ClassLoader>
+}
diff --git a/src/main/kotlin/buj/tl/ITranslationLocaleResolver.kt b/src/main/kotlin/buj/tl/ITranslationLocaleResolver.kt
new file mode 100644
index 0000000..db35262
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ITranslationLocaleResolver.kt
@@ -0,0 +1,5 @@
+package buj.tl
+
+interface ITranslationLocaleResolver {
+    fun resolve(locale: String, key: String): Script
+}
diff --git a/src/main/kotlin/buj/tl/ITranslationParserFactory.kt b/src/main/kotlin/buj/tl/ITranslationParserFactory.kt
new file mode 100644
index 0000000..9f361b1
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ITranslationParserFactory.kt
@@ -0,0 +1,3 @@
+package buj.tl
+
+interface ITranslationParserFactory { fun create(): ITranslationScriptParser }
diff --git a/src/main/kotlin/buj/tl/ITranslationParserProvider.kt b/src/main/kotlin/buj/tl/ITranslationParserProvider.kt
new file mode 100644
index 0000000..a980596
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ITranslationParserProvider.kt
@@ -0,0 +1,3 @@
+package buj.tl
+
+interface ITranslationParserProvider { fun provide(): ITranslationParserFactory }
diff --git a/src/main/kotlin/buj/tl/ITranslationParserSelector.kt b/src/main/kotlin/buj/tl/ITranslationParserSelector.kt
new file mode 100644
index 0000000..ea5b62f
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ITranslationParserSelector.kt
@@ -0,0 +1,3 @@
+package buj.tl
+
+interface ITranslationParserSelector { fun select(): ITranslationParserProvider }
diff --git a/src/main/kotlin/buj/tl/ITranslationRuntime.kt b/src/main/kotlin/buj/tl/ITranslationRuntime.kt
new file mode 100644
index 0000000..58742ec
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ITranslationRuntime.kt
@@ -0,0 +1,13 @@
+package buj.tl
+
+import mindustry.gen.Player
+
+interface ITranslationRuntime {
+    fun broadcast(): La
+    fun send(player: Player): Lc
+    fun fmtFor(player: Player): Ls
+    fun fmt(locale: String): Ls
+    fun fmt(player: Player): Ls
+    fun init(loader: ClassLoader)
+    fun parse(script: String): Script
+}
diff --git a/src/main/kotlin/buj/tl/ITranslationScriptParser.kt b/src/main/kotlin/buj/tl/ITranslationScriptParser.kt
new file mode 100644
index 0000000..44775f7
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ITranslationScriptParser.kt
@@ -0,0 +1,5 @@
+package buj.tl
+
+interface ITranslationScriptParser {
+    fun parse(source: String): Script
+}
diff --git a/src/main/kotlin/buj/tl/Tl.kt b/src/main/kotlin/buj/tl/Tl.kt
index f3ba86b..e538bea 100644
--- a/src/main/kotlin/buj/tl/Tl.kt
+++ b/src/main/kotlin/buj/tl/Tl.kt
@@ -9,262 +9,6 @@ import mindustry.gen.Groups
 import mindustry.gen.Player
 import java.io.IOException
 
-private fun minIdx(vararg vals: Int): Int {
-    var min = -1
-    for (v in vals) if (v != -1 && v < min || min == -1) min = v
-    return min
-}
-
-private fun destructLocale(locale: String): Array<String> {
-    val san = locale.replace(Regex("[^a-zA-Z0-9_-]"), "_")
-        .replace(Regex("_+"), "_")
-        .replace(Regex("^_|_$"), "")
-        .lowercase()
-    if (san.indexOf('_') > 0) return arrayOf(san, san.take(san.indexOf('_')), "c")
-    if (san != "c") return arrayOf(san, "c")
-    return arrayOf("c")
-}
-// @formatter:off
-private val COLORS = arrayOf(
-    "clear", "black", "white", "lightgray",
-    "gray", "darkgray", "blue", "navy",
-    "royal", "slate", "sky", "cyan",
-    "teal", "green", "acid", "lime",
-    "forest", "olive", "yellow", "gold",
-    "goldenrod", "orange", "brown", "tan",
-    "brick", "red", "scarlet", "coral",
-    "salmon", "pink", "magenta", "purple",
-    "violet", "maroon",
-)
-// @formatter:on
-private fun isValidColor(color: String): Boolean {
-    if (color.startsWith("#")) return color.matches(Regex("^#([0-9a-fA-F]{1,6}|[0-9a-fA-F]{8})$"))
-    return color in COLORS
-}
-
-private val loaders = Seq<ClassLoader>()
-private val localeCache = ObjectMap<ClassLoader, ObjectMap<String, LocaleFile?>>()
-
-internal class LocaleFile {
-    companion object {
-        operator fun get(localeBase: String, key: String): Script {
-            var i = loaders.size
-            while (--i >= 0) {
-                val loader = loaders[i]
-                for (locale in destructLocale(localeBase)) {
-                    val file = this[loader, locale]
-                    if (file == null || !file.tls.containsKey(key)) continue
-                    return file.tls.get(key)
-                }
-            }
-            return ScrText("[red]$key[]")
-        }
-
-        operator fun get(loader: ClassLoader, locale: String): LocaleFile? {
-            val cache = localeCache.get(loader) { ObjectMap() }
-            if (cache.containsKey(locale)) {
-                return cache.get(locale)
-            }
-
-            val str: String
-            try {
-                val stream = loader.getResourceAsStream("lang/${locale}.l")
-                if (stream == null) {
-                    cache.put(locale, null)
-                    return null
-                }
-                val bytes = stream.readBytes()
-                str = bytes.toString(Charsets.UTF_8)
-            } catch (_: IOException) {
-                return null
-            }
-
-            val file = parse(str)
-
-            cache.put(locale, file)
-            return file
-        }
-
-        internal fun parse(str: String): LocaleFile {
-            val span = StringSpan(str)
-
-            val file = LocaleFile()
-            var prefix = ""
-            var name = ""
-            var collection = TemplateSpanCollection()
-
-            while (!span.isEmpty) {
-                span.trimStart()
-
-                if (span.stripPrefix("#")) {
-                    if (name.isNotEmpty()) {
-                        if (file.tls.put(name, Tl.parse(collection.intoSpanCollection())) != null) throw RuntimeException("duplicate key $name")
-                        collection = TemplateSpanCollection()
-                    }
-
-                    name = ""
-                    while (!span.isEmpty && span[0] != '\n') span.inc()
-                    continue
-                }
-
-                if (span.stripPrefix("[")) {
-                    if (name.isNotEmpty()) {
-                        if (file.tls.put(name, Tl.parse(collection.intoSpanCollection())) != null) throw RuntimeException("duplicate key $name")
-                        collection = TemplateSpanCollection()
-                    }
-
-                    name = ""
-                    span.trimStart()
-                    prefix = buildString {
-                        while (!span.isEmpty && (span[0].isLetterOrDigit() || span[0] in "-_.")) append(span.next())
-                    }
-                    span.trimStart()
-                    if (!span.stripPrefix("]")) throw RuntimeException("unenclosed prefix statement at ${span.at}")
-                    continue
-                }
-
-                if (span.stripPrefix("=")) {
-                    if (name.isEmpty()) throw RuntimeException("attempt to append a value despite not having an entry open")
-
-                    // It's fine since it's just one character
-                    collection.growFrom(StringSpan("\n"))
-                    span.stripPrefix(" ")
-                    while (!span.isEmpty && span[0] != '\n') {
-                        if (span[0] == '\r') {
-                            span.inc()
-                            continue
-                        }
-                        collection.growFrom(span)
-                        span.inc()
-                    }
-                    continue
-                }
-
-                // Both do not do the same thing anymore.
-                if (span.stripPrefix("-")) {
-                    if (name.isEmpty()) throw RuntimeException("attempt to append a value despite not having an entry open")
-
-                    collection.growFrom(StringSpan(" "))
-                    span.stripPrefix(" ")
-                    while (!span.isEmpty && span[0] != '\n') {
-                        if (span[0] == '\r') {
-                            span.inc()
-                            continue
-                        }
-                        collection.growFrom(span)
-                        span.inc()
-                    }
-                    continue
-                }
-
-                if (span.stripPrefix(":")) {
-                    if (name.isEmpty()) throw RuntimeException("attempt to append a value despite not having an entry open")
-
-                    span.stripPrefix(" ")
-                    while (!span.isEmpty && span[0] != '\n') {
-                        if (span[0] == '\r') {
-                            span.inc()
-                            continue
-                        }
-                        collection.growFrom(span)
-                        span.inc()
-                    }
-                    continue
-                }
-
-                if (name.isNotEmpty()) {
-                    if (file.tls.put(name, Tl.parse(collection.intoSpanCollection())) != null) throw RuntimeException("duplicate key $name")
-                    collection = TemplateSpanCollection()
-                }
-
-                val at = span.at
-
-                name = buildString {
-                    while (!span.isEmpty && (span[0].isLetterOrDigit() || span[0] in "-_.")) append(span.next())
-                }
-
-                if (name.isEmpty()) continue
-
-                name = (if (prefix.isEmpty()) { "" } else { "$prefix." }) + name
-                if (name.startsWith(".")) throw RuntimeException("entry name cannot start with a dot ($name) at $at")
-                if (name.endsWith(".")) throw RuntimeException("entry name cannot end with a dot ($name) at $at")
-                if (name.contains("..")) throw RuntimeException("entry name cannot contain 2 consecutive dots ($name) at $at")
-
-                span.trimStart()
-                if (!span.stripPrefix("=")) throw RuntimeException("'=' must be used to assign a value to the entry at ${span.at}")
-
-                val t = StringBuilder()
-
-                span.stripPrefix(" ")
-                while (!span.isEmpty && span[0] != '\n') {
-                    if (span[0] == '\r') {
-                        span.inc()
-                        continue
-                    }
-                    collection.growFrom(span)
-                    span.inc()
-                }
-            }
-
-            if (name.isNotEmpty()) {
-                if (file.tls.put(name, Tl.parse(collection.intoSpanCollection())) != null) throw RuntimeException("duplicate key $name")
-            }
-
-            return file
-        }
-    }
-
-    private val tls = ObjectMap<String, Script>()
-
-    operator fun get(key: String): Script? = if (tls.containsKey(key)) tls[key] else null
-}
-
-private fun encloseColors(s: String): String {
-    var s = s
-
-    if (s.isEmpty()) return s
-
-    var colorNestness = 0
-    var ptr = 0
-
-    while (run { ptr = s.indexOf('[', ptr); ptr } != -1) {
-        val start = ptr
-        ptr = s.indexOf(']', ptr)
-        if (ptr == -1) break
-
-        val maybeColor = s.substring(start + 1, ptr)
-        if (maybeColor.contains('[')) {
-            ptr = start + 1 + maybeColor.indexOf('[')
-            continue
-        }
-        if (isValidColor(maybeColor)) colorNestness += 1
-        else if (start + 1 == ptr) {
-            if (colorNestness == 0) {
-                s = if (ptr + 1 == s.length) s.substring(0, start)
-                    else s.substring(0, start) + s.substring(ptr + 1)
-                ptr -= 2
-            } else {
-                colorNestness -= 1
-            }
-        }
-    }
-
-    return closeColors(s) + run { val b = StringBuilder(colorNestness * 2); repeat(colorNestness) { b.append("[]") }; b }
-}
-
-private fun closeColors(s: String): String {
-    if (s.isEmpty()) return s
-
-    var ptr = s.length - 1
-    while ((s[ptr] in 'a'..'f' || s[ptr] in 'A'..'F' || s[ptr] == '#') && ptr > 0) ptr--
-    if (s[ptr] != '[') return s
-    val start = ptr
-    while (s[ptr] == '[' && ptr > 0) ptr--
-    if ((start - ptr) % 2 == 1) return s
-
-    return s.substring(0, start) + "["
-}
-
 class LCtx(private val parent: LCtx? = null) {
     private val tls = ObjectMap<String, Script>()
 
@@ -280,20 +24,12 @@ class LCtx(private val parent: LCtx? = null) {
 
     fun tl(key: String, lang: String): Script {
         if (tls.containsKey(key)) return tls[key]
-        return LocaleFile[lang, key]
+        return Tl.resolve(lang, key)
     }
 }
 
-interface L<Self: L<Self>> {
-    /** Add a mapping for a translation key. */
-    fun put(key: String, value: Script): Self
-    /** Set translation key to an unformatted text. */
-    fun put(key: String, text: String): Self
-}
-
-interface LVoidDone<Self: LVoidDone<Self>> : L<Self> {
-    fun done(key: String)
-}
+typealias L<Self> = IL<Self>
+typealias LVoidDone<Self> = ILVoidDone<Self>
 
 class La(val ctx: LCtx = LCtx()) : LVoidDone<La> {
     /** Add a mapping for a translation key. */
@@ -352,730 +88,7 @@ class Ls(val locale: String, val ctx: LCtx = LCtx()) : L<Ls> {
     }
 }
 
-interface Script {
-    fun append(ctx: LCtx, source: String, lang: String): String
-    fun debug(): String
-}
-
-private class ScrCombo(val list: Seq<Script>) : Script {
-    override fun append(ctx: LCtx, source: String, lang: String): String {
-        var txt = source
-        for (scr in list) {
-            txt = scr.append(ctx, txt, lang)
-        }
-        return txt
-    }
-
-    override fun debug(): String = "Combo(${list.map { it.debug() }.joinToString(", ")})"
-}
-
-private class ScrText(val text: String) : Script {
-    override fun append(ctx: LCtx, source: String, lang: String): String = source + text
-    override fun debug(): String = "\"$text\""
-}
-
-private class ScrKey(val key: Script) : Script {
-    override fun append(ctx: LCtx, source: String, lang: String): String {
-        val key = this.key.append(ctx, "", lang)
-        val inner = encloseColors(ctx.tl(key, lang).append(ctx, "", lang))
-        return closeColors(source) + inner
-    }
-
-    override fun debug(): String = "Key(${key.debug()})"
-}
-
-private class ScrEach(
-    val key: String,
-    val source: Script,
-    val template: Script,
-    val separator: Script,
-    val join: Script
-) : Script {
-    override fun append(ctx: LCtx, source: String, lang: String): String {
-        var txt = source
-        var first = true
-        for (name in this.source.append(ctx, "", lang).split(separator.append(ctx, "", lang))) {
-            if (first) first = false else txt = join.append(ctx, txt, lang)
-            val lctx = LCtx(ctx)
-            lctx.put(key, name)
-            txt = template.append(lctx, txt, lang)
-        }
-        return txt
-    }
-
-    override fun debug(): String =
-        "Each($key in ${source.debug()} split ${separator.debug()} join ${join.debug()})"
-}
-
-private class ScrIf(
-    val rhs: Script,
-    val op: Op,
-    val lhs: Script,
-    val then: Script,
-    val other: Script
-) : Script {
-    enum class Op {
-        Equals,
-        EqualsIgnoreCase,
-        NotEquals,
-        NotEqualsIgnoreCase,
-        Contains,
-        ContainsIgnoreCase,
-        StartsWith,
-        EndsWith,
-        Greater,
-        Smaller,
-        GreaterOrEqual,
-        SmallerOrEqual,
-        Spans,
-
-        ;
-
-        fun debug(): String = when (this) {
-            Equals -> "="
-            EqualsIgnoreCase -> "=="
-            NotEquals -> "!="
-            NotEqualsIgnoreCase -> "!=="
-            Contains -> "~"
-            ContainsIgnoreCase -> "~="
-            StartsWith -> "&="
-            EndsWith -> "=&"
-            Greater -> ">"
-            Smaller -> "<"
-            GreaterOrEqual -> ">="
-            SmallerOrEqual -> "<="
-            Spans -> "&~"
-        }
-
-        companion object {
-            fun fromString(op: String): Op = when (op) {
-                "=" -> Equals
-                "==" -> EqualsIgnoreCase
-                "!=" -> NotEquals
-                "!==" -> NotEqualsIgnoreCase
-                "~" -> Contains
-                "~=" -> ContainsIgnoreCase
-                "&=" -> StartsWith
-                "=&" -> EndsWith
-                ">" -> Greater
-                "<" -> Smaller
-                ">=" -> GreaterOrEqual
-                "<=" -> SmallerOrEqual
-                "&~" -> Spans
-                else -> throw RuntimeException("invalid operator '${op}'")
-            }
-        }
-    }
-
-    override fun append(ctx: LCtx, source: String, lang: String): String {
-        val rhs = rhs.append(ctx, "", lang)
-        val lhs = lhs.append(ctx, "", lang)
-
-        return if (when (op) {
-            Op.Equals -> rhs == lhs
-            Op.EqualsIgnoreCase -> rhs.equals(lhs, true)
-            Op.NotEquals -> rhs != lhs
-            Op.NotEqualsIgnoreCase -> !rhs.equals(lhs, true)
-            Op.Contains -> lhs in rhs
-            Op.ContainsIgnoreCase -> rhs.contains(lhs, true)
-            Op.StartsWith -> rhs.startsWith(lhs)
-            Op.EndsWith -> rhs.endsWith(lhs)
-            Op.Greater -> {
-                val rval = rhs.toFloatOrNull()
-                val lval = lhs.toFloatOrNull()
-
-                rval != null && lval != null && rval > lval
-            }
-            Op.Smaller -> {
-                val rval = rhs.toFloatOrNull()
-                val lval = lhs.toFloatOrNull()
-
-                rval != null && lval != null && rval < lval
-            }
-            Op.GreaterOrEqual -> {
-                val rval = rhs.toFloatOrNull()
-                val lval = lhs.toFloatOrNull()
-
-                rval != null && lval != null && rval >= lval
-            }
-            Op.SmallerOrEqual -> {
-                val rval = rhs.toFloatOrNull()
-                val lval = lhs.toFloatOrNull()
-
-                rval != null && lval != null && rval <= lval
-            }
-            Op.Spans -> {
-                if (lhs.isEmpty()) true
-                else {
-                    var i = 0
-                    for (ch in rhs) {
-                        if (ch == lhs[i]) {
-                            i++
-                            if (i == lhs.length) break
-                        }
-                    }
-                    i == lhs.length
-                }
-            }
-        }) then.append(ctx, source, lang)
-        else other.append(ctx, source, lang)
-    }
-    override fun debug(): String =
-        "If(${rhs.debug()} ${op.debug()} ${lhs.debug()}, ${then.debug()}, ${other.debug()})"
-}
-
-private object ScrNone : Script {
-    override fun append(ctx: LCtx, source: String, lang: String): String = source
-    override fun debug(): String = "<empty>"
-}
-
-// General rules for parse* functions:
-//
-// 1. idx must point to the first character of the expression
-// 2. returned idx must be at the character after the expression
-
-/**
- * ```
- * &=
- * ^^*
- * ```
- */
-private fun parseOp(script: SpanCollection): ScrIf.Op? {
-    script.trimStart()
-    if (script.stripPrefix("==")) return ScrIf.Op.EqualsIgnoreCase
-    if (script.stripPrefix("=")) return ScrIf.Op.Equals
-    if (script.stripPrefix("!==")) return ScrIf.Op.NotEqualsIgnoreCase
-    if (script.stripPrefix("!=")) return ScrIf.Op.NotEquals
-    if (script.stripPrefix("~=")) return ScrIf.Op.ContainsIgnoreCase
-    if (script.stripPrefix("~")) return ScrIf.Op.Contains
-    if (script.stripPrefix("&=")) return ScrIf.Op.StartsWith
-    if (script.stripPrefix("=&")) return ScrIf.Op.EndsWith
-    if (script.stripPrefix(">=")) return ScrIf.Op.GreaterOrEqual
-    if (script.stripPrefix(">")) return ScrIf.Op.Greater
-    if (script.stripPrefix("<=")) return ScrIf.Op.SmallerOrEqual
-    if (script.stripPrefix("<")) return ScrIf.Op.Smaller
-    if (script.stripPrefix("&~")) return ScrIf.Op.Spans
-    return null
-}
-
-/**
- * ```
- * \u{ACB}
- *   ^^^^^*
- * ```
- */
-private fun parseUnicode(script: SpanCollection): Char {
-    var num = 0
-    if (script.isEmpty || script[0] != '{')
-        throw RuntimeException("invalid unicode escape (Tl unicode escapes must follow the format of \\u{..}) at ${script.at}")
-    while (!script.incIsEmpty() && script[0] != '}') {
-        val ch = script[0]
-        num *= 16
-        num += when (ch) {
-            in '0'..'9' -> ch.code - '0'.code
-            in 'a'..'f' -> ch.code - 'a'.code + 10
-            in 'A'..'F' -> ch.code - 'A'.code + 10
-            else        -> throw RuntimeException("invalid unicode escape (unicode codepoint must be in hex) at ${script.at}")
-        }
-    }
-    if (script.isEmpty || script[0] != '}')
-        throw RuntimeException("invalid unicode escape (Tl unicode escapes must follow the format of \\u{..}) at ${script.at}")
-    if (num !in (Char.MIN_VALUE.code..Char.MAX_VALUE.code))
-        throw RuntimeException("invalid unicode escape (invalid codepoint $num) at ${script.at}")
-    script.inc()
-    return num.toChar()
-}
-
-/**
- * ```
- * Hello, world
- * ^^^^^^*
- *
- * (Hiii (e) )
- * ^^^^^^^^^^^*
- *
- * {some.key}
- * ^^^^^^^^^^*
- * ```
- */
-private fun parseExpr(script: SpanCollection): Script {
-    script.trimStart()
-    if (script.isEmpty) throw RuntimeException("input ended before an expression could have been parsed at ${script.at}")
-
-    var keepOn0 = true
-
-    when (script[0]) {
-        '}' -> throw RuntimeException("unexpected char '}' when parsing an expression at ${script.at}")
-        ')' -> throw RuntimeException("unexpected char ')' when parsing an expression at ${script.at}")
-        '\\' -> script.inc()
-        '(' -> {
-            keepOn0 = false
-            script.inc()
-        }
-        '{' -> return parseKey(script)
-    }
-
-    val list = newSeq<Script>()
-
-    var depth = if (keepOn0) 0 else 1
-    var backspace = false
-    val text = StringBuilder()
-
-    while (depth > 0 || keepOn0) {
-        if (script.isEmpty) throw RuntimeException("input ended before an expression could have been parsed at ${script.at}")
-        val chr = script[0]
-        if (backspace) {
-            when (chr) {
-                'u' -> text.append(parseUnicode(script))
-                'n' -> text.append('\n')
-                else -> text.append(chr)
-            }
-            script.inc()
-            backspace = false
-            continue
-        }
-        if (chr == '}') {
-            if (depth == 0) break
-            throw RuntimeException("unexpected char '}' when parsing an expression at ${script.at}")
-        }
-        if (chr == ')') {
-            if (depth > 1 || keepOn0) text.append(')')
-            if (depth == 0) throw RuntimeException("closing a string without an opened string at ${script.at}")
-            depth--
-            script.inc()
-            continue
-        }
-        if (chr == '\\') {
-            backspace = true
-            script.inc()
-            continue
-        }
-        if (chr == '(') {
-            text.append('(')
-            depth++
-            script.inc()
-            continue
-        }
-        if (chr == '{') {
-            if (!text.isEmpty()) {
-                list.add(ScrText(text.toString()))
-                text.setLength(0)
-            }
-
-            list.add(parseKey(script))
-
-            continue
-        }
-        if (depth == 0 && chr.isWhitespace()) break
-
-        text.append(chr)
-        script.inc()
-        continue
-    }
-
-    if (!text.isEmpty()) list.add(ScrText(text.toString()))
-
-    if (list.size == 0) return ScrNone
-    if (list.size == 1) return list[0]
-    return ScrCombo(list)
-}
-
-/**
- * ```
- * {each {name} in {key} split {sep} join {sep}}
- *      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*
- * ```
- */
-private fun parseEach(script: SpanCollection): Script {
-    // TODO: {each {name} in {key} <template> split <sep> join <sep> [..if <cond>]}
-
-    script.trimStart()
-    if (script.isEmpty) throw RuntimeException("missing variable at ${script.at}")
-    if (!script.stripPrefix("{")) throw RuntimeException("expected char '{', found '${script[0]}' at ${script.at}")
-    script.trimStart()
-
-    val name = buildString { while (true) {
-        if (script.isEmpty) throw RuntimeException("missing variable at ${script.at}")
-        val chr = script[0]
-        if (!chr.isLetterOrDigit() && chr !in "-_.") break
-        script.inc()
-        append(chr)
-    } }
-    script.trimStart()
-
-    if (!script.stripPrefix("}")) throw RuntimeException("expected char '}', found '${script[0]}' at ${script.at}")
-    script.trimStart()
-
-    if (script.isEmpty) throw RuntimeException("missing \"in\" at ${script.at}")
-    if (!script.stripPrefix("in")) throw RuntimeException("expected \"in\", found char '${script[0]}' at ${script.at}")
-
-    val key = parseExpr(script)
-    val template = parseExpr(script)
-    script.trimStart()
-
-    if (script.isEmpty) throw RuntimeException("missing \"split\" at ${script.at}")
-    if (!script.stripPrefix("split")) throw RuntimeException("expected \"split\", found char '${script[0]}' at ${script.at}")
-
-    val split = parseExpr(script)
-    script.trimStart()
-
-    if (script.isEmpty) throw RuntimeException("missing \"join\" at ${script.at}")
-    if (!script.stripPrefix("join")) throw RuntimeException("expected \"join\", found char '${script[0]}' at ${script.at}")
-
-    val join = parseExpr(script)
-    script.trimStart()
-
-    if (!script.stripPrefix("}")) throw RuntimeException("could not close a 'for' statement at ${script.at}")
-
-    return ScrEach(name, key, template, split, join)
-}
-
-/**
- * ```
- * {if a = b then hi else if a = a then hoi else eh}
- *     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*
- * ```
- */
-private fun parseIf(script: SpanCollection): Script {
-    val lhs = parseExpr(script)
-    val op = parseOp(script) ?: throw RuntimeException("expected an operator, found char '${script[0]}' at ${script.at}")
-    val rhs = parseExpr(script)
-
-    script.trimStart()
-    if (script.isEmpty) throw RuntimeException("missing \"then\" at ${script.at}")
-    if (!script.stripPrefix("then")) throw RuntimeException("expected \"then\", found char '${script[0]}' at ${script.at}")
-
-    val then = parseExpr(script)
-
-    script.trimStart()
-    if (script.stripPrefix("}")) return ScrIf(rhs, op, lhs, then, ScrNone)
-
-    if (!script.stripPrefix("else")) throw RuntimeException("missing \"else\" at ${script.at}")
-    script.trimStart()
-    if (script.stripPrefix("if")) return ScrIf(rhs, op, lhs, then, parseIf(script))
-
-    val other = parseExpr(script)
-    script.trimStart()
-    if (script.isEmpty) throw RuntimeException("missing '}' at ${script.at}")
-    if (!script.stripPrefix("}")) throw RuntimeException("expected char '}', found '${script[0]}' at ${script.at}")
-
-    return ScrIf(rhs, op, lhs, then, other)
-}
-
-/**
- * ```
- * {hello}
- * ^^^^^^^*
- * ```
- */
-private fun parseKey(script: SpanCollection): Script {
-    // TODO: {<key> [..with {<key>} = (<value>)]}
-
-    assert(script.stripPrefix("{"))
-    script.trimStart()
-
-    if (script.startsWith("each ") || script.startsWith("each{")) {
-        script.stripPrefix("each")
-        return parseEach(script)
-    }
-    if (script.startsWith("if ") || script.startsWith("if{")) {
-        script.stripPrefix("if")
-        return parseIf(script)
-    }
-
-    return ScrKey(parseRoot(script, true))
-}
-
-private fun parseRoot(script: SpanCollection, insideBlock: Boolean = false): Script {
-    val combo = Seq<Script>()
-
-    val text = StringBuilder()
-    var backslash = false
-    while (!script.isEmpty) {
-        val ch = script[0]
-
-        if (backslash) {
-            backslash = false
-            script.inc()
-
-            text.append(when (ch) {
-                'u' -> parseUnicode(script)
-                'n' -> '\n'
-                else -> ch
-            })
-
-            continue
-        }
-
-        when (ch) {
-            '\\' -> {
-                backslash = true
-                script.inc()
-            }
-            '{' -> {
-                if (!text.isEmpty()) combo.add(ScrText(text.toString()))
-                text.setLength(0)
-                combo.add(parseKey(script))
-            }
-            '}' -> {
-                if (insideBlock) {
-                    script.inc()
-
-                    if (!text.isEmpty()) combo.add(ScrText(text.toString()))
-
-                    if (combo.isEmpty) return ScrNone
-                    if (combo.size == 1) return combo[0]
-                    return ScrCombo(combo)
-                }
-                throw RuntimeException("unexpected '}' at ${script.at}")
-            }
-            else -> {
-                text.append(ch)
-                script.inc()
-            }
-        }
-    }
-    if (insideBlock) throw RuntimeException("unenclosed key at ${script.at}")
-    if (!text.isEmpty()) combo.add(ScrText(text.toString()))
-
-    if (combo.isEmpty) return ScrNone
-    if (combo.size == 1) return combo[0]
-    return ScrCombo(combo)
-}
-
-internal class SpanCollection(val spans: Seq<StringSpan>) {
-    constructor(span: StringSpan) : this(seqOf(span))
-
-    init { assert(!spans.isEmpty) }
-
-    val nonEmptySpan: StringSpan? get() {
-        for (span in spans) {
-            if (span.isEmpty) continue
-            return span
-        }
-        return null
-    }
-    val length get() = spans.sum { it.length }
-    val line get() = span.line
-    val column get() = span.column
-    val start get() = span.start
-    val source get() = span.source
-    val span: StringSpan get() = nonEmptySpan ?: spans.last()
-    val at get() = "$line:$column"
-    val isEmpty get() = spans.all { it.isEmpty }
-
-    operator fun get(pos: Int): Char {
-        if (pos < 0) throw IndexOutOfBoundsException("Index is negative")
-        var p = pos
-        for (span in spans) {
-            if (span.length <= p) {
-                p -= span.length
-                continue
-            }
-            return span[p]
-        }
-        throw IndexOutOfBoundsException("Index is too large ($pos >= $length)")
-    }
-
-    fun inc(): Int {
-        for (span in spans) {
-            if (span.isEmpty) continue
-            span.inc()
-            break
-        }
-
-        return length
-    }
-
-    fun incIsEmpty(): Boolean {
-        for (span in spans) {
-            if (span.isEmpty) continue
-            span.inc()
-            break
-        }
-
-        return isEmpty
-    }
-
-    fun incAfter(): Int {
-        val length = length
-
-        for (span in spans) {
-            if (span.isEmpty) continue
-            span.inc()
-            break
-        }
-
-        return length
-    }
-
-    fun dec(): Int {
-        for (i in 0..<spans.size) {
-            val span = spans[spans.size - i - 1]
-            if (span.length == span.initalLength) continue
-            span.dec()
-            return length
-        }
-        throw IndexOutOfBoundsException("Cannot subtract any more")
-    }
-
-    fun stripPrefix(prefix: String): Boolean {
-        for (span in spans) {
-            if (span.isEmpty) continue
-            return span.stripPrefix(prefix)
-        }
-        return false
-    }
-
-    fun startsWith(prefix: String): Boolean {
-        for (span in spans) {
-            if (span.isEmpty) continue
-            return span.startsWith(prefix)
-        }
-        return false
-    }
-
-    fun trimStart() {
-        for (span in spans) {
-            if (span.isEmpty) continue
-            span.trimStart()
-            return
-        }
-    }
-
-    fun copy() = SpanCollection(Seq.with(spans))
-}
-
-internal class TemplateSpan(val source: String, var start: Int, var length: Int, val line: Int, val column: Int) {
-    constructor(source: SpanCollection) : this(source.nonEmptySpan!!)
-    constructor(source: StringSpan) : this(source.source, source.start, 1, source.line, source.column)
-}
-
-internal class TemplateSpanCollection {
-    val spans = newSeq<TemplateSpan>()
-    var predictPos = -1
-    var lastString: String? = null
-
-    fun growFrom(source: StringSpan) {
-        if (source.start == predictPos && source.source === lastString) {
-            spans.last().length++
-            predictPos++
-            return
-        }
-        spans.add(TemplateSpan(source))
-        predictPos = source.start + 1
-        lastString = source.source
-    }
-
-    fun growFrom(source: SpanCollection) {
-        if (source.start == predictPos && source.source === lastString) {
-            spans.last().length++
-            predictPos++
-            return
-        }
-        spans.add(TemplateSpan(source))
-        predictPos = source.start + 1
-        lastString = source.source
-    }
-
-    fun intoSpanCollection(): SpanCollection {
-        val s = newSeq<StringSpan>(spans.size)
-        for (span in spans) {
-            s.add(StringSpan(span.source, span.start, span.length, span.line, span.column))
-        }
-        return SpanCollection(s)
-    }
-}
-
-internal class StringSpan(
-    var source: String,
-    var start: Int,
-    var length: Int,
-    var line: Int,
-    var column: Int,
-    val initalLength: Int,
-    // var columnCollection: IntSeq?,
-) {
-    constructor(
-        source: String,
-        start: Int,
-        length: Int,
-        line: Int,
-        column: Int,
-    ) : this(
-        source,
-        start,
-        length,
-        line,
-        column,
-        length,
-        // null,
-    )
-    constructor(source: String) : this(source, 0, source.length, 1, 1)
-
-    val at get() = "$line:$column"
-    val isEmpty get() = length == 0
-
-    operator fun get(pos: Int): Char {
-        if (pos < 0) throw IndexOutOfBoundsException("Index is negative")
-        if (pos >= length) throw IndexOutOfBoundsException("Index is too large ($pos >= $length)")
-        return source[start + pos]
-    }
-
-    fun next(): Char {
-        val c = get(0)
-        inc()
-        return c
-    }
-
-    fun inc(): Int {
-        if (get(0) == '\n') {
-            // if (columnCollection?.let { it.add(column); K } == null) columnCollection = IntSeq.with(column)
-            line++
-            column = 1
-        } else column++
-        length--
-        start++
-        return length
-    }
-
-    fun dec(): Int {
-        if (length == initalLength) throw IndexOutOfBoundsException("Cannot subtract any more")
-
-        length++
-        start--
-
-        if (get(0) == '\n') {
-            line--
-            // Those must always be available.
-            // column = columnCollection!!.pop()
-            column = Int.MAX_VALUE // This is OK since dec() is only used to counter inc() in a loop, thus this value
-                                   // is immediately discarded.
-        } else column--
-
-        return length
-    }
-
-    fun stripPrefix(prefix: String): Boolean {
-        if (length < prefix.length) return false
-        if (!source.startsWith(prefix, start)) return false
-        prefix.indices.forEach { _ -> inc() }
-        return true
-    }
-
-    fun startsWith(prefix: String): Boolean {
-        if (length < prefix.length) return false
-        return source.startsWith(prefix, start)
-    }
-
-    fun trimStart() {
-        while (!isEmpty && get(0).isWhitespace()) inc()
-        return
-    }
-
-    // fun copy(): StringSpan = StringSpan(source, start, length, line, column, initalLength, columnCollection?.let { IntSeq(it.size).apply { addAll(it) } })
-    fun copy(): StringSpan = StringSpan(source, start, length, line, column, initalLength)
-}
+typealias Script = IScript
 
 /**
  * Translation API.
@@ -1084,20 +97,34 @@ internal class StringSpan(
  * Tl.send(player).
  * ```
  */
-object Tl {
-    @JvmStatic fun broadcast(): La = La()
-    @JvmStatic fun send(player: Player): Lc = Lc(player)
-    @JvmStatic fun fmtFor(player: Player): Ls = Ls(player.locale)
-    @JvmStatic fun fmt(locale: String): Ls = Ls(locale)
-    @JvmStatic fun fmt(player: Player): Ls = Ls(player.locale)
+object Tl : ITranslationRuntime {
+    private val localeRegistry: ITranslationLocaleRegistry = DefaultTranslationLocaleRegistry()
+    private val scriptParser: ITranslationScriptParser = TranslationParserAssembly(
+        TokenizingTranslationScriptParser(
+            DefaultTranslationTokenizer(),
+            DefaultTranslationScriptParser { source -> parseRoot(SpanCollection(StringSpan(source))) }
+        )
+    ).create()
+    private val localeResolver: ITranslationLocaleResolver = DefaultTranslationLocaleResolver { locale, key ->
+        LocaleFile[locale, key]
+    }
+
+    internal fun localeLoaders(): List<ClassLoader> = localeRegistry.all()
+    internal fun resolve(locale: String, key: String): Script = localeResolver.resolve(locale, key)
+
+    @JvmStatic override fun broadcast(): La = La()
+    @JvmStatic override fun send(player: Player): Lc = Lc(player)
+    @JvmStatic override fun fmtFor(player: Player): Ls = Ls(player.locale)
+    @JvmStatic override fun fmt(locale: String): Ls = Ls(locale)
+    @JvmStatic override fun fmt(player: Player): Ls = Ls(player.locale)
 
     @JvmStatic
-    fun init(loader: ClassLoader) {
-        loaders.add(loader)
+    override fun init(loader: ClassLoader) {
+        localeRegistry.register(loader)
     }
 
     @JvmStatic
-    fun parse(script: String): Script = parse(StringSpan(script))
+    override fun parse(script: String): Script = scriptParser.parse(script)
     @JvmStatic
     internal inline fun parse(script: StringSpan): Script = parse(SpanCollection(script))
     @JvmStatic
diff --git a/src/main/kotlin/buj/tl/TranslationParserAssembly.kt b/src/main/kotlin/buj/tl/TranslationParserAssembly.kt
new file mode 100644
index 0000000..5c61426
--- /dev/null
+++ b/src/main/kotlin/buj/tl/TranslationParserAssembly.kt
@@ -0,0 +1,29 @@
+package buj.tl
+
+private class DefaultTranslationParserFactory(
+    private val parser: ITranslationScriptParser,
+) : ITranslationParserFactory {
+    override fun create(): ITranslationScriptParser = parser
+}
+
+private class DefaultTranslationParserProvider(
+    private val factory: ITranslationParserFactory,
+) : ITranslationParserProvider {
+    override fun provide(): ITranslationParserFactory = factory
+}
+
+private class DefaultTranslationParserSelector(
+    private val provider: ITranslationParserProvider,
+) : ITranslationParserSelector {
+    override fun select(): ITranslationParserProvider = provider
+}
+
+class TranslationParserAssembly(
+    private val parser: ITranslationScriptParser,
+) {
+    private val selector: ITranslationParserSelector = DefaultTranslationParserSelector(
+        DefaultTranslationParserProvider(DefaultTranslationParserFactory(parser))
+    )
+
+    fun create(): ITranslationScriptParser = selector.select().provide().create()
+}
diff --git a/src/main/kotlin/buj/tl/TranslationRuntimeInfrastructure.kt b/src/main/kotlin/buj/tl/TranslationRuntimeInfrastructure.kt
new file mode 100644
index 0000000..b544c07
--- /dev/null
+++ b/src/main/kotlin/buj/tl/TranslationRuntimeInfrastructure.kt
@@ -0,0 +1,24 @@
+package buj.tl
+
+class DefaultTranslationLocaleRegistry : ITranslationLocaleRegistry {
+    private val loaders = LinkedHashSet<ClassLoader>()
+
+    override fun register(loader: ClassLoader) {
+        loaders.remove(loader)
+        loaders.add(loader)
+    }
+
+    override fun all(): List<ClassLoader> = loaders.toList()
+}
+
+class DefaultTranslationScriptParser(
+    private val delegate: (String) -> Script,
+) : ITranslationScriptParser {
+    override fun parse(source: String): Script = delegate(source)
+}
+
+class DefaultTranslationLocaleResolver(
+    private val delegate: (String, String) -> Script,
+) : ITranslationLocaleResolver {
+    override fun resolve(locale: String, key: String): Script = delegate(locale, key)
+}
diff --git a/src/main/kotlin/buj/tl/ast/ColorPalette.kt b/src/main/kotlin/buj/tl/ast/ColorPalette.kt
new file mode 100644
index 0000000..583469f
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ast/ColorPalette.kt
@@ -0,0 +1,12 @@
+package buj.tl
+
+internal val TRANSLATION_COLORS = arrayOf(
+    "clear", "black", "white", "lightgray", "gray", "darkgray", "blue", "navy",
+    "royal", "slate", "sky", "cyan", "teal", "green", "acid", "lime", "forest",
+    "olive", "yellow", "gold", "goldenrod", "orange", "brown", "tan", "brick",
+    "red", "scarlet", "coral", "salmon", "pink", "magenta", "purple", "violet", "maroon",
+)
+
+internal fun isValidTranslationColor(color: String): Boolean =
+    if (color.startsWith("#")) color.matches(Regex("^#([0-9a-fA-F]{1,6}|[0-9a-fA-F]{8})$"))
+    else color in TRANSLATION_COLORS
\ No newline at end of file
diff --git a/src/main/kotlin/buj/tl/ast/ColorScopeRenderer.kt b/src/main/kotlin/buj/tl/ast/ColorScopeRenderer.kt
new file mode 100644
index 0000000..4fee60b
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ast/ColorScopeRenderer.kt
@@ -0,0 +1,48 @@
+package buj.tl
+
+internal fun encloseColors(s: String): String {
+    var s = s
+
+    if (s.isEmpty()) return s
+
+    var colorNestness = 0
+    var ptr = 0
+
+    while (run { ptr = s.indexOf('[', ptr); ptr } != -1) {
+        val start = ptr
+        ptr = s.indexOf(']', ptr)
+        if (ptr == -1) break
+
+        val maybeColor = s.substring(start + 1, ptr)
+        if (maybeColor.contains('[')) {
+            ptr = start + 1 + maybeColor.indexOf('[')
+            continue
+        }
+        if (isValidTranslationColor(maybeColor)) colorNestness += 1
+        else if (start + 1 == ptr) {
+            if (colorNestness == 0) {
+                s = if (ptr + 1 == s.length) s.substring(0, start)
+                    else s.substring(0, start) + s.substring(ptr + 1)
+                ptr -= 2
+            } else {
+                colorNestness -= 1
+            }
+        }
+    }
+
+    return closeColors(s) + run { val b = StringBuilder(colorNestness * 2); repeat(colorNestness) { b.append("[]") }; b }
+}
+
+internal fun closeColors(s: String): String {
+    if (s.isEmpty()) return s
+
+    var ptr = s.length - 1
+    while ((s[ptr] in 'a'..'f' || s[ptr] in 'A'..'F' || s[ptr] == '#') && ptr > 0) ptr--
+    if (s[ptr] != '[') return s
+    val start = ptr
+    while (s[ptr] == '[' && ptr > 0) ptr--
+    if ((start - ptr) % 2 == 1) return s
+
+    return s.substring(0, start) + "["
+}
+
diff --git a/src/main/kotlin/buj/tl/ast/ScrCombo.kt b/src/main/kotlin/buj/tl/ast/ScrCombo.kt
new file mode 100644
index 0000000..f933625
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ast/ScrCombo.kt
@@ -0,0 +1,16 @@
+package buj.tl
+
+import arc.struct.Seq
+
+internal class ScrCombo(val list: Seq<Script>) : Script {
+    override fun append(ctx: LCtx, source: String, lang: String): String {
+        var txt = source
+        for (scr in list) {
+            txt = scr.append(ctx, txt, lang)
+        }
+        return txt
+    }
+
+    override fun debug(): String = "Combo(${list.map { it.debug() }.joinToString(", ")})"
+}
+
diff --git a/src/main/kotlin/buj/tl/ast/ScrEach.kt b/src/main/kotlin/buj/tl/ast/ScrEach.kt
new file mode 100644
index 0000000..69a95fe
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ast/ScrEach.kt
@@ -0,0 +1,25 @@
+package buj.tl
+
+internal class ScrEach(
+    val key: String,
+    val source: Script,
+    val template: Script,
+    val separator: Script,
+    val join: Script
+) : Script {
+    override fun append(ctx: LCtx, source: String, lang: String): String {
+        var txt = source
+        var first = true
+        for (name in this.source.append(ctx, "", lang).split(separator.append(ctx, "", lang))) {
+            if (first) first = false else txt = join.append(ctx, txt, lang)
+            val lctx = LCtx(ctx)
+            lctx.put(key, name)
+            txt = template.append(lctx, txt, lang)
+        }
+        return txt
+    }
+
+    override fun debug(): String =
+        "Each($key in ${source.debug()} split ${separator.debug()} join ${join.debug()})"
+}
+
diff --git a/src/main/kotlin/buj/tl/ast/ScrIf.kt b/src/main/kotlin/buj/tl/ast/ScrIf.kt
new file mode 100644
index 0000000..1d0abfb
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ast/ScrIf.kt
@@ -0,0 +1,119 @@
+package buj.tl
+
+internal class ScrIf(
+    val rhs: Script,
+    val op: Op,
+    val lhs: Script,
+    val then: Script,
+    val other: Script
+) : Script {
+    enum class Op {
+        Equals,
+        EqualsIgnoreCase,
+        NotEquals,
+        NotEqualsIgnoreCase,
+        Contains,
+        ContainsIgnoreCase,
+        StartsWith,
+        EndsWith,
+        Greater,
+        Smaller,
+        GreaterOrEqual,
+        SmallerOrEqual,
+        Spans,
+
+        ;
+
+        fun debug(): String = when (this) {
+            Equals -> "="
+            EqualsIgnoreCase -> "=="
+            NotEquals -> "!="
+            NotEqualsIgnoreCase -> "!=="
+            Contains -> "~"
+            ContainsIgnoreCase -> "~="
+            StartsWith -> "&="
+            EndsWith -> "=&"
+            Greater -> ">"
+            Smaller -> "<"
+            GreaterOrEqual -> ">="
+            SmallerOrEqual -> "<="
+            Spans -> "&~"
+        }
+
+        companion object {
+            fun fromString(op: String): Op = when (op) {
+                "=" -> Equals
+                "==" -> EqualsIgnoreCase
+                "!=" -> NotEquals
+                "!==" -> NotEqualsIgnoreCase
+                "~" -> Contains
+                "~=" -> ContainsIgnoreCase
+                "&=" -> StartsWith
+                "=&" -> EndsWith
+                ">" -> Greater
+                "<" -> Smaller
+                ">=" -> GreaterOrEqual
+                "<=" -> SmallerOrEqual
+                "&~" -> Spans
+                else -> throw RuntimeException("invalid operator '${op}'")
+            }
+        }
+    }
+
+    override fun append(ctx: LCtx, source: String, lang: String): String {
+        val rhs = rhs.append(ctx, "", lang)
+        val lhs = lhs.append(ctx, "", lang)
+
+        return if (when (op) {
+            Op.Equals -> rhs == lhs
+            Op.EqualsIgnoreCase -> rhs.equals(lhs, true)
+            Op.NotEquals -> rhs != lhs
+            Op.NotEqualsIgnoreCase -> !rhs.equals(lhs, true)
+            Op.Contains -> lhs in rhs
+            Op.ContainsIgnoreCase -> rhs.contains(lhs, true)
+            Op.StartsWith -> rhs.startsWith(lhs)
+            Op.EndsWith -> rhs.endsWith(lhs)
+            Op.Greater -> {
+                val rval = rhs.toFloatOrNull()
+                val lval = lhs.toFloatOrNull()
+
+                rval != null && lval != null && rval > lval
+            }
+            Op.Smaller -> {
+                val rval = rhs.toFloatOrNull()
+                val lval = lhs.toFloatOrNull()
+
+                rval != null && lval != null && rval < lval
+            }
+            Op.GreaterOrEqual -> {
+                val rval = rhs.toFloatOrNull()
+                val lval = lhs.toFloatOrNull()
+
+                rval != null && lval != null && rval >= lval
+            }
+            Op.SmallerOrEqual -> {
+                val rval = rhs.toFloatOrNull()
+                val lval = lhs.toFloatOrNull()
+
+                rval != null && lval != null && rval <= lval
+            }
+            Op.Spans -> {
+                if (lhs.isEmpty()) true
+                else {
+                    var i = 0
+                    for (ch in rhs) {
+                        if (ch == lhs[i]) {
+                            i++
+                            if (i == lhs.length) break
+                        }
+                    }
+                    i == lhs.length
+                }
+            }
+        }) then.append(ctx, source, lang)
+        else other.append(ctx, source, lang)
+    }
+    override fun debug(): String =
+        "If(${rhs.debug()} ${op.debug()} ${lhs.debug()}, ${then.debug()}, ${other.debug()})"
+}
+
diff --git a/src/main/kotlin/buj/tl/ast/ScrKey.kt b/src/main/kotlin/buj/tl/ast/ScrKey.kt
new file mode 100644
index 0000000..22b9341
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ast/ScrKey.kt
@@ -0,0 +1,12 @@
+package buj.tl
+
+internal class ScrKey(val key: Script) : Script {
+    override fun append(ctx: LCtx, source: String, lang: String): String {
+        val key = this.key.append(ctx, "", lang)
+        val inner = encloseColors(ctx.tl(key, lang).append(ctx, "", lang))
+        return closeColors(source) + inner
+    }
+
+    override fun debug(): String = "Key(${key.debug()})"
+}
+
diff --git a/src/main/kotlin/buj/tl/ast/ScrNone.kt b/src/main/kotlin/buj/tl/ast/ScrNone.kt
new file mode 100644
index 0000000..8af8d20
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ast/ScrNone.kt
@@ -0,0 +1,7 @@
+package buj.tl
+
+internal object ScrNone : Script {
+    override fun append(ctx: LCtx, source: String, lang: String): String = source
+    override fun debug(): String = "<empty>"
+}
+
diff --git a/src/main/kotlin/buj/tl/ast/ScrText.kt b/src/main/kotlin/buj/tl/ast/ScrText.kt
new file mode 100644
index 0000000..5c16957
--- /dev/null
+++ b/src/main/kotlin/buj/tl/ast/ScrText.kt
@@ -0,0 +1,7 @@
+package buj.tl
+
+internal class ScrText(val text: String) : Script {
+    override fun append(ctx: LCtx, source: String, lang: String): String = source + text
+    override fun debug(): String = "\"$text\""
+}
+
diff --git a/src/main/kotlin/buj/tl/lexer/SpanModel.kt b/src/main/kotlin/buj/tl/lexer/SpanModel.kt
new file mode 100644
index 0000000..207c71c
--- /dev/null
+++ b/src/main/kotlin/buj/tl/lexer/SpanModel.kt
@@ -0,0 +1,240 @@
+package buj.tl
+
+import arc.struct.Seq
+import mindurka.util.newSeq
+import mindurka.util.seqOf
+
+internal class SpanCollection(val spans: Seq<StringSpan>) {
+    constructor(span: StringSpan) : this(seqOf(span))
+
+    init { assert(!spans.isEmpty) }
+
+    val nonEmptySpan: StringSpan? get() {
+        for (span in spans) {
+            if (span.isEmpty) continue
+            return span
+        }
+        return null
+    }
+    val length get() = spans.sum { it.length }
+    val line get() = span.line
+    val column get() = span.column
+    val start get() = span.start
+    val source get() = span.source
+    val span: StringSpan get() = nonEmptySpan ?: spans.last()
+    val at get() = "$line:$column"
+    val isEmpty get() = spans.all { it.isEmpty }
+
+    operator fun get(pos: Int): Char {
+        if (pos < 0) throw IndexOutOfBoundsException("Index is negative")
+        var p = pos
+        for (span in spans) {
+            if (span.length <= p) {
+                p -= span.length
+                continue
+            }
+            return span[p]
+        }
+        throw IndexOutOfBoundsException("Index is too large ($pos >= $length)")
+    }
+
+    fun inc(): Int {
+        for (span in spans) {
+            if (span.isEmpty) continue
+            span.inc()
+            break
+        }
+
+        return length
+    }
+
+    fun incIsEmpty(): Boolean {
+        for (span in spans) {
+            if (span.isEmpty) continue
+            span.inc()
+            break
+        }
+
+        return isEmpty
+    }
+
+    fun incAfter(): Int {
+        val length = length
+
+        for (span in spans) {
+            if (span.isEmpty) continue
+            span.inc()
+            break
+        }
+
+        return length
+    }
+
+    fun dec(): Int {
+        for (i in 0..<spans.size) {
+            val span = spans[spans.size - i - 1]
+            if (span.length == span.initalLength) continue
+            span.dec()
+            return length
+        }
+        throw IndexOutOfBoundsException("Cannot subtract any more")
+    }
+
+    fun stripPrefix(prefix: String): Boolean {
+        for (span in spans) {
+            if (span.isEmpty) continue
+            return span.stripPrefix(prefix)
+        }
+        return false
+    }
+
+    fun startsWith(prefix: String): Boolean {
+        for (span in spans) {
+            if (span.isEmpty) continue
+            return span.startsWith(prefix)
+        }
+        return false
+    }
+
+    fun trimStart() {
+        for (span in spans) {
+            if (span.isEmpty) continue
+            span.trimStart()
+            return
+        }
+    }
+
+    fun copy() = SpanCollection(Seq.with(spans))
+}
+
+internal class TemplateSpan(val source: String, var start: Int, var length: Int, val line: Int, val column: Int) {
+    constructor(source: SpanCollection) : this(source.nonEmptySpan!!)
+    constructor(source: StringSpan) : this(source.source, source.start, 1, source.line, source.column)
+}
+
+internal class TemplateSpanCollection {
+    val spans = newSeq<TemplateSpan>()
+    var predictPos = -1
+    var lastString: String? = null
+
+    fun growFrom(source: StringSpan) {
+        if (source.start == predictPos && source.source === lastString) {
+            spans.last().length++
+            predictPos++
+            return
+        }
+        spans.add(TemplateSpan(source))
+        predictPos = source.start + 1
+        lastString = source.source
+    }
+
+    fun growFrom(source: SpanCollection) {
+        if (source.start == predictPos && source.source === lastString) {
+            spans.last().length++
+            predictPos++
+            return
+        }
+        spans.add(TemplateSpan(source))
+        predictPos = source.start + 1
+        lastString = source.source
+    }
+
+    fun intoSpanCollection(): SpanCollection {
+        val s = newSeq<StringSpan>(spans.size)
+        for (span in spans) {
+            s.add(StringSpan(span.source, span.start, span.length, span.line, span.column))
+        }
+        return SpanCollection(s)
+    }
+}
+
+internal class StringSpan(
+    var source: String,
+    var start: Int,
+    var length: Int,
+    var line: Int,
+    var column: Int,
+    val initalLength: Int,
+    // var columnCollection: IntSeq?,
+) {
+    constructor(
+        source: String,
+        start: Int,
+        length: Int,
+        line: Int,
+        column: Int,
+    ) : this(
+        source,
+        start,
+        length,
+        line,
+        column,
+        length,
+        // null,
+    )
+    constructor(source: String) : this(source, 0, source.length, 1, 1)
+
+    val at get() = "$line:$column"
+    val isEmpty get() = length == 0
+
+    operator fun get(pos: Int): Char {
+        if (pos < 0) throw IndexOutOfBoundsException("Index is negative")
+        if (pos >= length) throw IndexOutOfBoundsException("Index is too large ($pos >= $length)")
+        return source[start + pos]
+    }
+
+    fun next(): Char {
+        val c = get(0)
+        inc()
+        return c
+    }
+
+    fun inc(): Int {
+        if (get(0) == '\n') {
+            // if (columnCollection?.let { it.add(column); K } == null) columnCollection = IntSeq.with(column)
+            line++
+            column = 1
+        } else column++
+        length--
+        start++
+        return length
+    }
+
+    fun dec(): Int {
+        if (length == initalLength) throw IndexOutOfBoundsException("Cannot subtract any more")
+
+        length++
+        start--
+
+        if (get(0) == '\n') {
+            line--
+            // Those must always be available.
+            // column = columnCollection!!.pop()
+            column = Int.MAX_VALUE // This is OK since dec() is only used to counter inc() in a loop, thus this value
+                                   // is immediately discarded.
+        } else column--
+
+        return length
+    }
+
+    fun stripPrefix(prefix: String): Boolean {
+        if (length < prefix.length) return false
+        if (!source.startsWith(prefix, start)) return false
+        prefix.indices.forEach { _ -> inc() }
+        return true
+    }
+
+    fun startsWith(prefix: String): Boolean {
+        if (length < prefix.length) return false
+        return source.startsWith(prefix, start)
+    }
+
+    fun trimStart() {
+        while (!isEmpty && get(0).isWhitespace()) inc()
+        return
+    }
+
+    // fun copy(): StringSpan = StringSpan(source, start, length, line, column, initalLength, columnCollection?.let { IntSeq(it.size).apply { addAll(it) } })
+    fun copy(): StringSpan = StringSpan(source, start, length, line, column, initalLength)
+}
+
diff --git a/src/main/kotlin/buj/tl/locale/LocaleColorPalette.kt b/src/main/kotlin/buj/tl/locale/LocaleColorPalette.kt
new file mode 100644
index 0000000..c6468d6
--- /dev/null
+++ b/src/main/kotlin/buj/tl/locale/LocaleColorPalette.kt
@@ -0,0 +1,19 @@
+package buj.tl
+
+private val COLORS = arrayOf(
+    "clear", "black", "white", "lightgray",
+    "gray", "darkgray", "blue", "navy",
+    "royal", "slate", "sky", "cyan",
+    "teal", "green", "acid", "lime",
+    "forest", "olive", "yellow", "gold",
+    "goldenrod", "orange", "brown", "tan",
+    "brick", "red", "scarlet", "coral",
+    "salmon", "pink", "magenta", "purple",
+    "violet", "maroon",
+)
+// @formatter:on
+private fun isValidColor(color: String): Boolean {
+    if (color.startsWith("#")) return color.matches(Regex("^#([0-9a-fA-F]{1,6}|[0-9a-fA-F]{8})$"))
+    return color in COLORS
+}
+
diff --git a/src/main/kotlin/buj/tl/locale/LocaleFile.kt b/src/main/kotlin/buj/tl/locale/LocaleFile.kt
new file mode 100644
index 0000000..b40c4f1
--- /dev/null
+++ b/src/main/kotlin/buj/tl/locale/LocaleFile.kt
@@ -0,0 +1,182 @@
+package buj.tl
+
+import arc.struct.ObjectMap
+import java.io.IOException
+
+private val localeCache = ObjectMap<ClassLoader, ObjectMap<String, LocaleFile?>>()
+
+internal class LocaleFile {
+    companion object {
+        operator fun get(localeBase: String, key: String): Script {
+            val registeredLoaders = Tl.localeLoaders()
+            var i = registeredLoaders.size
+            while (--i >= 0) {
+                val loader = registeredLoaders[i]
+                for (locale in destructLocale(localeBase)) {
+                    val file = this[loader, locale]
+                    if (file == null || !file.tls.containsKey(key)) continue
+                    return file.tls.get(key)
+                }
+            }
+            return ScrText("[red]$key[]")
+        }
+
+        operator fun get(loader: ClassLoader, locale: String): LocaleFile? {
+            val cache = localeCache.get(loader) { ObjectMap() }
+            if (cache.containsKey(locale)) {
+                return cache.get(locale)
+            }
+
+            val str: String
+            try {
+                val stream = loader.getResourceAsStream("lang/${locale}.l")
+                if (stream == null) {
+                    cache.put(locale, null)
+                    return null
+                }
+                val bytes = stream.readBytes()
+                str = bytes.toString(Charsets.UTF_8)
+            } catch (_: IOException) {
+                return null
+            }
+
+            val file = parse(str)
+
+            cache.put(locale, file)
+            return file
+        }
+
+        internal fun parse(str: String): LocaleFile {
+            val span = StringSpan(str)
+
+            val file = LocaleFile()
+            var prefix = ""
+            var name = ""
+            var collection = TemplateSpanCollection()
+
+            while (!span.isEmpty) {
+                span.trimStart()
+
+                if (span.stripPrefix("#")) {
+                    if (name.isNotEmpty()) {
+                        if (file.tls.put(name, Tl.parse(collection.intoSpanCollection())) != null) throw RuntimeException("duplicate key $name")
+                        collection = TemplateSpanCollection()
+                    }
+
+                    name = ""
+                    while (!span.isEmpty && span[0] != '\n') span.inc()
+                    continue
+                }
+
+                if (span.stripPrefix("[")) {
+                    if (name.isNotEmpty()) {
+                        if (file.tls.put(name, Tl.parse(collection.intoSpanCollection())) != null) throw RuntimeException("duplicate key $name")
+                        collection = TemplateSpanCollection()
+                    }
+
+                    name = ""
+                    span.trimStart()
+                    prefix = buildString {
+                        while (!span.isEmpty && (span[0].isLetterOrDigit() || span[0] in "-_.")) append(span.next())
+                    }
+                    span.trimStart()
+                    if (!span.stripPrefix("]")) throw RuntimeException("unenclosed prefix statement at ${span.at}")
+                    continue
+                }
+
+                if (span.stripPrefix("=")) {
+                    if (name.isEmpty()) throw RuntimeException("attempt to append a value despite not having an entry open")
+
+                    // It's fine since it's just one character
+                    collection.growFrom(StringSpan("\n"))
+                    span.stripPrefix(" ")
+                    while (!span.isEmpty && span[0] != '\n') {
+                        if (span[0] == '\r') {
+                            span.inc()
+                            continue
+                        }
+                        collection.growFrom(span)
+                        span.inc()
+                    }
+                    continue
+                }
+
+                // Both do not do the same thing anymore.
+                if (span.stripPrefix("-")) {
+                    if (name.isEmpty()) throw RuntimeException("attempt to append a value despite not having an entry open")
+
+                    collection.growFrom(StringSpan(" "))
+                    span.stripPrefix(" ")
+                    while (!span.isEmpty && span[0] != '\n') {
+                        if (span[0] == '\r') {
+                            span.inc()
+                            continue
+                        }
+                        collection.growFrom(span)
+                        span.inc()
+                    }
+                    continue
+                }
+
+                if (span.stripPrefix(":")) {
+                    if (name.isEmpty()) throw RuntimeException("attempt to append a value despite not having an entry open")
+
+                    span.stripPrefix(" ")
+                    while (!span.isEmpty && span[0] != '\n') {
+                        if (span[0] == '\r') {
+                            span.inc()
+                            continue
+                        }
+                        collection.growFrom(span)
+                        span.inc()
+                    }
+                    continue
+                }
+
+                if (name.isNotEmpty()) {
+                    if (file.tls.put(name, Tl.parse(collection.intoSpanCollection())) != null) throw RuntimeException("duplicate key $name")
+                    collection = TemplateSpanCollection()
+                }
+
+                val at = span.at
+
+                name = buildString {
+                    while (!span.isEmpty && (span[0].isLetterOrDigit() || span[0] in "-_.")) append(span.next())
+                }
+
+                if (name.isEmpty()) continue
+
+                name = (if (prefix.isEmpty()) { "" } else { "$prefix." }) + name
+                if (name.startsWith(".")) throw RuntimeException("entry name cannot start with a dot ($name) at $at")
+                if (name.endsWith(".")) throw RuntimeException("entry name cannot end with a dot ($name) at $at")
+                if (name.contains("..")) throw RuntimeException("entry name cannot contain 2 consecutive dots ($name) at $at")
+
+                span.trimStart()
+                if (!span.stripPrefix("=")) throw RuntimeException("'=' must be used to assign a value to the entry at ${span.at}")
+
+                val t = StringBuilder()
+
+                span.stripPrefix(" ")
+                while (!span.isEmpty && span[0] != '\n') {
+                    if (span[0] == '\r') {
+                        span.inc()
+                        continue
+                    }
+                    collection.growFrom(span)
+                    span.inc()
+                }
+            }
+
+            if (name.isNotEmpty()) {
+                if (file.tls.put(name, Tl.parse(collection.intoSpanCollection())) != null) throw RuntimeException("duplicate key $name")
+            }
+
+            return file
+        }
+    }
+
+    private val tls = ObjectMap<String, Script>()
+
+    operator fun get(key: String): Script? = if (tls.containsKey(key)) tls[key] else null
+}
+
diff --git a/src/main/kotlin/buj/tl/locale/LocaleNormalizer.kt b/src/main/kotlin/buj/tl/locale/LocaleNormalizer.kt
new file mode 100644
index 0000000..dc225a1
--- /dev/null
+++ b/src/main/kotlin/buj/tl/locale/LocaleNormalizer.kt
@@ -0,0 +1,12 @@
+package buj.tl
+
+internal fun destructLocale(locale: String): Array<String> {
+    val san = locale.replace(Regex("[^a-zA-Z0-9_-]"), "_")
+        .replace(Regex("_+"), "_")
+        .replace(Regex("^_|_$"), "")
+        .lowercase()
+    if (san.indexOf('_') > 0) return arrayOf(san, san.take(san.indexOf('_')), "c")
+    if (san != "c") return arrayOf(san, "c")
+    return arrayOf("c")
+}
+// @formatter:off
diff --git a/src/main/kotlin/buj/tl/parser/ParseEach.kt b/src/main/kotlin/buj/tl/parser/ParseEach.kt
new file mode 100644
index 0000000..3099d51
--- /dev/null
+++ b/src/main/kotlin/buj/tl/parser/ParseEach.kt
@@ -0,0 +1,52 @@
+package buj.tl
+
+internal fun parseEach(script: SpanCollection): Script {
+    // TODO: {each {name} in {key} <template> split <sep> join <sep> [..if <cond>]}
+
+    script.trimStart()
+    if (script.isEmpty) throw RuntimeException("missing variable at ${script.at}")
+    if (!script.stripPrefix("{")) throw RuntimeException("expected char '{', found '${script[0]}' at ${script.at}")
+    script.trimStart()
+
+    val name = buildString { while (true) {
+        if (script.isEmpty) throw RuntimeException("missing variable at ${script.at}")
+        val chr = script[0]
+        if (!chr.isLetterOrDigit() && chr !in "-_.") break
+        script.inc()
+        append(chr)
+    } }
+    script.trimStart()
+
+    if (!script.stripPrefix("}")) throw RuntimeException("expected char '}', found '${script[0]}' at ${script.at}")
+    script.trimStart()
+
+    if (script.isEmpty) throw RuntimeException("missing \"in\" at ${script.at}")
+    if (!script.stripPrefix("in")) throw RuntimeException("expected \"in\", found char '${script[0]}' at ${script.at}")
+
+    val key = parseExpr(script)
+    val template = parseExpr(script)
+    script.trimStart()
+
+    if (script.isEmpty) throw RuntimeException("missing \"split\" at ${script.at}")
+    if (!script.stripPrefix("split")) throw RuntimeException("expected \"split\", found char '${script[0]}' at ${script.at}")
+
+    val split = parseExpr(script)
+    script.trimStart()
+
+    if (script.isEmpty) throw RuntimeException("missing \"join\" at ${script.at}")
+    if (!script.stripPrefix("join")) throw RuntimeException("expected \"join\", found char '${script[0]}' at ${script.at}")
+
+    val join = parseExpr(script)
+    script.trimStart()
+
+    if (!script.stripPrefix("}")) throw RuntimeException("could not close a 'for' statement at ${script.at}")
+
+    return ScrEach(name, key, template, split, join)
+}
+
+/**
+ * ```
+ * {if a = b then hi else if a = a then hoi else eh}
+ *     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*
+ * ```
+ */
diff --git a/src/main/kotlin/buj/tl/parser/ParseExpression.kt b/src/main/kotlin/buj/tl/parser/ParseExpression.kt
new file mode 100644
index 0000000..773cf38
--- /dev/null
+++ b/src/main/kotlin/buj/tl/parser/ParseExpression.kt
@@ -0,0 +1,92 @@
+package buj.tl
+
+import mindurka.util.newSeq
+
+internal fun parseExpr(script: SpanCollection): Script {
+    script.trimStart()
+    if (script.isEmpty) throw RuntimeException("input ended before an expression could have been parsed at ${script.at}")
+
+    var keepOn0 = true
+
+    when (script[0]) {
+        '}' -> throw RuntimeException("unexpected char '}' when parsing an expression at ${script.at}")
+        ')' -> throw RuntimeException("unexpected char ')' when parsing an expression at ${script.at}")
+        '\\' -> script.inc()
+        '(' -> {
+            keepOn0 = false
+            script.inc()
+        }
+        '{' -> return parseKey(script)
+    }
+
+    val list = newSeq<Script>()
+
+    var depth = if (keepOn0) 0 else 1
+    var backspace = false
+    val text = StringBuilder()
+
+    while (depth > 0 || keepOn0) {
+        if (script.isEmpty) throw RuntimeException("input ended before an expression could have been parsed at ${script.at}")
+        val chr = script[0]
+        if (backspace) {
+            when (chr) {
+                'u' -> text.append(parseUnicode(script))
+                'n' -> text.append('\n')
+                else -> text.append(chr)
+            }
+            script.inc()
+            backspace = false
+            continue
+        }
+        if (chr == '}') {
+            if (depth == 0) break
+            throw RuntimeException("unexpected char '}' when parsing an expression at ${script.at}")
+        }
+        if (chr == ')') {
+            if (depth > 1 || keepOn0) text.append(')')
+            if (depth == 0) throw RuntimeException("closing a string without an opened string at ${script.at}")
+            depth--
+            script.inc()
+            continue
+        }
+        if (chr == '\\') {
+            backspace = true
+            script.inc()
+            continue
+        }
+        if (chr == '(') {
+            text.append('(')
+            depth++
+            script.inc()
+            continue
+        }
+        if (chr == '{') {
+            if (!text.isEmpty()) {
+                list.add(ScrText(text.toString()))
+                text.setLength(0)
+            }
+
+            list.add(parseKey(script))
+
+            continue
+        }
+        if (depth == 0 && chr.isWhitespace()) break
+
+        text.append(chr)
+        script.inc()
+        continue
+    }
+
+    if (!text.isEmpty()) list.add(ScrText(text.toString()))
+
+    if (list.size == 0) return ScrNone
+    if (list.size == 1) return list[0]
+    return ScrCombo(list)
+}
+
+/**
+ * ```
+ * {each {name} in {key} split {sep} join {sep}}
+ *      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*
+ * ```
+ */
diff --git a/src/main/kotlin/buj/tl/parser/ParseIf.kt b/src/main/kotlin/buj/tl/parser/ParseIf.kt
new file mode 100644
index 0000000..6670b07
--- /dev/null
+++ b/src/main/kotlin/buj/tl/parser/ParseIf.kt
@@ -0,0 +1,34 @@
+package buj.tl
+
+internal fun parseIf(script: SpanCollection): Script {
+    val lhs = parseExpr(script)
+    val op = parseOp(script) ?: throw RuntimeException("expected an operator, found char '${script[0]}' at ${script.at}")
+    val rhs = parseExpr(script)
+
+    script.trimStart()
+    if (script.isEmpty) throw RuntimeException("missing \"then\" at ${script.at}")
+    if (!script.stripPrefix("then")) throw RuntimeException("expected \"then\", found char '${script[0]}' at ${script.at}")
+
+    val then = parseExpr(script)
+
+    script.trimStart()
+    if (script.stripPrefix("}")) return ScrIf(rhs, op, lhs, then, ScrNone)
+
+    if (!script.stripPrefix("else")) throw RuntimeException("missing \"else\" at ${script.at}")
+    script.trimStart()
+    if (script.stripPrefix("if")) return ScrIf(rhs, op, lhs, then, parseIf(script))
+
+    val other = parseExpr(script)
+    script.trimStart()
+    if (script.isEmpty) throw RuntimeException("missing '}' at ${script.at}")
+    if (!script.stripPrefix("}")) throw RuntimeException("expected char '}', found '${script[0]}' at ${script.at}")
+
+    return ScrIf(rhs, op, lhs, then, other)
+}
+
+/**
+ * ```
+ * {hello}
+ * ^^^^^^^*
+ * ```
+ */
diff --git a/src/main/kotlin/buj/tl/parser/ParseKey.kt b/src/main/kotlin/buj/tl/parser/ParseKey.kt
new file mode 100644
index 0000000..47def45
--- /dev/null
+++ b/src/main/kotlin/buj/tl/parser/ParseKey.kt
@@ -0,0 +1,20 @@
+package buj.tl
+
+internal fun parseKey(script: SpanCollection): Script {
+    // TODO: {<key> [..with {<key>} = (<value>)]}
+
+    assert(script.stripPrefix("{"))
+    script.trimStart()
+
+    if (script.startsWith("each ") || script.startsWith("each{")) {
+        script.stripPrefix("each")
+        return parseEach(script)
+    }
+    if (script.startsWith("if ") || script.startsWith("if{")) {
+        script.stripPrefix("if")
+        return parseIf(script)
+    }
+
+    return ScrKey(parseRoot(script, true))
+}
+
diff --git a/src/main/kotlin/buj/tl/parser/ParseOperator.kt b/src/main/kotlin/buj/tl/parser/ParseOperator.kt
new file mode 100644
index 0000000..11f3bde
--- /dev/null
+++ b/src/main/kotlin/buj/tl/parser/ParseOperator.kt
@@ -0,0 +1,26 @@
+package buj.tl
+
+internal fun parseOp(script: SpanCollection): ScrIf.Op? {
+    script.trimStart()
+    if (script.stripPrefix("==")) return ScrIf.Op.EqualsIgnoreCase
+    if (script.stripPrefix("=")) return ScrIf.Op.Equals
+    if (script.stripPrefix("!==")) return ScrIf.Op.NotEqualsIgnoreCase
+    if (script.stripPrefix("!=")) return ScrIf.Op.NotEquals
+    if (script.stripPrefix("~=")) return ScrIf.Op.ContainsIgnoreCase
+    if (script.stripPrefix("~")) return ScrIf.Op.Contains
+    if (script.stripPrefix("&=")) return ScrIf.Op.StartsWith
+    if (script.stripPrefix("=&")) return ScrIf.Op.EndsWith
+    if (script.stripPrefix(">=")) return ScrIf.Op.GreaterOrEqual
+    if (script.stripPrefix(">")) return ScrIf.Op.Greater
+    if (script.stripPrefix("<=")) return ScrIf.Op.SmallerOrEqual
+    if (script.stripPrefix("<")) return ScrIf.Op.Smaller
+    if (script.stripPrefix("&~")) return ScrIf.Op.Spans
+    return null
+}
+
+/**
+ * ```
+ * \u{ACB}
+ *   ^^^^^*
+ * ```
+ */
diff --git a/src/main/kotlin/buj/tl/parser/ParseRoot.kt b/src/main/kotlin/buj/tl/parser/ParseRoot.kt
new file mode 100644
index 0000000..3b074b0
--- /dev/null
+++ b/src/main/kotlin/buj/tl/parser/ParseRoot.kt
@@ -0,0 +1,61 @@
+package buj.tl
+
+import arc.struct.Seq
+
+internal fun parseRoot(script: SpanCollection, insideBlock: Boolean = false): Script {
+    val combo = Seq<Script>()
+
+    val text = StringBuilder()
+    var backslash = false
+    while (!script.isEmpty) {
+        val ch = script[0]
+
+        if (backslash) {
+            backslash = false
+            script.inc()
+
+            text.append(when (ch) {
+                'u' -> parseUnicode(script)
+                'n' -> '\n'
+                else -> ch
+            })
+
+            continue
+        }
+
+        when (ch) {
+            '\\' -> {
+                backslash = true
+                script.inc()
+            }
+            '{' -> {
+                if (!text.isEmpty()) combo.add(ScrText(text.toString()))
+                text.setLength(0)
+                combo.add(parseKey(script))
+            }
+            '}' -> {
+                if (insideBlock) {
+                    script.inc()
+
+                    if (!text.isEmpty()) combo.add(ScrText(text.toString()))
+
+                    if (combo.isEmpty) return ScrNone
+                    if (combo.size == 1) return combo[0]
+                    return ScrCombo(combo)
+                }
+                throw RuntimeException("unexpected '}' at ${script.at}")
+            }
+            else -> {
+                text.append(ch)
+                script.inc()
+            }
+        }
+    }
+    if (insideBlock) throw RuntimeException("unenclosed key at ${script.at}")
+    if (!text.isEmpty()) combo.add(ScrText(text.toString()))
+
+    if (combo.isEmpty) return ScrNone
+    if (combo.size == 1) return combo[0]
+    return ScrCombo(combo)
+}
+
diff --git a/src/main/kotlin/buj/tl/parser/ParseUnicode.kt b/src/main/kotlin/buj/tl/parser/ParseUnicode.kt
new file mode 100644
index 0000000..78f4e09
--- /dev/null
+++ b/src/main/kotlin/buj/tl/parser/ParseUnicode.kt
@@ -0,0 +1,36 @@
+package buj.tl
+
+internal fun parseUnicode(script: SpanCollection): Char {
+    var num = 0
+    if (script.isEmpty || script[0] != '{')
+        throw RuntimeException("invalid unicode escape (Tl unicode escapes must follow the format of \\u{..}) at ${script.at}")
+    while (!script.incIsEmpty() && script[0] != '}') {
+        val ch = script[0]
+        num *= 16
+        num += when (ch) {
+            in '0'..'9' -> ch.code - '0'.code
+            in 'a'..'f' -> ch.code - 'a'.code + 10
+            in 'A'..'F' -> ch.code - 'A'.code + 10
+            else        -> throw RuntimeException("invalid unicode escape (unicode codepoint must be in hex) at ${script.at}")
+        }
+    }
+    if (script.isEmpty || script[0] != '}')
+        throw RuntimeException("invalid unicode escape (Tl unicode escapes must follow the format of \\u{..}) at ${script.at}")
+    if (num !in (Char.MIN_VALUE.code..Char.MAX_VALUE.code))
+        throw RuntimeException("invalid unicode escape (invalid codepoint $num) at ${script.at}")
+    script.inc()
+    return num.toChar()
+}
+
+/**
+ * ```
+ * Hello, world
+ * ^^^^^^*
+ *
+ * (Hiii (e) )
+ * ^^^^^^^^^^^*
+ *
+ * {some.key}
+ * ^^^^^^^^^^*
+ * ```
+ */
diff --git a/src/main/kotlin/buj/tl/tokenizer/ITranslationTokenizer.kt b/src/main/kotlin/buj/tl/tokenizer/ITranslationTokenizer.kt
new file mode 100644
index 0000000..5311068
--- /dev/null
+++ b/src/main/kotlin/buj/tl/tokenizer/ITranslationTokenizer.kt
@@ -0,0 +1,5 @@
+package buj.tl
+
+interface ITranslationTokenizer {
+    fun tokenize(source: String): String
+}
diff --git a/src/main/kotlin/buj/tl/tokenizer/TranslationTokenizer.kt b/src/main/kotlin/buj/tl/tokenizer/TranslationTokenizer.kt
new file mode 100644
index 0000000..7827927
--- /dev/null
+++ b/src/main/kotlin/buj/tl/tokenizer/TranslationTokenizer.kt
@@ -0,0 +1,12 @@
+package buj.tl
+
+class DefaultTranslationTokenizer : ITranslationTokenizer {
+    override fun tokenize(source: String): String = source.removePrefix("\uFEFF")
+}
+
+class TokenizingTranslationScriptParser(
+    private val tokenizer: ITranslationTokenizer,
+    private val delegate: ITranslationScriptParser,
+) : ITranslationScriptParser {
+    override fun parse(source: String): Script = delegate.parse(tokenizer.tokenize(source))
+}
diff --git a/src/main/kotlin/mindurka/api/EventDispatchStrategy.kt b/src/main/kotlin/mindurka/api/EventDispatchStrategy.kt
new file mode 100644
index 0000000..2041bde
--- /dev/null
+++ b/src/main/kotlin/mindurka/api/EventDispatchStrategy.kt
@@ -0,0 +1,20 @@
+package mindurka.api
+
+import arc.Events
+import mindurka.annotations.NetworkEvent
+import mindurka.coreplugin.RabbitMQ
+import mindurka.util.Async
+import mindustry.NiMetadata
+
+class DefaultEventDispatchStrategy : IEventDispatchStrategy {
+    override fun dispatch(event: Any) {
+        if (event.javaClass.getAnnotation(NetworkEvent::class.java) != null) {
+            if (!NiMetadata.shortcircuit()) Async.run { RabbitMQ.broadcast(event) }
+        } else Events.fire(event)
+    }
+}
+
+object EventDispatchStrategies {
+    @JvmField
+    val default: IEventDispatchStrategy = DefaultEventDispatchStrategy()
+}
diff --git a/src/main/kotlin/mindurka/api/Events.kt b/src/main/kotlin/mindurka/api/Events.kt
index 2dafff4..123c582 100644
--- a/src/main/kotlin/mindurka/api/Events.kt
+++ b/src/main/kotlin/mindurka/api/Events.kt
@@ -138,68 +138,7 @@ annotation class CancellableInternals
 
 /** A cancellable object. */
 @PublicAPI
-interface Cancellable {
-    /**
-     * Cancel another [Cancellable] when this [Cancellable] gets canceled.
-     */
-    @PublicAPI
-    fun alsoCancel(other: Cancellable)
-    /**
-     * Unbind a [Cancellable].
-     *
-     * This removes both forwards and backwards binds. Caller should always set [recursive]
-     * to `true` or use the method without the extra argument.
-     *
-     * @param cancel [Cancellable] to unbind from.
-     * @param recursive If `true`, must call [Cancellable.unbind] on [cancel].
-     */
-    @PublicAPI
-    @CancellableInternals
-    fun unbind(cancel: Cancellable, recursive: Boolean)
-
-    /**
-     * Unbind a [Cancellable].
-     *
-     * This removes both forwards and backwards binds.
-     *
-     * @param cancel [Cancellable] to unbind from.
-     */
-    @PublicAPI
-    @OptIn(CancellableInternals::class)
-    fun unbind(cancel: Cancellable) = unbind(cancel, true)
-
-    /**
-     * Called by the binder upon [Cancellable.alsoCancel].
-     *
-     * When a binder cancels, it should call [Cancellable.unbind]
-     * on all backwards-bound [Cancellable]s.
-     *
-     * This is used for optimization purposes.
-     *
-     * This method should not be called manually.
-     *
-     * Forwards- and backwards- binding to a cancellable is a logic bug.
-     */
-    @PublicAPI
-    @CancellableInternals
-    fun backwardsBind(cancel: Cancellable)
-
-    /**
-     * Check if this [Cancellable] is cancelled.
-     *
-     * If `true`, [Cancellable.cancel] will do nothing.
-     */
-    @PublicAPI
-    fun cancelled(): Boolean
-    /**
-     * Cancel this [Cancellable].
-     *
-     * Implementors must ensure that calling this method multiple times only
-     * cancels once.
-     */
-    @PublicAPI
-    fun cancel()
-}
+typealias Cancellable = ICancellable
 
 private var lastCancelId = 0
 
@@ -571,8 +510,7 @@ object Events {
     /** Emit an event. */
     @JvmStatic
     fun <T: Any> fire(event: T) {
-        if (event.javaClass.getAnnotation(NetworkEvent::class.java) != null) { if (!NiMetadata.shortcircuit()) Async.run { RabbitMQ.broadcast(event) } }
-        else arc.Events.fire(event)
+        EventDispatchStrategies.default.dispatch(event)
     }
 
     /** Remove an event handler. */
diff --git a/src/main/kotlin/mindurka/api/Gamemode.kt b/src/main/kotlin/mindurka/api/Gamemode.kt
index ef31eb8..8cabd94 100644
--- a/src/main/kotlin/mindurka/api/Gamemode.kt
+++ b/src/main/kotlin/mindurka/api/Gamemode.kt
@@ -26,59 +26,10 @@ enum class MapFlags {
 }
 
 @PublicAPI
-interface MapHandle {
-    /** Get the name of the specified map. */
-    fun name(): String
-    /** Get the description of the specified map. */
-    fun description(): String
-    /** Get the author of the specified map. */
-    fun author(): String
-    /** Get the width of the specified map. */
-    fun width(): Int
-    /** Get the height of the specified map. */
-    fun height(): Int
-    /** Obtain flags for the specified map. */
-    fun flags(): Iterator<MapFlags>
-    /**
-     * Load this map.
-     *
-     * Must be executed immediately.
-     */
-    fun rtv()
-}
+typealias MapHandle = IMapHandle
 
 @PublicAPI
-interface MapManager {
-    /** Current map. */
-    fun current(): MapHandle
-    /** All available maps. */
-    fun maps(): Iterator<MapHandle>
-    /** All available saves. */
-    fun saves(): Iterator<MapHandle>
-
-    /**
-     * Whether this gamemode support saves.
-     *
-     * Setting this to `false` disables /votesave, /voteload, etc.
-     */
-    fun hasSaves(): Boolean
-
-    /** Get the next map. */
-    fun next(): MapHandle
-
-    /** Refresh maps. */
-    fun setNext(map: MapHandle)
-
-    /**
-     * Make a save with the provided name.
-     *
-     * Caller must prove that the filename is valid.
-     */
-    fun save(name: SafeFilename)
-
-    /** Refresh maps. */
-    fun refresh()
-}
+typealias MapManager = IMapManager
 
 /**
  * Default map handler that simply wraps over Mindustry's API.
@@ -186,27 +137,7 @@ open class DefaultMapManager : MapManager {
 }
 
 /** Manager for spectator mode. */
-interface SpectateManager {
-    /** Check if a player is spectating. */
-    operator fun get(player: Player): Boolean
-    /** Set spectator mode for a player. */
-    operator fun set(player: Player, spectating: Boolean)
-    /** Update spectator status for a player. */
-    fun playerTeamChanged(player: Player, previous: Team)
-    /**
-     * Check if a team is a spectator team.
-     *
-     * Spectator teams are considered to be service teams, thus players can't normally join them.
-     */
-    fun isSpectatorTeam(team: Team): Boolean
-
-    /**
-     * Restore spectator status for a player.
-     */
-    fun spectateRestore(player: Player, ogTeam: Team?): Team
-    /** Reset all round data. */
-    fun reset()
-}
+typealias SpectateManager = ISpectateManager
 
 class DefaultSpectateManager: SpectateManager {
     val spectatorTeam: Team = Team.all[69]
diff --git a/src/main/kotlin/mindurka/api/ICancellable.kt b/src/main/kotlin/mindurka/api/ICancellable.kt
new file mode 100644
index 0000000..69d16c8
--- /dev/null
+++ b/src/main/kotlin/mindurka/api/ICancellable.kt
@@ -0,0 +1,10 @@
+package mindurka.api
+
+interface ICancellable {
+    fun alsoCancel(other: ICancellable)
+    fun unbind(cancel: ICancellable, recursive: Boolean)
+    fun unbind(cancel: ICancellable) = unbind(cancel, true)
+    fun backwardsBind(cancel: ICancellable)
+    fun cancelled(): Boolean
+    fun cancel()
+}
diff --git a/src/main/kotlin/mindurka/api/IEventDispatchStrategy.kt b/src/main/kotlin/mindurka/api/IEventDispatchStrategy.kt
new file mode 100644
index 0000000..8949068
--- /dev/null
+++ b/src/main/kotlin/mindurka/api/IEventDispatchStrategy.kt
@@ -0,0 +1,3 @@
+package mindurka.api
+
+interface IEventDispatchStrategy { fun dispatch(event: Any) }
diff --git a/src/main/kotlin/mindurka/api/IMapHandle.kt b/src/main/kotlin/mindurka/api/IMapHandle.kt
new file mode 100644
index 0000000..22f13b8
--- /dev/null
+++ b/src/main/kotlin/mindurka/api/IMapHandle.kt
@@ -0,0 +1,11 @@
+package mindurka.api
+
+interface IMapHandle {
+    fun name(): String
+    fun description(): String
+    fun author(): String
+    fun width(): Int
+    fun height(): Int
+    fun flags(): Iterator<MapFlags>
+    fun rtv()
+}
diff --git a/src/main/kotlin/mindurka/api/IMapManager.kt b/src/main/kotlin/mindurka/api/IMapManager.kt
new file mode 100644
index 0000000..38eff85
--- /dev/null
+++ b/src/main/kotlin/mindurka/api/IMapManager.kt
@@ -0,0 +1,14 @@
+package mindurka.api
+
+import mindurka.util.SafeFilename
+
+interface IMapManager {
+    fun current(): MapHandle
+    fun maps(): Iterator<MapHandle>
+    fun saves(): Iterator<MapHandle>
+    fun hasSaves(): Boolean
+    fun next(): MapHandle
+    fun setNext(map: MapHandle)
+    fun save(name: SafeFilename)
+    fun refresh()
+}
diff --git a/src/main/kotlin/mindurka/api/ISpectateManager.kt b/src/main/kotlin/mindurka/api/ISpectateManager.kt
new file mode 100644
index 0000000..a57bbfe
--- /dev/null
+++ b/src/main/kotlin/mindurka/api/ISpectateManager.kt
@@ -0,0 +1,13 @@
+package mindurka.api
+
+import mindustry.game.Team
+import mindustry.gen.Player
+
+interface ISpectateManager {
+    operator fun get(player: Player): Boolean
+    operator fun set(player: Player, spectating: Boolean)
+    fun playerTeamChanged(player: Player, previous: Team)
+    fun isSpectatorTeam(team: Team): Boolean
+    fun spectateRestore(player: Player, ogTeam: Team?): Team
+    fun reset()
+}
diff --git a/src/main/kotlin/mindurka/api/ITimerScheduler.kt b/src/main/kotlin/mindurka/api/ITimerScheduler.kt
new file mode 100644
index 0000000..01166e0
--- /dev/null
+++ b/src/main/kotlin/mindurka/api/ITimerScheduler.kt
@@ -0,0 +1,10 @@
+package mindurka.api
+
+import java.lang.Runnable
+
+interface ITimerScheduler {
+    fun schedule(runnable: Runnable, delaySeconds: Float): Cancel
+    fun schedule(runnable: Runnable, delaySeconds: Float, intervalSeconds: Float): Cancel
+    fun timer(seconds: Float, lifetime: Lifetime = Lifetime.Forever, run: Runnable): Cancel
+    fun interval(interval: Float, delay: Float = 0f, lifetime: Lifetime = Lifetime.Forever, run: Runnable): Cancel
+}
diff --git a/src/main/kotlin/mindurka/api/Timer.kt b/src/main/kotlin/mindurka/api/Timer.kt
index dd0675f..a4fc3d7 100644
--- a/src/main/kotlin/mindurka/api/Timer.kt
+++ b/src/main/kotlin/mindurka/api/Timer.kt
@@ -43,16 +43,16 @@ fun interval(interval: Float, delay: Float = 0f, lifetime: Lifetime = Lifetime.F
     = Timer.interval(interval, delay, lifetime, run)
 
 @PublicAPI
-object Timer {
+object Timer : ITimerScheduler {
     @PublicAPI
     @JvmStatic
-    fun schedule(runnable: Runnable, delaySeconds: Float): Cancel {
+    override fun schedule(runnable: Runnable, delaySeconds: Float): Cancel {
         val task = ArcTimer.schedule(runnable, delaySeconds)
         return Cancel.get(task::cancel)
     }
     @PublicAPI
     @JvmStatic
-    fun schedule(runnable: Runnable, delaySeconds: Float, intervalSeconds: Float): Cancel {
+    override fun schedule(runnable: Runnable, delaySeconds: Float, intervalSeconds: Float): Cancel {
         val task = ArcTimer.schedule(runnable, delaySeconds, intervalSeconds)
         return Cancel.get(task::cancel)
     }
@@ -65,7 +65,7 @@ object Timer {
     @PublicAPI
     @JvmStatic
     @JvmOverloads
-    fun timer(seconds: Float, lifetime: Lifetime = Lifetime.Forever, run: Runnable): Cancel {
+    override fun timer(seconds: Float, lifetime: Lifetime, run: Runnable): Cancel {
         val timer = schedule(run, seconds)
         lifetime.alsoCancel(timer)
         return timer
@@ -79,9 +79,9 @@ object Timer {
     @PublicAPI
     @JvmStatic
     @JvmOverloads
-    fun interval(interval: Float, delay: Float = 0f, lifetime: Lifetime = Lifetime.Forever, run: Runnable): Cancel {
+    override fun interval(interval: Float, delay: Float, lifetime: Lifetime, run: Runnable): Cancel {
         val timer = schedule(run, delay, interval)
         lifetime.alsoCancel(timer)
         return timer
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/mindurka/bootstrap/ApplicationBootstrap.kt b/src/main/kotlin/mindurka/bootstrap/ApplicationBootstrap.kt
new file mode 100644
index 0000000..e65f204
--- /dev/null
+++ b/src/main/kotlin/mindurka/bootstrap/ApplicationBootstrap.kt
@@ -0,0 +1,89 @@
+package mindurka.bootstrap
+
+import mindurka.coreplugin.CorePlugin
+import mindurka.coreplugin.contracts.ApplicationBootstrap
+import mindurka.coreplugin.contracts.ApplicationBootstrapFactory
+import mindurka.coreplugin.contracts.ApplicationBootstrapProvider
+import mindurka.coreplugin.contracts.ApplicationBootstrapSelector
+import mindurka.coreplugin.contracts.ApplicationLaunchStrategy
+import mindurka.coreplugin.contracts.LifecycleCoordinator
+import mindurka.coreplugin.contracts.LifecyclePhase
+import mindurka.di.DependencyScope
+import mindurka.di.EnterpriseDependencyInjectionContainer
+import mindurka.coreplugin.registry.DefaultComponentRegistry
+import mindurka.coreplugin.registry.RegistryBackedComponentResolver
+import mindurka.util.prefixed
+
+private class CorePluginStartupPhase(
+    private val classLoader: ClassLoader,
+) : LifecyclePhase {
+    override val name: String = "core-plugin-runtime-initialization"
+    override fun execute() = CorePlugin.init(classLoader)
+}
+
+private class DefaultLifecycleCoordinator(
+    private val phases: List<LifecyclePhase>,
+) : LifecycleCoordinator {
+    override fun executeStartup() {
+        phases.forEach { phase ->
+            try {
+                phase.execute()
+            } catch (failure: Throwable) {
+                throw IllegalStateException("Lifecycle phase '${phase.name}' failed", failure)
+            }
+        }
+    }
+}
+
+private class CorePluginApplicationBootstrap(
+    private val lifecycleCoordinator: LifecycleCoordinator,
+) : ApplicationBootstrap {
+    override fun bootstrap(classLoader: ClassLoader) = lifecycleCoordinator.executeStartup()
+}
+
+private class CorePluginApplicationBootstrapFactory(
+    private val container: EnterpriseDependencyInjectionContainer,
+    private val classLoader: ClassLoader,
+) : ApplicationBootstrapFactory {
+    override fun create(): ApplicationBootstrap {
+        val coordinator = DefaultLifecycleCoordinator(listOf(CorePluginStartupPhase(classLoader)))
+        container.register(LifecycleCoordinator::class, DependencyScope.SINGLETON) { coordinator }
+        return CorePluginApplicationBootstrap(container.resolve())
+    }
+}
+
+private class DefaultApplicationBootstrapProvider(
+    private val container: EnterpriseDependencyInjectionContainer,
+    private val classLoader: ClassLoader,
+) : ApplicationBootstrapProvider {
+    override fun provide(): ApplicationBootstrapFactory =
+        CorePluginApplicationBootstrapFactory(container, classLoader)
+}
+
+private class DefaultApplicationBootstrapSelector(
+    private val provider: ApplicationBootstrapProvider,
+) : ApplicationBootstrapSelector {
+    override fun select(): ApplicationBootstrapProvider = provider
+}
+
+private class EnterpriseApplicationLauncher(
+    private val selector: ApplicationBootstrapSelector,
+) : ApplicationLaunchStrategy {
+    override fun launch(classLoader: ClassLoader) {
+        selector.select().provide().create().bootstrap(classLoader)
+    }
+}
+
+object EnterpriseApplicationLauncherProvider {
+    fun provide(classLoader: ClassLoader): ApplicationLaunchStrategy {
+        val container = EnterpriseDependencyInjectionContainer()
+        val registry = DefaultComponentRegistry()
+        val resolver = RegistryBackedComponentResolver(registry)
+        registry.register(ApplicationBootstrapProvider::class, DefaultApplicationBootstrapProvider(container, classLoader))
+        registry.register(ApplicationBootstrapSelector::class, DefaultApplicationBootstrapSelector(resolver.resolve(ApplicationBootstrapProvider::class)))
+        return EnterpriseApplicationLauncher(resolver.resolve(ApplicationBootstrapSelector::class))
+    }
+
+    fun provideDefault(classLoader: ClassLoader): ApplicationLaunchStrategy =
+        provide(classLoader.prefixed("coreplugin"))
+}
diff --git a/src/main/kotlin/mindurka/config/ConfigurationContracts.kt b/src/main/kotlin/mindurka/config/ConfigurationContracts.kt
new file mode 100644
index 0000000..cd35cfc
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/ConfigurationContracts.kt
@@ -0,0 +1,7 @@
+package mindurka.config
+
+typealias ConfigurationSource<T> = IConfigurationSource<T>
+typealias ConfigurationLoader<T> = IConfigurationLoader<T>
+typealias ConfigurationProvider<T> = IConfigurationProvider<T>
+typealias ConfigurationResolver<T> = IConfigurationResolver<T>
+typealias ConfigurationRegistry = IConfigurationRegistry
diff --git a/src/main/kotlin/mindurka/config/CorePluginConfigurationPipeline.kt b/src/main/kotlin/mindurka/config/CorePluginConfigurationPipeline.kt
new file mode 100644
index 0000000..4c2baee
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/CorePluginConfigurationPipeline.kt
@@ -0,0 +1,76 @@
+package mindurka.config
+
+import arc.files.Fi
+import com.akuleshov7.ktoml.source.decodeFromStream
+import kotlinx.serialization.encodeToString
+import mindurka.config.Serializers
+import mindurka.coreplugin.Config
+import mindustry.Vars
+import java.io.IOException
+
+class CorePluginConfigurationFileSource(
+    private val file: Fi,
+) : ConfigurationSource<Config> {
+    override fun load(): Config? = try {
+        Serializers.toml.decodeFromStream(file.read(8192))
+    } catch (_: IOException) {
+        null
+    }
+}
+
+class DefaultCorePluginConfigurationSource : ConfigurationSource<Config> {
+    override fun load(): Config = Config()
+}
+
+class CorePluginConfigurationLoader(
+    private val fileSource: ConfigurationSource<Config>,
+    private val defaultSource: ConfigurationSource<Config>,
+    private val file: Fi,
+) : ConfigurationLoader<Config> {
+    override fun load(): Config {
+        val config = try {
+            fileSource.load()
+        } catch (failure: Exception) {
+            throw RuntimeException("Failed to load 'corePlugin.toml'! Please check whether the file is in correct format!", failure)
+        } ?: defaultSource.load()!!
+
+        if (!file.exists()) {
+            try {
+                file.writeString(Serializers.toml.encodeToString(config))
+            } catch (_: Exception) {
+                // Configuration persistence is best-effort, matching the legacy behavior.
+            }
+        }
+        return config
+    }
+}
+
+class CorePluginConfigurationProvider(
+    private val loader: ConfigurationLoader<Config> = run {
+        val file = Vars.dataDirectory.child("corePlugin.toml")
+        CorePluginConfigurationLoader(
+            CorePluginConfigurationFileSource(file),
+            DefaultCorePluginConfigurationSource(),
+            file,
+        )
+    },
+) : ConfigurationProvider<Config> {
+    private val resolved = lazy(loader::load)
+    override fun provide(): Config = resolved.value
+}
+
+class CorePluginConfigurationResolver(
+    private val registry: ConfigurationRegistry,
+) : ConfigurationResolver<Config> {
+    override fun resolve(): Config = registry.resolve(Config::class)
+}
+
+class CorePluginConfigurationAssembly {
+    private val registry = DefaultConfigurationRegistry()
+
+    init {
+        registry.register(Config::class, CorePluginConfigurationProvider())
+    }
+
+    fun resolve(): Config = CorePluginConfigurationResolver(registry).resolve()
+}
diff --git a/src/main/kotlin/mindurka/config/CorePluginConfigurationRegistry.kt b/src/main/kotlin/mindurka/config/CorePluginConfigurationRegistry.kt
new file mode 100644
index 0000000..f8b293e
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/CorePluginConfigurationRegistry.kt
@@ -0,0 +1,18 @@
+package mindurka.config
+
+import kotlin.reflect.KClass
+
+class DefaultConfigurationRegistry : ConfigurationRegistry {
+    private val providers = LinkedHashMap<KClass<*>, ConfigurationProvider<*>>()
+
+    override fun <T : Any> register(type: KClass<T>, provider: ConfigurationProvider<T>) {
+        providers[type] = provider
+    }
+
+    override fun <T : Any> resolve(type: KClass<T>): T {
+        @Suppress("UNCHECKED_CAST")
+        val provider = providers[type] as? ConfigurationProvider<T>
+            ?: error("Configuration provider is not registered: ${type.qualifiedName}")
+        return provider.provide()
+    }
+}
diff --git a/src/main/kotlin/mindurka/config/IConfigurationLoader.kt b/src/main/kotlin/mindurka/config/IConfigurationLoader.kt
new file mode 100644
index 0000000..0a55ee2
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/IConfigurationLoader.kt
@@ -0,0 +1,3 @@
+package mindurka.config
+
+interface IConfigurationLoader<T : Any> { fun load(): T }
diff --git a/src/main/kotlin/mindurka/config/IConfigurationProvider.kt b/src/main/kotlin/mindurka/config/IConfigurationProvider.kt
new file mode 100644
index 0000000..2c5a023
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/IConfigurationProvider.kt
@@ -0,0 +1,3 @@
+package mindurka.config
+
+interface IConfigurationProvider<T : Any> { fun provide(): T }
diff --git a/src/main/kotlin/mindurka/config/IConfigurationRegistry.kt b/src/main/kotlin/mindurka/config/IConfigurationRegistry.kt
new file mode 100644
index 0000000..19431af
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/IConfigurationRegistry.kt
@@ -0,0 +1,8 @@
+package mindurka.config
+
+import kotlin.reflect.KClass
+
+interface IConfigurationRegistry {
+    fun <T : Any> register(type: KClass<T>, provider: IConfigurationProvider<T>)
+    fun <T : Any> resolve(type: KClass<T>): T
+}
diff --git a/src/main/kotlin/mindurka/config/IConfigurationResolver.kt b/src/main/kotlin/mindurka/config/IConfigurationResolver.kt
new file mode 100644
index 0000000..2af4350
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/IConfigurationResolver.kt
@@ -0,0 +1,3 @@
+package mindurka.config
+
+interface IConfigurationResolver<T : Any> { fun resolve(): T }
diff --git a/src/main/kotlin/mindurka/config/IConfigurationSource.kt b/src/main/kotlin/mindurka/config/IConfigurationSource.kt
new file mode 100644
index 0000000..1f78b2b
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/IConfigurationSource.kt
@@ -0,0 +1,3 @@
+package mindurka.config
+
+interface IConfigurationSource<T : Any> { fun load(): T? }
diff --git a/src/main/kotlin/mindurka/config/ISharedConfigLoader.kt b/src/main/kotlin/mindurka/config/ISharedConfigLoader.kt
new file mode 100644
index 0000000..a257971
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/ISharedConfigLoader.kt
@@ -0,0 +1,3 @@
+package mindurka.config
+
+interface ISharedConfigLoader { fun load(): SharedConfig }
diff --git a/src/main/kotlin/mindurka/config/ISharedConfigProvider.kt b/src/main/kotlin/mindurka/config/ISharedConfigProvider.kt
new file mode 100644
index 0000000..b048819
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/ISharedConfigProvider.kt
@@ -0,0 +1,3 @@
+package mindurka.config
+
+interface ISharedConfigProvider { fun provide(): SharedConfig }
diff --git a/src/main/kotlin/mindurka/config/ISharedConfigRegistry.kt b/src/main/kotlin/mindurka/config/ISharedConfigRegistry.kt
new file mode 100644
index 0000000..f2059de
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/ISharedConfigRegistry.kt
@@ -0,0 +1,3 @@
+package mindurka.config
+
+interface ISharedConfigRegistry { fun resolve(): SharedConfig }
diff --git a/src/main/kotlin/mindurka/config/ISharedConfigSource.kt b/src/main/kotlin/mindurka/config/ISharedConfigSource.kt
new file mode 100644
index 0000000..495f689
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/ISharedConfigSource.kt
@@ -0,0 +1,3 @@
+package mindurka.config
+
+interface ISharedConfigSource { fun load(): SharedConfig? }
diff --git a/src/main/kotlin/mindurka/config/SharedConfig.kt b/src/main/kotlin/mindurka/config/SharedConfig.kt
index fae2408..cde6b45 100644
--- a/src/main/kotlin/mindurka/config/SharedConfig.kt
+++ b/src/main/kotlin/mindurka/config/SharedConfig.kt
@@ -1,14 +1,6 @@
 package mindurka.config
 
-import com.akuleshov7.ktoml.source.decodeFromStream
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.encodeToString
-import java.io.IOException
-import java.net.HttpURLConnection
-import java.net.URI
-import arc.files.Fi
-import arc.util.Log
-import mindurka.coreplugin.Config as CorePluginConfig
 
 @Serializable
 data class SharedConfig(
@@ -20,30 +12,7 @@ data class SharedConfig(
 ) {
     companion object {
         @JvmStatic
-        val sharedConfig: SharedConfig = run {
-            val file = Fi.get((+CorePluginConfig).sharedConfigPath)
-            var instance: SharedConfig
-            try {
-                instance = Serializers.toml.decodeFromStream(file.read(8192))
-            } catch (_: IOException) {
-                instance = SharedConfig(
-                    serverIp = run {
-                        val con = URI.create("https://ip.me/").toURL().openConnection() as HttpURLConnection
-                        con.requestMethod = "GET"
-                        con.doInput = true
-                        val txt = con.inputStream.readAllBytes().toString(Charsets.UTF_8).trim()
-                        Log.warn("Fetching IP via an external service! Current IP: $txt")
-                        txt
-                    }
-                )
-                if (!file.exists()) try {
-                    file.writeString(Serializers.toml.encodeToString(instance))
-                } catch (_: Exception) {}
-            } catch (e: Exception) {
-                throw RuntimeException("Failed to load 'sharedConfig.toml'! Please check whether the file is in the correct format!", e)
-            }
-            instance
-        }
+        val sharedConfig: SharedConfig = SharedConfigRuntimeRegistry().resolve()
 
         val i: SharedConfig get() = sharedConfig
 
diff --git a/src/main/kotlin/mindurka/config/SharedConfigAssembly.kt b/src/main/kotlin/mindurka/config/SharedConfigAssembly.kt
new file mode 100644
index 0000000..5c3af94
--- /dev/null
+++ b/src/main/kotlin/mindurka/config/SharedConfigAssembly.kt
@@ -0,0 +1,77 @@
+package mindurka.config
+
+import arc.files.Fi
+import arc.util.Log
+import com.akuleshov7.ktoml.source.decodeFromStream
+import kotlinx.serialization.encodeToString
+import mindurka.coreplugin.Config
+import java.io.IOException
+import java.net.HttpURLConnection
+import java.net.URI
+
+class SharedConfigFileSource(private val file: Fi) : ISharedConfigSource {
+    override fun load(): SharedConfig? = try {
+        Serializers.toml.decodeFromStream(file.read(8192))
+    } catch (_: IOException) {
+        null
+    }
+}
+
+class SharedConfigExternalIpResolver {
+    fun resolve(): String {
+        val con = URI.create("https://ip.me/").toURL().openConnection() as HttpURLConnection
+        con.requestMethod = "GET"
+        con.doInput = true
+        return con.inputStream.readAllBytes().toString(Charsets.UTF_8).trim().also {
+            Log.warn("Fetching IP via an external service! Current IP: $it")
+        }
+    }
+}
+
+class SharedConfigDefaultSource(
+    private val ipResolver: SharedConfigExternalIpResolver = SharedConfigExternalIpResolver(),
+) : ISharedConfigSource {
+    override fun load(): SharedConfig = SharedConfig(serverIp = ipResolver.resolve())
+}
+
+class DefaultSharedConfigLoader(
+    private val fileSource: ISharedConfigSource,
+    private val defaultSource: ISharedConfigSource,
+    private val file: Fi,
+) : ISharedConfigLoader {
+    override fun load(): SharedConfig {
+        val config = try {
+            fileSource.load()
+        } catch (failure: Exception) {
+            throw RuntimeException("Failed to load 'sharedConfig.toml'! Please check whether the file is in the correct format!", failure)
+        } ?: defaultSource.load()!!
+        if (!file.exists()) try {
+            file.writeString(Serializers.toml.encodeToString(config))
+        } catch (_: Exception) {}
+        return config
+    }
+}
+
+class DefaultSharedConfigProvider(
+    private val loader: ISharedConfigLoader,
+) : ISharedConfigProvider {
+    private val value = lazy(loader::load)
+    override fun provide(): SharedConfig = value.value
+}
+
+class SharedConfigRuntimeRegistry : ISharedConfigRegistry {
+    private val provider: ISharedConfigProvider
+
+    init {
+        val file = Fi.get((+Config).sharedConfigPath)
+        provider = DefaultSharedConfigProvider(
+            DefaultSharedConfigLoader(
+                SharedConfigFileSource(file),
+                SharedConfigDefaultSource(),
+                file,
+            )
+        )
+    }
+
+    override fun resolve(): SharedConfig = provider.provide()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/ChatInitializationCoordinator.kt b/src/main/kotlin/mindurka/coreplugin/ChatInitializationCoordinator.kt
new file mode 100644
index 0000000..82a55a0
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/ChatInitializationCoordinator.kt
@@ -0,0 +1,5 @@
+package mindurka.coreplugin
+
+class DefaultChatInitializationCoordinator : IChatInitializationCoordinator {
+    override fun initialize() = initChat()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/CommandMessageNormalizer.kt b/src/main/kotlin/mindurka/coreplugin/CommandMessageNormalizer.kt
new file mode 100644
index 0000000..97ba98d
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/CommandMessageNormalizer.kt
@@ -0,0 +1,12 @@
+package mindurka.coreplugin
+
+class DefaultCommandMessageNormalizer : ICommandMessageNormalizer {
+    override fun normalize(message: String): String {
+        var normalized = message
+        var spaceIndex = normalized.indexOf(" ")
+        if (spaceIndex == -1) spaceIndex = normalized.length
+        normalized = normalized.take(spaceIndex).lowercase() + normalized.substring(spaceIndex)
+        if (normalized.matches(Regex("\\/t +\\/"))) normalized = normalized.substring(2).trimStart()
+        return normalized
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/Config.kt b/src/main/kotlin/mindurka/coreplugin/Config.kt
index 93a3f3e..880e555 100644
--- a/src/main/kotlin/mindurka/coreplugin/Config.kt
+++ b/src/main/kotlin/mindurka/coreplugin/Config.kt
@@ -1,12 +1,9 @@
 package mindurka.coreplugin
 
-import com.akuleshov7.ktoml.source.decodeFromStream
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.encodeToString
-import mindustry.Vars
-import java.io.IOException
 import arc.math.Mathf
-import mindurka.config.Serializers
+import mindustry.Vars
+import mindurka.config.CorePluginConfigurationAssembly
 
 @Serializable
 data class Config(
@@ -19,21 +16,7 @@ data class Config(
 ) {
     companion object {
         @JvmField
-        val config: Config = run {
-            val file = Vars.dataDirectory.child("corePlugin.toml")
-            var instance: Config
-            try {
-                instance = Serializers.toml.decodeFromStream(file.read(8192))
-            } catch (_: IOException) {
-                instance = Config()
-                if (!file.exists()) try {
-                    file.writeString(Serializers.toml.encodeToString(instance))
-                } catch (_: Exception) {}
-            } catch (e: Exception) {
-                throw RuntimeException("Failed to load 'corePlugin.toml'! Please check whether the file is in correct format!", e)
-            }
-            instance
-        }
+        val config: Config = CorePluginConfigurationAssembly().resolve()
 
         inline val i: Config get() = config
         @Suppress("NOTHING_TO_INLINE") // ik it's insignificant.
diff --git a/src/main/kotlin/mindurka/coreplugin/CorePlugin.kt b/src/main/kotlin/mindurka/coreplugin/CorePlugin.kt
index 64f336d..5be9f8e 100644
--- a/src/main/kotlin/mindurka/coreplugin/CorePlugin.kt
+++ b/src/main/kotlin/mindurka/coreplugin/CorePlugin.kt
@@ -26,14 +26,14 @@ import mindurka.api.emit
 import mindurka.api.interval
 import mindurka.api.on
 import mindurka.api.timer
-import mindurka.build.CommandImpl
-import mindurka.coreplugin.commands.registerCommand
 import mindurka.coreplugin.database.Database
-import mindurka.coreplugin.database.DatabaseScripts
 import mindurka.coreplugin.messages.BringPlayerBack
 import mindurka.coreplugin.messages.ServerDown
 import mindurka.coreplugin.messages.ServerMessage
-import mindurka.coreplugin.nativeimage.nativeImageHeatUp
+import mindurka.coreplugin.pipeline.CommandInitializationPipeline
+import mindurka.coreplugin.pipeline.FeatureInitializationPipeline
+import mindurka.coreplugin.pipeline.InfrastructureInitializationPipeline
+import mindurka.coreplugin.protocol.ProtocolRuntimeAssembly
 import mindurka.coreplugin.recording.initRecording
 import mindurka.coreplugin.votes.Vote
 import mindurka.ui.handleUiEvent
@@ -77,20 +77,7 @@ object CorePlugin {
     @OptIn(ExperimentalSerializationApi::class)
     @JvmStatic
     fun init(loader: ClassLoader) {
-        Tl.init(loader)
-
-        (loader.getResourceAsStream("META-INF/mindurka.coreplugin.commands")?.readAllBytes()?.toString(charset("UTF-8")) ?: "")
-            .split("\n")
-            .listIterator()
-            .map { it.trim() }
-            .filter { !it.isEmpty() }
-            .forEach {
-                @Suppress("UNCHECKED_CAST")
-                val klass = loader.loadClass(it) as Class<CommandImpl>
-                val init = klass.constructors.first()
-                val cmd = init.newInstance() as CommandImpl
-                registerCommand(cmd)
-            }
+        CommandInitializationPipeline(loader).execute()
     }
 
     class TeamRestoreCache(player: Player) {
@@ -153,16 +140,7 @@ object CorePlugin {
         Log.info("Starting CorePlugin")
         Time.mark()
 
-        MdUtil.init()
-
-        if (!NiMetadata.shortcircuit()) Database.load()
-        else DatabaseScripts.noop()
-        Overrides.load()
-        if (!NiMetadata.shortcircuit()) RabbitMQ.init()
-
-        if (NiMetadata.shortcircuit()) { // Ensure that the agent generates bindings for everything.
-            nativeImageHeatUp()
-        }
+        InfrastructureInitializationPipeline().execute()
 
         on<EventType.WorldLoadEndEvent>(priority = Priority.Before) {
             SpecialSettings.`coreplugin$loadSettings`()
@@ -545,12 +523,7 @@ object CorePlugin {
             emit(BuildEventPost)
         }
 
-        initModActions()
-        initChat()
-        initHubDiscovery()
-        initSchemeSize()
-        initTeams()
-        initRecording()
+        FeatureInitializationPipeline().execute()
 
         interval(30f) { Async.run {
             for (player in Groups.player) {
@@ -613,7 +586,7 @@ object CorePlugin {
             scheduleRestart()
         }
 
-        protocol = Protocol()
+        protocol = ProtocolRuntimeAssembly().create()
 
         Runtime.getRuntime().addShutdownHook(Thread {
             shuttingDown = true
@@ -642,7 +615,7 @@ object CorePlugin {
 
             Threads.sleep(500)
 
-            if (!NiMetadata.shortcircuit()) RabbitMQ.close()
+            if (!NiMetadata.shortcircuit()) DefaultRabbitMqLifecycle().shutdown()
         })
 
         Log.info("CorePlugin loaded in ${Time.elapsed()} ms.")
diff --git a/src/main/kotlin/mindurka/coreplugin/GoogleTranslator.kt b/src/main/kotlin/mindurka/coreplugin/GoogleTranslator.kt
index 133d486..2df21eb 100644
--- a/src/main/kotlin/mindurka/coreplugin/GoogleTranslator.kt
+++ b/src/main/kotlin/mindurka/coreplugin/GoogleTranslator.kt
@@ -141,7 +141,7 @@ val supportedLanguageCodes = arrayOf(
     LanguageCode("Zulu", "zu"),
 )
 val auto = LanguageCode("Detect Language", "auto")
-fun languageCodeFor(locale: String): LanguageCode? =
+internal fun resolveLanguageCodeFor(locale: String): LanguageCode? =
     supportedLanguageCodes.find { it.code.equals(locale, true) } ?:
     supportedLanguageCodes.find { it.code.equals(locale.replace('-', '_'), true) } ?:
     supportedLanguageCodes.find { splitOnceFirst(it.code, "-").equals(splitOnceFirst(locale, "-"), true) } ?:
@@ -162,7 +162,7 @@ suspend fun translateFor(source: String, from: LanguageCode, to: LanguageCode):
     }
 }
 
-fun sameLang(that: String, other: String): Boolean {
+internal fun resolveSameLang(that: String, other: String): Boolean {
     val that = that.replace('_', '-').lowercase()
     val other = other.replace('_', '-').lowercase()
 
@@ -171,3 +171,7 @@ fun sameLang(that: String, other: String): Boolean {
 
     return false
 }
+
+fun languageCodeFor(locale: String): LanguageCode? = GoogleTranslatorProvider.default.languageCodeFor(locale)
+
+fun sameLang(that: String, other: String): Boolean = GoogleTranslatorProvider.default.sameLanguage(that, other)
diff --git a/src/main/kotlin/mindurka/coreplugin/GoogleTranslatorProvider.kt b/src/main/kotlin/mindurka/coreplugin/GoogleTranslatorProvider.kt
new file mode 100644
index 0000000..6b3b194
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/GoogleTranslatorProvider.kt
@@ -0,0 +1,14 @@
+package mindurka.coreplugin
+
+class DefaultGoogleTranslator : IGoogleTranslator {
+    override fun languageCodeFor(locale: String): LanguageCode? =
+        resolveLanguageCodeFor(locale)
+
+    override fun sameLanguage(first: String, second: String): Boolean =
+        resolveSameLang(first, second)
+}
+
+object GoogleTranslatorProvider {
+    @JvmField
+    val default: IGoogleTranslator = DefaultGoogleTranslator()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/HubDiscovery.kt b/src/main/kotlin/mindurka/coreplugin/HubDiscovery.kt
index 3984c66..f85183e 100644
--- a/src/main/kotlin/mindurka/coreplugin/HubDiscovery.kt
+++ b/src/main/kotlin/mindurka/coreplugin/HubDiscovery.kt
@@ -31,7 +31,7 @@ private class HubServer(
 )
 private val hubServers = ObjectMap<String, HubServer>(2)
 
-private fun serverInfo(): ServerInfo? {
+internal fun serverInfo(): ServerInfo? {
     if (CorePlugin.shuttingDown) return null
     if (!Vars.net.active()) return null
 
@@ -86,11 +86,13 @@ internal fun initHubDiscovery() {
     }
 }
 
-fun hubServer(): String? {
+internal fun resolveHubServer(): String? {
     if (hubServers.isEmpty) return null
     return hubServers.first().value.ip
 }
 
+fun hubServer(): String? = DefaultHubDiscoveryGateway().currentServer()
+
 @Command
 private fun hub(caller: Player) = Async.run {
     if (caller.checkOnCooldown("/hub")) return@run
diff --git a/src/main/kotlin/mindurka/coreplugin/HubDiscoveryGateway.kt b/src/main/kotlin/mindurka/coreplugin/HubDiscoveryGateway.kt
new file mode 100644
index 0000000..c48540a
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/HubDiscoveryGateway.kt
@@ -0,0 +1,6 @@
+package mindurka.coreplugin
+
+class DefaultHubDiscoveryGateway : IHubDiscoveryGateway {
+    override fun initialize() = initHubDiscovery()
+    override fun currentServer(): String? = resolveHubServer()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/IChatInitializationCoordinator.kt b/src/main/kotlin/mindurka/coreplugin/IChatInitializationCoordinator.kt
new file mode 100644
index 0000000..1207348
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/IChatInitializationCoordinator.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin
+
+interface IChatInitializationCoordinator { fun initialize() }
diff --git a/src/main/kotlin/mindurka/coreplugin/ICommandMessageNormalizer.kt b/src/main/kotlin/mindurka/coreplugin/ICommandMessageNormalizer.kt
new file mode 100644
index 0000000..69fa6b7
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/ICommandMessageNormalizer.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin
+
+interface ICommandMessageNormalizer { fun normalize(message: String): String }
diff --git a/src/main/kotlin/mindurka/coreplugin/IGoogleTranslator.kt b/src/main/kotlin/mindurka/coreplugin/IGoogleTranslator.kt
new file mode 100644
index 0000000..498ad52
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/IGoogleTranslator.kt
@@ -0,0 +1,6 @@
+package mindurka.coreplugin
+
+interface IGoogleTranslator {
+    fun languageCodeFor(locale: String): LanguageCode?
+    fun sameLanguage(first: String, second: String): Boolean
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/IHubDiscoveryGateway.kt b/src/main/kotlin/mindurka/coreplugin/IHubDiscoveryGateway.kt
new file mode 100644
index 0000000..5bafdbb
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/IHubDiscoveryGateway.kt
@@ -0,0 +1,6 @@
+package mindurka.coreplugin
+
+interface IHubDiscoveryGateway {
+    fun initialize()
+    fun currentServer(): String?
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/IModerationActionPolicy.kt b/src/main/kotlin/mindurka/coreplugin/IModerationActionPolicy.kt
new file mode 100644
index 0000000..d5cfe3a
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/IModerationActionPolicy.kt
@@ -0,0 +1,5 @@
+package mindurka.coreplugin
+
+import mindustry.gen.Player
+
+interface IModerationActionPolicy { fun rejects(actor: Player, target: Player?): Boolean }
diff --git a/src/main/kotlin/mindurka/coreplugin/IPlayerDataProvider.kt b/src/main/kotlin/mindurka/coreplugin/IPlayerDataProvider.kt
new file mode 100644
index 0000000..5ae763c
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/IPlayerDataProvider.kt
@@ -0,0 +1,8 @@
+package mindurka.coreplugin
+
+import mindustry.gen.Player
+
+interface IPlayerDataProvider {
+    fun get(player: Player): PlayerData
+    fun getOrNull(player: Player): PlayerData?
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/IPluginLaunchCoordinator.kt b/src/main/kotlin/mindurka/coreplugin/IPluginLaunchCoordinator.kt
new file mode 100644
index 0000000..3e7fef6
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/IPluginLaunchCoordinator.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin
+
+interface IPluginLaunchCoordinator { fun launch(classLoader: ClassLoader) }
diff --git a/src/main/kotlin/mindurka/coreplugin/IRabbitMqLifecycle.kt b/src/main/kotlin/mindurka/coreplugin/IRabbitMqLifecycle.kt
new file mode 100644
index 0000000..89614b4
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/IRabbitMqLifecycle.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin
+
+interface IRabbitMqLifecycle { fun initialize(); fun shutdown() }
diff --git a/src/main/kotlin/mindurka/coreplugin/Main.kt b/src/main/kotlin/mindurka/coreplugin/Main.kt
index 30cd185..73ff4b1 100644
--- a/src/main/kotlin/mindurka/coreplugin/Main.kt
+++ b/src/main/kotlin/mindurka/coreplugin/Main.kt
@@ -1,11 +1,9 @@
 package mindurka.coreplugin
 
 import mindustry.mod.Plugin
-import mindurka.api.Gamemode
-import mindurka.util.prefixed
 
 class Main : Plugin() {
     override fun init() {
-        Gamemode.init(javaClass.classLoader.prefixed("coreplugin"))
+        DefaultPluginLaunchCoordinator().launch(javaClass.classLoader)
     }
 }
diff --git a/src/main/kotlin/mindurka/coreplugin/ModCommandHandler.kt b/src/main/kotlin/mindurka/coreplugin/ModCommandHandler.kt
index 14fa388..3472b19 100644
--- a/src/main/kotlin/mindurka/coreplugin/ModCommandHandler.kt
+++ b/src/main/kotlin/mindurka/coreplugin/ModCommandHandler.kt
@@ -5,15 +5,11 @@ import arc.struct.Seq
 import mindustry.gen.Player
 
 class ModCommandHandler(private val parent: CommandHandler) : CommandHandler(parent.prefix) {
-    override fun handleMessage(message_: String, params: Any): CommandResponse {
-        var message = message_
-
-        var spaceIdx = message.indexOf(" ")
-        if (spaceIdx == -1) spaceIdx = message.length
+    private val messageNormalizer: ICommandMessageNormalizer = DefaultCommandMessageNormalizer()
 
-        message = message.take(spaceIdx).lowercase() + message.substring(spaceIdx)
-
-        if (message.matches(Regex("\\/t +\\/"))) message = message.substring(2).trimStart()
+    override fun handleMessage(message_: String, params: Any): CommandResponse {
+        val message = messageNormalizer.normalize(message_)
+        val spaceIdx = message.indexOf(" ").let { if (it == -1) message.length else it }
 
         if (params is Player && message.startsWith("/fuck")) {
             // Necessary due to CorePlugin commands being async
diff --git a/src/main/kotlin/mindurka/coreplugin/ModerationActionPolicy.kt b/src/main/kotlin/mindurka/coreplugin/ModerationActionPolicy.kt
new file mode 100644
index 0000000..2c253dc
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/ModerationActionPolicy.kt
@@ -0,0 +1,5 @@
+package mindurka.coreplugin
+
+class DefaultModerationActionPolicy : IModerationActionPolicy {
+    override fun rejects(actor: Player, target: Player?): Boolean = !actor.admin || target == null || target.admin
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/ModerationActions.kt b/src/main/kotlin/mindurka/coreplugin/ModerationActions.kt
index 3505175..b95ab75 100644
--- a/src/main/kotlin/mindurka/coreplugin/ModerationActions.kt
+++ b/src/main/kotlin/mindurka/coreplugin/ModerationActions.kt
@@ -15,6 +15,7 @@ import mindustry.net.Packets
 import kotlin.time.Duration
 
 internal fun initModActions() {
+    val moderationPolicy: IModerationActionPolicy = DefaultModerationActionPolicy()
     Vars.net.handleServer(AdminRequestCallPacket::class.java) { con, packet ->
         val admin = con.player
         val target = packet.other
@@ -25,12 +26,12 @@ internal fun initModActions() {
         }
 
         fun adminChecks(target: Player?): Boolean {
-            if (target == null) {
+            if (moderationPolicy.rejects(admin, target) && target == null) {
                 Tl.send(admin).done("{generic.checks.admin-action-no-target}")
                 return true
             }
 
-            if (target.admin) {
+            if (moderationPolicy.rejects(admin, target) && target!!.admin) {
                 Tl.send(admin).done("{generic.checks.admin-action-target-admin}")
                 return true
             }
@@ -164,4 +165,4 @@ private suspend fun moderationDialog(admin: Player, target: Player, prefix: Stri
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/PlayerData.kt b/src/main/kotlin/mindurka/coreplugin/PlayerData.kt
index d979582..237155a 100644
--- a/src/main/kotlin/mindurka/coreplugin/PlayerData.kt
+++ b/src/main/kotlin/mindurka/coreplugin/PlayerData.kt
@@ -59,6 +59,7 @@ enum class TranslatorStyle(@JvmField val shortName: String) {
 class PlayerData private constructor(player: Player) {
     companion object {
         internal const val defaultString = ""
+        private val provider: IPlayerDataProvider = DefaultPlayerDataProvider()
         private val cache = WeakHashMap<Player, PlayerData>()
         private class GcEntry(@JvmField val player: WeakReference<Player>, @JvmField val data: PlayerData)
         private val gc = newSeq<GcEntry>(ordered = false)
@@ -95,7 +96,7 @@ class PlayerData private constructor(player: Player) {
          */
         @PublicAPI
         @JvmStatic
-        fun of(player: Player): PlayerData = cache.getOrPut(player) { PlayerData(player) }
+        fun of(player: Player): PlayerData = provider.get(player)
 
         /**
          * Obtain session data for player.
@@ -104,7 +105,10 @@ class PlayerData private constructor(player: Player) {
          */
         @PublicAPI
         @JvmStatic
-        fun ofOrNull(player: Player): PlayerData? = cache[player]
+        fun ofOrNull(player: Player): PlayerData? = provider.getOrNull(player)
+
+        internal fun obtainInternal(player: Player): PlayerData = cache.getOrPut(player) { PlayerData(player) }
+        internal fun obtainInternalOrNull(player: Player): PlayerData? = cache[player]
     }
 
     init {
diff --git a/src/main/kotlin/mindurka/coreplugin/PlayerDataProvider.kt b/src/main/kotlin/mindurka/coreplugin/PlayerDataProvider.kt
new file mode 100644
index 0000000..d18ffb9
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/PlayerDataProvider.kt
@@ -0,0 +1,8 @@
+package mindurka.coreplugin
+
+import mindustry.gen.Player
+
+class DefaultPlayerDataProvider : IPlayerDataProvider {
+    override fun get(player: Player): PlayerData = PlayerData.obtainInternal(player)
+    override fun getOrNull(player: Player): PlayerData? = PlayerData.obtainInternalOrNull(player)
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/PluginLaunchCoordinator.kt b/src/main/kotlin/mindurka/coreplugin/PluginLaunchCoordinator.kt
new file mode 100644
index 0000000..1d0e080
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/PluginLaunchCoordinator.kt
@@ -0,0 +1,9 @@
+package mindurka.coreplugin
+
+import mindurka.bootstrap.EnterpriseApplicationLauncherProvider
+
+class DefaultPluginLaunchCoordinator : IPluginLaunchCoordinator {
+    override fun launch(classLoader: ClassLoader) {
+        EnterpriseApplicationLauncherProvider.provideDefault(classLoader).launch(classLoader)
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/Protocol.kt b/src/main/kotlin/mindurka/coreplugin/Protocol.kt
index 2fdbbec..8c1ded6 100644
--- a/src/main/kotlin/mindurka/coreplugin/Protocol.kt
+++ b/src/main/kotlin/mindurka/coreplugin/Protocol.kt
@@ -29,6 +29,7 @@ import mindurka.coreplugin.database.PermLevels
 import mindurka.coreplugin.database.SharedAccountException
 import mindurka.coreplugin.database.VotekickedAccountException
 import mindurka.coreplugin.messages.AddFirewallBan
+import mindurka.coreplugin.protocol.IProtocolNetState
 import mindurka.util.Async
 import mindurka.util.K
 import mindurka.util.ip
@@ -191,7 +192,7 @@ class Protocol {
     private val outStream = ReusableByteOutStream()
     private val outData = DataOutputStream(outStream)
 
-    interface NetState { val priority: Int get() = Packet.priorityNormal }
+    abstract class NetState : IProtocolNetState { override val priority: Int get() = Packet.priorityNormal }
     object BeginState: NetState { override val priority: Int get() = Packet.priorityHigh }
 
     object VanillaClientState: NetState
@@ -594,4 +595,4 @@ class Protocol {
             if (!done) PlayerData.of(player).playerLeft(player)
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/RabbitMqLifecycle.kt b/src/main/kotlin/mindurka/coreplugin/RabbitMqLifecycle.kt
new file mode 100644
index 0000000..68c0173
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/RabbitMqLifecycle.kt
@@ -0,0 +1,6 @@
+package mindurka.coreplugin
+
+class DefaultRabbitMqLifecycle : IRabbitMqLifecycle {
+    override fun initialize() = RabbitMQ.init()
+    override fun shutdown() = RabbitMQ.close()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/commands/CommandConstraint.kt b/src/main/kotlin/mindurka/coreplugin/commands/CommandConstraint.kt
index dba08a5..56ad261 100644
--- a/src/main/kotlin/mindurka/coreplugin/commands/CommandConstraint.kt
+++ b/src/main/kotlin/mindurka/coreplugin/commands/CommandConstraint.kt
@@ -1,7 +1,6 @@
 package mindurka.coreplugin.commands
 
 import arc.util.Log
-import mindurka.annotations.BaseCommandConstraint
 import mindurka.api.Gamemode
 import mindurka.api.SpecialSettings
 import mindustry.Vars
@@ -14,9 +13,7 @@ import mindustry.gen.Player
  *
  * Any object extending this interface must contain a static `obtain(): CommandConstraint` method.
  */
-interface CommandConstraint: BaseCommandConstraint {
-    fun enabled(player: Player): Boolean
-}
+typealias CommandConstraint = ICommandConstraint
 
 /**
  * Whether /rtv and /surrender are enabled.
diff --git a/src/main/kotlin/mindurka/coreplugin/commands/CommandRegistry.kt b/src/main/kotlin/mindurka/coreplugin/commands/CommandRegistry.kt
new file mode 100644
index 0000000..e791cf3
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/commands/CommandRegistry.kt
@@ -0,0 +1,16 @@
+package mindurka.coreplugin.commands
+
+import arc.struct.Seq
+import mindurka.build.CommandImpl
+import mindurka.util.filter
+
+class DefaultCommandRegistry : ICommandRegistry {
+    override val commands = Seq<CommandImpl>()
+
+    override fun register(command: CommandImpl) {
+        commands.add(command)
+    }
+
+    override fun find(command: String): Iterator<CommandImpl> =
+        commands.iterator().filter { it.command[0] == command }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/commands/Commands.kt b/src/main/kotlin/mindurka/coreplugin/commands/Commands.kt
index 3d80be5..a848677 100644
--- a/src/main/kotlin/mindurka/coreplugin/commands/Commands.kt
+++ b/src/main/kotlin/mindurka/coreplugin/commands/Commands.kt
@@ -22,7 +22,8 @@ import mindurka.util.unreachable
 
 private class CommandRegistrationContext(private val handle: CommandHandler) {
     private var sorted = true
-    private val commandList = Seq<CommandImpl>()
+    private val commandRegistry: ICommandRegistry = DefaultCommandRegistry()
+    private val commandList: Seq<CommandImpl> get() = commandRegistry.commands
 
     companion object {
         private val playerCtx = CommandRegistrationContext(run {
@@ -110,11 +111,11 @@ private class CommandRegistrationContext(private val handle: CommandHandler) {
                 else Log.err(message)
             } }
         }
-        commandList.add(command)
+        commandRegistry.register(command)
         sorted = false
     }
 
-    fun all(command: String): Iterator<CommandImpl> = commandList.iterator().filter { it.command[0] == command }
+    fun all(command: String): Iterator<CommandImpl> = commandRegistry.find(command)
 }
 
 fun metadataForCommand(command: String, type: CommandType) =
diff --git a/src/main/kotlin/mindurka/coreplugin/commands/ICommandConstraint.kt b/src/main/kotlin/mindurka/coreplugin/commands/ICommandConstraint.kt
new file mode 100644
index 0000000..7abe3aa
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/commands/ICommandConstraint.kt
@@ -0,0 +1,8 @@
+package mindurka.coreplugin.commands
+
+import mindurka.annotations.BaseCommandConstraint
+import mindustry.gen.Player
+
+interface ICommandConstraint : BaseCommandConstraint {
+    fun enabled(player: Player): Boolean
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/commands/ICommandRegistry.kt b/src/main/kotlin/mindurka/coreplugin/commands/ICommandRegistry.kt
new file mode 100644
index 0000000..16bbf97
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/commands/ICommandRegistry.kt
@@ -0,0 +1,10 @@
+package mindurka.coreplugin.commands
+
+import arc.struct.Seq
+import mindurka.build.CommandImpl
+
+interface ICommandRegistry {
+    val commands: Seq<CommandImpl>
+    fun register(command: CommandImpl)
+    fun find(command: String): Iterator<CommandImpl>
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/EnterpriseContracts.kt b/src/main/kotlin/mindurka/coreplugin/contracts/EnterpriseContracts.kt
new file mode 100644
index 0000000..4819c4d
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/EnterpriseContracts.kt
@@ -0,0 +1,11 @@
+package mindurka.coreplugin.contracts
+
+typealias ApplicationLaunchStrategy = IApplicationLaunchStrategy
+typealias ApplicationBootstrap = IApplicationBootstrap
+typealias ApplicationBootstrapFactory = IApplicationBootstrapFactory
+typealias ApplicationBootstrapProvider = IApplicationBootstrapProvider
+typealias ApplicationBootstrapSelector = IApplicationBootstrapSelector
+typealias ComponentRegistry = IComponentRegistry
+typealias ComponentResolver = IComponentResolver
+typealias LifecyclePhase = ILifecyclePhase
+typealias LifecycleCoordinator = ILifecycleCoordinator
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrap.kt b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrap.kt
new file mode 100644
index 0000000..c90468d
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrap.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface IApplicationBootstrap { fun bootstrap(classLoader: ClassLoader) }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapFactory.kt b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapFactory.kt
new file mode 100644
index 0000000..3ae38ae
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapFactory.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface IApplicationBootstrapFactory { fun create(): IApplicationBootstrap }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapProvider.kt b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapProvider.kt
new file mode 100644
index 0000000..045be3c
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapProvider.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface IApplicationBootstrapProvider { fun provide(): IApplicationBootstrapFactory }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapSelector.kt b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapSelector.kt
new file mode 100644
index 0000000..4136a14
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationBootstrapSelector.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface IApplicationBootstrapSelector { fun select(): IApplicationBootstrapProvider }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationLaunchStrategy.kt b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationLaunchStrategy.kt
new file mode 100644
index 0000000..a6c34ff
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/IApplicationLaunchStrategy.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+fun interface IApplicationLaunchStrategy { fun launch(classLoader: ClassLoader) }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/IComponentRegistry.kt b/src/main/kotlin/mindurka/coreplugin/contracts/IComponentRegistry.kt
new file mode 100644
index 0000000..049e29a
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/IComponentRegistry.kt
@@ -0,0 +1,8 @@
+package mindurka.coreplugin.contracts
+
+import kotlin.reflect.KClass
+
+interface IComponentRegistry {
+    fun <T : Any> register(type: KClass<T>, component: T)
+    fun <T : Any> lookup(type: KClass<T>): T?
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/IComponentResolver.kt b/src/main/kotlin/mindurka/coreplugin/contracts/IComponentResolver.kt
new file mode 100644
index 0000000..a1e17b4
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/IComponentResolver.kt
@@ -0,0 +1,5 @@
+package mindurka.coreplugin.contracts
+
+import kotlin.reflect.KClass
+
+interface IComponentResolver { fun <T : Any> resolve(type: KClass<T>): T }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystem.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystem.kt
new file mode 100644
index 0000000..af71426
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystem.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ICorePluginSubsystem { val id: String; fun initialize() }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemExecutionStrategy.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemExecutionStrategy.kt
new file mode 100644
index 0000000..9f50f16
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemExecutionStrategy.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ICorePluginSubsystemExecutionStrategy { fun execute(subsystems: List<ICorePluginSubsystem>) }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemFactory.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemFactory.kt
new file mode 100644
index 0000000..0711d94
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemFactory.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ICorePluginSubsystemFactory { fun create(): ICorePluginSubsystemExecutionStrategy }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemProvider.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemProvider.kt
new file mode 100644
index 0000000..9521693
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemProvider.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ICorePluginSubsystemProvider { fun provide(): ICorePluginSubsystemFactory }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemRegistry.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemRegistry.kt
new file mode 100644
index 0000000..442898d
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemRegistry.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ICorePluginSubsystemRegistry { fun register(subsystem: ICorePluginSubsystem); fun all(): List<ICorePluginSubsystem> }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemResolver.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemResolver.kt
new file mode 100644
index 0000000..9a237c2
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemResolver.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ICorePluginSubsystemResolver { fun resolve(): List<ICorePluginSubsystem> }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemSelector.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemSelector.kt
new file mode 100644
index 0000000..8642a6e
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ICorePluginSubsystemSelector.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ICorePluginSubsystemSelector { fun select(): ICorePluginSubsystemExecutionStrategy }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ILifecycleCoordinator.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ILifecycleCoordinator.kt
new file mode 100644
index 0000000..bc4ad7f
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ILifecycleCoordinator.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ILifecycleCoordinator { fun executeStartup() }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/ILifecyclePhase.kt b/src/main/kotlin/mindurka/coreplugin/contracts/ILifecyclePhase.kt
new file mode 100644
index 0000000..508af58
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/ILifecyclePhase.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.contracts
+
+interface ILifecyclePhase { val name: String; fun execute() }
diff --git a/src/main/kotlin/mindurka/coreplugin/contracts/SubsystemContracts.kt b/src/main/kotlin/mindurka/coreplugin/contracts/SubsystemContracts.kt
new file mode 100644
index 0000000..1ef77d1
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/contracts/SubsystemContracts.kt
@@ -0,0 +1,9 @@
+package mindurka.coreplugin.contracts
+
+typealias CorePluginSubsystem = ICorePluginSubsystem
+typealias CorePluginSubsystemExecutionStrategy = ICorePluginSubsystemExecutionStrategy
+typealias CorePluginSubsystemRegistry = ICorePluginSubsystemRegistry
+typealias CorePluginSubsystemResolver = ICorePluginSubsystemResolver
+typealias CorePluginSubsystemSelector = ICorePluginSubsystemSelector
+typealias CorePluginSubsystemFactory = ICorePluginSubsystemFactory
+typealias CorePluginSubsystemProvider = ICorePluginSubsystemProvider
diff --git a/src/main/kotlin/mindurka/coreplugin/database/DatabaseLifecycleProvider.kt b/src/main/kotlin/mindurka/coreplugin/database/DatabaseLifecycleProvider.kt
new file mode 100644
index 0000000..34eea77
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/database/DatabaseLifecycleProvider.kt
@@ -0,0 +1,9 @@
+package mindurka.coreplugin.database
+
+import mindustry.NiMetadata
+
+class DefaultDatabaseLifecycleProvider : IDatabaseLifecycleProvider {
+    override fun initialize() {
+        if (!NiMetadata.shortcircuit()) Database.load() else DatabaseScripts.noop()
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/database/IDatabaseLifecycleProvider.kt b/src/main/kotlin/mindurka/coreplugin/database/IDatabaseLifecycleProvider.kt
new file mode 100644
index 0000000..a06f3ab
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/database/IDatabaseLifecycleProvider.kt
@@ -0,0 +1,5 @@
+package mindurka.coreplugin.database
+
+interface IDatabaseLifecycleProvider {
+    fun initialize()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/extern/ExternalServerGateway.kt b/src/main/kotlin/mindurka/coreplugin/extern/ExternalServerGateway.kt
new file mode 100644
index 0000000..48b916e
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/extern/ExternalServerGateway.kt
@@ -0,0 +1,24 @@
+package mindurka.coreplugin.extern
+
+import mindurka.api.SpecialSettings
+import mindurka.coreplugin.CorePlugin
+import mindurka.coreplugin.hasMindurkaCompat
+import mindurka.coreplugin.sessionData
+import mindurka.util.Async
+import mindustry.game.Team
+import mindustry.gen.Player
+
+class DefaultExternalServerGateway : IExternalServerGateway {
+    override fun onDisconnected(player: Player) {
+        Async.run { player.sessionData.playerLeft(player) }
+    }
+
+    override fun hasMindurkaCompat(player: Player?): Boolean = player?.hasMindurkaCompat ?: false
+
+    override fun onMapLoad(): Boolean {
+        if (CorePlugin.restarting) CorePlugin.actuallyDoARestart()
+        return !CorePlugin.restarting
+    }
+
+    override fun countAlive(team: Team): Boolean = SpecialSettings.currentMap().teams[team].pvpTeamDeathRequired
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/extern/HeaderI.kt b/src/main/kotlin/mindurka/coreplugin/extern/HeaderI.kt
index 6e5776e..00b69ee 100644
--- a/src/main/kotlin/mindurka/coreplugin/extern/HeaderI.kt
+++ b/src/main/kotlin/mindurka/coreplugin/extern/HeaderI.kt
@@ -1,10 +1,5 @@
 package mindurka.coreplugin.extern
 
-import mindurka.api.SpecialSettings
-import mindurka.coreplugin.CorePlugin
-import mindurka.coreplugin.hasMindurkaCompat
-import mindurka.coreplugin.sessionData
-import mindurka.util.Async
 import mindustry.game.Team
 import mindustry.gen.Player
 
@@ -12,23 +7,16 @@ import mindustry.gen.Player
  * Frontend for custom Mindustry server to interact with CorePlugin.
  */
 object HeaderI: Header() {
+    private val gateway: IExternalServerGateway = DefaultExternalServerGateway()
     /** Return this object because apparently 'INSTANCE' doesn't work. */
     @JvmStatic
     fun self() = HeaderI
 
     override fun onDisconnected(player: Player) {
-        Async.run {
-            player.sessionData.playerLeft(player)
-        }
+        gateway.onDisconnected(player)
     }
 
-    override fun hasMindurkaCompat(player: Player?): Boolean = player?.hasMindurkaCompat ?: false
-    override fun onMapLoad(): Boolean {
-        if (CorePlugin.restarting) {
-            CorePlugin.actuallyDoARestart()
-        }
-        return !CorePlugin.restarting
-    }
-    override fun countAlive(team: Team): Boolean =
-        SpecialSettings.currentMap().teams[team].pvpTeamDeathRequired
-}
\ No newline at end of file
+    override fun hasMindurkaCompat(player: Player?): Boolean = gateway.hasMindurkaCompat(player)
+    override fun onMapLoad(): Boolean = gateway.onMapLoad()
+    override fun countAlive(team: Team): Boolean = gateway.countAlive(team)
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/extern/IExternalServerGateway.kt b/src/main/kotlin/mindurka/coreplugin/extern/IExternalServerGateway.kt
new file mode 100644
index 0000000..17de34a
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/extern/IExternalServerGateway.kt
@@ -0,0 +1,11 @@
+package mindurka.coreplugin.extern
+
+import mindustry.game.Team
+import mindustry.gen.Player
+
+interface IExternalServerGateway {
+    fun onDisconnected(player: Player)
+    fun hasMindurkaCompat(player: Player?): Boolean
+    fun onMapLoad(): Boolean
+    fun countAlive(team: Team): Boolean
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/factory/SubsystemAssembly.kt b/src/main/kotlin/mindurka/coreplugin/factory/SubsystemAssembly.kt
new file mode 100644
index 0000000..48559aa
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/factory/SubsystemAssembly.kt
@@ -0,0 +1,46 @@
+package mindurka.coreplugin.factory
+
+import mindurka.coreplugin.contracts.CorePluginSubsystemFactory
+import mindurka.coreplugin.contracts.CorePluginSubsystemProvider
+import mindurka.coreplugin.contracts.CorePluginSubsystemResolver
+import mindurka.coreplugin.contracts.CorePluginSubsystemSelector
+import mindurka.coreplugin.contracts.CorePluginSubsystemExecutionStrategy
+import mindurka.coreplugin.registry.DefaultCorePluginSubsystemRegistry
+import mindurka.coreplugin.strategy.SequentialCorePluginSubsystemExecutionStrategy
+
+class RegistryBackedCorePluginSubsystemResolver(
+    private val registry: DefaultCorePluginSubsystemRegistry,
+) : CorePluginSubsystemResolver {
+    override fun resolve() = registry.all()
+}
+
+class DefaultCorePluginSubsystemFactory(
+    private val strategy: CorePluginSubsystemExecutionStrategy,
+) : CorePluginSubsystemFactory {
+    override fun create(): CorePluginSubsystemExecutionStrategy = strategy
+}
+
+class DefaultCorePluginSubsystemProvider(
+    private val factory: CorePluginSubsystemFactory,
+) : CorePluginSubsystemProvider {
+    override fun provide(): CorePluginSubsystemFactory = factory
+}
+
+class DefaultCorePluginSubsystemSelector(
+    private val provider: CorePluginSubsystemProvider,
+) : CorePluginSubsystemSelector {
+    override fun select(): CorePluginSubsystemExecutionStrategy = provider.provide().create()
+}
+
+class CorePluginSubsystemAssembly(
+    val registry: DefaultCorePluginSubsystemRegistry = DefaultCorePluginSubsystemRegistry(),
+) {
+    private val resolver = RegistryBackedCorePluginSubsystemResolver(registry)
+    private val selector = DefaultCorePluginSubsystemSelector(
+        DefaultCorePluginSubsystemProvider(
+            DefaultCorePluginSubsystemFactory(SequentialCorePluginSubsystemExecutionStrategy())
+        )
+    )
+
+    fun execute() = selector.select().execute(resolver.resolve())
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/messages/IMessageTypeRegistry.kt b/src/main/kotlin/mindurka/coreplugin/messages/IMessageTypeRegistry.kt
new file mode 100644
index 0000000..3a0fa01
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/messages/IMessageTypeRegistry.kt
@@ -0,0 +1,9 @@
+package mindurka.coreplugin.messages
+
+import kotlin.reflect.KClass
+
+interface IMessageTypeRegistry {
+    fun register(type: KClass<*>)
+    fun contains(type: KClass<*>): Boolean
+    fun all(): List<KClass<*>>
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/messages/MessageTypeRegistry.kt b/src/main/kotlin/mindurka/coreplugin/messages/MessageTypeRegistry.kt
new file mode 100644
index 0000000..c81198f
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/messages/MessageTypeRegistry.kt
@@ -0,0 +1,21 @@
+package mindurka.coreplugin.messages
+
+import kotlin.reflect.KClass
+
+class DefaultMessageTypeRegistry : IMessageTypeRegistry {
+    private val types = LinkedHashSet<KClass<*>>()
+
+    override fun register(type: KClass<*>) { types.add(type) }
+    override fun contains(type: KClass<*>): Boolean = type in types
+    override fun all(): List<KClass<*>> = types.toList()
+}
+
+object CorePluginMessageCatalog {
+    val registry: IMessageTypeRegistry = DefaultMessageTypeRegistry().also {
+        it.register(ServerInfo::class)
+        it.register(ServerDown::class)
+        it.register(ServersRefresh::class)
+        it.register(BringPlayerBack::class)
+        it.register(AddFirewallBan::class)
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/pipeline/CorePluginInitializationPipelines.kt b/src/main/kotlin/mindurka/coreplugin/pipeline/CorePluginInitializationPipelines.kt
new file mode 100644
index 0000000..6351f07
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/pipeline/CorePluginInitializationPipelines.kt
@@ -0,0 +1,20 @@
+package mindurka.coreplugin.pipeline
+
+import mindurka.coreplugin.subsystems.CommandInitializationSubsystem
+import mindurka.coreplugin.subsystems.FeatureInitializationSubsystem
+import mindurka.coreplugin.subsystems.InfrastructureInitializationSubsystem
+
+class CommandInitializationPipeline(classLoader: ClassLoader) : CorePluginSubsystemPipeline() {
+    private val commandSubsystem = CommandInitializationSubsystem(classLoader)
+    override fun subsystems() = listOf(commandSubsystem)
+}
+
+class InfrastructureInitializationPipeline : CorePluginSubsystemPipeline() {
+    private val infrastructureSubsystem = InfrastructureInitializationSubsystem()
+    override fun subsystems() = listOf(infrastructureSubsystem)
+}
+
+class FeatureInitializationPipeline : CorePluginSubsystemPipeline() {
+    private val featureSubsystem = FeatureInitializationSubsystem()
+    override fun subsystems() = listOf(featureSubsystem)
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/pipeline/CorePluginSubsystemPipeline.kt b/src/main/kotlin/mindurka/coreplugin/pipeline/CorePluginSubsystemPipeline.kt
new file mode 100644
index 0000000..508b2dc
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/pipeline/CorePluginSubsystemPipeline.kt
@@ -0,0 +1,14 @@
+package mindurka.coreplugin.pipeline
+
+import mindurka.coreplugin.contracts.CorePluginSubsystem
+import mindurka.coreplugin.factory.CorePluginSubsystemAssembly
+
+abstract class CorePluginSubsystemPipeline {
+    protected abstract fun subsystems(): List<CorePluginSubsystem>
+
+    fun execute() {
+        val assembly = CorePluginSubsystemAssembly()
+        subsystems().forEach(assembly.registry::register)
+        assembly.execute()
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactory.kt b/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactory.kt
new file mode 100644
index 0000000..792bc57
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactory.kt
@@ -0,0 +1,7 @@
+package mindurka.coreplugin.protocol
+
+import mindurka.coreplugin.Protocol
+
+interface IProtocolFactory {
+    fun create(): Protocol
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactoryProvider.kt b/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactoryProvider.kt
new file mode 100644
index 0000000..5f6fa2a
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactoryProvider.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.protocol
+
+interface IProtocolFactoryProvider { fun provide(): IProtocolFactory }
diff --git a/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactorySelector.kt b/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactorySelector.kt
new file mode 100644
index 0000000..d17bfb8
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolFactorySelector.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.protocol
+
+interface IProtocolFactorySelector { fun select(): IProtocolFactoryProvider }
diff --git a/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolNetState.kt b/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolNetState.kt
new file mode 100644
index 0000000..b5c6c54
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/protocol/IProtocolNetState.kt
@@ -0,0 +1,3 @@
+package mindurka.coreplugin.protocol
+
+interface IProtocolNetState { val priority: Int }
diff --git a/src/main/kotlin/mindurka/coreplugin/protocol/ProtocolFactoryAssembly.kt b/src/main/kotlin/mindurka/coreplugin/protocol/ProtocolFactoryAssembly.kt
new file mode 100644
index 0000000..910378c
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/protocol/ProtocolFactoryAssembly.kt
@@ -0,0 +1,22 @@
+package mindurka.coreplugin.protocol
+
+import mindurka.coreplugin.Protocol
+
+class DefaultProtocolFactory : IProtocolFactory {
+    override fun create(): Protocol = Protocol()
+}
+
+class DefaultProtocolFactoryProvider : IProtocolFactoryProvider {
+    override fun provide(): IProtocolFactory = DefaultProtocolFactory()
+}
+
+class DefaultProtocolFactorySelector(
+    private val provider: IProtocolFactoryProvider = DefaultProtocolFactoryProvider(),
+) : IProtocolFactorySelector {
+    override fun select(): IProtocolFactoryProvider = provider
+}
+
+class ProtocolRuntimeAssembly {
+    private val selector: IProtocolFactorySelector = DefaultProtocolFactorySelector()
+    fun create(): Protocol = selector.select().provide().create()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/recording/IRecordingLifecycle.kt b/src/main/kotlin/mindurka/coreplugin/recording/IRecordingLifecycle.kt
new file mode 100644
index 0000000..240f51e
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/recording/IRecordingLifecycle.kt
@@ -0,0 +1,5 @@
+package mindurka.coreplugin.recording
+
+interface IRecordingLifecycle {
+    fun initialize()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/recording/Mod.kt b/src/main/kotlin/mindurka/coreplugin/recording/Mod.kt
index fa0fa9a..6834319 100644
--- a/src/main/kotlin/mindurka/coreplugin/recording/Mod.kt
+++ b/src/main/kotlin/mindurka/coreplugin/recording/Mod.kt
@@ -1,4 +1,7 @@
 package mindurka.coreplugin.recording
 
+private val recordingLifecycle: IRecordingLifecycle = DefaultRecordingLifecycleCoordinator()
+
 fun initRecording() {
-}
\ No newline at end of file
+    recordingLifecycle.initialize()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/recording/RecordingLifecycleCoordinator.kt b/src/main/kotlin/mindurka/coreplugin/recording/RecordingLifecycleCoordinator.kt
new file mode 100644
index 0000000..1d6a856
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/recording/RecordingLifecycleCoordinator.kt
@@ -0,0 +1,7 @@
+package mindurka.coreplugin.recording
+
+class DefaultRecordingLifecycleCoordinator : IRecordingLifecycle {
+    override fun initialize() {
+        // Reserved lifecycle boundary for recorder backends and format negotiation.
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/registry/EnterpriseRegistry.kt b/src/main/kotlin/mindurka/coreplugin/registry/EnterpriseRegistry.kt
new file mode 100644
index 0000000..cff9535
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/registry/EnterpriseRegistry.kt
@@ -0,0 +1,25 @@
+package mindurka.coreplugin.registry
+
+import mindurka.coreplugin.contracts.ComponentRegistry
+import mindurka.coreplugin.contracts.ComponentResolver
+import kotlin.reflect.KClass
+
+class DefaultComponentRegistry : ComponentRegistry {
+    private val components = LinkedHashMap<KClass<*>, Any>()
+
+    override fun <T : Any> register(type: KClass<T>, component: T) {
+        components[type] = component
+    }
+
+    override fun <T : Any> lookup(type: KClass<T>): T? {
+        @Suppress("UNCHECKED_CAST")
+        return components[type] as T?
+    }
+}
+
+class RegistryBackedComponentResolver(
+    private val registry: ComponentRegistry,
+) : ComponentResolver {
+    override fun <T : Any> resolve(type: KClass<T>): T = registry.lookup(type)
+        ?: error("Enterprise component is not registered: ${type.qualifiedName}")
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/registry/SubsystemRegistry.kt b/src/main/kotlin/mindurka/coreplugin/registry/SubsystemRegistry.kt
new file mode 100644
index 0000000..35f5f75
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/registry/SubsystemRegistry.kt
@@ -0,0 +1,16 @@
+package mindurka.coreplugin.registry
+
+import mindurka.coreplugin.contracts.CorePluginSubsystem
+import mindurka.coreplugin.contracts.CorePluginSubsystemRegistry
+
+class DefaultCorePluginSubsystemRegistry : CorePluginSubsystemRegistry {
+    private val subsystems = LinkedHashMap<String, CorePluginSubsystem>()
+
+    override fun register(subsystem: CorePluginSubsystem) {
+        check(subsystems.put(subsystem.id, subsystem) == null) {
+            "CorePlugin subsystem '${subsystem.id}' is already registered"
+        }
+    }
+
+    override fun all(): List<CorePluginSubsystem> = subsystems.values.toList()
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/strategy/SubsystemExecutionStrategy.kt b/src/main/kotlin/mindurka/coreplugin/strategy/SubsystemExecutionStrategy.kt
new file mode 100644
index 0000000..aa423eb
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/strategy/SubsystemExecutionStrategy.kt
@@ -0,0 +1,16 @@
+package mindurka.coreplugin.strategy
+
+import mindurka.coreplugin.contracts.CorePluginSubsystem
+import mindurka.coreplugin.contracts.CorePluginSubsystemExecutionStrategy
+
+class SequentialCorePluginSubsystemExecutionStrategy : CorePluginSubsystemExecutionStrategy {
+    override fun execute(subsystems: List<CorePluginSubsystem>) {
+        subsystems.forEach { subsystem ->
+            try {
+                subsystem.initialize()
+            } catch (failure: Throwable) {
+                throw IllegalStateException("Subsystem '${subsystem.id}' failed to initialize", failure)
+            }
+        }
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/subsystems/CommandInitializationSubsystem.kt b/src/main/kotlin/mindurka/coreplugin/subsystems/CommandInitializationSubsystem.kt
new file mode 100644
index 0000000..436bdcf
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/subsystems/CommandInitializationSubsystem.kt
@@ -0,0 +1,26 @@
+package mindurka.coreplugin.subsystems
+
+import buj.tl.Tl
+import mindurka.build.CommandImpl
+import mindurka.coreplugin.commands.registerCommand
+import mindurka.coreplugin.contracts.CorePluginSubsystem
+
+class CommandInitializationSubsystem(
+    private val classLoader: ClassLoader,
+) : CorePluginSubsystem {
+    override val id: String = "command-and-localization-initialization"
+
+    override fun initialize() {
+        Tl.init(classLoader)
+        (classLoader.getResourceAsStream("META-INF/mindurka.coreplugin.commands")
+            ?.readAllBytes()?.toString(Charsets.UTF_8) ?: "")
+            .lineSequence()
+            .map(String::trim)
+            .filter(String::isNotEmpty)
+            .forEach { className ->
+                @Suppress("UNCHECKED_CAST")
+                val commandClass = classLoader.loadClass(className) as Class<CommandImpl>
+                registerCommand(commandClass.constructors.first().newInstance() as CommandImpl)
+            }
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/subsystems/FeatureInitializationSubsystem.kt b/src/main/kotlin/mindurka/coreplugin/subsystems/FeatureInitializationSubsystem.kt
new file mode 100644
index 0000000..1d8f223
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/subsystems/FeatureInitializationSubsystem.kt
@@ -0,0 +1,25 @@
+package mindurka.coreplugin.subsystems
+
+import mindurka.coreplugin.contracts.CorePluginSubsystem
+import mindurka.coreplugin.messages.CorePluginMessageCatalog
+import mindurka.coreplugin.initChat
+import mindurka.coreplugin.initModActions
+import mindurka.coreplugin.initSchemeSize
+import mindurka.coreplugin.initTeams
+import mindurka.coreplugin.DefaultChatInitializationCoordinator
+import mindurka.coreplugin.DefaultHubDiscoveryGateway
+import mindurka.coreplugin.recording.initRecording
+
+class FeatureInitializationSubsystem : CorePluginSubsystem {
+    override val id: String = "gameplay-feature-registration"
+
+    override fun initialize() {
+        CorePluginMessageCatalog.registry.all()
+        initModActions()
+        DefaultChatInitializationCoordinator().initialize()
+        DefaultHubDiscoveryGateway().initialize()
+        initSchemeSize()
+        initTeams()
+        initRecording()
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/subsystems/InfrastructureInitializationSubsystem.kt b/src/main/kotlin/mindurka/coreplugin/subsystems/InfrastructureInitializationSubsystem.kt
new file mode 100644
index 0000000..aef03a8
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/subsystems/InfrastructureInitializationSubsystem.kt
@@ -0,0 +1,22 @@
+package mindurka.coreplugin.subsystems
+
+import mindustry.MdUtil
+import mindustry.NiMetadata
+import mindurka.coreplugin.Overrides
+import mindurka.coreplugin.RabbitMQ
+import mindurka.coreplugin.database.Database
+import mindurka.coreplugin.database.DefaultDatabaseLifecycleProvider
+import mindurka.coreplugin.contracts.CorePluginSubsystem
+import mindurka.coreplugin.nativeimage.nativeImageHeatUp
+
+class InfrastructureInitializationSubsystem : CorePluginSubsystem {
+    override val id: String = "infrastructure-and-native-runtime-initialization"
+
+    override fun initialize() {
+        MdUtil.init()
+        DefaultDatabaseLifecycleProvider().initialize()
+        Overrides.load()
+        if (!NiMetadata.shortcircuit()) DefaultRabbitMqLifecycle().initialize()
+        if (NiMetadata.shortcircuit()) nativeImageHeatUp()
+    }
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/votes/IVoteResolutionPolicy.kt b/src/main/kotlin/mindurka/coreplugin/votes/IVoteResolutionPolicy.kt
new file mode 100644
index 0000000..9e65bd0
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/votes/IVoteResolutionPolicy.kt
@@ -0,0 +1,5 @@
+package mindurka.coreplugin.votes
+
+interface IVoteResolutionPolicy {
+    fun requiredVotes(eligiblePlayers: Int): Int
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/votes/Vote.kt b/src/main/kotlin/mindurka/coreplugin/votes/Vote.kt
index 1279c16..01b63fc 100644
--- a/src/main/kotlin/mindurka/coreplugin/votes/Vote.kt
+++ b/src/main/kotlin/mindurka/coreplugin/votes/Vote.kt
@@ -84,7 +84,7 @@ abstract class Vote(val initiator: Player, val team: Team?) {
         if (finished) return
 
         val selector = Boolf<Player> { filter(it) && if (team == null) (!it.team().isServiceTeam || votesFor.contains(it) || votesAgainst.contains(it)) else it.team() == team }
-        totalPlayers = Groups.player.count(selector) / 2 + 1
+        totalPlayers = VoteResolutionPolicies.default.requiredVotes(Groups.player.count(selector))
         votesForNumber = votesFor.count(selector) - votesAgainst.count(selector)
 
         if (votesForNumber >= totalPlayers) {
@@ -108,4 +108,4 @@ abstract class Vote(val initiator: Player, val team: Team?) {
     abstract fun commit(send: SendMessage)
     abstract fun voted(send: SendMessage, player: Player, fo: Boolean)
     abstract val cancelsIfRoundChanged: Boolean
-}
\ No newline at end of file
+}
diff --git a/src/main/kotlin/mindurka/coreplugin/votes/VoteResolutionPolicy.kt b/src/main/kotlin/mindurka/coreplugin/votes/VoteResolutionPolicy.kt
new file mode 100644
index 0000000..f8b6bca
--- /dev/null
+++ b/src/main/kotlin/mindurka/coreplugin/votes/VoteResolutionPolicy.kt
@@ -0,0 +1,10 @@
+package mindurka.coreplugin.votes
+
+object DefaultVoteResolutionPolicy : IVoteResolutionPolicy {
+    override fun requiredVotes(eligiblePlayers: Int): Int = eligiblePlayers / 2 + 1
+}
+
+object VoteResolutionPolicies {
+    @JvmField
+    val default: IVoteResolutionPolicy = DefaultVoteResolutionPolicy
+}
diff --git a/src/main/kotlin/mindurka/di/DependencyInjection.kt b/src/main/kotlin/mindurka/di/DependencyInjection.kt
new file mode 100644
index 0000000..7b60918
--- /dev/null
+++ b/src/main/kotlin/mindurka/di/DependencyInjection.kt
@@ -0,0 +1,40 @@
+package mindurka.di
+
+import kotlin.reflect.KClass
+
+enum class DependencyScope {
+    SINGLETON,
+    TRANSIENT,
+}
+
+private data class DependencyDefinition<T : Any>(
+    val scope: DependencyScope,
+    val factory: () -> T,
+    var singleton: T? = null,
+)
+
+class EnterpriseDependencyInjectionContainer {
+    private val definitions = LinkedHashMap<KClass<*>, DependencyDefinition<*>>()
+
+    fun <T : Any> register(
+        type: KClass<T>,
+        scope: DependencyScope = DependencyScope.SINGLETON,
+        factory: () -> T,
+    ) {
+        definitions[type] = DependencyDefinition(scope, factory)
+    }
+
+    fun <T : Any> resolve(type: KClass<T>): T {
+        @Suppress("UNCHECKED_CAST")
+        val definition = definitions[type] as? DependencyDefinition<T>
+            ?: error("No registered dependency for ${type.qualifiedName}")
+
+        if (definition.scope == DependencyScope.SINGLETON) {
+            definition.singleton?.let { return it }
+            return definition.factory().also { definition.singleton = it }
+        }
+        return definition.factory()
+    }
+
+    inline fun <reified T : Any> resolve(): T = resolve(T::class)
+}
diff --git a/src/main/kotlin/mindurka/ui/DialogRegistry.kt b/src/main/kotlin/mindurka/ui/DialogRegistry.kt
new file mode 100644
index 0000000..3e9190c
--- /dev/null
+++ b/src/main/kotlin/mindurka/ui/DialogRegistry.kt
@@ -0,0 +1,12 @@
+package mindurka.ui
+
+import mindustry.gen.Player
+import java.util.WeakHashMap
+
+class DefaultDialogRegistry : IDialogRegistry {
+    private val states = WeakHashMap<Player, OpenDialogs>()
+    override fun state(player: Player): OpenDialogs? = states[player]
+    override fun create(player: Player): OpenDialogs = states.getOrPut(player) { OpenDialogs() }
+    override fun open(player: Player, dialog: Dialog) { create(player).openedDialogs.addUnique(dialog) }
+    override fun close(player: Player, dialog: Dialog) { create(player).openedDialogs.removeAll { it == dialog } }
+}
diff --git a/src/main/kotlin/mindurka/ui/IDialog.kt b/src/main/kotlin/mindurka/ui/IDialog.kt
new file mode 100644
index 0000000..62d5d99
--- /dev/null
+++ b/src/main/kotlin/mindurka/ui/IDialog.kt
@@ -0,0 +1,3 @@
+package mindurka.ui
+
+interface IDialog
diff --git a/src/main/kotlin/mindurka/ui/IDialogRegistry.kt b/src/main/kotlin/mindurka/ui/IDialogRegistry.kt
new file mode 100644
index 0000000..5979790
--- /dev/null
+++ b/src/main/kotlin/mindurka/ui/IDialogRegistry.kt
@@ -0,0 +1,10 @@
+package mindurka.ui
+
+import mindustry.gen.Player
+
+interface IDialogRegistry {
+    fun state(player: Player): OpenDialogs?
+    fun create(player: Player): OpenDialogs
+    fun open(player: Player, dialog: Dialog)
+    fun close(player: Player, dialog: Dialog)
+}
diff --git a/src/main/kotlin/mindurka/ui/Ui.kt b/src/main/kotlin/mindurka/ui/Ui.kt
index 969afbd..254326d 100644
--- a/src/main/kotlin/mindurka/ui/Ui.kt
+++ b/src/main/kotlin/mindurka/ui/Ui.kt
@@ -2,7 +2,6 @@ package mindurka.ui
 
 import mindurka.annotations.PublicAPI
 import mindustry.gen.Player
-import java.util.WeakHashMap
 import arc.func.Cons
 import mindustry.game.EventType.MenuOptionChooseEvent
 import java.util.concurrent.CompletableFuture
@@ -27,29 +26,27 @@ const val TIMER_CLOSE_TIME = 0.031f
 
 @UiInternals
 object DialogsInternal {
-    val data = WeakHashMap<Player, OpenDialogs>()
+    private val registry: IDialogRegistry = DefaultDialogRegistry()
 
     fun newId(player: Player): Int {
-        val dialogs = data.getOrPut(player) { OpenDialogs() }
+        val dialogs = registry.create(player)
         val id = dialogs.id
         dialogs.id = id + 1
         return id
     }
 
     fun openDialog(player: Player, dialog: Dialog) {
-        val dialogs = data.getOrPut(player) { OpenDialogs() }
-        dialogs.openedDialogs.addUnique(dialog)
+        registry.open(player, dialog)
     }
 
     fun closeDialog(player: Player, dialog: Dialog) {
-        val dialogs = data.getOrPut(player) { OpenDialogs() }
-        dialogs.openedDialogs.removeAll { it == dialog }
+        registry.close(player, dialog)
     }
 
-    operator fun get(player: Player) = data[player]
+    operator fun get(player: Player) = registry.state(player)
 }
 
-interface Dialog {}
+typealias Dialog = IDialog
 
 @UiInternals
 data class OpenDialogs (
diff --git a/src/main/kotlin/mindurka/util/IRead.kt b/src/main/kotlin/mindurka/util/IRead.kt
new file mode 100644
index 0000000..400cca4
--- /dev/null
+++ b/src/main/kotlin/mindurka/util/IRead.kt
@@ -0,0 +1,9 @@
+package mindurka.util
+
+interface IRead<E : Exception> {
+    fun i(): Int
+    fun l(): Long
+    fun f(): Float
+    fun sym(): String?
+    fun nil(): Boolean
+}
diff --git a/src/main/kotlin/mindurka/util/ISendMessage.kt b/src/main/kotlin/mindurka/util/ISendMessage.kt
new file mode 100644
index 0000000..14ed72c
--- /dev/null
+++ b/src/main/kotlin/mindurka/util/ISendMessage.kt
@@ -0,0 +1,45 @@
+package mindurka.util
+
+import buj.tl.LCtx
+import buj.tl.LVoidDone
+import buj.tl.Lc
+import buj.tl.Script
+import buj.tl.Tl
+import mindustry.game.Team
+import mindustry.gen.Groups
+import mindustry.gen.Player
+
+interface ISendMessage {
+    object All : ISendMessage {
+        override fun send(): LVoidDone<*> = Tl.broadcast()
+    }
+
+    data class One(val player: Player) : ISendMessage {
+        override fun send(): LVoidDone<*> = Tl.send(player)
+    }
+
+    data class Multi(val team: Team) : ISendMessage {
+        override fun send(): LVoidDone<*> {
+            class EnterpriseMessageSender : LVoidDone<EnterpriseMessageSender> {
+                val context = LCtx()
+
+                override fun put(key: String, text: String): EnterpriseMessageSender {
+                    context.put(key, text)
+                    return this
+                }
+
+                override fun put(key: String, value: Script): EnterpriseMessageSender {
+                    context.put(key, value)
+                    return this
+                }
+
+                override fun done(key: String) {
+                    Groups.player.each({ it.team() == team }) { Lc(it, context).done(key) }
+                }
+            }
+            return EnterpriseMessageSender()
+        }
+    }
+
+    fun send(): LVoidDone<*>
+}
diff --git a/src/main/kotlin/mindurka/util/IWrite.kt b/src/main/kotlin/mindurka/util/IWrite.kt
new file mode 100644
index 0000000..07eaff9
--- /dev/null
+++ b/src/main/kotlin/mindurka/util/IWrite.kt
@@ -0,0 +1,9 @@
+package mindurka.util
+
+interface IWrite<E : Exception?> {
+    fun i(value: Int)
+    fun l(value: Long)
+    fun f(value: Float)
+    fun sym(value: String?)
+    fun nil()
+}
diff --git a/src/main/kotlin/mindurka/util/Read.kt b/src/main/kotlin/mindurka/util/Read.kt
index de673b7..aa33ce6 100644
--- a/src/main/kotlin/mindurka/util/Read.kt
+++ b/src/main/kotlin/mindurka/util/Read.kt
@@ -1,9 +1,3 @@
 package mindurka.util
 
-interface Read<E : Exception> {
-    fun i(): Int
-    fun l(): Long
-    fun f(): Float
-    fun sym(): String?
-    fun nil(): Boolean
-}
+typealias Read<E> = IRead<E>
diff --git a/src/main/kotlin/mindurka/util/SendMessage.kt b/src/main/kotlin/mindurka/util/SendMessage.kt
index aa2bc05..315b314 100644
--- a/src/main/kotlin/mindurka/util/SendMessage.kt
+++ b/src/main/kotlin/mindurka/util/SendMessage.kt
@@ -9,35 +9,4 @@ import mindustry.game.Team
 import mindustry.gen.Groups
 import mindustry.gen.Player
 
-interface SendMessage {
-    object All: SendMessage {
-        override fun send(): LVoidDone<*> = Tl.broadcast()
-    }
-    data class One(val player: Player): SendMessage {
-        override fun send(): LVoidDone<*> = Tl.send(player)
-    }
-    data class Multi(val team: Team): SendMessage {
-        override fun send(): LVoidDone<*> {
-            class O: LVoidDone<O> {
-                val ctx = LCtx()
-
-                override fun put(key: String, text: String): O {
-                    ctx.put(key, text)
-                    return this
-                }
-
-                override fun put(key: String, value: Script): O {
-                    ctx.put(key, value)
-                    return this
-                }
-
-                override fun done(key: String) {
-                    Groups.player.each({ it.team() == team }) { Lc(it, ctx).done(key) }
-                }
-            }
-            return O()
-        }
-    }
-
-    fun send(): LVoidDone<*>
-}
\ No newline at end of file
+typealias SendMessage = ISendMessage
diff --git a/src/main/kotlin/mindurka/util/Write.kt b/src/main/kotlin/mindurka/util/Write.kt
index c8b0c2a..a35c5a1 100644
--- a/src/main/kotlin/mindurka/util/Write.kt
+++ b/src/main/kotlin/mindurka/util/Write.kt
@@ -1,9 +1,3 @@
 package mindurka.util
 
-interface Write<E : Exception?> {
-    fun i(value: Int)
-    fun l(value: Long)
-    fun f(value: Float)
-    fun sym(value: String?)
-    fun nil()
-}
+typealias Write<E> = IWrite<E>