Merge branch 'v1-rewrite'

120 files changed, 5172 insertions, 2428 deletions

diff --git a/.gitignore b/.gitignore
index 2c770e0..ad6da4d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,3 +20,4 @@ build
 # other
 eclipse
 run
+srcOld
diff --git a/build.gradle b/build.gradle
index 7f7f191..aec5b5f 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,43 +1,74 @@
 plugins {
-    id 'fabric-loom' version '0.10-SNAPSHOT'
+    id 'fabric-loom' version '0.11-SNAPSHOT' apply false
+    id 'io.shcm.shsupercm.fabric.fletchingtable' version '1.4' apply false
 }
 
 version = project.mod_version + "+" + project.minecraft_version
 group = project.maven_group
 
-repositories {
-    maven { url "https://maven.shedaniel.me/" }
-    maven { url "https://maven.terraformersmc.com/releases" }
-    maven { url "https://cursemaven.com" }
-}
+allprojects {
+    apply plugin: "fabric-loom"
+    apply plugin: "io.shcm.shsupercm.fabric.fletchingtable"
 
-dependencies {
-    // To change the versions see the gradle.properties file
-    minecraft "com.mojang:minecraft:${project.minecraft_version}"
-    mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
-    modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
+    repositories {
+        maven { url "https://maven.shedaniel.me/" }
+        maven { url "https://maven.terraformersmc.com/releases" }
+        maven { url "https://cursemaven.com" }
+    }
+
+    dependencies {
+        minecraft "com.mojang:minecraft:${project.minecraft_version}"
+        mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
+        modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
+
+        modImplementation fabricApi.module("fabric-api-base", "${project.fabric_api}")
+        modImplementation fabricApi.module("fabric-resource-loader-v0", "${project.fabric_api}")
+        modImplementation fabricApi.module("fabric-command-api-v1", "${project.fabric_api}")
 
-    modImplementation fabricApi.module("fabric-api-base", "${project.fabric_api}")
-    modImplementation fabricApi.module("fabric-resource-loader-v0", "${project.fabric_api}")
-    modImplementation fabricApi.module("fabric-command-api-v1", "${project.fabric_api}")
+        modCompileOnly("com.terraformersmc:modmenu:${project.modmenu}") {
+            exclude(group: "net.fabricmc.fabric-api")
+        }
 
-    modCompileOnly("com.terraformersmc:modmenu:${project.modmenu}") {
-        exclude(group: "net.fabricmc.fabric-api")
+        modCompileOnly("me.shedaniel.cloth:cloth-config-fabric:${project.cloth}") {
+            exclude(group: "net.fabricmc.fabric-api")
+        }
+
+        //modCompileOnly("curse.maven:cosmeticarmor-436659:${project.cosmetic_armor}")
+
+
+        //fletchingTable.shutUpDrasil18()
     }
 
-    modCompileOnly("me.shedaniel.cloth:cloth-config-fabric:${project.cloth}") {
-        exclude(group: "net.fabricmc.fabric-api")
+    fletchingTable {
+        defaultMixinEnvironment = "auto"
     }
 
-    modCompileOnly("curse.maven:cosmeticarmor-436659:${project.cosmetic_armor}")
-}
+    processResources {
+        inputs.property "version", rootProject.version
+        filteringCharset "UTF-8"
+
+        filesMatching("fabric.mod.json") {
+            expand "version": rootProject.version
+        }
+    }
+
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+
+    java {
+        archivesBaseName = project.archives_base_name
+    }
+
+    jar {
+        archiveClassifier.set "dev"
 
-processResources {
-    inputs.property "version", project.version
-    filteringCharset "UTF-8"
+        from("LICENSE") {
+            rename { "${it}_${project.archivesBaseName}" }
+        }
+    }
 
-    filesMatching("fabric.mod.json") {
-        expand "version": project.version
+    loom {
+        shareCaches()
     }
 }
 
@@ -45,19 +76,16 @@ loom {
     accessWidenerPath = file("src/main/resources/citresewn.accesswidener")
 }
 
-sourceCompatibility = JavaVersion.VERSION_17
-targetCompatibility = JavaVersion.VERSION_17
+dependencies {
+    afterEvaluate {
+        include project("defaults:")
+    }
+}
 
 java {
-    archivesBaseName = project.archives_base_name
-    // Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
-    // if it is present.
-    // If you remove this line, sources will not be generated.
     withSourcesJar()
 }
 
-jar {
-    from("LICENSE") {
-        rename { "${it}_${project.archivesBaseName}" }
-    }
+sourcesJar {
+    from project("defaults:").sourceSets.main.java.srcDirs
 }
\ No newline at end of file
diff --git a/defaults/build.gradle b/defaults/build.gradle
new file mode 100644
index 0000000..2e88283
--- /dev/null
+++ b/defaults/build.gradle
@@ -0,0 +1,13 @@
+archivesBaseName = "citresewn-defaults"
+
+dependencies {
+	implementation project(path: ":", configuration: "namedElements")
+}
+
+loom {
+	accessWidenerPath = file("src/main/resources/citresewn-defaults.accesswidener")
+
+	runConfigs.configureEach {
+		ideConfigGenerated = true
+	}
+}
\ No newline at end of file
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionDamage.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionDamage.java
new file mode 100644
index 0000000..c5c31f9
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionDamage.java
@@ -0,0 +1,46 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.IntegerCondition;
+
+import java.util.Set;
+
+public class ConditionDamage extends IntegerCondition {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<ConditionDamage> CONTAINER = new CITConditionContainer<>(ConditionDamage.class, ConditionDamage::new,
+            "damage");
+
+    protected Integer mask = null;
+
+    public ConditionDamage() {
+        super(true, false, true);
+    }
+
+    @Override
+    protected int getValue(CITContext context) {
+        int value = context.stack.isDamageable() ? context.stack.getDamage() : 0;
+        if (mask != null)
+            value &= mask;
+        return value;
+    }
+
+    @Override
+    protected int getPercentageTotalValue(CITContext context) {
+        return context.stack.isDamageable() ? context.stack.getItem().getMaxDamage() : 0;
+    }
+
+    @Override
+    public Set<Class<? extends CITCondition>> siblingConditions() {
+        return Set.of(ConditionDamageMask.class);
+    }
+
+    @Override
+    public <T extends CITCondition> T modifySibling(T sibling) {
+        if (sibling instanceof ConditionDamageMask damageMask)
+            this.mask = damageMask.getMask();
+        return null;
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionDamageMask.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionDamageMask.java
new file mode 100644
index 0000000..6adde08
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionDamageMask.java
@@ -0,0 +1,38 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.IntegerCondition;
+
+import java.util.Set;
+
+public class ConditionDamageMask extends IntegerCondition {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<ConditionDamageMask> CONTAINER = new CITConditionContainer<>(ConditionDamageMask.class, ConditionDamageMask::new,
+            "damage_mask", "damageMask");
+
+    public ConditionDamageMask() {
+        super(false, false, false);
+    }
+
+    @Override
+    protected int getValue(CITContext context) {
+        return 0;
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        return true;
+    }
+
+    public int getMask() {
+        return this.min;
+    }
+
+    @Override
+    public Set<Class<? extends CITCondition>> siblingConditions() {
+        return Set.of(ConditionDamage.class);
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionEnchantmentLevels.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionEnchantmentLevels.java
new file mode 100644
index 0000000..da6b4f4
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionEnchantmentLevels.java
@@ -0,0 +1,62 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import net.minecraft.util.Identifier;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.IntegerCondition;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.ListCondition;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class ConditionEnchantmentLevels extends ListCondition<ConditionEnchantmentLevels.EnchantmentLevelCondition> {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<ConditionEnchantmentLevels> CONTAINER = new CITConditionContainer<>(ConditionEnchantmentLevels.class, ConditionEnchantmentLevels::new,
+            "enchantment_levels", "enchantmentLevels");
+
+    protected Set<Identifier> enchantments = null;
+
+    public ConditionEnchantmentLevels() {
+        super(EnchantmentLevelCondition.class, EnchantmentLevelCondition::new);
+    }
+
+    @Override
+    public Set<Class<? extends CITCondition>> siblingConditions() {
+        return Set.of(ConditionEnchantments.class);
+    }
+
+    @Override
+    public <T extends CITCondition> T modifySibling(T sibling) {
+        if (sibling instanceof ConditionEnchantments conditionEnchantments) {
+            if (enchantments == null) {
+                enchantments = new HashSet<>();
+                for (EnchantmentLevelCondition subCondition : this.conditions)
+                    subCondition.enchantments = enchantments;
+            }
+            enchantments.addAll(Arrays.asList(conditionEnchantments.getEnchantments()));
+        }
+
+        return sibling;
+    }
+
+    protected static class EnchantmentLevelCondition extends IntegerCondition {
+        protected Set<Identifier> enchantments = null;
+
+        protected EnchantmentLevelCondition() {
+            super(true, false, false);
+        }
+
+        @Override
+        public boolean test(CITContext context) {
+            for (Map.Entry<Identifier, Integer> entry : context.enchantments().entrySet())
+                if ((enchantments == null || enchantments.contains(entry.getKey())) && entry.getValue() != null && (range ? min <= entry.getValue() && entry.getValue() <= max : entry.getValue() == min))
+                    return true;
+
+            return false;
+        }
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionEnchantments.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionEnchantments.java
new file mode 100644
index 0000000..301f9c1
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionEnchantments.java
@@ -0,0 +1,59 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.Registry;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.IdentifierCondition;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.ListCondition;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.util.Set;
+
+public class ConditionEnchantments extends ListCondition<ConditionEnchantments.EnchantmentCondition> {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<ConditionEnchantments> CONTAINER = new CITConditionContainer<>(ConditionEnchantments.class, ConditionEnchantments::new,
+            "enchantments", "enchantmentIDs");
+
+    public ConditionEnchantments() {
+        super(EnchantmentCondition.class, EnchantmentCondition::new);
+    }
+
+    public Identifier[] getEnchantments() {
+        Identifier[] enchantments = new Identifier[this.conditions.length];
+
+        for (int i = 0; i < this.conditions.length; i++)
+            enchantments[i] = this.conditions[i].getValue(null);
+
+        return enchantments;
+    }
+
+    @Override
+    public Set<Class<? extends CITCondition>> siblingConditions() {
+        return Set.of(ConditionEnchantmentLevels.class);
+    }
+
+    protected static class EnchantmentCondition extends IdentifierCondition {
+        @Override
+        public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+            super.load(value, properties);
+
+            if (!Registry.ENCHANTMENT.containsId(this.value))
+                warn(this.value + " is not in the enchantment registry", value, properties);
+        }
+
+        @Override
+        public boolean test(CITContext context) {
+            return context.enchantments().containsKey(this.value);
+        }
+
+        @Override
+        protected Identifier getValue(CITContext context) {
+            return this.value;
+        }
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionHand.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionHand.java
new file mode 100644
index 0000000..0405cbc
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionHand.java
@@ -0,0 +1,49 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.EnumCondition;
+
+public class ConditionHand extends EnumCondition<ConditionHand.Hand> {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<ConditionHand> CONTAINER = new CITConditionContainer<>(ConditionHand.class, ConditionHand::new,
+            "hand");
+
+    public ConditionHand() {
+        super(ConditionHand.Hand::values);
+    }
+
+    @Override
+    protected Hand getValue(CITContext context) {
+        if (context.entity.getMainHandStack() == context.stack)
+            return Hand.MAINHAND;
+        if (context.entity.getOffHandStack() == context.stack)
+            return Hand.OFFHAND;
+
+        return null;
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        Hand hand = getValue(context);
+        return this.value == hand || (this.value == Hand.ANY && hand != null);
+    }
+
+    protected enum Hand implements EnumCondition.Aliased {
+        MAINHAND("main", "mainhand", "main_hand"),
+        OFFHAND("off", "offhand", "off_hand"),
+        ANY("any", "either", "*");
+
+        private final String[] aliases;
+
+        Hand(String... aliases) {
+            this.aliases = aliases;
+        }
+
+        @Override
+        public String[] getAliases() {
+            return this.aliases;
+        }
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionItems.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionItems.java
new file mode 100644
index 0000000..117aa47
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionItems.java
@@ -0,0 +1,75 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import net.minecraft.item.Item;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.Registry;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.IdentifierCondition;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.ListCondition;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public class ConditionItems extends ListCondition<ConditionItems.ItemCondition> {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<ConditionItems> CONTAINER = new CITConditionContainer<>(ConditionItems.class, ConditionItems::new,
+            "items", "matchItems");
+
+    public Item[] items = new Item[0];
+
+    public ConditionItems() {
+        super(ItemCondition.class, ItemCondition::new);
+    }
+
+    public ConditionItems(Item... items) {
+        this();
+        this.items = items;
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        super.load(value, properties);
+
+        Set<Item> items = new LinkedHashSet<>();
+
+        for (ItemCondition itemCondition : this.conditions)
+            items.add(itemCondition.item);
+
+        this.items = items.toArray(new Item[0]);
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        for (Item item : this.items)
+            if (context.stack.getItem() == item)
+                return true;
+
+        return false;
+    }
+
+    protected static class ItemCondition extends IdentifierCondition {
+        public Item item = null;
+
+        @Override
+        public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+            super.load(value, properties);
+
+            if (Registry.ITEM.containsId(this.value))
+                this.item = Registry.ITEM.get(this.value);
+            else {
+                this.item = null;
+                warn(this.value + " is not in the item registry", value, properties);
+            }
+        }
+
+        @Override
+        protected Identifier getValue(CITContext context) {
+            return this.value;
+        }
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionNBT.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionNBT.java
new file mode 100644
index 0000000..09ae08e
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionNBT.java
@@ -0,0 +1,244 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import net.minecraft.nbt.*;
+import net.minecraft.text.Text;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.util.Locale;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+public class ConditionNBT extends CITCondition {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<ConditionNBT> CONTAINER = new CITConditionContainer<>(ConditionNBT.class, ConditionNBT::new,
+            "nbt");
+
+    protected String[] path;
+
+    protected StringMatcher matchString = null;
+    protected NbtInt matchInteger = null;
+    protected NbtByte matchByte = null;
+    protected NbtFloat matchFloat = null;
+    protected NbtDouble matchDouble = null;
+    protected NbtLong matchLong = null;
+    protected NbtShort matchShort = null;
+    protected NbtCompound matchCompound = null;
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        if (value.keyMetadata() == null || value.keyMetadata().isEmpty())
+            throw new CITParsingException("Missing nbt path", properties, value.position());
+
+        path = value.keyMetadata().split("\\.");
+        for (String s : path)
+            if (s.isEmpty())
+                throw new CITParsingException("Path segment cannot be empty", properties, value.position());
+
+        try {
+            if (value.value().startsWith("regex:"))
+                matchString = new StringMatcher.RegexMatcher(value.value().substring(6));
+            else if (value.value().startsWith("iregex:"))
+                matchString = new StringMatcher.IRegexMatcher(value.value().substring(7));
+            else if (value.value().startsWith("pattern:"))
+                matchString = new StringMatcher.PatternMatcher(value.value().substring(8));
+            else if (value.value().startsWith("ipattern:"))
+                matchString = new StringMatcher.IPatternMatcher(value.value().substring(9));
+            else
+                matchString = new StringMatcher.DirectMatcher(value.value());
+        } catch (PatternSyntaxException e) {
+            throw new CITParsingException("Malformatted regex expression", properties, value.position(), e);
+        } catch (Exception ignored) { }
+        try {
+            if (value.value().startsWith("#"))
+                matchInteger = NbtInt.of(Integer.parseInt(value.value().substring(1).toLowerCase(Locale.ENGLISH), 16));
+            else if (value.value().startsWith("0x"))
+                matchInteger = NbtInt.of(Integer.parseInt(value.value().substring(2).toLowerCase(Locale.ENGLISH), 16));
+            else
+                matchInteger = NbtInt.of(Integer.parseInt(value.value()));
+        } catch (Exception ignored) { }
+        try {
+            matchByte = NbtByte.of(Byte.parseByte(value.value()));
+        } catch (Exception ignored) { }
+        try {
+            matchFloat = NbtFloat.of(Float.parseFloat(value.value()));
+        } catch (Exception ignored) { }
+        try {
+            matchDouble = NbtDouble.of(Double.parseDouble(value.value()));
+        } catch (Exception ignored) { }
+        try {
+            matchLong = NbtLong.of(Long.parseLong(value.value()));
+        } catch (Exception ignored) { }
+        try {
+            matchShort = NbtShort.of(Short.parseShort(value.value()));
+        } catch (Exception ignored) { }
+        try {
+            matchCompound = StringNbtReader.parse(value.value());
+        } catch (Exception ignored) { }
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        return testPath(context.stack.getNbt(), 0);
+    }
+
+    protected boolean testPath(NbtElement element, int pathIndex) {
+        if (element == null)
+            return false;
+
+        if (pathIndex >= path.length)
+            return testValue(element);
+
+        final String path = this.path[pathIndex];
+        if (path.equals("*")) {
+            if (element instanceof NbtCompound compound) {
+                for (NbtElement subElement : compound.entries.values())
+                    if (testPath(subElement, pathIndex + 1))
+                        return true;
+            } else if (element instanceof NbtList list) {
+                for (NbtElement subElement : list)
+                    if (testPath(subElement, pathIndex + 1))
+                        return true;
+            }
+        } else {
+            if (element instanceof NbtCompound compound)
+                return testPath(compound.get(path), pathIndex + 1);
+            else if (element instanceof NbtList list)
+                try {
+                    return testPath(list.get(Integer.parseInt(path)), pathIndex + 1);
+                } catch (NumberFormatException | IndexOutOfBoundsException ignored) { }
+        }
+
+        return false;
+    }
+
+    private boolean testValue(NbtElement element) {
+        try {
+            if (element instanceof NbtString nbtString) //noinspection ConstantConditions
+                return matchString.matches(nbtString.asString()) || matchString.matches(Text.Serializer.fromJson(nbtString.asString()).getString());
+            else if (element instanceof NbtInt nbtInt)
+                return nbtInt.equals(matchInteger);
+            else if (element instanceof NbtByte nbtByte)
+                return nbtByte.equals(matchByte);
+            else if (element instanceof NbtFloat nbtFloat)
+                return nbtFloat.equals(matchFloat);
+            else if (element instanceof NbtDouble nbtDouble)
+                return nbtDouble.equals(matchDouble);
+            else if (element instanceof NbtLong nbtLong)
+                return nbtLong.equals(matchLong);
+            else if (element instanceof NbtShort nbtShort)
+                return nbtShort.equals(matchShort);
+            else if (element instanceof NbtCompound nbtCompound)
+                return NbtHelper.matches(matchCompound, nbtCompound, true);
+        } catch (Exception ignored) { }
+        return false;
+    }
+
+    protected static abstract class StringMatcher {
+        public abstract boolean matches(String value);
+
+        public static class DirectMatcher extends StringMatcher {
+            protected final String pattern;
+
+            public DirectMatcher(String pattern) {
+                this.pattern = pattern;
+            }
+
+            @Override
+            public boolean matches(String value) {
+                return pattern.equals(value);
+            }
+        }
+
+        public static class RegexMatcher extends StringMatcher {
+            protected final Pattern pattern;
+
+            public RegexMatcher(String pattern) {
+                this(Pattern.compile(pattern));
+            }
+
+            protected RegexMatcher(Pattern pattern) {
+                this.pattern = pattern;
+            }
+
+            @Override
+            public boolean matches(String value) {
+                return this.pattern.matcher(value).matches();
+            }
+        }
+
+        public static class PatternMatcher extends StringMatcher {
+            protected final String pattern;
+
+            public PatternMatcher(String pattern) {
+                this.pattern = pattern;
+            }
+
+            @Override
+            public boolean matches(String value) {
+                return matchesPattern(value, this.pattern, 0, value.length(), 0, pattern.length());
+            }
+
+            /**
+             * Author: Paul "prupe" Rupe<br>
+             * Taken and modified from MCPatcher under public domain licensing.<br>
+             * https://bitbucket.org/prupe/mcpatcher/src/1aa45839b2cd029143809edfa60ec59e5ef75f80/newcode/src/com/prupe/mcpatcher/mal/nbt/NBTRule.java#lines-269:301
+             */
+            protected boolean matchesPattern(String value, String pattern, int curV, int maxV, int curG, int maxG) {
+                for (; curG < maxG; curG++, curV++) {
+                    char g = pattern.charAt(curG);
+                    if (g == '*') {
+                        while (true) {
+                            if (matchesPattern(value, pattern, curV, maxV, curG + 1, maxG)) {
+                                return true;
+                            }
+                            if (curV >= maxV) {
+                                break;
+                            }
+                            curV++;
+                        }
+                        return false;
+                    } else if (curV >= maxV) {
+                        break;
+                    } else if (g == '?') {
+                        continue;
+                    }
+                    if (g == '\\' && curG + 1 < maxG) {
+                        curG++;
+                        g = pattern.charAt(curG);
+                    }
+
+                    if (!charsEqual(g, value.charAt(curV)))
+                        return false;
+                }
+                return curG == maxG && curV == maxV;
+            }
+
+            protected boolean charsEqual(char p, char v) {
+                return p == v;
+            }
+        }
+
+        public static class IRegexMatcher extends RegexMatcher {
+            public IRegexMatcher(String pattern) {
+                super(Pattern.compile(pattern, Pattern.CASE_INSENSITIVE));
+            }
+        }
+
+        public static class IPatternMatcher extends PatternMatcher {
+            public IPatternMatcher(String pattern) {
+                super(pattern.toLowerCase(Locale.ROOT));
+            }
+
+            @Override
+            protected boolean charsEqual(char p, char v) {
+                return p == v || p == Character.toLowerCase(v);
+            }
+        }
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionStackSize.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionStackSize.java
new file mode 100644
index 0000000..1d22a53
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/conditions/ConditionStackSize.java
@@ -0,0 +1,21 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.IntegerCondition;
+
+public class ConditionStackSize extends IntegerCondition {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<ConditionStackSize> CONTAINER = new CITConditionContainer<>(ConditionStackSize.class, ConditionStackSize::new,
+            "stack_size", "stackSize", "amount");
+
+    public ConditionStackSize() {
+        super(true, false, false);
+    }
+
+    @Override
+    protected int getValue(CITContext context) {
+        return context.stack.getCount();
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeArmor.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeArmor.java
new file mode 100644
index 0000000..d97bf67
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeArmor.java
@@ -0,0 +1,111 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.types;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import net.minecraft.item.ArmorItem;
+import net.minecraft.item.Item;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.Registry;
+import shcm.shsupercm.fabric.citresewn.api.CITTypeContainer;
+import shcm.shsupercm.fabric.citresewn.cit.*;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.conditions.ConditionItems;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.util.*;
+
+public class TypeArmor extends CITType {
+    @Entrypoint(CITTypeContainer.ENTRYPOINT)
+    public static final Container CONTAINER = new Container();
+
+    public final Map<String, Identifier> textures = new HashMap<>();
+
+    @Override
+    public Set<PropertyKey> typeProperties() {
+        return Set.of(PropertyKey.of("texture"));
+    }
+
+    @Override
+    public void load(List<CITCondition> conditions, PropertyGroup properties, ResourceManager resourceManager) throws CITParsingException {
+        boolean itemsConditionPresent = false;
+        for (CITCondition condition : conditions)
+            if (condition instanceof ConditionItems conditionItems)
+                for (Item item : conditionItems.items)
+                    if (item instanceof ArmorItem)
+                        itemsConditionPresent = true;
+                    else
+                        throw new CITParsingException("This type only accepts armor items for the items condition", properties, -1);
+
+        if (!itemsConditionPresent)
+            try {
+                Identifier propertiesName = new Identifier(properties.stripName());
+                if (!Registry.ITEM.containsId(propertiesName))
+                    throw new Exception();
+                Item item = Registry.ITEM.get(propertiesName);
+                if (!(item instanceof ArmorItem))
+                    throw new Exception();
+                conditions.add(new ConditionItems(item));
+            } catch (Exception ignored) {
+                throw new CITParsingException("Not targeting any item type", properties, -1);
+            }
+
+        for (PropertyValue propertyValue : properties.get("citresewn", "texture")) {
+            Identifier identifier = resolveAsset(properties.identifier, propertyValue, "textures", ".png", resourceManager);
+            if (identifier == null)
+                throw new CITParsingException("Could not resolve texture", properties, propertyValue.position());
+
+            textures.put(propertyValue.keyMetadata(), identifier);
+        }
+        if (textures.size() == 0)
+            throw new CITParsingException("Texture not specified", properties, -1);
+    }
+
+    public static class Container extends CITTypeContainer<TypeArmor> {
+        public Container() {
+            super(TypeArmor.class, TypeArmor::new, "armor");
+        }
+
+        public Set<CIT<TypeArmor>> loaded = new HashSet<>();
+        public Map<ArmorItem, Set<CIT<TypeArmor>>> loadedTyped = new IdentityHashMap<>();
+
+        @Override
+        public void load(List<CIT<TypeArmor>> parsedCITs) {
+            loaded.addAll(parsedCITs);
+            for (CIT<TypeArmor> cit : parsedCITs)
+                for (CITCondition condition : cit.conditions)
+                    if (condition instanceof ConditionItems items)
+                        for (Item item : items.items)
+                            if (item instanceof ArmorItem armorItem)
+                                loadedTyped.computeIfAbsent(armorItem, i -> new LinkedHashSet<>()).add(cit);
+        }
+
+        @Override
+        public void dispose() {
+            loaded.clear();
+            loadedTyped.clear();
+        }
+
+        public CIT<TypeArmor> getCIT(CITContext context) {
+            return ((CITCacheArmor) (Object) context.stack).citresewn$getCacheTypeArmor().get(context).get();
+        }
+
+        public CIT<TypeArmor> getRealTimeCIT(CITContext context) {
+            if (!(context.stack.getItem() instanceof ArmorItem))
+                return null;
+
+            Set<CIT<TypeArmor>> loadedForItemType = loadedTyped.get(context.stack.getItem());
+            if (loadedForItemType != null)
+                for (CIT<TypeArmor> cit : loadedForItemType)
+                    if (cit.test(context))
+                        return cit;
+
+            return null;
+        }
+    }
+
+    public interface CITCacheArmor {
+        CITCache.Single<TypeArmor> citresewn$getCacheTypeArmor();
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeElytra.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeElytra.java
new file mode 100644
index 0000000..40e6fbe
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeElytra.java
@@ -0,0 +1,76 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.types;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import net.minecraft.item.ElytraItem;
+import net.minecraft.item.Item;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import shcm.shsupercm.fabric.citresewn.api.CITTypeContainer;
+import shcm.shsupercm.fabric.citresewn.cit.*;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.conditions.ConditionItems;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class TypeElytra extends CITType {
+    @Entrypoint(CITTypeContainer.ENTRYPOINT)
+    public static final Container CONTAINER = new Container();
+
+    public Identifier texture;
+
+    @Override
+    public Set<PropertyKey> typeProperties() {
+        return Set.of(PropertyKey.of("texture"));
+    }
+
+    @Override
+    public void load(List<CITCondition> conditions, PropertyGroup properties, ResourceManager resourceManager) throws CITParsingException {
+        for (CITCondition condition : conditions)
+            if (condition instanceof ConditionItems items)
+                for (Item item : items.items)
+                    if (!(item instanceof ElytraItem))
+                        warn("Non elytra item type condition", null, properties);
+
+        texture = resolveAsset(properties.identifier, properties.getLastWithoutMetadata("citresewn", "texture"), "textures", ".png", resourceManager);
+        if (texture == null)
+            throw new CITParsingException("Texture not specified", properties, -1);
+    }
+
+    public static class Container extends CITTypeContainer<TypeElytra> {
+        public Container() {
+            super(TypeElytra.class, TypeElytra::new, "elytra");
+        }
+
+        public Set<CIT<TypeElytra>> loaded = new HashSet<>();
+
+        @Override
+        public void load(List<CIT<TypeElytra>> parsedCITs) {
+            loaded.addAll(parsedCITs);
+        }
+
+        @Override
+        public void dispose() {
+            loaded.clear();
+        }
+
+        public CIT<TypeElytra> getCIT(CITContext context) {
+            return ((CITCacheElytra) (Object) context.stack).citresewn$getCacheTypeElytra().get(context).get();
+        }
+
+        public CIT<TypeElytra> getRealTimeCIT(CITContext context) {
+            for (CIT<TypeElytra> cit : loaded)
+                if (cit.test(context))
+                    return cit;
+
+            return null;
+        }
+    }
+
+    public interface CITCacheElytra {
+        CITCache.Single<TypeElytra> citresewn$getCacheTypeElytra();
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeEnchantment.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeEnchantment.java
new file mode 100644
index 0000000..0bd29e7
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeEnchantment.java
@@ -0,0 +1,528 @@
+package shcm.shsupercm.fabric.citresewn.defaults.cit.types;
+
+import com.mojang.blaze3d.systems.RenderSystem;
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.*;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.Util;
+import net.minecraft.util.math.Matrix4f;
+import net.minecraft.util.math.Vec3f;
+import org.lwjgl.opengl.GL11;
+import shcm.shsupercm.fabric.citresewn.api.CITGlobalProperties;
+import shcm.shsupercm.fabric.citresewn.api.CITTypeContainer;
+import shcm.shsupercm.fabric.citresewn.cit.*;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.conditions.ConditionEnchantments;
+import shcm.shsupercm.fabric.citresewn.defaults.config.CITResewnDefaultsConfig;
+import shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment.BufferBuilderStorageAccessor;
+import shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment.RenderPhaseAccessor;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+import shcm.shsupercm.util.logic.Loops;
+
+import javax.annotation.Nullable;
+import java.lang.ref.WeakReference;
+import java.util.*;
+import java.util.function.Consumer;
+
+import static com.mojang.blaze3d.systems.RenderSystem.*;
+import static org.lwjgl.opengl.GL11.*;
+
+public class TypeEnchantment extends CITType {
+    @Entrypoint(CITGlobalProperties.ENTRYPOINT)
+    @Entrypoint(CITTypeContainer.ENTRYPOINT)
+    public static final Container CONTAINER = new Container();
+
+    @Override
+    public Set<PropertyKey> typeProperties() {
+        return Set.of(
+                PropertyKey.of("texture"),
+                PropertyKey.of("layer"),
+                PropertyKey.of("speed"),
+                PropertyKey.of("rotation"),
+                PropertyKey.of("duration"),
+                PropertyKey.of("r"),
+                PropertyKey.of("g"),
+                PropertyKey.of("b"),
+                PropertyKey.of("a"),
+                PropertyKey.of("useGlint"),
+                PropertyKey.of("blur"),
+                PropertyKey.of("blend"));
+    }
+
+    public Identifier texture;
+    public int layer;
+    public float speed, rotation, duration, r, g, b, a;
+    public boolean useGlint, blur;
+    public Blend blend;
+
+    public final Map<GlintRenderLayer, RenderLayer> renderLayers = new EnumMap<>(GlintRenderLayer.class);
+    private final MergeMethodIntensity methodIntensity = new MergeMethodIntensity();
+    private Set<Identifier> enchantmentChecks = null;
+
+    @Override
+    public void load(List<CITCondition> conditions, PropertyGroup properties, ResourceManager resourceManager) throws CITParsingException {
+        PropertyValue textureProp = properties.getLastWithoutMetadata("citresewn", "texture");
+        this.texture = resolveAsset(properties.identifier, textureProp, "textures", ".png", resourceManager);
+        if (this.texture == null)
+            throw textureProp == null ? new CITParsingException("No texture specified", properties, -1) : new CITParsingException("Could not resolve texture", properties, textureProp.position());
+
+        PropertyValue layerProp = properties.getLastWithoutMetadataOrDefault("0", "citresewn", "layer");
+        try {
+            this.layer = Integer.parseInt(layerProp.value());
+        } catch (Exception e) {
+            throw new CITParsingException("Could not parse integer", properties, layerProp.position(), e);
+        }
+
+        this.speed = parseFloatOrDefault(1f, "speed", properties);
+        this.rotation = parseFloatOrDefault(10f, "rotation", properties);
+        this.duration = Math.max(0f, parseFloatOrDefault(0f, "duration", properties));
+        this.r = Math.max(0f, parseFloatOrDefault(1f, "r", properties));
+        this.g = Math.max(0f, parseFloatOrDefault(1f, "g", properties));
+        this.b = Math.max(0f, parseFloatOrDefault(1f, "b", properties));
+        this.a = Math.max(0f, parseFloatOrDefault(1f, "a", properties));
+
+        this.useGlint = Boolean.parseBoolean(properties.getLastWithoutMetadataOrDefault("false", "citresewn", "useGlint").value());
+        this.blur = Boolean.parseBoolean(properties.getLastWithoutMetadataOrDefault("true", "citresewn", "blur").value());
+
+        PropertyValue blendProp = properties.getLastWithoutMetadataOrDefault("add", "citresewn", "blend");
+        try {
+            this.blend = Blend.getBlend(blendProp.value());
+        } catch (Exception e) {
+            throw new CITParsingException("Could not parse blending method", properties, blendProp.position(), e);
+        }
+
+        for (CITCondition condition : conditions)
+            if (condition instanceof ConditionEnchantments enchantments) {
+                if (enchantmentChecks == null && enchantments.getEnchantments().length > 0)
+                    enchantmentChecks = new HashSet<>();
+
+                enchantmentChecks.addAll(Arrays.asList(enchantments.getEnchantments()));
+            }
+    }
+
+    private float parseFloatOrDefault(float defaultValue, String propertyName, PropertyGroup properties) throws CITParsingException {
+        PropertyValue property = properties.getLastWithoutMetadata("citresewn", propertyName);
+        if (property == null)
+            return defaultValue;
+        try {
+            return Float.parseFloat(property.value());
+        } catch (Exception e) {
+            throw new CITParsingException("Could not parse float", properties, property.position(), e);
+        }
+    }
+
+    public static class Container extends CITTypeContainer<TypeEnchantment> implements CITGlobalProperties {
+        public Container() {
+            super(TypeEnchantment.class, TypeEnchantment::new, "enchantment");
+        }
+
+        public boolean globalUseGlint = true;
+        public int globalCap = Integer.MAX_VALUE;
+        public MergeMethodIntensity.MergeMethod globalMergeMethod = MergeMethodIntensity.MergeMethod.AVERAGE;
+        public float globalFade = 0.5f;
+
+        public List<CIT<TypeEnchantment>> loaded = new ArrayList<>();
+        public List<List<CIT<TypeEnchantment>>> loadedLayered = new ArrayList<>();
+
+        private List<CIT<TypeEnchantment>> appliedContext = null;
+        private boolean apply = false, defaultGlint = false;
+
+        @Override
+        public void load(List<CIT<TypeEnchantment>> parsedCITs) {
+            loaded.addAll(parsedCITs);
+
+            Map<Integer, List<CIT<TypeEnchantment>>> layers = new HashMap<>();
+            for (CIT<TypeEnchantment> cit : loaded)
+                layers.computeIfAbsent(cit.type.layer, i -> new ArrayList<>()).add(cit);
+            loadedLayered.clear();
+            layers.entrySet().stream()
+                    .sorted(Map.Entry.comparingByKey())
+                    .forEachOrdered(layer -> loadedLayered.add(layer.getValue()));
+
+            for (CIT<TypeEnchantment> cit : loaded)
+                for (GlintRenderLayer glintLayer : GlintRenderLayer.values()) {
+                    RenderLayer renderLayer = glintLayer.build(cit.type, cit.propertiesIdentifier);
+
+                    cit.type.renderLayers.put(glintLayer, renderLayer);
+                    ((BufferBuilderStorageAccessor) MinecraftClient.getInstance().getBufferBuilders()).getEntityBuilders().put(renderLayer, new BufferBuilder(renderLayer.getExpectedBufferSize()));
+                }
+        }
+
+        @Override
+        public void globalProperty(String key, @Nullable PropertyValue value) throws Exception {
+            switch (key) {
+                case "useGlint" -> {
+                    globalUseGlint = value == null ? true : Boolean.parseBoolean(value.value());
+                    if (!globalUseGlint && !"false".equalsIgnoreCase(value.value()))
+                        throw new Exception("Could not parse boolean");
+                }
+                case "cap" -> {
+                    globalCap = value == null ? Integer.MAX_VALUE : Integer.parseInt(value.value());
+                }
+                case "method" -> {
+                    globalMergeMethod = value == null ? MergeMethodIntensity.MergeMethod.AVERAGE : MergeMethodIntensity.MergeMethod.parse(value.value());
+                }
+                case "fade" -> {
+                    globalFade = value == null ? 0.5f : Float.parseFloat(value.value());
+                }
+            }
+        }
+
+        @Override
+        public void dispose() {
+            appliedContext = null;
+            apply = false;
+
+            for (CIT<TypeEnchantment> cit : loaded)
+                for (RenderLayer renderLayer : cit.type.renderLayers.values())
+                    ((BufferBuilderStorageAccessor) MinecraftClient.getInstance().getBufferBuilders()).getEntityBuilders().remove(renderLayer);
+
+            loaded.clear();
+            loadedLayered.clear();
+        }
+
+        public void apply() {
+            if (appliedContext != null)
+                apply = true;
+        }
+
+        public boolean shouldApply() {
+            return apply && active();
+        }
+
+        public boolean shouldNotApplyDefaultGlint() {
+            return !globalUseGlint || (apply && !defaultGlint);
+        }
+
+        public Container setContext(CITContext context) {
+            apply = false;
+            defaultGlint = false;
+            appliedContext = null;
+            if (context == null)
+                return this;
+
+            List<WeakReference<CIT<TypeEnchantment>>> cits = ((CITCacheEnchantment) (Object) context.stack).citresewn$getCacheTypeEnchantment().get(context);
+
+            appliedContext = new ArrayList<>();
+            if (cits != null)
+                for (WeakReference<CIT<TypeEnchantment>> citRef : cits)
+                    if (citRef != null) {
+                        CIT<TypeEnchantment> cit = citRef.get();
+                        if (cit != null) {
+                            appliedContext.add(cit);
+                            if (cit.type.useGlint)
+                                defaultGlint = true;
+                        }
+                    }
+
+            if (appliedContext.isEmpty())
+                appliedContext = null;
+            else
+                globalMergeMethod.applyMethod(appliedContext, context);
+
+            return this;
+        }
+
+        public List<CIT<TypeEnchantment>> getRealTimeCIT(CITContext context) {
+            List<CIT<TypeEnchantment>> cits = new ArrayList<>();
+            for (List<CIT<TypeEnchantment>> layer : loadedLayered)
+                for (CIT<TypeEnchantment> cit : layer)
+                    if (cit.test(context)) {
+                        cits.add(cit);
+                        break;
+                    }
+
+            return cits;
+        }
+    }
+    
+    public enum GlintRenderLayer {
+        ARMOR_GLINT("armor_glint", 8f, layer -> layer
+                .shader(RenderPhaseAccessor.ARMOR_GLINT_SHADER())
+                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
+                .cull(RenderPhaseAccessor.DISABLE_CULLING())
+                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())
+                .layering(RenderPhaseAccessor.VIEW_OFFSET_Z_LAYERING())),
+        ARMOR_ENTITY_GLINT("armor_entity_glint", 0.16f, layer -> layer
+                .shader(RenderPhaseAccessor.ARMOR_ENTITY_GLINT_SHADER())
+                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
+                .cull(RenderPhaseAccessor.DISABLE_CULLING())
+                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())
+                .layering(RenderPhaseAccessor.VIEW_OFFSET_Z_LAYERING())),
+        GLINT_TRANSLUCENT("glint_translucent", 8f, layer -> layer
+                .shader(RenderPhaseAccessor.TRANSLUCENT_GLINT_SHADER())
+                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
+                .cull(RenderPhaseAccessor.DISABLE_CULLING())
+                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())
+                .target(RenderPhaseAccessor.ITEM_TARGET())),
+        GLINT("glint", 8f, layer -> layer
+                .shader(RenderPhaseAccessor.GLINT_SHADER())
+                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
+                .cull(RenderPhaseAccessor.DISABLE_CULLING())
+                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())),
+        DIRECT_GLINT("glint_direct", 8f, layer -> layer
+                .shader(RenderPhaseAccessor.DIRECT_GLINT_SHADER())
+                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
+                .cull(RenderPhaseAccessor.DISABLE_CULLING())
+                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())),
+        ENTITY_GLINT("entity_glint", 0.16f, layer -> layer
+                .shader(RenderPhaseAccessor.ENTITY_GLINT_SHADER())
+                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
+                .cull(RenderPhaseAccessor.DISABLE_CULLING())
+                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())
+                .target(RenderPhaseAccessor.ITEM_TARGET())),
+        DIRECT_ENTITY_GLINT("entity_glint_direct", 0.16f, layer -> layer
+                .shader(RenderPhaseAccessor.DIRECT_ENTITY_GLINT_SHADER())
+                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
+                .cull(RenderPhaseAccessor.DISABLE_CULLING())
+                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST()));
+
+        public final String name;
+        private final Consumer<RenderLayer.MultiPhaseParameters.Builder> setup;
+        private final float scale;
+
+        GlintRenderLayer(String name, float scale, Consumer<RenderLayer.MultiPhaseParameters.Builder> setup) {
+            this.name = name;
+            this.scale = scale;
+            this.setup = setup;
+        }
+
+        public RenderLayer build(TypeEnchantment enchantment, Identifier propertiesIdentifier) {
+            class Texturing implements Runnable {
+                private final float speed, rotation, r, g, b, a;
+                private final MergeMethodIntensity methodIntensity;
+
+                Texturing(float speed, float rotation, float r, float g, float b, float a, MergeMethodIntensity methodIntensity) {
+                    this.speed = speed;
+                    this.rotation = rotation;
+                    this.r = r;
+                    this.g = g;
+                    this.b = b;
+                    this.a = a;
+                    this.methodIntensity = methodIntensity;
+                }
+
+                @Override
+                public void run() {
+                    float l = Util.getMeasuringTimeMs() * CITResewnDefaultsConfig.INSTANCE.type_enchantment_scroll_multiplier * speed;
+                    float x = (l % 110000f) / 110000f;
+                    float y = (l % 30000f) / 30000f;
+                    Matrix4f matrix4f = Matrix4f.translate(-x, y, 0.0f);
+                    matrix4f.multiply(Vec3f.POSITIVE_Z.getDegreesQuaternion(rotation));
+                    matrix4f.multiply(Matrix4f.scale(scale, scale, scale));
+                    setTextureMatrix(matrix4f);
+
+                    setShaderColor(r, g, b, a * methodIntensity.intensity);
+                }
+            }
+
+            RenderLayer.MultiPhaseParameters.Builder layer = RenderLayer.MultiPhaseParameters.builder()
+                    .texture(new RenderPhase.Texture(enchantment.texture, enchantment.blur, false))
+                    .texturing(new RenderPhase.Texturing("citresewn_glint_texturing", new Texturing(enchantment.speed, enchantment.rotation, enchantment.r, enchantment.g, enchantment.b, enchantment.a, enchantment.methodIntensity), () -> {
+                        RenderSystem.resetTextureMatrix();
+
+                        setShaderColor(1f, 1f, 1f, 1f);
+                    }))
+                    .transparency(enchantment.blend);
+
+            this.setup.accept(layer);
+
+            return RenderLayer.of("citresewn:enchantment_" + this.name + ":" + propertiesIdentifier.toString(),
+                    VertexFormats.POSITION_TEXTURE,
+                    VertexFormat.DrawMode.QUADS,
+                    256,
+                    layer.build(false));
+        }
+
+        public VertexConsumer tryApply(VertexConsumer base, RenderLayer baseLayer, VertexConsumerProvider provider) {
+            if (!CONTAINER.apply || CONTAINER.appliedContext == null || CONTAINER.appliedContext.size() == 0)
+                return null;
+
+            VertexConsumer[] layers = new VertexConsumer[Math.min(CONTAINER.appliedContext.size(), CONTAINER.globalCap)];
+
+            for (int i = 0; i < layers.length; i++)
+                layers[i] = provider.getBuffer(CONTAINER.appliedContext.get(i).type.renderLayers.get(GlintRenderLayer.this));
+
+            provider.getBuffer(baseLayer); // refresh base layer for armor consumer
+
+            return base == null ? VertexConsumers.union(layers) : VertexConsumers.union(VertexConsumers.union(layers), base);
+        }
+    }
+
+    public static class MergeMethodIntensity {
+        public float intensity = 1f;
+
+        public enum MergeMethod {
+            NONE,
+            AVERAGE {
+                @Override
+                public void applyIntensity(Map<Identifier, Integer> stackEnchantments, CIT<TypeEnchantment> cit) {
+                    Identifier enchantment = null;
+                    for (Identifier enchantmentMatch : cit.type.enchantmentChecks)
+                        if (stackEnchantments.containsKey(enchantmentMatch)) {
+                            enchantment = enchantmentMatch;
+                            break;
+                        }
+
+                    if (enchantment == null) {
+                        cit.type.methodIntensity.intensity = 0f;
+                    } else {
+                        float sum = 0f;
+                        for (Integer value : stackEnchantments.values())
+                            sum += value;
+
+                        cit.type.methodIntensity.intensity = (float) stackEnchantments.get(enchantment) / sum;
+                    }
+                }
+            },
+            LAYERED {
+                @Override
+                public void applyIntensity(Map<Identifier, Integer> stackEnchantments, CIT<TypeEnchantment> cit) {
+                    Identifier enchantment = null;
+                    for (Identifier enchantmentMatch : cit.type.enchantmentChecks)
+                        if (stackEnchantments.containsKey(enchantmentMatch)) {
+                            enchantment = enchantmentMatch;
+                            break;
+                        }
+                    if (enchantment == null) {
+                        cit.type.methodIntensity.intensity = 0f;
+                        return;
+                    }
+
+                    float max = 0f;
+                    for (Integer value : stackEnchantments.values())
+                        if (value > max)
+                            max = value;
+
+                    cit.type.methodIntensity.intensity = (float) stackEnchantments.get(enchantment) / max;
+                }
+            },
+            CYCLE {
+                @Override
+                public void applyMethod(List<CIT<TypeEnchantment>> citEnchantments, CITContext context) {
+                    List<Map.Entry<CIT<TypeEnchantment>, Float>> durations = new ArrayList<>();
+                    for (CIT<TypeEnchantment> cit : citEnchantments)
+                        durations.add(new HashMap.SimpleEntry<>(cit, cit.type.duration));
+
+                    for (Map.Entry<CIT<TypeEnchantment>, Float> intensity : Loops.statelessFadingLoop(durations, CONTAINER.globalFade, ticks, 20).entrySet())
+                        intensity.getKey().type.methodIntensity.intensity = intensity.getValue();
+                }
+            };
+
+            public static int ticks = 0;
+
+            public void applyIntensity(Map<Identifier, Integer> stackEnchantments, CIT<TypeEnchantment> cit) {
+                cit.type.methodIntensity.intensity = 1f;
+            }
+
+            public void applyMethod(List<CIT<TypeEnchantment>> citEnchantments, CITContext context) {
+                Map<Identifier, Integer> stackEnchantments = context.enchantments();
+
+                for (CIT<TypeEnchantment> cit : citEnchantments)
+                    if (cit.type.enchantmentChecks != null)
+                        applyIntensity(stackEnchantments, cit);
+            }
+
+            public static MergeMethod parse(String value) {
+                return switch (value.toLowerCase(Locale.ROOT)) {
+                    case "none" -> NONE;
+                    case "average" -> AVERAGE;
+                    case "layered" -> LAYERED;
+                    case "cycle" -> CYCLE;
+                    default -> throw new IllegalArgumentException("Unknown merge method");
+                };
+            }
+        }
+    }
+
+    public static class Blend extends RenderPhase.Transparency {
+        private final int src, dst, srcAlpha, dstAlpha;
+
+        private Blend(String name, int src, int dst, int srcAlpha, int dstAlpha) {
+            super(name + "_glint_transparency", null, null);
+            this.src = src;
+            this.dst = dst;
+            this.srcAlpha = srcAlpha;
+            this.dstAlpha = dstAlpha;
+        }
+
+        private Blend(String name, int src, int dst) {
+            this(name, src, dst, GL_ZERO, GL_ONE);
+        }
+
+        @Override
+        public void startDrawing() {
+            enableBlend();
+            blendFuncSeparate(src, dst, srcAlpha, dstAlpha);
+        }
+
+        @Override
+        public void endDrawing() {
+            defaultBlendFunc();
+            disableBlend();
+        }
+
+        public static Blend getBlend(String blendString) throws Exception {
+            try { //check named blending function
+                return Named.valueOf(blendString.toUpperCase(Locale.ENGLISH)).blend;
+            } catch (IllegalArgumentException ignored) { // create custom blending function
+                String[] split = blendString.split("\\p{Zs}+");
+                int src, dst, srcAlpha, dstAlpha;
+                if (split.length == 2) {
+                    src = parseGLConstant(split[0]);
+                    dst = parseGLConstant(split[1]);
+                    srcAlpha = GL_ZERO;
+                    dstAlpha = GL_ONE;
+                } else if (split.length == 4) {
+                    src = parseGLConstant(split[0]);
+                    dst = parseGLConstant(split[1]);
+                    srcAlpha = parseGLConstant(split[2]);
+                    dstAlpha = parseGLConstant(split[3]);
+                } else
+                    throw new Exception();
+
+                return new Blend("custom_" + src + "_" + dst + "_" + srcAlpha + "_" + dstAlpha, src, dst, srcAlpha, dstAlpha);
+            }
+        }
+
+        private enum Named {
+            REPLACE(new Blend("replace", 0, 0) {
+                @Override
+                public void startDrawing() {
+                    disableBlend();
+                }
+            }),
+            GLINT(new Blend("glint", GL_SRC_COLOR, GL_ONE)),
+            ALPHA(new Blend("alpha", GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)),
+            ADD(new Blend("add", GL_SRC_ALPHA, GL_ONE)),
+            SUBTRACT(new Blend("subtract", GL_ONE_MINUS_DST_COLOR, GL_ZERO)),
+            MULTIPLY(new Blend("multiply", GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA)),
+            DODGE(new Blend("dodge", GL_ONE, GL_ONE)),
+            BURN(new Blend("burn", GL_ZERO, GL_ONE_MINUS_SRC_COLOR)),
+            SCREEN(new Blend("screen", GL_ONE, GL_ONE_MINUS_SRC_COLOR)),
+            OVERLAY(new Blend("overlay", GL_DST_COLOR, GL_SRC_COLOR));
+
+            public final Blend blend;
+
+            Named(Blend blend) {
+                this.blend = blend;
+            }
+        }
+
+        private static int parseGLConstant(String s) throws Exception {
+            try {
+                return GL11.class.getDeclaredField(s).getInt(null);
+            } catch (NoSuchFieldException ignored) { }
+
+            return s.startsWith("0x") ? Integer.parseInt(s.substring(2), 16) : Integer.parseInt(s);
+        }
+    }
+
+    public interface CITCacheEnchantment {
+        CITCache.MultiList<TypeEnchantment> citresewn$getCacheTypeEnchantment();
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITItem.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeItem.java
index 2300f88..fe0bafb 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITItem.java
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/cit/types/TypeItem.java
@@ -1,7 +1,8 @@
-package shcm.shsupercm.fabric.citresewn.pack.cits;
+package shcm.shsupercm.fabric.citresewn.defaults.cit.types;
 
 import com.google.common.collect.ImmutableMap;
 import com.mojang.datafixers.util.Either;
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 import net.minecraft.client.render.model.BakedModel;
@@ -12,36 +13,48 @@ import net.minecraft.client.render.model.json.ModelTransformation;
 import net.minecraft.client.texture.SpriteAtlasTexture;
 import net.minecraft.client.util.SpriteIdentifier;
 import net.minecraft.client.world.ClientWorld;
-import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
 import net.minecraft.resource.Resource;
 import net.minecraft.resource.ResourceManager;
-import net.minecraft.resource.ResourceType;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 import org.apache.commons.io.IOUtils;
 import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.ex.CITLoadException;
-import shcm.shsupercm.fabric.citresewn.ex.CITParseException;
-import shcm.shsupercm.fabric.citresewn.mixin.cititem.JsonUnbakedModelAccessor;
-import shcm.shsupercm.fabric.citresewn.pack.CITPack;
-import shcm.shsupercm.fabric.citresewn.pack.ResewnItemModelIdentifier;
-import shcm.shsupercm.fabric.citresewn.pack.ResewnTextureIdentifier;
+import shcm.shsupercm.fabric.citresewn.api.CITTypeContainer;
+import shcm.shsupercm.fabric.citresewn.cit.*;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.conditions.ConditionItems;
+import shcm.shsupercm.fabric.citresewn.defaults.common.ResewnItemModelIdentifier;
+import shcm.shsupercm.fabric.citresewn.defaults.common.ResewnTextureIdentifier;
+import shcm.shsupercm.fabric.citresewn.defaults.mixin.types.item.JsonUnbakedModelAccessor;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
 
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.nio.charset.StandardCharsets;
 import java.util.*;
-import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
-@SuppressWarnings("deprecation")
-public class CITItem extends CIT {
+/**
+ * ///// PORTED FROM BETA \\\\\
+ * This shit was ported from the
+ * beta and will be rewritten at
+ * some point!
+ * \\\\\                  /////
+ */
+public class TypeItem extends CITType {
+    @Entrypoint(CITTypeContainer.ENTRYPOINT)
+    public static final Container CONTAINER = new Container();
+
     private static final String GENERATED_SUB_CITS_PREFIX = "sub_cititem_generated_";
     public static final Set<Identifier> GENERATED_SUB_CITS_SEEN = new HashSet<>();
 
+    private final List<Item> items = new ArrayList<>();
+
     public Map<Identifier, Identifier> assetIdentifiers = new LinkedHashMap<>();
     public Map<List<ModelOverride.Condition>, JsonUnbakedModel> unbakedAssets = new LinkedHashMap<>();
     private Map<String, Either<SpriteIdentifier, String>> textureOverrideMap = new HashMap<>();
@@ -50,93 +63,95 @@ public class CITItem extends CIT {
     public BakedModel bakedModel = null;
     public CITOverrideList bakedSubModels = new CITOverrideList();
 
-    public CITItem(CITPack pack, Identifier identifier, Properties properties) throws CITParseException {
-        super(pack, identifier, properties);
-        try {
-            if (this.items.size() == 0)
-                throw new Exception("CIT must target at least one item type");
-
-            Identifier assetIdentifier;
-            boolean containsTexture = false;
-            String modelProp = properties.getProperty("model");
-            if (modelProp == null)
-                for (Object o : properties.keySet())
-                    if (o instanceof String property && (property.startsWith("texture") || property.startsWith("tile"))) {
-                        containsTexture = true;
-                        break;
-                    }
-            if (!containsTexture) {
-                assetIdentifier = resolvePath(identifier, modelProp, ".json", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-                if (assetIdentifier != null)
-                    assetIdentifiers.put(null, assetIdentifier);
-                else if (modelProp != null) {
-                    assetIdentifier = resolvePath(identifier, modelProp, ".json", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-                    if (assetIdentifier != null)
-                        assetIdentifiers.put(null, assetIdentifier);
-                }
-            }
+    @Override
+    public Set<PropertyKey> typeProperties() {
+        return Set.of(PropertyKey.of("model"), PropertyKey.of("texture"), PropertyKey.of("tile"));
+    }
 
-            for (Object o : properties.keySet())
-                if (o instanceof String property && property.startsWith("model.")) {
-                    Identifier subIdentifier = resolvePath(identifier, properties.getProperty(property), ".json", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-                    if (subIdentifier == null)
-                        throw new Exception("Cannot resolve path for " + property);
+    @Override
+    public void load(List<CITCondition> conditions, PropertyGroup properties, ResourceManager resourceManager) throws CITParsingException {
+        for (CITCondition condition : conditions)
+            if (condition instanceof ConditionItems conditionItems)
+                items.addAll(Arrays.asList(conditionItems.items));
 
-                    String subItem = property.substring(6);
-                    Identifier subItemIdentifier = fixDeprecatedSubItem(subItem);
-                    assetIdentifiers.put(subItemIdentifier == null ? new Identifier("minecraft", "item/" + subItem) : subItemIdentifier, subIdentifier);
-                }
+        if (this.items.size() == 0)
+            try {
+                Identifier propertiesName = new Identifier(properties.stripName());
+                if (!Registry.ITEM.containsId(propertiesName))
+                    throw new Exception();
+                Item item = Registry.ITEM.get(propertiesName);
+                conditions.add(new ConditionItems(item));
+                this.items.add(item);
+            } catch (Exception ignored) {
+                throw new CITParsingException("Not targeting any item type", properties, -1);
+            }
+
+        Identifier assetIdentifier;
+        PropertyValue modelProp = properties.getLastWithoutMetadata("citresewn", "model");
+        boolean containsTexture = modelProp == null && !properties.get("citresewn", "texture", "tile").isEmpty();
 
-            if (assetIdentifiers.size() == 0) { // attempt to load texture
-                isTexture = true;
-                String textureProp = properties.getProperty("texture");
-                if (textureProp == null)
-                    textureProp = properties.getProperty("tile");
-                assetIdentifier = resolvePath(identifier, textureProp, ".png", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
+        if (!containsTexture) {
+            assetIdentifier = resolveAsset(properties.identifier, modelProp, "models", ".json", resourceManager);
+            if (assetIdentifier != null)
+                assetIdentifiers.put(null, assetIdentifier);
+            else if (modelProp != null) {
+                assetIdentifier = resolveAsset(properties.identifier, modelProp, "models", ".json", resourceManager);
                 if (assetIdentifier != null)
                     assetIdentifiers.put(null, assetIdentifier);
+            }
+        }
 
-                for (Object o : properties.keySet())
-                    if (o instanceof String property && property.startsWith("texture.")) {
-                        Identifier subIdentifier = resolvePath(identifier, properties.getProperty(property), ".png", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-                        if (subIdentifier == null)
-                            throw new Exception("Cannot resolve path for " + property);
-
-                        String subItem = property.substring(8);
-                        Identifier subItemIdentifier = fixDeprecatedSubItem(subItem);
-                        assetIdentifiers.put(subItemIdentifier == null ? new Identifier("minecraft", "item/" + subItem) : subItemIdentifier, subIdentifier);
-                    }
-            } else { // attempt to load textureOverrideMap from textures
-                String textureProp = properties.getProperty("texture");
-                if (textureProp == null)
-                    textureProp = properties.getProperty("tile");
-                if (textureProp != null) {
-                    assetIdentifier = resolvePath(identifier, textureProp, ".png", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-                    if (assetIdentifier != null)
-                        textureOverrideMap.put(null, Either.left(new SpriteIdentifier(SpriteAtlasTexture.BLOCK_ATLAS_TEXTURE, new ResewnTextureIdentifier(assetIdentifier))));
-                    else
-                        throw new Exception("Cannot resolve path for texture");
-                }
+        for (PropertyValue property : properties.get("citresewn", "model")) {
+            Identifier subIdentifier = resolveAsset(properties.identifier, property, "models", ".json", resourceManager);
+            if (subIdentifier == null)
+                throw new CITParsingException("Cannot resolve path", properties, property.position());
 
-                for (Object o : properties.keySet())
-                    if (o instanceof String property && property.startsWith("texture.")) {
-                        textureProp = properties.getProperty(property);
-                        Identifier subIdentifier = resolvePath(identifier, textureProp, ".png", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-                        if (subIdentifier == null)
-                            throw new Exception("Cannot resolve path for " + property);
+            String subItem = property.keyMetadata();
+            Identifier subItemIdentifier = fixDeprecatedSubItem(subItem, properties, property.position());
+            assetIdentifiers.put(subItemIdentifier == null ? new Identifier("minecraft", "item/" + subItem) : subItemIdentifier, subIdentifier);
+        }
 
-                        textureOverrideMap.put(property.substring(8), Either.left(new SpriteIdentifier(SpriteAtlasTexture.BLOCK_ATLAS_TEXTURE, new ResewnTextureIdentifier(subIdentifier))));
-                    }
+        if (assetIdentifiers.size() == 0) { // attempt to load texture
+            isTexture = true;
+            PropertyValue textureProp = properties.getLastWithoutMetadata("citresewn", "texture", "tile");
+            assetIdentifier = resolveAsset(properties.identifier, textureProp, "textures", ".png", resourceManager);
+            if (assetIdentifier != null)
+                assetIdentifiers.put(null, assetIdentifier);
+
+            for (PropertyValue property : properties.get("citresewn", "texture", "tile")) {
+                Identifier subIdentifier = resolveAsset(properties.identifier, property, "textures", ".png", resourceManager);
+                if (subIdentifier == null)
+                    throw new CITParsingException("Cannot resolve path", properties, property.position());
+
+                String subItem = property.keyMetadata();
+                Identifier subItemIdentifier = fixDeprecatedSubItem(subItem, properties, property.position());
+                assetIdentifiers.put(subItemIdentifier == null ? new Identifier("minecraft", "item/" + subItem) : subItemIdentifier, subIdentifier);
+            }
+        } else { // attempt to load textureOverrideMap from textures
+            PropertyValue textureProp = properties.getLastWithoutMetadata("citresewn", "texture", "tile");
+            if (textureProp != null) {
+                assetIdentifier = resolveAsset(properties.identifier, textureProp, "textures", ".png", resourceManager);
+                if (assetIdentifier != null)
+                    textureOverrideMap.put(null, Either.left(new SpriteIdentifier(SpriteAtlasTexture.BLOCK_ATLAS_TEXTURE, new ResewnTextureIdentifier(assetIdentifier))));
+                else
+                    throw new CITParsingException("Cannot resolve path", properties, textureProp.position());
             }
 
-            if (assetIdentifiers.size() == 0)
-                throw new Exception("Cannot resolve path for model/texture");
-        } catch (Exception e) {
-            throw new CITParseException(pack.resourcePack, identifier, (e.getClass() == Exception.class ? "" : e.getClass().getSimpleName() + ": ") + e.getMessage());
+            for (PropertyValue property : properties.get("citresewn", "texture", "tile")) {
+                textureProp = property;
+                Identifier subIdentifier = resolveAsset(properties.identifier, textureProp, "textures", ".png", resourceManager);
+                if (subIdentifier == null)
+                    throw new CITParsingException("Cannot resolve path", properties, property.position());
+
+                textureOverrideMap.put(property.keyMetadata(), Either.left(new SpriteIdentifier(SpriteAtlasTexture.BLOCK_ATLAS_TEXTURE, new ResewnTextureIdentifier(subIdentifier))));
+            }
         }
+
+        if (assetIdentifiers.size() == 0)
+            throw new CITParsingException("Could not resolve a replacement model/texture", properties, -1);
     }
 
-    public void loadUnbakedAssets(ResourceManager resourceManager) throws CITLoadException {
+    public void loadUnbakedAssets(ResourceManager resourceManager) throws Exception {
         try {
             if (isTexture) {
                 JsonUnbakedModel itemJson = getModelForFirstItemType(resourceManager);
@@ -212,7 +227,7 @@ public class CITItem extends CIT {
                         Collections.reverse(overrideModels);
 
                         for (Identifier overrideModel : overrideModels) {
-                            Identifier replacement = resolvePath(baseIdentifier, overrideModel.toString(), ".json", resourceManager::containsResource);
+                            Identifier replacement = resolveAsset(baseIdentifier, overrideModel.toString(), "models", ".json", resourceManager);
                             if (replacement != null) {
                                 String subTexturePath = replacement.toString().substring(0, replacement.toString().lastIndexOf('.'));
                                 final String subTextureName = subTexturePath.substring(subTexturePath.lastIndexOf('/') + 1);
@@ -274,8 +289,6 @@ public class CITItem extends CIT {
                     }
                 }
             }
-        } catch (Exception e) {
-            throw new CITLoadException(pack.resourcePack, propertiesIdentifier, (e.getClass() == Exception.class ? "" : e.getClass().getSimpleName() + ": ") + e.getMessage());
         } finally {
             assetIdentifiers = null;
             textureOverrideMap = null;
@@ -302,7 +315,7 @@ public class CITItem extends CIT {
                 ((JsonUnbakedModelAccessor) json).getTextureMap().replaceAll((layer, original) -> {
                     Optional<SpriteIdentifier> left = original.left();
                     if (left.isPresent()) {
-                        Identifier resolvedIdentifier = resolvePath(identifier, left.get().getTextureId().getPath(), ".png", resourceManager::containsResource);
+                        Identifier resolvedIdentifier = resolveAsset(identifier, left.get().getTextureId().getPath(), "textures", ".png", resourceManager);
                         if (resolvedIdentifier != null)
                             return Either.left(new SpriteIdentifier(left.get().getAtlasId(), new ResewnTextureIdentifier(resolvedIdentifier)));
                     }
@@ -337,7 +350,7 @@ public class CITItem extends CIT {
                 if (parentId != null) {
                     String[] parentIdPathSplit = parentId.getPath().split("/");
                     if (parentId.getPath().startsWith("./") || (parentIdPathSplit.length > 2 && parentIdPathSplit[1].equals("cit"))) {
-                        parentId = resolvePath(identifier, parentId.getPath(), ".json", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
+                        parentId = resolveAsset(identifier, parentId.getPath(), "models", ".json", resourceManager);
                         if (parentId != null)
                             ((JsonUnbakedModelAccessor) json).setParentId(new ResewnItemModelIdentifier(parentId));
                     }
@@ -346,7 +359,7 @@ public class CITItem extends CIT {
                 json.getOverrides().replaceAll(override -> {
                     String[] modelIdPathSplit = override.getModelId().getPath().split("/");
                     if (override.getModelId().getPath().startsWith("./") || (modelIdPathSplit.length > 2 && modelIdPathSplit[1].equals("cit"))) {
-                        Identifier resolvedOverridePath = resolvePath(identifier, override.getModelId().getPath(), ".json", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
+                        Identifier resolvedOverridePath = resolveAsset(identifier, override.getModelId().getPath(), "models", ".json", resourceManager);
                         if (resolvedOverridePath != null)
                             return new ModelOverride(new ResewnItemModelIdentifier(resolvedOverridePath), override.streamConditions().collect(Collectors.toList()));
                     }
@@ -381,7 +394,9 @@ public class CITItem extends CIT {
         throw new Exception("Unknown asset type");
     }
 
-    public Identifier fixDeprecatedSubItem(String subItem) {
+    public Identifier fixDeprecatedSubItem(String subItem, PropertyGroup properties, int position) {
+        if (subItem == null)
+            return null;
         String replacement = switch (subItem) {
             case "bow_pulling_standby" -> "bow";
             case "crossbow_standby" -> "crossbow";
@@ -394,7 +409,7 @@ public class CITItem extends CIT {
         };
 
         if (replacement != null) {
-            CITResewn.logWarnLoading("CIT Warning: Using deprecated sub item id \"" + subItem + "\" instead of \"" + replacement + "\" in " + pack.resourcePack.getName() + " -> " + propertiesIdentifier.toString());
+            CITResewn.logWarnLoading(properties.messageWithDescriptorOf("Warning: Using deprecated sub item id \"" + subItem + "\" instead of \"" + replacement + "\"", position));
 
             return new Identifier("minecraft", "item/" + replacement);
         }
@@ -422,13 +437,14 @@ public class CITItem extends CIT {
         }
     }
 
-    public BakedModel getItemModel(ItemStack stack, ClientWorld world, LivingEntity entity, int seed) {
+    public BakedModel getItemModel(CITContext context, int seed) {
+        ClientWorld world = context.world instanceof ClientWorld clientWorld ? clientWorld : null;
         // get sub items or bakedModel if no sub item matches @Nullable
-        BakedModel bakedModel = bakedSubModels.apply(this.bakedModel, stack, world, entity, seed);
+        BakedModel bakedModel = bakedSubModels.apply(this.bakedModel, context.stack, world, context.entity, seed);
 
         // apply model overrides
         if (bakedModel != null && bakedModel.getOverrides() != null)
-            bakedModel = bakedModel.getOverrides().apply(bakedModel, stack, world, entity, seed);
+            bakedModel = bakedModel.getOverrides().apply(bakedModel, context.stack, world, context.entity, seed);
 
         return bakedModel;
     }
@@ -448,16 +464,57 @@ public class CITItem extends CIT {
 
             this.overrides[this.overrides.length - 1] = new BakedOverride(
                     key.stream()
-                        .map((condition) -> new InlinedCondition(object2IntMap.getInt(condition.getType()), condition.getThreshold()))
-                        .toArray(InlinedCondition[]::new)
+                            .map((condition) -> new InlinedCondition(object2IntMap.getInt(condition.getType()), condition.getThreshold()))
+                            .toArray(InlinedCondition[]::new)
                     , bakedModel);
         }
     }
 
-    public interface Cached {
-        CITItem citresewn_getCachedCITItem(Supplier<CITItem> realtime);
+    public static class Container extends CITTypeContainer<TypeItem> {
+        public Container() {
+            super(TypeItem.class, TypeItem::new, "item");
+        }
+
+        public Set<CIT<TypeItem>> loaded = new HashSet<>();
+        public Map<Item, Set<CIT<TypeItem>>> loadedTyped = new IdentityHashMap<>();
+
+        @Override
+        public void load(List<CIT<TypeItem>> parsedCITs) {
+            loaded.addAll(parsedCITs);
+            for (CIT<TypeItem> cit : parsedCITs)
+                for (CITCondition condition : cit.conditions)
+                    if (condition instanceof ConditionItems items)
+                        for (Item item : items.items)
+                            if (item != null)
+                                loadedTyped.computeIfAbsent(item, i -> new LinkedHashSet<>()).add(cit);
+        }
+
+        @Override
+        public void dispose() {
+            loaded.clear();
+            loadedTyped.clear();
+        }
+
+        public CIT<TypeItem> getCIT(CITContext context, int seed) {
+            return ((CITCacheItem) (Object) context.stack).citresewn$getCacheTypeItem().get(context).get();
+        }
+
+        public CIT<TypeItem> getRealTimeCIT(CITContext context) {
+            Set<CIT<TypeItem>> loadedForItemType = loadedTyped.get(context.stack.getItem());
+            if (loadedForItemType != null)
+                for (CIT<TypeItem> cit : loadedForItemType)
+                    if (cit.test(context))
+                        return cit;
+
+            return null;
+        }
+    }
+
+    public interface CITCacheItem {
+        CITCache.Single<TypeItem> citresewn$getCacheTypeItem();
+    }
 
-        boolean citresewn_isMojankCIT();
-        void citresewn_setMojankCIT(boolean mojankCIT);
+    public interface BakedModelManagerMixinAccess {
+        void citresewn$forceMojankModel(BakedModel model);
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/ResewnItemModelIdentifier.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/common/ResewnItemModelIdentifier.java
index c531983..498f61f 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/ResewnItemModelIdentifier.java
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/common/ResewnItemModelIdentifier.java
@@ -1,11 +1,9 @@
-package shcm.shsupercm.fabric.citresewn.pack;
+package shcm.shsupercm.fabric.citresewn.defaults.common;
 
 import net.minecraft.util.Identifier;
-import shcm.shsupercm.fabric.citresewn.mixin.core.ModelLoaderMixin;
 
 /**
- * Marks models as cit item models.
- * @see ModelLoaderMixin
+ * Marks models as cit models.
  */
 public class ResewnItemModelIdentifier extends Identifier {
     public ResewnItemModelIdentifier(String id) {
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/ResewnTextureIdentifier.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/common/ResewnTextureIdentifier.java
index 033c567..a6dd2ef 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/ResewnTextureIdentifier.java
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/common/ResewnTextureIdentifier.java
@@ -1,11 +1,9 @@
-package shcm.shsupercm.fabric.citresewn.pack;
+package shcm.shsupercm.fabric.citresewn.defaults.common;
 
 import net.minecraft.util.Identifier;
-import shcm.shsupercm.fabric.citresewn.mixin.core.SpriteAtlasTextureMixin;
 
 /**
  * Marks path identifiers as forced literal texture paths.
- * @see SpriteAtlasTextureMixin
  */
 public class ResewnTextureIdentifier extends Identifier {
     public ResewnTextureIdentifier(Identifier identifier) {
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsConfig.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsConfig.java
new file mode 100644
index 0000000..41126d2
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsConfig.java
@@ -0,0 +1,50 @@
+package shcm.shsupercm.fabric.citresewn.defaults.config;
+
+import com.google.gson.Gson;
+import com.google.gson.stream.JsonWriter;
+import org.apache.commons.io.IOUtils;
+import shcm.shsupercm.fabric.citresewn.CITResewn;
+
+import java.io.*;
+
+public class CITResewnDefaultsConfig {
+    public float type_enchantment_scroll_multiplier = 1f;
+
+    private static final File FILE = new File("config/citresewn-defaults.json");
+
+    public static final CITResewnDefaultsConfig INSTANCE = read();
+
+    public static CITResewnDefaultsConfig read() {
+        if (!FILE.exists())
+            return new CITResewnDefaultsConfig().write();
+
+        Reader reader = null;
+        try {
+            return new Gson().fromJson(reader = new FileReader(FILE), CITResewnDefaultsConfig.class);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        } finally {
+            IOUtils.closeQuietly(reader);
+        }
+    }
+
+    public CITResewnDefaultsConfig write() {
+        Gson gson = new Gson();
+        JsonWriter writer = null;
+        try {
+            FILE.getParentFile().mkdirs();
+            writer = gson.newJsonWriter(new FileWriter(FILE));
+            writer.setIndent("    ");
+
+            gson.toJson(gson.toJsonTree(this, CITResewnDefaultsConfig.class), writer);
+        } catch (Exception e) {
+            CITResewn.LOG.error("Couldn't save defaults config");
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        } finally {
+            IOUtils.closeQuietly(writer);
+        }
+        return this;
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsConfigScreenFactory.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsConfigScreenFactory.java
new file mode 100644
index 0000000..95b0579
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsConfigScreenFactory.java
@@ -0,0 +1,33 @@
+package shcm.shsupercm.fabric.citresewn.defaults.config;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import me.shedaniel.clothconfig2.api.ConfigBuilder;
+import me.shedaniel.clothconfig2.api.ConfigCategory;
+import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.LiteralText;
+import net.minecraft.text.TranslatableText;
+import shcm.shsupercm.fabric.citresewn.config.CITResewnConfigScreenFactory;
+
+public class CITResewnDefaultsConfigScreenFactory {
+    @Entrypoint(CITResewnConfigScreenFactory.DEFAULTS_CONFIG_ENTRYPOINT)
+    public static Screen create(Screen parent) {
+        CITResewnDefaultsConfig currentConfig = CITResewnDefaultsConfig.INSTANCE, defaultConfig = new CITResewnDefaultsConfig();
+
+        ConfigBuilder builder = ConfigBuilder.create()
+                .setParentScreen(parent)
+                .setTitle(new TranslatableText("config.citresewn-defaults.title"))
+                .setSavingRunnable(currentConfig::write);
+
+        ConfigCategory category = builder.getOrCreateCategory(new LiteralText(""));
+        ConfigEntryBuilder entryBuilder = builder.entryBuilder();
+
+        category.addEntry(entryBuilder.startFloatField(new TranslatableText("config.citresewn-defaults.type_enchantment_scroll_multiplier.title"), currentConfig.type_enchantment_scroll_multiplier)
+                .setTooltip(new TranslatableText("config.citresewn-defaults.type_enchantment_scroll_multiplier.tooltip"))
+                .setSaveConsumer(newConfig -> currentConfig.type_enchantment_scroll_multiplier = newConfig)
+                .setDefaultValue(defaultConfig.type_enchantment_scroll_multiplier)
+                .build());
+
+        return builder.build();
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsModMenu.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsModMenu.java
new file mode 100644
index 0000000..48edf33
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/config/CITResewnDefaultsModMenu.java
@@ -0,0 +1,27 @@
+package shcm.shsupercm.fabric.citresewn.defaults.config;
+
+import com.terraformersmc.modmenu.api.ConfigScreenFactory;
+import com.terraformersmc.modmenu.api.ModMenuApi;
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.NoticeScreen;
+import net.minecraft.text.Text;
+
+@Entrypoint("modmenu")
+public class CITResewnDefaultsModMenu implements ModMenuApi {
+    @Override
+    public ConfigScreenFactory<?> getModConfigScreenFactory() {
+        if (FabricLoader.getInstance().isModLoaded("cloth-config2"))
+            return new ClothConfigOpenImpl().getModConfigScreenFactory();
+
+        return parent -> new NoticeScreen(() -> MinecraftClient.getInstance().setScreen(parent), Text.of("CIT Resewn: Defaults"), Text.of("CIT Resewn requires Cloth Config to be able to show the config."));
+    }
+
+    private static class ClothConfigOpenImpl implements ModMenuApi {
+        @Override
+        public ConfigScreenFactory<?> getModConfigScreenFactory() {
+            return CITResewnDefaultsConfigScreenFactory::create;
+        }
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/common/ModelLoaderMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/common/ModelLoaderMixin.java
new file mode 100644
index 0000000..8ed0e20
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/common/ModelLoaderMixin.java
@@ -0,0 +1,87 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.common;
+
+import com.mojang.datafixers.util.Either;
+import net.minecraft.client.render.model.ModelLoader;
+import net.minecraft.client.render.model.json.JsonUnbakedModel;
+import net.minecraft.client.render.model.json.ModelOverride;
+import net.minecraft.client.util.SpriteIdentifier;
+import net.minecraft.resource.Resource;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import org.apache.commons.io.IOUtils;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.cit.CITType;
+import shcm.shsupercm.fabric.citresewn.defaults.common.ResewnItemModelIdentifier;
+import shcm.shsupercm.fabric.citresewn.defaults.common.ResewnTextureIdentifier;
+import shcm.shsupercm.fabric.citresewn.defaults.mixin.types.item.JsonUnbakedModelAccessor;
+
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ * Will be rewritten at some point.
+ */
+@Mixin(ModelLoader.class)
+public class ModelLoaderMixin {
+    @Shadow @Final private ResourceManager resourceManager;
+
+    @Inject(method = "loadModelFromJson", cancellable = true, at = @At("HEAD"))
+    public void citresewn$forceLiteralResewnModelIdentifier(Identifier id, CallbackInfoReturnable<JsonUnbakedModel> cir) {
+        if (id instanceof ResewnItemModelIdentifier) {
+            InputStream is = null;
+            Resource resource = null;
+            try {
+                JsonUnbakedModel json = JsonUnbakedModel.deserialize(IOUtils.toString(is = (resource = resourceManager.getResource(id)).getInputStream(), StandardCharsets.UTF_8));
+                json.id = id.toString();
+                json.id = json.id.substring(0, json.id.length() - 5);
+
+                ((JsonUnbakedModelAccessor) json).getTextureMap().replaceAll((layer, original) -> {
+                    Optional<SpriteIdentifier> left = original.left();
+                    if (left.isPresent()) {
+                        String originalPath = left.get().getTextureId().getPath();
+                        String[] split = originalPath.split("/");
+                        if (originalPath.startsWith("./") || (split.length > 2 && split[1].equals("cit"))) {
+                            Identifier resolvedIdentifier = CITType.resolveAsset(id, originalPath, "textures", ".png", resourceManager);
+                            if (resolvedIdentifier != null)
+                                return Either.left(new SpriteIdentifier(left.get().getAtlasId(), new ResewnTextureIdentifier(resolvedIdentifier)));
+                        }
+                    }
+                    return original;
+                });
+
+                Identifier parentId = ((JsonUnbakedModelAccessor) json).getParentId();
+                if (parentId != null) {
+                    String[] parentIdPathSplit = parentId.getPath().split("/");
+                    if (parentId.getPath().startsWith("./") || (parentIdPathSplit.length > 2 && parentIdPathSplit[1].equals("cit"))) {
+                        parentId = CITType.resolveAsset(id, parentId.getPath(), "models", ".json", resourceManager);
+                        if (parentId != null)
+                            ((JsonUnbakedModelAccessor) json).setParentId(new ResewnItemModelIdentifier(parentId));
+                    }
+                }
+
+                json.getOverrides().replaceAll(override -> {
+                    String[] modelIdPathSplit = override.getModelId().getPath().split("/");
+                    if (override.getModelId().getPath().startsWith("./") || (modelIdPathSplit.length > 2 && modelIdPathSplit[1].equals("cit"))) {
+                        Identifier resolvedOverridePath = CITType.resolveAsset(id, override.getModelId().getPath(), "models", ".json", resourceManager);
+                        if (resolvedOverridePath != null)
+                            return new ModelOverride(new ResewnItemModelIdentifier(resolvedOverridePath), override.streamConditions().collect(Collectors.toList()));
+                    }
+
+                    return override;
+                });
+
+                cir.setReturnValue(json);
+            } catch (Exception ignored) {
+            } finally {
+                IOUtils.closeQuietly(is, resource);
+            }
+        }
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/SpriteAtlasTextureMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/common/SpriteAtlasTextureMixin.java
index 8cc195b..61eff5c 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/SpriteAtlasTextureMixin.java
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/common/SpriteAtlasTextureMixin.java
@@ -1,4 +1,4 @@
-package shcm.shsupercm.fabric.citresewn.mixin.core;
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.common;
 
 import net.minecraft.client.texture.SpriteAtlasTexture;
 import net.minecraft.util.Identifier;
@@ -6,7 +6,7 @@ import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import shcm.shsupercm.fabric.citresewn.pack.ResewnTextureIdentifier;
+import shcm.shsupercm.fabric.citresewn.defaults.common.ResewnTextureIdentifier;
 
 @Mixin(SpriteAtlasTexture.class)
 public class SpriteAtlasTextureMixin {
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/armor/ArmorFeatureRendererMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/armor/ArmorFeatureRendererMixin.java
new file mode 100644
index 0000000..d61af4c
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/armor/ArmorFeatureRendererMixin.java
@@ -0,0 +1,51 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.armor;
+
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.ArmorFeatureRenderer;
+import net.minecraft.client.render.entity.model.BipedEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.EquipmentSlot;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ArmorItem;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Identifier;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.cit.CIT;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeArmor;
+
+import java.util.Map;
+
+import static shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeArmor.CONTAINER;
+
+@Mixin(ArmorFeatureRenderer.class)
+public class ArmorFeatureRendererMixin<T extends LivingEntity, M extends BipedEntityModel<T>, A extends BipedEntityModel<T>> {
+    private Map<String, Identifier> citresewn$cachedTextures = null;
+
+    @Inject(method = "renderArmor", at = @At("HEAD"))
+    public void citresewn$renderArmor(MatrixStack matrices, VertexConsumerProvider vertexConsumers, T entity, EquipmentSlot armorSlot, int light, A model, CallbackInfo ci) {
+        citresewn$cachedTextures = null;
+        if (!CONTAINER.active())
+            return;
+
+        ItemStack equippedStack = entity.getEquippedStack(armorSlot);
+
+        CIT<TypeArmor> cit = CONTAINER.getCIT(new CITContext(equippedStack, entity.getWorld(), entity));
+        if (cit != null)
+            citresewn$cachedTextures = cit.type.textures;
+    }
+
+    @Inject(method = "getArmorTexture", cancellable = true, at = @At("HEAD"))
+    private void citresewn$getArmorTexture(ArmorItem item, boolean legs, String overlay, CallbackInfoReturnable<Identifier> cir) {
+        if (citresewn$cachedTextures == null)
+            return;
+
+        Identifier identifier = citresewn$cachedTextures.get(item.getMaterial().getName() + "_layer_" + (legs ? "2" : "1") + (overlay == null ? "" : "_" + overlay));
+        if (identifier != null)
+            cir.setReturnValue(identifier);
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/armor/ItemStackMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/armor/ItemStackMixin.java
new file mode 100644
index 0000000..85b0d22
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/armor/ItemStackMixin.java
@@ -0,0 +1,16 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.armor;
+
+import net.minecraft.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import shcm.shsupercm.fabric.citresewn.cit.CITCache;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeArmor;
+
+@Mixin(ItemStack.class)
+public class ItemStackMixin implements TypeArmor.CITCacheArmor {
+    private final CITCache.Single<TypeArmor> citresewn$cacheTypeArmor = new CITCache.Single<>(TypeArmor.CONTAINER::getRealTimeCIT);
+
+    @Override
+    public CITCache.Single<TypeArmor> citresewn$getCacheTypeArmor() {
+        return this.citresewn$cacheTypeArmor;
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/elytra/ElytraFeatureRendererMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/elytra/ElytraFeatureRendererMixin.java
new file mode 100644
index 0000000..0772adf
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/elytra/ElytraFeatureRendererMixin.java
@@ -0,0 +1,42 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.elytra;
+
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.ElytraFeatureRenderer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.EquipmentSlot;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.util.Identifier;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import shcm.shsupercm.fabric.citresewn.cit.CIT;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeElytra;
+
+import static shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeElytra.CONTAINER;
+
+@Mixin(ElytraFeatureRenderer.class)
+public class ElytraFeatureRendererMixin {
+    @Shadow @Mutable @Final private static Identifier SKIN;
+
+    private final static Identifier citresewn$ORIGINAL_SKIN = SKIN;
+
+    @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/entity/LivingEntity;FFFFFF)V", at = @At("HEAD"))
+    public void citresewn$render(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, LivingEntity livingEntity, float f, float g, float h, float j, float k, float l, CallbackInfo ci) {
+        if (!CONTAINER.active())
+            return;
+
+        ItemStack equippedStack = livingEntity.getEquippedStack(EquipmentSlot.CHEST);
+        if (!equippedStack.isOf(Items.ELYTRA))
+            return;
+
+        CIT<TypeElytra> cit = CONTAINER.getCIT(new CITContext(equippedStack, livingEntity.getWorld(), livingEntity));
+        SKIN = cit == null ? citresewn$ORIGINAL_SKIN : cit.type.texture;
+    }
+}
\ No newline at end of file
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/elytra/ItemStackMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/elytra/ItemStackMixin.java
new file mode 100644
index 0000000..a751fb9
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/elytra/ItemStackMixin.java
@@ -0,0 +1,16 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.elytra;
+
+import net.minecraft.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import shcm.shsupercm.fabric.citresewn.cit.CITCache;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeElytra;
+
+@Mixin(ItemStack.class)
+public class ItemStackMixin implements TypeElytra.CITCacheElytra {
+    private final CITCache.Single<TypeElytra> citresewn$cacheTypeElytra = new CITCache.Single<>(TypeElytra.CONTAINER::getRealTimeCIT);
+
+    @Override
+    public CITCache.Single<TypeElytra> citresewn$getCacheTypeElytra() {
+        return this.citresewn$cacheTypeElytra;
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ArmorFeatureRendererMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ArmorFeatureRendererMixin.java
new file mode 100644
index 0000000..4a852ca
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ArmorFeatureRendererMixin.java
@@ -0,0 +1,30 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment;
+
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.ArmorFeatureRenderer;
+import net.minecraft.client.render.entity.model.BipedEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.EquipmentSlot;
+import net.minecraft.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+
+import static shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeEnchantment.CONTAINER;
+
+@Mixin(ArmorFeatureRenderer.class)
+public class ArmorFeatureRendererMixin<T extends LivingEntity, M extends BipedEntityModel<T>, A extends BipedEntityModel<T>> {
+    @Inject(method = "renderArmor", at = @At("HEAD"))
+    private void citresewn$enchantment$setAppliedContextAndStartApplyingArmor(MatrixStack matrices, VertexConsumerProvider vertexConsumers, T livingEntity, EquipmentSlot armorSlot, int light, A model, CallbackInfo ci) {
+        if (CONTAINER.active())
+            CONTAINER.setContext(new CITContext(livingEntity.getEquippedStack(armorSlot), livingEntity.world, livingEntity)).apply();
+    }
+
+    @Inject(method = "renderArmor", at = @At("RETURN"))
+    private void citresewn$enchantment$stopApplyingArmor(MatrixStack matrices, VertexConsumerProvider vertexConsumers, T livingEntity, EquipmentSlot armorSlot, int light, A model, CallbackInfo ci) {
+        if (CONTAINER.active())
+            CONTAINER.setContext(null);
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/BufferBuilderStorageAccessor.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/BufferBuilderStorageAccessor.java
index 619a82d..e23e091 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/BufferBuilderStorageAccessor.java
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/BufferBuilderStorageAccessor.java
@@ -1,4 +1,4 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citenchantment;
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment;
 
 import net.minecraft.client.render.BufferBuilder;
 import net.minecraft.client.render.BufferBuilderStorage;
@@ -10,6 +10,6 @@ import java.util.SortedMap;
 
 @Mixin(BufferBuilderStorage.class)
 public interface BufferBuilderStorageAccessor {
-    @Accessor("entityBuilders")
-    SortedMap<RenderLayer, BufferBuilder> entityBuilders();
+    @Accessor
+    SortedMap<RenderLayer, BufferBuilder> getEntityBuilders();
 }
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ElytraFeatureRendererMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ElytraFeatureRendererMixin.java
new file mode 100644
index 0000000..c64fb77
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ElytraFeatureRendererMixin.java
@@ -0,0 +1,29 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment;
+
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.ElytraFeatureRenderer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.EquipmentSlot;
+import net.minecraft.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+
+import static shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeEnchantment.CONTAINER;
+
+@Mixin(ElytraFeatureRenderer.class)
+public class ElytraFeatureRendererMixin {
+    @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/entity/LivingEntity;FFFFFF)V", at = @At("HEAD"))
+    private void citresewn$enchantment$setAppliedContextAndStartApplyingElytra(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, LivingEntity livingEntity, float f, float g, float h, float j, float k, float l, CallbackInfo ci) {
+        if (CONTAINER.active())
+            CONTAINER.setContext(new CITContext(livingEntity.getEquippedStack(EquipmentSlot.CHEST), livingEntity.world, livingEntity)).apply();
+    }
+
+    @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/entity/LivingEntity;FFFFFF)V", at = @At("RETURN"))
+    private void citresewn$enchantment$stopApplyingElytra(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, LivingEntity livingEntity, float f, float g, float h, float j, float k, float l, CallbackInfo ci) {
+        if (CONTAINER.active())
+            CONTAINER.setContext(null);
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ItemRendererMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ItemRendererMixin.java
new file mode 100644
index 0000000..b4bd37d
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ItemRendererMixin.java
@@ -0,0 +1,86 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.*;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeEnchantment;
+
+import static shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeEnchantment.CONTAINER;
+
+@Mixin(value = ItemRenderer.class, priority = 200)
+public class ItemRendererMixin {
+    @Inject(method = "getModel", at = @At("HEAD"))
+    private void citresewn$enchantment$setAppliedContext(ItemStack stack, World world, LivingEntity entity, int seed, CallbackInfoReturnable<BakedModel> cir) {
+        if (CONTAINER.active())
+            CONTAINER.setContext(new CITContext(stack, world, entity));
+    }
+
+    @Inject(method = "renderItem(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/render/model/json/ModelTransformation$Mode;ZLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/client/render/model/BakedModel;)V", at = @At("HEAD"))
+    private void citresewn$enchantment$startApplyingItem(ItemStack stack, ModelTransformation.Mode renderMode, boolean leftHanded, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, BakedModel model, CallbackInfo ci) {
+        if (CONTAINER.active())
+            CONTAINER.apply();
+    }
+
+    @Inject(method = "renderItem(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/render/model/json/ModelTransformation$Mode;ZLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/client/render/model/BakedModel;)V", at = @At("RETURN"))
+    private void citresewn$enchantment$stopApplyingItem(ItemStack stack, ModelTransformation.Mode renderMode, boolean leftHanded, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, BakedModel model, CallbackInfo ci) {
+        if (CONTAINER.active())
+            CONTAINER.setContext(null);
+    }
+
+    @Inject(method = "getArmorGlintConsumer", cancellable = true, at = @At("RETURN"))
+    private static void citresewn$enchantment$getArmorGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, boolean solid, boolean glint, CallbackInfoReturnable<VertexConsumer> cir) {
+        if (!CONTAINER.shouldApply())
+            return;
+        VertexConsumer vertexConsumer = solid ? TypeEnchantment.GlintRenderLayer.ARMOR_GLINT.tryApply(cir.getReturnValue(), layer, provider) : TypeEnchantment.GlintRenderLayer.ARMOR_ENTITY_GLINT.tryApply(cir.getReturnValue(), layer, provider);
+        if (vertexConsumer != null)
+            cir.setReturnValue(vertexConsumer);
+    }
+
+    @Inject(method = "getCompassGlintConsumer", cancellable = true, at = @At("RETURN"))
+    private static void citresewn$enchantment$getCompassGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, MatrixStack.Entry entry, CallbackInfoReturnable<VertexConsumer> cir) {
+        if (!CONTAINER.shouldApply())
+            return;
+        VertexConsumer vertexConsumer = TypeEnchantment.GlintRenderLayer.GLINT.tryApply(null, layer, provider);
+        if (vertexConsumer != null)
+            cir.setReturnValue(VertexConsumers.union(new OverlayVertexConsumer(vertexConsumer, entry.getPositionMatrix(), entry.getNormalMatrix()), cir.getReturnValue()));
+    }
+
+    @Inject(method = "getDirectCompassGlintConsumer", cancellable = true, at = @At("RETURN"))
+    private static void citresewn$enchantment$getDirectCompassGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, MatrixStack.Entry entry, CallbackInfoReturnable<VertexConsumer> cir) {
+        if (!CONTAINER.shouldApply())
+            return;
+        VertexConsumer vertexConsumer = TypeEnchantment.GlintRenderLayer.DIRECT_GLINT.tryApply(null, layer, provider);
+        if (vertexConsumer != null)
+            cir.setReturnValue(VertexConsumers.union(new OverlayVertexConsumer(vertexConsumer, entry.getPositionMatrix(), entry.getNormalMatrix()), cir.getReturnValue()));
+    }
+
+    @Inject(method = "getItemGlintConsumer", cancellable = true, at = @At("RETURN"))
+    private static void citresewn$enchantment$getItemGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, boolean solid, boolean glint, CallbackInfoReturnable<VertexConsumer> cir) {
+        if (!CONTAINER.shouldApply())
+            return;
+        VertexConsumer vertexConsumer = MinecraftClient.isFabulousGraphicsOrBetter() && layer == TexturedRenderLayers.getItemEntityTranslucentCull() ? TypeEnchantment.GlintRenderLayer.GLINT_TRANSLUCENT.tryApply(cir.getReturnValue(), layer, provider) : (solid ? TypeEnchantment.GlintRenderLayer.GLINT.tryApply(cir.getReturnValue(), layer, provider) : TypeEnchantment.GlintRenderLayer.ENTITY_GLINT.tryApply(cir.getReturnValue(), layer, provider));
+        if (vertexConsumer != null)
+            cir.setReturnValue(vertexConsumer);
+    }
+
+    @Inject(method = "getDirectItemGlintConsumer", cancellable = true, at = @At("RETURN"))
+    private static void citresewn$enchantment$getDirectItemGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, boolean solid, boolean glint, CallbackInfoReturnable<VertexConsumer> cir) {
+        if (!CONTAINER.shouldApply())
+            return;
+        VertexConsumer vertexConsumer = solid ? TypeEnchantment.GlintRenderLayer.DIRECT_GLINT.tryApply(cir.getReturnValue(), layer, provider) : TypeEnchantment.GlintRenderLayer.DIRECT_ENTITY_GLINT.tryApply(cir.getReturnValue(), layer, provider);
+        if (vertexConsumer != null)
+            cir.setReturnValue(vertexConsumer);
+    }
+}
\ No newline at end of file
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ItemStackMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ItemStackMixin.java
new file mode 100644
index 0000000..d49e116
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/ItemStackMixin.java
@@ -0,0 +1,25 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment;
+
+import net.minecraft.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.cit.CITCache;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeEnchantment;
+
+@Mixin(ItemStack.class)
+public class ItemStackMixin implements TypeEnchantment.CITCacheEnchantment {
+    private final CITCache.MultiList<TypeEnchantment> citresewn$cacheTypeEnchantment = new CITCache.MultiList<>(TypeEnchantment.CONTAINER::getRealTimeCIT);
+
+    @Override
+    public CITCache.MultiList<TypeEnchantment> citresewn$getCacheTypeEnchantment() {
+        return this.citresewn$cacheTypeEnchantment;
+    }
+
+    @Inject(method = "hasGlint", cancellable = true, at = @At("HEAD"))
+    private void citresewn$enchantment$disableDefaultGlint(CallbackInfoReturnable<Boolean> cir) {
+        if (TypeEnchantment.CONTAINER.shouldNotApplyDefaultGlint())
+            cir.setReturnValue(false);
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/MinecraftClientMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/MinecraftClientMixin.java
index a9bea56..e8b346b 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/MinecraftClientMixin.java
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/MinecraftClientMixin.java
@@ -1,17 +1,16 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citenchantment;
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment;
 
 import net.minecraft.client.MinecraftClient;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import static shcm.shsupercm.fabric.citresewn.pack.cits.CITEnchantment.MergeMethod.ticks;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeEnchantment;
 
 @Mixin(MinecraftClient.class)
 public class MinecraftClientMixin {
     @Inject(method = "tick", at = @At("HEAD"))
     public void onTick(CallbackInfo ci) {
-        ticks++;
+        TypeEnchantment.MergeMethodIntensity.MergeMethod.ticks++;
     }
 }
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/RenderPhaseAccessor.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/RenderPhaseAccessor.java
index 24e7c3c..b2a59b4 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/RenderPhaseAccessor.java
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/enchantment/RenderPhaseAccessor.java
@@ -1,4 +1,4 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citenchantment;
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.enchantment;
 
 import net.minecraft.client.render.RenderPhase;
 import org.spongepowered.asm.mixin.Mixin;
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/BakedModelManagerMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/BakedModelManagerMixin.java
new file mode 100644
index 0000000..f7f6b48
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/BakedModelManagerMixin.java
@@ -0,0 +1,29 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.item;
+
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.BakedModelManager;
+import net.minecraft.client.util.ModelIdentifier;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeItem;
+
+@Mixin(BakedModelManager.class)
+public class BakedModelManagerMixin implements TypeItem.BakedModelManagerMixinAccess {
+    private BakedModel citresewn$forcedMojankModel = null;
+
+    @Inject(method = "getModel", cancellable = true, at =
+    @At("HEAD"))
+    private void citresewn$getCITMojankModel(ModelIdentifier id, CallbackInfoReturnable<BakedModel> cir) {
+        if (citresewn$forcedMojankModel != null) {
+            cir.setReturnValue(citresewn$forcedMojankModel);
+            citresewn$forcedMojankModel = null;
+        }
+    }
+
+    @Override
+    public void citresewn$forceMojankModel(BakedModel model) {
+        this.citresewn$forcedMojankModel = model;
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ItemRendererMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ItemRendererMixin.java
new file mode 100644
index 0000000..5f59329
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ItemRendererMixin.java
@@ -0,0 +1,68 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.item;
+
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.item.ItemModels;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.json.ModelTransformation;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.cit.CIT;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeItem;
+
+import java.lang.ref.WeakReference;
+
+import static shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeItem.CONTAINER;
+
+/**
+ * Do not go through this class, it looks awful because it was ported from a "proof of concept".<br>
+ * The whole type will be rewritten at some point.
+ */
+@Mixin(ItemRenderer.class)
+public class ItemRendererMixin {
+    @Shadow @Final private ItemModels models;
+
+    private WeakReference<BakedModel> citresewn$mojankCITModel = null;
+
+    @Inject(method = "getModel", cancellable = true, at = @At("HEAD"))
+    private void citresewn$getItemModel(ItemStack stack, World world, LivingEntity entity, int seed, CallbackInfoReturnable<BakedModel> cir) {
+        if (!CONTAINER.active())
+            return;
+
+        CITContext context = new CITContext(stack, world, entity);
+        CIT<TypeItem> cit = CONTAINER.getCIT(context, seed);
+        citresewn$mojankCITModel = null;
+        if (cit != null) {
+            BakedModel citModel = cit.type.getItemModel(context, seed);
+
+            if (citModel != null) {
+                if (stack.isOf(Items.TRIDENT) || stack.isOf(Items.SPYGLASS)) {
+                    citresewn$mojankCITModel = new WeakReference<>(citModel);
+                } else
+                    cir.setReturnValue(citModel);
+            }
+        }
+    }
+
+    @Inject(method = "renderItem(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/render/model/json/ModelTransformation$Mode;ZLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/client/render/model/BakedModel;)V", at = @At("HEAD"))
+    private void citresewn$fixMojankCITsContext(ItemStack stack, ModelTransformation.Mode renderMode, boolean leftHanded, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, BakedModel model, CallbackInfo ci) {
+        if (!CONTAINER.active() || citresewn$mojankCITModel == null)
+            return;
+
+        if (renderMode == ModelTransformation.Mode.GUI || renderMode == ModelTransformation.Mode.GROUND || renderMode == ModelTransformation.Mode.FIXED)
+            ((TypeItem.BakedModelManagerMixinAccess) this.models.getModelManager()).citresewn$forceMojankModel(citresewn$mojankCITModel.get());
+
+        citresewn$mojankCITModel = null;
+    }
+}
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ItemStackMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ItemStackMixin.java
new file mode 100644
index 0000000..450d8a3
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ItemStackMixin.java
@@ -0,0 +1,16 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.item;
+
+import net.minecraft.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import shcm.shsupercm.fabric.citresewn.cit.CITCache;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeItem;
+
+@Mixin(ItemStack.class)
+public class ItemStackMixin implements TypeItem.CITCacheItem {
+    private final CITCache.Single<TypeItem> citresewn$cacheTypeItem = new CITCache.Single<>(TypeItem.CONTAINER::getRealTimeCIT);
+
+    @Override
+    public CITCache.Single<TypeItem> citresewn$getCacheTypeItem() {
+        return this.citresewn$cacheTypeItem;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/JsonUnbakedModelAccessor.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/JsonUnbakedModelAccessor.java
index f997d3e..350d01a 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/JsonUnbakedModelAccessor.java
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/JsonUnbakedModelAccessor.java
@@ -1,4 +1,4 @@
-package shcm.shsupercm.fabric.citresewn.mixin.cititem;
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.item;
 
 import com.mojang.datafixers.util.Either;
 import net.minecraft.client.render.model.json.JsonUnbakedModel;
diff --git a/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ModelLoaderMixin.java b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ModelLoaderMixin.java
new file mode 100644
index 0000000..93bab6a
--- /dev/null
+++ b/defaults/src/main/java/shcm/shsupercm/fabric/citresewn/defaults/mixin/types/item/ModelLoaderMixin.java
@@ -0,0 +1,99 @@
+package shcm.shsupercm.fabric.citresewn.defaults.mixin.types.item;
+
+import net.minecraft.client.color.block.BlockColors;
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.ModelLoader;
+import net.minecraft.client.render.model.SpriteAtlasManager;
+import net.minecraft.client.render.model.UnbakedModel;
+import net.minecraft.client.render.model.json.JsonUnbakedModel;
+import net.minecraft.client.render.model.json.ModelOverride;
+import net.minecraft.client.texture.TextureManager;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.profiler.Profiler;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyArg;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.CITResewn;
+import shcm.shsupercm.fabric.citresewn.cit.CIT;
+import shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeItem;
+import shcm.shsupercm.fabric.citresewn.defaults.common.ResewnItemModelIdentifier;
+
+import java.util.*;
+
+import static shcm.shsupercm.fabric.citresewn.CITResewn.info;
+import static shcm.shsupercm.fabric.citresewn.defaults.cit.types.TypeItem.CONTAINER;
+
+@Mixin(ModelLoader.class)
+public class ModelLoaderMixin {
+    @Shadow @Final private Set<Identifier> modelsToLoad;
+    @Shadow @Final private Map<Identifier, UnbakedModel> modelsToBake;
+    @Shadow @Final private Map<Identifier, UnbakedModel> unbakedModels;
+    @Shadow @Final private Map<Identifier, BakedModel> bakedModels;
+
+    @Inject(method = "<init>", at =
+    @At(value = "INVOKE", ordinal = 0, target = "Lnet/minecraft/util/profiler/Profiler;swap(Ljava/lang/String;)V"))
+    public void citresewn$addTypeItemModels(ResourceManager resourceManager, BlockColors blockColors, Profiler profiler, int i, CallbackInfo ci) {
+        profiler.swap("citresewn:type_item_models");
+        if (!CONTAINER.active())
+            return;
+
+        info("Loading item CIT models...");
+        for (CIT<TypeItem> cit : CONTAINER.loaded)
+            try {
+                cit.type.loadUnbakedAssets(resourceManager);
+
+                for (JsonUnbakedModel unbakedModel : cit.type.unbakedAssets.values()) {
+                    ResewnItemModelIdentifier id = new ResewnItemModelIdentifier(unbakedModel.id);
+                    this.unbakedModels.put(id, unbakedModel);
+                    this.modelsToLoad.addAll(unbakedModel.getModelDependencies());
+                    this.modelsToBake.put(id, unbakedModel);
+                }
+            } catch (Exception e) {
+                CITResewn.logErrorLoading("Errored loading model in " + cit.propertiesIdentifier + " from " + cit.packName);
+                e.printStackTrace();
+            }
+
+        TypeItem.GENERATED_SUB_CITS_SEEN.clear();
+    }
+
+    @Inject(method = "upload", at = @At("RETURN"))
+    public void citresewn$linkTypeItemModels(TextureManager textureManager, Profiler profiler, CallbackInfoReturnable<SpriteAtlasManager> cir) {
+        if (!CONTAINER.active())
+            return;
+
+        profiler.push("citresewn:type_item_linking");
+        info("Linking baked models to item CITs...");
+
+        for (CIT<TypeItem> cit : CONTAINER.loaded) {
+            for (Map.Entry<List<ModelOverride.Condition>, JsonUnbakedModel> citModelEntry : cit.type.unbakedAssets.entrySet()) {
+                if (citModelEntry.getKey() == null) {
+                    cit.type.bakedModel = this.bakedModels.get(new ResewnItemModelIdentifier(citModelEntry.getValue().id));
+                } else {
+                    BakedModel bakedModel = bakedModels.get(new ResewnItemModelIdentifier(citModelEntry.getValue().id));
+                    if (bakedModel == null)
+                        CITResewn.logWarnLoading("Skipping sub cit: Failed loading model for \"" + citModelEntry.getValue().id + "\" in " + cit.propertiesIdentifier + " from " + cit.packName);
+                    else
+                        cit.type.bakedSubModels.override(citModelEntry.getKey(), bakedModel);
+                }
+            }
+            cit.type.unbakedAssets = null;
+        }
+
+        profiler.pop();
+    }
+
+    @ModifyArg(method = "loadModelFromJson", at =
+    @At(value = "INVOKE", target = "Lnet/minecraft/resource/ResourceManager;getResource(Lnet/minecraft/util/Identifier;)Lnet/minecraft/resource/Resource;"))
+    public Identifier citresewn$fixDuplicatePrefixSuffix(Identifier original) {
+        if (CONTAINER.active() && original.getPath().startsWith("models/models/") && original.getPath().endsWith(".json.json") && original.getPath().contains("cit"))
+            return new Identifier(original.getNamespace(), original.getPath().substring(7, original.getPath().length() - 5));
+
+        return original;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/util/logic/Loops.java b/defaults/src/main/java/shcm/shsupercm/util/logic/Loops.java
index 6c18244..6c18244 100644
--- a/src/main/java/shcm/shsupercm/util/logic/Loops.java
+++ b/defaults/src/main/java/shcm/shsupercm/util/logic/Loops.java
diff --git a/defaults/src/main/resources/assets/citresewn-defaults/lang/en_us.json b/defaults/src/main/resources/assets/citresewn-defaults/lang/en_us.json
new file mode 100644
index 0000000..5f68e45
--- /dev/null
+++ b/defaults/src/main/resources/assets/citresewn-defaults/lang/en_us.json
@@ -0,0 +1,7 @@
+{
+  "config.citresewn-defaults.title": "CIT Resewn: Defaults",
+  "config.citresewn-defaults.tooltip": "Go to the defaults' config menu",
+
+  "config.citresewn-defaults.type_enchantment_scroll_multiplier.title": "Type Enchantment: Scroll multiplier",
+  "config.citresewn-defaults.type_enchantment_scroll_multiplier.tooltip": "A general multiplier for how fast cit enchantment glints scroll"
+}
\ No newline at end of file
diff --git a/defaults/src/main/resources/assets/citresewn-defaults/logo.png b/defaults/src/main/resources/assets/citresewn-defaults/logo.png
new file mode 100644
index 0000000..35859ac
--- /dev/null
+++ b/defaults/src/main/resources/assets/citresewn-defaults/logo.png
diff --git a/defaults/src/main/resources/citresewn-defaults.accesswidener b/defaults/src/main/resources/citresewn-defaults.accesswidener
new file mode 100644
index 0000000..739fc5e
--- /dev/null
+++ b/defaults/src/main/resources/citresewn-defaults.accesswidener
@@ -0,0 +1,30 @@
+accessWidener v1 named
+
+# ConditionNBT
+accessible   field   net/minecraft/nbt/NbtCompound entries Ljava/util/Map;
+
+# TypeItem
+accessible   class   net/minecraft/client/render/model/json/ModelOverrideList$BakedOverride
+accessible   class   net/minecraft/client/render/model/json/ModelOverrideList$InlinedCondition
+accessible   method  net/minecraft/client/render/model/json/ModelOverrideList <init> ()V
+accessible   method  net/minecraft/client/render/model/json/ModelOverrideList$BakedOverride <init> ([Lnet/minecraft/client/render/model/json/ModelOverrideList$InlinedCondition;Lnet/minecraft/client/render/model/BakedModel;)V
+accessible   method  net/minecraft/client/render/model/json/ModelOverrideList$InlinedCondition <init> (IF)V
+accessible   field   net/minecraft/client/render/model/json/ModelOverrideList overrides [Lnet/minecraft/client/render/model/json/ModelOverrideList$BakedOverride;
+mutable      field   net/minecraft/client/render/model/json/ModelOverrideList overrides [Lnet/minecraft/client/render/model/json/ModelOverrideList$BakedOverride;
+accessible   field   net/minecraft/client/render/model/json/ModelOverrideList conditionTypes [Lnet/minecraft/util/Identifier;
+mutable      field   net/minecraft/client/render/model/json/ModelOverrideList conditionTypes [Lnet/minecraft/util/Identifier;
+
+# TypeEnchantment
+accessible   class   net/minecraft/client/render/RenderLayer$MultiPhaseParameters
+accessible   method  net/minecraft/client/render/RenderLayer of (Ljava/lang/String;Lnet/minecraft/client/render/VertexFormat;Lnet/minecraft/client/render/VertexFormat$DrawMode;ILnet/minecraft/client/render/RenderLayer$MultiPhaseParameters;)Lnet/minecraft/client/render/RenderLayer$MultiPhase;
+accessible   class   net/minecraft/client/render/RenderPhase$Shader
+accessible   class   net/minecraft/client/render/RenderPhase$Texturing
+accessible   class   net/minecraft/client/render/RenderPhase$Transparency
+accessible   class   net/minecraft/client/render/RenderPhase$Texture
+accessible   class   net/minecraft/client/render/RenderPhase$Lightmap
+accessible   class   net/minecraft/client/render/RenderPhase$Overlay
+accessible   class   net/minecraft/client/render/RenderPhase$Cull
+accessible   class   net/minecraft/client/render/RenderPhase$DepthTest
+accessible   class   net/minecraft/client/render/RenderPhase$WriteMaskState
+accessible   class   net/minecraft/client/render/RenderPhase$Layering
+accessible   class   net/minecraft/client/render/RenderPhase$Target
\ No newline at end of file
diff --git a/defaults/src/main/resources/citresewn-defaults.mixins.json b/defaults/src/main/resources/citresewn-defaults.mixins.json
new file mode 100644
index 0000000..536380b
--- /dev/null
+++ b/defaults/src/main/resources/citresewn-defaults.mixins.json
@@ -0,0 +1,9 @@
+{
+  "required": true,
+  "minVersion": "0.8",
+  "package": "shcm.shsupercm.fabric.citresewn.defaults.mixin",
+  "compatibilityLevel": "JAVA_17",
+  "injectors": {
+    "defaultRequire": 1
+  }
+}
diff --git a/defaults/src/main/resources/fabric.mod.json b/defaults/src/main/resources/fabric.mod.json
new file mode 100644
index 0000000..f35e7bb
--- /dev/null
+++ b/defaults/src/main/resources/fabric.mod.json
@@ -0,0 +1,36 @@
+{
+  "schemaVersion": 1,
+  "id": "citresewn-defaults",
+  "version": "${version}",
+  "name": "CIT Resewn: Defaults",
+  "description": "Default types and conditions for CIT Resewn",
+  "authors": [
+    "SHsuperCM"
+  ],
+  "license": "MIT",
+  "icon": "assets/citresewn-defaults/logo.png",
+  "contact": {
+    "homepage": "https://citresewn.shcm.io/",
+    "sources": "https://github.com/SHsuperCM/CITResewn",
+    "issues": "https://github.com/SHsuperCM/CITResewn/issues"
+  },
+
+  "environment": "client",
+  "accessWidener" : "citresewn-defaults.accesswidener",
+  "mixins": [
+    "citresewn-defaults.mixins.json"
+  ],
+  "custom": {
+    "modmenu": {
+      "parent": {
+        "id": "citresewn"
+      }
+    }
+  },
+  "depends": {
+    "citresewn": "${version}"
+  },
+  "conflicts": {
+    "eatinganimationid": "*"
+  }
+}
diff --git a/gradle.properties b/gradle.properties
index d24d6cd..425af40 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -3,18 +3,18 @@ org.gradle.jvmargs=-Xmx1G
 
 # Fabric Properties
 # check these on https://modmuss50.me/fabric.html
-minecraft_version=1.18.1
+minecraft_version=1.18.2
 minecraft_version_compat=1.18.x
-yarn_mappings=1.18.1+build.18
-loader_version=0.12.12
+yarn_mappings=1.18.2+build.1
+loader_version=0.13.3
 
-fabric_api=0.45.0+1.18
+fabric_api=0.47.9+1.18.2
 modmenu=3.0.1
 cloth=6.1.48
 cosmetic_armor=3544655
 
 # Mod Properties
-mod_version=0.9.1
+mod_version=rewrite-SNAPSHOT
 maven_group=shcm.shsupercm.fabric
 archives_base_name=CITResewn
 
diff --git a/settings.gradle b/settings.gradle
index f91a4fe..4ab5170 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -7,3 +7,5 @@ pluginManagement {
         gradlePluginPortal()
     }
 }
+
+include 'defaults'
\ No newline at end of file
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/ActiveCITs.java b/src/main/java/shcm/shsupercm/fabric/citresewn/ActiveCITs.java
deleted file mode 100644
index 8d56a35..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/ActiveCITs.java
+++ /dev/null
@@ -1,187 +0,0 @@
-package shcm.shsupercm.fabric.citresewn;
-
-import net.minecraft.client.render.model.BakedModel;
-import net.minecraft.client.world.ClientWorld;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.ArmorItem;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.util.Hand;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.registry.Registry;
-import net.minecraft.world.World;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.CITPack;
-import shcm.shsupercm.fabric.citresewn.pack.cits.*;
-
-import java.util.*;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-
-public class ActiveCITs {
-    public final List<CITPack> packs;
-    public final CITPack effectiveGlobalProperties = new CITPack(null);
-
-    public final List<CIT> cits;
-
-    public final Map<Item, List<CITItem>> citItems = new HashMap<>();
-    public final Map<ArmorItem, List<CITArmor>> citArmor = new HashMap<>();
-    public final List<CITElytra> citElytra = new ArrayList<>();
-    public final List<List<CITEnchantment>> citEnchantments = new ArrayList<>();
-
-
-    public ActiveCITs(List<CITPack> packs, List<CIT> cits) {
-        this.packs = packs;
-        this.cits = cits;
-
-        for (CITPack pack : packs)
-            effectiveGlobalProperties.loadGlobalProperties(pack);
-        for (CITPack pack : packs)
-            pack.loadGlobalProperties(effectiveGlobalProperties);
-
-        Map<Integer, List<CITEnchantment>> citEnchantmentLayers = new TreeMap<>(); // order citEnchantments by layers
-
-        for (CIT cit : cits.stream().sorted(Comparator.<CIT>comparingInt(cit -> cit.weight).reversed().thenComparing(cit -> cit.propertiesIdentifier.toString())).collect(Collectors.toList())) {
-            if (cit instanceof CITItem item)
-                for (Item type : item.items)
-                    citItems.computeIfAbsent(type, t -> new ArrayList<>()).add(item);
-            else if (cit instanceof CITArmor armor)
-                for (Item type : armor.items)
-                    if (type instanceof ArmorItem armorType)
-                        citArmor.computeIfAbsent(armorType, t -> new ArrayList<>()).add(armor);
-                    else
-                        CITResewn.logErrorLoading("Ignoring item type: " + Registry.ITEM.getId(type) + " is not armor in " + cit.pack.resourcePack.getName() + " -> " + cit.propertiesIdentifier.toString());
-            else if (cit instanceof CITElytra elytra)
-                citElytra.add(elytra);
-            else if (cit instanceof CITEnchantment enchantment)
-                citEnchantmentLayers.computeIfAbsent(enchantment.layer, l -> new ArrayList<>()).add(enchantment);
-        }
-
-        for (List<CITEnchantment> layer : citEnchantmentLayers.values()) {
-            for (CITEnchantment enchantment : layer)
-                enchantment.activate();
-            citEnchantments.add(layer);
-        }
-    }
-
-    public void dispose() {
-        for (CIT cit : cits)
-            cit.dispose();
-        cits.clear();
-        citItems.clear();
-        citArmor.clear();
-        citElytra.clear();
-        citEnchantments.clear();
-    }
-
-    public CITItem getCITItem(ItemStack stack, World world, LivingEntity entity) {
-        Hand hand = entity != null && stack == entity.getOffHandStack() ? Hand.OFF_HAND : Hand.MAIN_HAND;
-
-        ((CITItem.Cached) (Object) stack).citresewn_setMojankCIT(false);
-
-        List<CITItem> citItems = this.citItems.get(stack.getItem());
-        if (citItems != null)
-            for (CITItem citItem : citItems)
-                if (citItem.test(stack, hand, world, entity, true)) {
-                    if (stack.isOf(Items.TRIDENT) || stack.isOf(Items.SPYGLASS))
-                        ((CITItem.Cached) (Object) stack).citresewn_setMojankCIT(true);
-                    return citItem;
-                }
-        return null;
-    }
-
-    public CITElytra getCITElytra(ItemStack stack, World world, LivingEntity livingEntity) {
-        for (CITElytra citElytra : citElytra)
-            if (citElytra.test(stack, Hand.MAIN_HAND, world, livingEntity, true))
-                return citElytra;
-        return null;
-    }
-
-    public CITArmor getCITArmor(ItemStack stack, World world, LivingEntity livingEntity) {
-        Item item = stack.getItem();
-        if (item instanceof ArmorItem) {
-            List<CITArmor> citArmor = this.citArmor.get(item);
-            if (citArmor != null)
-                for (CITArmor armor : citArmor)
-                    if (armor.test(stack, null, world, livingEntity, true))
-                        return armor;
-        }
-        return null;
-    }
-
-    public List<CITEnchantment> getCITEnchantment(ItemStack stack, World world, LivingEntity livingEntity) {
-        Hand hand = livingEntity != null && stack == livingEntity.getOffHandStack() ? Hand.OFF_HAND : Hand.MAIN_HAND;
-
-        List<CITEnchantment> applied = new ArrayList<>();
-
-        for (List<CITEnchantment> layer : this.citEnchantments)
-            for (CITEnchantment cit : layer)
-                if (cit.test(stack, hand, world, livingEntity, false)) {
-                    applied.add(cit);
-                    break;
-                }
-
-        return applied;
-    }
-
-    public BakedModel getItemModelCached(ItemStack stack, World world, LivingEntity entity, int seed) {
-        BakedModel bakedModel = null;
-
-        Supplier<CITItem> realtime = () -> getCITItem(stack, world, entity);
-
-        //noinspection ConstantConditions
-        CITItem citItem = CITResewnConfig.INSTANCE().cache_ms == 0 ? realtime.get() : ((CITItem.Cached) (Object) stack).citresewn_getCachedCITItem(realtime);
-
-        if (citItem != null)
-            bakedModel = citItem.getItemModel(stack, (ClientWorld) world, entity, seed);
-
-        return bakedModel;
-    }
-
-    public Identifier getElytraTextureCached(ItemStack stack, World world, LivingEntity livingEntity) {
-        Supplier<CITElytra> realtime = () -> getCITElytra(stack, world, livingEntity);
-
-        //noinspection ConstantConditions
-        CITElytra citElytra = CITResewnConfig.INSTANCE().cache_ms == 0 ? realtime.get() : ((CITElytra.Cached) (Object) stack).citresewn_getCachedCITElytra(realtime);
-
-        if (citElytra != null)
-            return citElytra.textureIdentifier;
-
-        return null;
-    }
-
-    public Map<String, Identifier> getArmorTexturesCached(ItemStack stack, World world, LivingEntity livingEntity) {
-        Supplier<CITArmor> realtime = () -> getCITArmor(stack, world, livingEntity);
-
-        //noinspection ConstantConditions
-        CITArmor citArmor = CITResewnConfig.INSTANCE().cache_ms == 0 ? realtime.get() : ((CITArmor.Cached) (Object) stack).citresewn_getCachedCITArmor(realtime);
-
-        if (citArmor != null)
-            return citArmor.textures;
-
-        return null;
-    }
-
-    public void setEnchantmentAppliedContextCached(ItemStack stack, World world, LivingEntity entity) {
-        if (stack == null) {
-            CITEnchantment.appliedContext = null;
-            return;
-        }
-
-        Supplier<List<CITEnchantment>> realtime = () -> getCITEnchantment(stack, world, entity);
-
-        //noinspection ConstantConditions
-        List<CITEnchantment> citEnchantments = CITResewnConfig.INSTANCE().cache_ms == 0 ? realtime.get() : ((CITEnchantment.Cached) (Object) stack).citresewn_getCachedCITEnchantment(realtime);
-
-        if (citEnchantments == null || citEnchantments.isEmpty()) {
-            CITEnchantment.appliedContext = null;
-            return;
-        }
-
-        if (effectiveGlobalProperties.method != null)
-            effectiveGlobalProperties.method.applyMethod(citEnchantments, stack);
-
-        CITEnchantment.appliedContext = citEnchantments;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/CITResewn.java b/src/main/java/shcm/shsupercm/fabric/citresewn/CITResewn.java
index e53ba52..7d4be88 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/CITResewn.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/CITResewn.java
@@ -1,45 +1,55 @@
 package shcm.shsupercm.fabric.citresewn;
 
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
 import net.fabricmc.api.ClientModInitializer;
-import net.fabricmc.api.EnvType;
-import net.fabricmc.api.Environment;
+import net.fabricmc.loader.api.FabricLoader;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
+import shcm.shsupercm.fabric.citresewn.cit.CITRegistry;
 
-@Environment(EnvType.CLIENT)
+/**
+ * Main initializer for CIT Resewn. Contains various internal utilities(just logging for now).
+ */
 public class CITResewn implements ClientModInitializer {
     public static final Logger LOG = LogManager.getLogger("CITResewn");
-    public static CITResewn INSTANCE;
-
-    public ActiveCITs activeCITs = null;
-
-    public CITResewnConfig config = null;
-
-
-    public boolean processingBrokenPaths = false;
+    @Entrypoint(Entrypoint.CLIENT)
+    public static final CITResewn INSTANCE = new CITResewn();
 
     @Override
     public void onInitializeClient() {
-        INSTANCE = this;
-
-        config = CITResewnConfig.read();
+        CITRegistry.registerAll();
 
-        CITResewnCommand.register();
+        if (FabricLoader.getInstance().isModLoaded("fabric-command-api-v1"))
+            CITResewnCommand.register();
     }
 
+    /**
+     * Logs an info line in CIT Resewn's name.
+     * @param message log message
+     */
     public static void info(String message) {
         LOG.info("[citresewn] " + message);
     }
 
+    /**
+     * Logs a warning line in CIT Resewn's name if enabled in config.
+     * @see CITResewnConfig#mute_warns
+     * @param message warn message
+     */
     public static void logWarnLoading(String message) {
-        if (CITResewnConfig.INSTANCE().mute_warns)
+        if (CITResewnConfig.INSTANCE.mute_warns)
             return;
         LOG.error("[citresewn] " + message);
     }
 
+    /**
+     * Logs an error line in CIT Resewn's name if enabled in config.
+     * @see CITResewnConfig#mute_errors
+     * @param message error message
+     */
     public static void logErrorLoading(String message) {
-        if (CITResewnConfig.INSTANCE().mute_errors)
+        if (CITResewnConfig.INSTANCE.mute_errors)
             return;
         LOG.error("{citresewn} " + message);
     }
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/CITResewnCommand.java b/src/main/java/shcm/shsupercm/fabric/citresewn/CITResewnCommand.java
index 483cbfb..e07a772 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/CITResewnCommand.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/CITResewnCommand.java
@@ -1,33 +1,160 @@
 package shcm.shsupercm.fabric.citresewn;
 
+import com.mojang.brigadier.LiteralMessage;
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
 import net.fabricmc.fabric.api.client.command.v1.ClientCommandManager;
 import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.text.Text;
+import shcm.shsupercm.fabric.citresewn.cit.*;
 import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
 
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+import static net.fabricmc.fabric.api.client.command.v1.ClientCommandManager.argument;
 import static net.fabricmc.fabric.api.client.command.v1.ClientCommandManager.literal;
 import static net.minecraft.text.Text.of;
 
+/**
+ * Logic for the /citresewn client command. Only enabled when Fabric API is present.<br>
+ * Structure:
+ * <pre>
+ * /citresewn - General info command
+ * /citresewn config - Opens the config gui(only when Cloth Config is present)
+ * /citresewn analyze pack &lt;pack&gt; - Displays data for the given loaded cit pack.
+ * </pre>
+ */
 public class CITResewnCommand {
+    /**
+     * @see shcm.shsupercm.fabric.citresewn.mixin.ChatScreenMixin
+     */
     public static boolean openConfig = false;
 
+    /**
+     * Registers all of CIT Resewn's commands.
+     */
     public static void register() {
         ClientCommandManager.DISPATCHER.register(literal("citresewn")
-                .executes(context -> {
-                    context.getSource().sendFeedback(of("CIT Resewn v" + FabricLoader.getInstance().getModContainer("citresewn").get().getMetadata().getVersion() + ":"));
-                    boolean active = CITResewnConfig.INSTANCE().enabled && CITResewn.INSTANCE.activeCITs != null;
-                    context.getSource().sendFeedback(of("  Active: " + (active ? "yes" : "no")));
+                .executes(context -> { //citresewn
+                    context.getSource().sendFeedback(of("CIT Resewn v" + FabricLoader.getInstance().getModContainer("citresewn").orElseThrow().getMetadata().getVersion() + ":"));
+                    context.getSource().sendFeedback(of("  Registered: " + CITRegistry.TYPES.values().stream().distinct().count() + " types and " + CITRegistry.CONDITIONS.values().stream().distinct().count() + " conditions"));
+
+                    final boolean active = CITResewnConfig.INSTANCE.enabled && ActiveCITs.isActive();
+                    context.getSource().sendFeedback(of("  Active: " + (active ? "yes" : ("no, " + (CITResewnConfig.INSTANCE.enabled ? "no cit packs loaded" : "disabled in config")))));
                     if (active) {
-                        context.getSource().sendFeedback(of("  Loaded: " + CITResewn.INSTANCE.activeCITs.cits.size() + " CITs from " + CITResewn.INSTANCE.activeCITs.packs.size() + " resourcepacks"));
+                        context.getSource().sendFeedback(of("   Loaded: " + ActiveCITs.getActive().cits.values().stream().mapToLong(Collection::size).sum() + " CITs from " + ActiveCITs.getActive().cits.values().stream().flatMap(Collection::stream).map(cit -> cit.packName).distinct().count() + " resourcepacks"));
                     }
-                    context.getSource().sendFeedback(of("  "));
+                    context.getSource().sendFeedback(of(""));
 
                     return 1;
                 })
                 .then(literal("config")
-                    .executes(context -> {
-                        openConfig = true;
+                        .executes(context -> { //citresewn config
+                            openConfig = true;
+
+                            return 1;
+                        }))
+                .then(literal("analyze")
+                        .then(literal("pack")
+                                .then(argument("pack", new LoadedCITPackArgument())
+                                        .executes(context -> { //citresewn analyze <pack>
+                                            final String pack = context.getArgument("pack", String.class);
+                                            if (ActiveCITs.isActive()) {
+                                                context.getSource().sendFeedback(of("Analyzed CIT data of \"" + pack + "\u00a7r\":"));
+
+                                                List<Text> builder = new ArrayList<>();
+
+                                                for (Map.Entry<PropertyKey, Set<PropertyValue>> entry : ActiveCITs.getActive().globalProperties.properties.entrySet())
+                                                    for (PropertyValue value : entry.getValue())
+                                                        if (value.packName().equals(pack))
+                                                            builder.add(of("  " + entry.getKey().toString() + (value.keyMetadata() == null ? "" : "." + value.keyMetadata()) + " = " + value.value()));
+                                                if (!builder.isEmpty()) {
+                                                    context.getSource().sendFeedback(of(" Global Properties:"));
+                                                    for (Text text : builder)
+                                                        context.getSource().sendFeedback(text);
+
+                                                    builder.clear();
+                                                }
+
+                                                for (Map.Entry<Class<? extends CITType>, List<CIT<?>>> entry : ActiveCITs.getActive().cits.entrySet())
+                                                    if (!entry.getValue().isEmpty()) {
+                                                        long count = entry.getValue().stream().filter(cit -> cit.packName.equals(pack)).count();
+                                                        if (count > 0)
+                                                            builder.add(of("  " + CITRegistry.idOfType(entry.getKey()).toString() + " = " + count));
+                                                    }
+                                                if (!builder.isEmpty()) {
+                                                    context.getSource().sendFeedback(of(" Types:"));
+                                                    for (Text text : builder)
+                                                        context.getSource().sendFeedback(text);
+
+                                                    builder.clear();
+                                                }
+
+                                                List<CITCondition> conditions = ActiveCITs.getActive().cits.values().stream()
+                                                        .flatMap(Collection::stream)
+                                                        .filter(cit -> cit.packName.equals(pack))
+                                                        .flatMap(cit -> Arrays.stream(cit.conditions))
+                                                        .toList();
+                                                if (!conditions.isEmpty())
+                                                    context.getSource().sendFeedback(of(" Utilizing " + conditions.size() + " conditions(" + conditions.stream().map(Object::getClass).distinct().count() + " unique condition types)"));
+                                            } else
+                                                context.getSource().sendFeedback(of("Not active"));
+
+                                            return 1;
+                                        })
+                                )
+                        )
+                )
+        );
+    }
+
+    /**
+     * Greedy string argument that is limited to cit pack names loaded in {@link shcm.shsupercm.fabric.citresewn.cit.ActiveCITs}.
+     */
+    private static class LoadedCITPackArgument implements ArgumentType<String> {
+        @Override
+        public String parse(StringReader reader) throws CommandSyntaxException {
+            StringBuilder builder = new StringBuilder();
+            while (reader.canRead())
+                builder.append(reader.read());
+
+            String pack = builder.toString().trim();
+
+            if (!getPacks().contains(pack)) {
+                LiteralMessage message = new LiteralMessage("Could not find CIT pack");
+                throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
+            }
+
+            return pack;
+        }
+
+        @Override
+        public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+            return CompletableFuture.supplyAsync(() -> {
+                for (String pack : getPacks()) {
+                    builder.suggest(pack);
+                }
+                return builder.build();
+            });
+        }
 
-                        return 1;
-                    })));
+        private static Set<String> getPacks() {
+            if (ActiveCITs.isActive())
+                return ActiveCITs.getActive().cits.values().stream()
+                        .flatMap(Collection::stream)
+                        .map(cit -> cit.packName)
+                        .collect(Collectors.toSet());
+            else
+                return Collections.emptySet();
+        }
     }
 }
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/OptionalCompat.java b/src/main/java/shcm/shsupercm/fabric/citresewn/OptionalCompat.java
deleted file mode 100644
index 580aef5..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/OptionalCompat.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package shcm.shsupercm.fabric.citresewn;
-
-import io.github.apace100.cosmetic_armor.CosmeticArmor;
-import net.fabricmc.loader.api.FabricLoader;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.gui.screen.NoticeScreen;
-import net.minecraft.client.gui.screen.Screen;
-import net.minecraft.entity.EquipmentSlot;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.text.Text;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfigScreenFactory;
-
-import java.util.function.Function;
-import java.util.function.Predicate;
-
-public final class OptionalCompat {
-    private static final OptionalCompat INSTANCE = new OptionalCompat(s -> FabricLoader.getInstance().isModLoaded(s));
-
-    public final CompatClothConfig compatClothConfig;
-
-    public final CompatCosmeticArmor compatCosmeticArmor;
-
-    private OptionalCompat(Predicate<String> isLoaded) {
-        compatClothConfig = isLoaded.test("cloth-config2") ? CompatClothConfig.impl() : null;
-        compatCosmeticArmor = isLoaded.test("cosmetic-armor") ? CompatCosmeticArmor.impl() : null;
-    }
-
-    public static Function<Screen, Screen> getModConfigScreenFactory() {
-        if (INSTANCE.compatClothConfig != null) {
-            return INSTANCE.compatClothConfig.getModConfigScreenFactory();
-        }
-
-        return parent -> new NoticeScreen(() -> MinecraftClient.getInstance().setScreen(parent), Text.of("CIT Resewn"), Text.of("CIT Resewn requires Cloth Config 2 to be able to show the config."));
-    }
-
-    public static ItemStack getCosmeticArmor(ItemStack original, LivingEntity entity, EquipmentSlot slot, boolean elytra) {
-        if (INSTANCE.compatCosmeticArmor != null) {
-            ItemStack stackInCosmeticSlot = INSTANCE.compatCosmeticArmor.getStackInCosmeticSlot(entity, slot);
-            if (!stackInCosmeticSlot.isEmpty() && (!elytra || stackInCosmeticSlot.isOf(Items.ELYTRA)))
-                return stackInCosmeticSlot;
-        }
-
-        return original;
-    }
-
-    /**
-     * Compatibility with 'cloth-config2': Custom gui for CITResewn's config
-     */
-    public interface CompatClothConfig {
-        private static CompatClothConfig impl() {
-            return () -> CITResewnConfigScreenFactory::create;
-        }
-
-        Function<Screen, Screen> getModConfigScreenFactory();
-    }
-
-    /**
-     * Compatibility with 'cosmetic-armor': Display cits for cosmetic armors instead of equipped armors
-     */
-    public interface CompatCosmeticArmor {
-        private static CompatCosmeticArmor impl() {
-            return CosmeticArmor::getCosmeticArmor;
-        }
-
-        ItemStack getStackInCosmeticSlot(LivingEntity entity, EquipmentSlot slot);
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITConditionContainer.java b/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITConditionContainer.java
new file mode 100644
index 0000000..886185c
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITConditionContainer.java
@@ -0,0 +1,42 @@
+package shcm.shsupercm.fabric.citresewn.api;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITRegistry;
+
+import java.util.function.Supplier;
+
+/**
+ * Wrapper to facilitate metadata, registry and creation of condition class types.
+ * @see #ENTRYPOINT
+ * @see CITRegistry
+ */
+public class CITConditionContainer<T extends CITCondition> {
+    /**
+     * Entrypoint for container singletons, usually kept as a static final field in the condition type's class.
+     */
+    public static final String ENTRYPOINT = "citresewn:condition";
+
+    /**
+     * Associated condition's class.
+     */
+    public final Class<T> condition;
+
+    /**
+     * Method reference to the condition's constructor or any other supplier of new condition instances.
+     */
+    public final Supplier<T> createCondition;
+
+    /**
+     * Possible names in property groups for the associated condition type.<br>
+	 * Condition names are declared in groups with a mod id prefix to avoid conflicts with other 3rd party 
+	 * properties(formatted as "modid:alias").<br>
+	 * If a modid is not declared, defaults to "citresewn" which is handled by CIT Resewn: Defaults.
+     */
+    public final String[] aliases;
+
+    public CITConditionContainer(Class<T> condition, Supplier<T> createCondition, String... aliases) {
+        this.condition = condition;
+        this.createCondition = createCondition;
+        this.aliases = aliases;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITDisposable.java b/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITDisposable.java
new file mode 100644
index 0000000..dec7098
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITDisposable.java
@@ -0,0 +1,18 @@
+package shcm.shsupercm.fabric.citresewn.api;
+
+/**
+ * @see #dispose()
+ */
+@FunctionalInterface
+public interface CITDisposable {
+    /**
+     * Entrypoint for any disposing method that is not covered by CIT Resewn automatically.
+	 * @see #dispose()
+     */
+    String ENTRYPOINT = "citresewn:dispose";
+
+    /**
+     * Invoked just before reloading CITs. Use to clean up and changes CIT loading made.
+     */
+    void dispose();
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITGlobalProperties.java b/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITGlobalProperties.java
new file mode 100644
index 0000000..05495af
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITGlobalProperties.java
@@ -0,0 +1,26 @@
+package shcm.shsupercm.fabric.citresewn.api;
+
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import javax.annotation.Nullable;
+
+/**
+ * @see #globalProperty(String, PropertyValue)
+ */
+@FunctionalInterface
+public interface CITGlobalProperties {
+    /**
+     * Entrypoint for handlers of global properties.
+	 * @see #globalProperty(String, PropertyValue)
+     */
+    String ENTRYPOINT = "citresewn:global_property";
+
+    /**
+     * Invoked before CIT parsing for any global property name associated with the handler's modid.<br>
+	 * May be called multiple times for a key to overwrite its global property with higher-priority resourcepacks.<br>
+	 * When unloading resourcepacks(usually before reloading), all keys that were invoked in the previous load will get called again with a null value to allow for disposal.
+	 * @param key name of the property key stripped of its modid
+	 * @param value the value it's been set to or null if resetting
+     */
+    void globalProperty(String key, @Nullable PropertyValue value) throws Exception;
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITTypeContainer.java b/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITTypeContainer.java
new file mode 100644
index 0000000..b49b4a6
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/api/CITTypeContainer.java
@@ -0,0 +1,87 @@
+package shcm.shsupercm.fabric.citresewn.api;
+
+import shcm.shsupercm.fabric.citresewn.cit.ActiveCITs;
+import shcm.shsupercm.fabric.citresewn.cit.CIT;
+import shcm.shsupercm.fabric.citresewn.cit.CITType;
+import shcm.shsupercm.fabric.citresewn.cit.CITRegistry;
+import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
+
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * Wrapper to facilitate metadata, registry and creation of CIT types.
+ * @see #ENTRYPOINT
+ * @see CITRegistry
+ */
+public abstract class CITTypeContainer<T extends CITType> implements CITDisposable {
+    /**
+     * Entrypoint for container singletons, usually kept as a static final field in the type's class.
+     */
+	public static final String ENTRYPOINT = "citresewn:type";
+
+    /**
+     * Associated type's class.
+     */
+    public final Class<T> type;
+
+    /**
+     * Method reference to the type's constructor or any other supplier of new CIT type instances.
+     */
+    public final Supplier<T> createType;
+
+    /**
+     * Identifier for this type to be used in the "type=" property.<br>
+	 * When used in property groups the type's modid must be added to avoid conflicts with other 
+	 * 3rd party types(formatted as "modid:id").
+     */
+    public final String id;
+
+    /**
+     * True when the container should not have any CITs loaded.
+     */
+    protected boolean empty = true;
+
+    public CITTypeContainer(Class<T> type, Supplier<T> createType, String id) {
+        this.type = type;
+        this.createType = createType;
+        this.id = id;
+    }
+
+    /**
+     * Loads and keeps a copy of loaded CITs of this container's type.
+     * @param parsedCITs all loaded CITs of this container's type ordered by weight>path
+     */
+    protected abstract void load(List<CIT<T>> parsedCITs);
+
+    /**
+     * Loads and keeps a copy of loaded CITs of this container's type.
+     * @param parsedCITs all loaded CITs of this container's type ordered by weight>path
+     */
+    @SuppressWarnings("unchecked")
+    public final void loadUntyped(List<?> parsedCITs) {
+        if (!parsedCITs.isEmpty())
+            empty = false;
+        load((List<CIT<T>>) parsedCITs);
+    }
+
+    /**
+     * Unloads CITs from this container.<br>
+	 * Override dispose() to add more logic.
+	 * @see CITDisposable#dispose()
+     */
+    public final void unload() {
+        dispose();
+        empty = true;
+    }
+
+    /**
+	 * @see #empty
+	 * @see CITResewnConfig#enabled
+	 * @see ActiveCITs#isActive()
+     * @return whether this container's associated type should work or not
+     */
+    public boolean active() {
+        return !empty && CITResewnConfig.INSTANCE.enabled && ActiveCITs.isActive();
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/ActiveCITs.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/ActiveCITs.java
new file mode 100644
index 0000000..82f341f
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/ActiveCITs.java
@@ -0,0 +1,106 @@
+package shcm.shsupercm.fabric.citresewn.cit;
+
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.profiler.Profiler;
+import shcm.shsupercm.fabric.citresewn.api.CITDisposable;
+import shcm.shsupercm.fabric.citresewn.api.CITTypeContainer;
+import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
+import shcm.shsupercm.fabric.citresewn.pack.GlobalProperties;
+import shcm.shsupercm.fabric.citresewn.pack.PackParser;
+import shcm.shsupercm.fabric.citresewn.mixin.ModelLoaderMixin;
+
+import java.util.*;
+
+/**
+ * Holds and manages the currently loaded CITs.
+ * @see #getActive()
+ * @see ModelLoaderMixin
+ */
+public class ActiveCITs { private ActiveCITs() {}
+	/**
+	 * @see #load(ResourceManager, Profiler)
+	 * @see #getActive()
+	 * @see #isActive()
+	 */
+    private static ActiveCITs active = null;
+
+	/**
+	 * @see #isActive()
+	 * @return the current active CITs manager or null if none are loaded
+	 */
+    public static ActiveCITs getActive() {
+        return active;
+    }
+	
+	/**
+	 * @see #getActive()
+	 * @return whether there are active; loaded CITs
+	 */
+    public static boolean isActive() {
+        return active != null;
+    }
+
+	/**
+	 * Currently effective global properties merged from all loaded packs.
+	 */
+    public final GlobalProperties globalProperties = new GlobalProperties();
+
+	/**
+	 * All loaded CITs ordered by their type's class and their weight.
+	 */
+    public final Map<Class<? extends CITType>, List<CIT<?>>> cits = new IdentityHashMap<>();
+
+	/**
+	 * Attempts to load/activate CITs from packs in the given resource manager, disposing of any previously loaded CITs if present.
+	 * @see ModelLoaderMixin
+	 * @see PackParser#loadGlobalProperties(ResourceManager, GlobalProperties)
+	 * @see GlobalProperties#callHandlers()
+	 * @see PackParser#parseCITs(ResourceManager)
+	 * @param resourceManager manager containing resourcepacks with possible CITs
+	 * @param profiler loading profiler that was pushed once into "citresewn:reloading_cits" and would pop after
+	 */
+    public static void load(ResourceManager resourceManager, Profiler profiler) {
+        profiler.push("citresewn:disposing");
+        for (CITDisposable disposable : FabricLoader.getInstance().getEntrypoints(CITDisposable.ENTRYPOINT, CITDisposable.class))
+            disposable.dispose();
+
+        for (CITTypeContainer<? extends CITType> typeContainer : CITRegistry.TYPES.values())
+            typeContainer.unload();
+
+        if (active != null) {
+            active.globalProperties.properties.replaceAll((key, value) -> Set.of());
+            active.globalProperties.callHandlers();
+
+            active = null;
+        }
+
+        if (!CITResewnConfig.INSTANCE.enabled) {
+            profiler.pop();
+            return;
+        }
+
+        ActiveCITs active = new ActiveCITs();
+
+        profiler.swap("citresewn:load_global_properties");
+        PackParser.loadGlobalProperties(resourceManager, active.globalProperties).callHandlers();
+
+        profiler.swap("citresewn:load_cits");
+        List<CIT<?>> cits = PackParser.parseCITs(resourceManager);
+        for (CIT<?> cit : cits)
+            active.cits.computeIfAbsent(cit.type.getClass(), type -> new ArrayList<>()).add(cit);
+        for (Map.Entry<Class<? extends CITType>, List<CIT<?>>> entry : active.cits.entrySet()) {
+            entry.getValue().sort(Comparator.<CIT<?>>comparingInt(cit -> cit.weight).reversed().thenComparing(cit -> cit.propertiesIdentifier.toString()));
+            for (CITTypeContainer<? extends CITType> typeContainer : CITRegistry.TYPES.values())
+                if (typeContainer.type == entry.getKey()) {
+                    typeContainer.loadUntyped(entry.getValue());
+                    break;
+                }
+        }
+
+        profiler.pop();
+
+        if (!cits.isEmpty())
+            ActiveCITs.active = active;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CIT.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CIT.java
new file mode 100644
index 0000000..7c7ba5b
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CIT.java
@@ -0,0 +1,61 @@
+package shcm.shsupercm.fabric.citresewn.cit;
+
+import net.minecraft.util.Identifier;
+
+/**
+ * Runtime representation of a CIT, holding its type and conditions as well as additional metadata.
+ */
+public class CIT<T extends CITType> {
+    /**
+     * The full location of this CIT in its resourcepack.
+     */
+    public final Identifier propertiesIdentifier;
+
+    /**
+     * Name of the resourcepack that contains this CIT.
+     */
+    public final String packName;
+
+    /**
+     * The CIT's type.
+     * @see CITType
+     */
+    public final T type;
+
+    /**
+     * Conditions that must be met for this CIT to work.
+     */
+    public final CITCondition[] conditions;
+
+    /**
+     * The weight of this CIT to be used when resolving multiple CIT matching conflicts.
+     */
+    public final int weight;
+
+    public CIT(Identifier propertiesIdentifier, String packName, T type, CITCondition[] conditions, int weight) {
+        this.propertiesIdentifier = propertiesIdentifier;
+        this.packName = packName;
+        this.type = type;
+        this.conditions = conditions;
+        this.weight = weight;
+    }
+
+    /**
+     * Tests the given context against all of this CIT's conditions.
+     *
+     * @see #conditions
+     * @param context context to check
+     * @return true if none of this CIT's {@link #conditions} tested false
+     */
+    public boolean test(CITContext context) {
+        try {
+            for (CITCondition condition : conditions)
+                if (!condition.test(context))
+                    return false;
+
+            return true;
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITCache.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITCache.java
new file mode 100644
index 0000000..31ccf04
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITCache.java
@@ -0,0 +1,93 @@
+package shcm.shsupercm.fabric.citresewn.cit;
+
+import net.minecraft.item.ItemStack;
+import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * Runtime cache for a CIT type to be stored in type implementation specific locations. (usually ducked onto {@link ItemStack}s)
+ * @see Single
+ * @see MultiList
+ */
+public abstract class CITCache<T extends CITType> {
+    /**
+     * The last time in epoch milliseconds that this cache invalidated its stored CIT.
+     */
+    public long lastCachedStamp = 0;
+
+    /**
+     * Common implementation of a single CIT per holder({@link ItemStack}) caching.
+     */
+    public static class Single<T extends CITType> extends CITCache<T> {
+        /**
+         * A reload-safe reference to the CIT that was last selected for this holder.
+         */
+        protected WeakReference<CIT<T>> cit = null;
+
+        /**
+         * Real time Context -> CIT supplier for this cache for invalidated holders.
+         */
+        protected final Function<CITContext, CIT<T>> realtime;
+
+        public Single(Function<CITContext, CIT<T>> realtime) {
+            this.realtime = realtime;
+        }
+
+        /**
+         * Retrieves the CIT reference associated with this cache and invalidates it every config-defined interval.
+         *
+         * @see CITResewnConfig#cache_ms
+         * @param context context to check
+         * @return reference to the CIT or reference to null if no CIT applied
+         */
+        public WeakReference<CIT<T>> get(CITContext context) {
+            if (this.cit == null || System.currentTimeMillis() - this.lastCachedStamp >= CITResewnConfig.INSTANCE.cache_ms) {
+                this.cit = new WeakReference<>(this.realtime.apply(context));
+                this.lastCachedStamp = System.currentTimeMillis();
+            }
+
+            return this.cit;
+        }
+    }
+
+    /**
+     * Common implementation of multiple CITs per holder({@link ItemStack}) caching.
+     */
+    public static class MultiList<T extends CITType> extends CITCache<T> {
+        /**
+         * List of reload-safe references to CITs that were last selected for this holder.
+         */
+        protected List<WeakReference<CIT<T>>> cit = null;
+
+        /**
+         * Real time Context -> CIT list supplier for this cache for invalidated holders.
+         */
+        protected final Function<CITContext, List<CIT<T>>> realtime;
+
+        public MultiList(Function<CITContext, List<CIT<T>>> realtime) {
+            this.realtime = realtime;
+        }
+
+        /**
+         * Retrieves the CIT references associated with this cache and invalidates them every config-defined interval.
+         *
+         * @see CITResewnConfig#cache_ms
+         * @param context context to check
+         * @return list of references to CITs or empty list no CIT applied
+         */
+        public List<WeakReference<CIT<T>>> get(CITContext context) {
+            if (this.cit == null || System.currentTimeMillis() - this.lastCachedStamp >= CITResewnConfig.INSTANCE.cache_ms) {
+                this.cit = new ArrayList<>();
+                for (CIT<T> realtimeCIT : this.realtime.apply(context))
+                    this.cit.add(new WeakReference<>(realtimeCIT));
+                this.lastCachedStamp = System.currentTimeMillis();
+            }
+
+            return cit;
+        }
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITCondition.java
new file mode 100644
index 0000000..cd4cb9d
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITCondition.java
@@ -0,0 +1,63 @@
+package shcm.shsupercm.fabric.citresewn.cit;
+
+import shcm.shsupercm.fabric.citresewn.CITResewn;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * Instanced parent for CIT Types that are applied to items when conditions pass.<br>
+ * Common condition types are available under {@link shcm.shsupercm.fabric.citresewn.cit.builtin.conditions}.
+ * @see CITConditionContainer
+ * @see CIT
+ */
+public abstract class CITCondition {
+    /**
+     * Parses the given property value into the condition.
+     * @param value value to read
+     * @param properties the group containing value
+     * @throws CITParsingException if errored while parsing the condition
+     */
+    public abstract void load(PropertyValue value, PropertyGroup properties) throws CITParsingException;
+
+    /**
+     * @return a set of classes of conditions that have integration with this condition
+     */
+    public Set<Class<? extends CITCondition>> siblingConditions() {
+        return Collections.emptySet();
+    }
+
+    /**
+     * Modifies the given sibling if present in the CIT and declared in {@link #siblingConditions()}.
+     * @param sibling sibling to modify or be modified by
+     * @return the sibling or null to remove it from the CIT.
+     */
+    public <T extends CITCondition> T modifySibling(T sibling) {
+        return sibling;
+    }
+
+    /**
+     * Tests the given context against this condition.
+     * @param context context to check
+     * @return true if the given context passes
+     */
+    public abstract boolean test(CITContext context);
+
+    /**
+     * Logs a warning with the given value's descriptor if enabled in config.
+     *
+     * @see CITResewn#logWarnLoading(String)
+     * @see CITResewnConfig#mute_warns
+     * @param message warning message
+     * @param value value associated with the warning
+     * @param properties property group associated with the warning
+     */
+    protected void warn(String message, PropertyValue value, PropertyGroup properties) {
+        CITResewn.logWarnLoading("Warning: " + properties.messageWithDescriptorOf(message, value.position()));
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITContext.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITContext.java
new file mode 100644
index 0000000..cfc10f8
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITContext.java
@@ -0,0 +1,76 @@
+package shcm.shsupercm.fabric.citresewn.cit;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.enchantment.EnchantmentHelper;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.EnchantedBookItem;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtElement;
+import net.minecraft.util.Identifier;
+import net.minecraft.world.World;
+
+import javax.annotation.Nullable;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Holds momentary information to be used for CITs' condition matching and type effects.
+ */
+public class CITContext {
+    /**
+     * The main item stack to check for the CIT.
+     */
+    public final ItemStack stack;
+
+    /**
+     * The item's containing world(defaults to {@link MinecraftClient#world} if null)
+     */
+    public final World world;
+
+    /**
+     * The item's associated living entity if present. (null if not relevant)
+     */
+    @Nullable
+    public final LivingEntity entity;
+
+    /**
+     * Cached enchantment map from {@link #stack}.
+     * @see #enchantments()
+     */
+    private Map<Identifier, Integer> enchantments = null;
+
+    public CITContext(ItemStack stack, @Nullable World world, @Nullable LivingEntity entity) {
+        this.stack = stack;
+        this.world = world == null ? MinecraftClient.getInstance().world : world;
+        this.entity = entity;
+    }
+
+    /**
+     * @see #enchantments
+     * @return a map of this context item's enchantments
+     */
+    public Map<Identifier, Integer> enchantments() {
+        if (this.enchantments == null) {
+            this.enchantments = new LinkedHashMap<>();
+            for (NbtElement nbtElement : stack.isOf(Items.ENCHANTED_BOOK) ? EnchantedBookItem.getEnchantmentNbt(stack) : stack.getEnchantments())
+                this.enchantments.put(EnchantmentHelper.getIdFromNbt((NbtCompound) nbtElement), EnchantmentHelper.getLevelFromNbt((NbtCompound) nbtElement));
+        }
+        return this.enchantments;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return obj instanceof CITContext that &&
+                Objects.equals(this.stack, that.stack) &&
+                Objects.equals(this.world, that.world) &&
+                Objects.equals(this.entity, that.entity);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(stack, world, entity);
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITRegistry.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITRegistry.java
new file mode 100644
index 0000000..bf7c2ca
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITRegistry.java
@@ -0,0 +1,144 @@
+package shcm.shsupercm.fabric.citresewn.cit;
+
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.util.Identifier;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.api.CITTypeContainer;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.ConstantCondition;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.ex.UnknownCITTypeException;
+import shcm.shsupercm.fabric.citresewn.pack.PackParser;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.util.*;
+
+import static shcm.shsupercm.fabric.citresewn.CITResewn.info;
+import static shcm.shsupercm.fabric.citresewn.CITResewn.logWarnLoading;
+
+/**
+ * Holds a static registry runtime for all types and conditions.
+ * @see PackParser
+ * @see CITTypeContainer
+ * @see CITConditionContainer
+ */
+public final class CITRegistry { private CITRegistry(){}
+    /**
+     * Currently registered CIT types.
+     */
+    public static final Map<Identifier, CITTypeContainer<? extends CITType>> TYPES = new HashMap<>();
+    /**
+     * Currently registered condition types.
+     */
+    public static final Map<PropertyKey, CITConditionContainer<? extends CITCondition>> CONDITIONS = new HashMap<>();
+
+    /**
+     * Fast id lookup map for types.
+     * @see #idOfType(Class)
+     */
+    private static final Map<Class<? extends CITType>, Identifier> TYPE_TO_ID = new IdentityHashMap<>();
+    /**
+     * Fast id lookup map for conditions.
+     * @see #idOfCondition(Class)
+     */
+    private static final Map<Class<? extends CITCondition>, PropertyKey> CONDITION_TO_ID = new IdentityHashMap<>();
+
+    /**
+     * Loads all available CIT and condition types to registry. (internal use only)
+     * @see CITTypeContainer
+     * @see CITConditionContainer
+     */
+    public static void registerAll() {
+        info("Registering CIT Conditions");
+        for (var entrypointContainer : FabricLoader.getInstance().getEntrypointContainers(CITConditionContainer.ENTRYPOINT, CITConditionContainer.class)) {
+            String namespace = entrypointContainer.getProvider().getMetadata().getId();
+            if (namespace.equals("citresewn-defaults"))
+                namespace = "citresewn";
+
+            for (String alias : entrypointContainer.getEntrypoint().aliases) {
+                final PropertyKey key = new PropertyKey(namespace, alias);
+                CITConditionContainer<?> container = entrypointContainer.getEntrypoint();
+
+                CONDITIONS.put(key, container);
+                CONDITION_TO_ID.putIfAbsent(container.createCondition.get().getClass(), key);
+            }
+        }
+
+        info("Registering CIT Types");
+        for (var entrypointContainer : FabricLoader.getInstance().getEntrypointContainers(CITTypeContainer.ENTRYPOINT, CITTypeContainer.class)) {
+            String namespace = entrypointContainer.getProvider().getMetadata().getId();
+            if (namespace.equals("citresewn-defaults"))
+                namespace = "citresewn";
+
+            final Identifier id = new Identifier(namespace, entrypointContainer.getEntrypoint().id);
+            CITTypeContainer<?> container = entrypointContainer.getEntrypoint();
+
+            TYPES.put(id, container);
+            TYPE_TO_ID.putIfAbsent(container.createType.get().getClass(), id);
+        }
+    }
+
+    /**
+     * Parses a condition from the given property.<br>
+     *
+     * @param key the condition's key in the group
+     * @param value the condition's value
+     * @param properties the containing property group
+     * @return the parsed condition or an always-failing {@link ConstantCondition} if unrecognized
+     * @throws CITParsingException if errored while parsing hte condition
+     */
+    public static CITCondition parseCondition(PropertyKey key, PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        CITConditionContainer<? extends CITCondition> conditionContainer = CONDITIONS.get(key);
+        if (conditionContainer == null) {
+            logWarnLoading(properties.messageWithDescriptorOf("Unknown condition type \"" + key.toString() + "\"", value.position()));
+            return new ConstantCondition(false);
+        }
+
+        CITCondition condition = conditionContainer.createCondition.get();
+        condition.load(value, properties);
+        return condition;
+    }
+
+    /**
+     * Parses a CIT type from the given property group.<br>
+     * If the group does not contain a "citresewn:type" property, defaults to "citresewn:item".
+     * @param properties group of properties to parse the CIT type from
+     * @return a new instance of the group's CIT type
+     * @throws UnknownCITTypeException if the given type is unrecognized in the registry
+     */
+    public static CITType parseType(PropertyGroup properties) throws UnknownCITTypeException {
+        Identifier type = new Identifier("citresewn", "item");
+
+        PropertyValue propertiesType = properties.getLastWithoutMetadata("citresewn", "type");
+        if (propertiesType != null) {
+            String value = propertiesType.value();
+            if (!value.contains(":"))
+                value = "citresewn:" + value;
+            type = new Identifier(value);
+        }
+
+        CITTypeContainer<? extends CITType> typeContainer = TYPES.get(type);
+        if (typeContainer == null)
+            // assert (propertiesType != null) because the default citresewn:item should always be registered
+            throw new UnknownCITTypeException(properties, propertiesType == null ? -1 : propertiesType.position());
+
+        return typeContainer.createType.get();
+    }
+
+    /**
+     * @see #TYPE_TO_ID
+     * @return the id of the given CIT type's class.
+     */
+    public static Identifier idOfType(Class<? extends CITType> clazz) {
+        return TYPE_TO_ID.get(clazz);
+    }
+
+    /**
+     * @see #CONDITION_TO_ID
+     * @return the first key of the given condition's class.
+     */
+    public static PropertyKey idOfCondition(Class<? extends CITCondition> clazz) {
+        return CONDITION_TO_ID.get(clazz);
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITType.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITType.java
new file mode 100644
index 0000000..65b3097
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/CITType.java
@@ -0,0 +1,109 @@
+package shcm.shsupercm.fabric.citresewn.cit;
+
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import shcm.shsupercm.fabric.citresewn.CITResewn;
+import shcm.shsupercm.fabric.citresewn.api.CITTypeContainer;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.util.*;
+
+/**
+ * Instanced parent for CIT Types that are applied to items when conditions pass.
+ * @see CITTypeContainer
+ * @see CIT
+ */
+public abstract class CITType {
+    /**
+     * Used to determine which property keys are not conditions.
+     * @return a set of property keys used by this type
+     */
+    public abstract Set<PropertyKey> typeProperties();
+
+    /**
+     * Loads the given property group into the type.
+     * @param conditions conditions that were parsed out of the property group
+     * @param properties group of properties to be read into this type
+     * @param resourceManager the CIT's containing resource manager
+     * @throws CITParsingException if errored while parsing the type
+     */
+    public abstract void load(List<CITCondition> conditions, PropertyGroup properties, ResourceManager resourceManager) throws CITParsingException;
+
+    protected void warn(String message, PropertyValue value, PropertyGroup properties) {
+        CITResewn.logWarnLoading("Warning: " + properties.messageWithDescriptorOf(message, value == null ? -1 : value.position()));
+    }
+
+    /**
+     * ///// PORTED FROM BETA \\\\\
+     * This shit was ported from the
+     * beta and will be rewritten at
+     * some point!
+     * \\\\\                  /////
+     *
+     * Takes a defined path and resolves it to an identifier pointing to the resourcepack's path of the specified extension(returns null if no path can be resolved).<br>
+     * If definedPath is null, will try to resolve a relative file with the same name as the rootIdentifier with the extension, otherwise: <br>
+     * definedPath will be formatted to replace "\\" with "/" the extension will be appended if not there already. <br>
+     * It will first try using definedPath as an absolute path, if it cant resolve(or definedPath starts with ./), definedPath will be considered relative. <br>
+     * Relative paths support going to parent directories using "..".
+     */
+    public static Identifier resolveAsset(Identifier rootIdentifier, String path, String defaultedTypeDirectory, String extension, ResourceManager resourceManager) {
+        if (path == null) {
+            path = rootIdentifier.getPath().substring(0, rootIdentifier.getPath().length() - 11);
+            if (!path.endsWith(extension))
+                path = path + extension;
+            Identifier pathIdentifier = new Identifier(rootIdentifier.getNamespace(), path);
+            return resourceManager.containsResource(pathIdentifier) ? pathIdentifier : null;
+        }
+
+        Identifier pathIdentifier = new Identifier(path);
+
+        path = pathIdentifier.getPath().replace('\\', '/');
+        if (!path.endsWith(extension))
+            path = path + extension;
+
+        if (path.startsWith("./"))
+            path = path.substring(2);
+        else if (!path.contains("..")) {
+            pathIdentifier = new Identifier(pathIdentifier.getNamespace(), path);
+            if (resourceManager.containsResource(pathIdentifier))
+                return pathIdentifier;
+            else if (path.startsWith("assets/")) {
+                path = path.substring(7);
+                int sep = path.indexOf('/');
+                pathIdentifier = new Identifier(path.substring(0, sep), path.substring(sep + 1));
+                if (resourceManager.containsResource(pathIdentifier))
+                    return pathIdentifier;
+            }
+            pathIdentifier = new Identifier(pathIdentifier.getNamespace(), defaultedTypeDirectory + "/" + path);
+            if (resourceManager.containsResource(pathIdentifier))
+                return pathIdentifier;
+        }
+
+        LinkedList<String> pathParts = new LinkedList<>(Arrays.asList(rootIdentifier.getPath().split("/")));
+        pathParts.removeLast();
+
+        if (path.contains("/")) {
+            for (String part : path.split("/")) {
+                if (part.equals("..")) {
+                    if (pathParts.size() == 0)
+                        return null;
+                    pathParts.removeLast();
+                } else
+                    pathParts.addLast(part);
+            }
+        } else
+            pathParts.addLast(path);
+        path = String.join("/", pathParts);
+
+        pathIdentifier = new Identifier(rootIdentifier.getNamespace(), path);
+
+        return resourceManager.containsResource(pathIdentifier) ? pathIdentifier : null;
+    }
+
+    public static Identifier resolveAsset(Identifier rootIdentifier, PropertyValue path, String defaultedTypeDirectory, String extension, ResourceManager resourceManager) {
+        return resolveAsset(rootIdentifier, path == null ? null : path.value(), defaultedTypeDirectory, extension, resourceManager);
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/BooleanCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/BooleanCondition.java
new file mode 100644
index 0000000..989318f
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/BooleanCondition.java
@@ -0,0 +1,41 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+/**
+ * Common condition parser for booleans.
+ */
+public abstract class BooleanCondition extends CITCondition {
+	/**
+     * Parsed boolean.
+     */
+    protected boolean value;
+
+    /**
+	 * Converts the given context to a boolean to compare the parsed value to.
+     * @param context context to retrieve the compared value from
+	 * @return the boolean value associated with the given context
+     */
+    protected boolean getValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        if (value.value().equalsIgnoreCase("true"))
+            this.value = true;
+        else if (value.value().equalsIgnoreCase("false"))
+            this.value = false;
+        else
+            throw new CITParsingException("Not a boolean", properties, value.position());
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        return getValue(context) == this.value;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/ConstantCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/ConstantCondition.java
new file mode 100644
index 0000000..5bc9354
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/ConstantCondition.java
@@ -0,0 +1,31 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+/**
+ * Common condition type with no parsing for constant true/false testing output.
+ */
+public class ConstantCondition extends CITCondition {
+    /**
+     * What testing contexts will always result in.
+     */
+    public final boolean value;
+
+    public ConstantCondition(boolean value) {
+        this.value = value;
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        return value;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/DoubleCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/DoubleCondition.java
new file mode 100644
index 0000000..44bb906
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/DoubleCondition.java
@@ -0,0 +1,157 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import static java.lang.Double.*;
+
+/**
+ * Common condition parser for doubles with optional support for ranges, negatives and percentages.
+ */
+public abstract class DoubleCondition extends CITCondition {
+	/**
+     * Whether this condition should accept given ranges/negatives/percentages.
+     */
+    protected final boolean supportsRanges, supportsNegatives, supportsPercentages;
+
+    /**
+     * If ranges are accepted, parsed minimum/maximum double. If not, minimum is the parsed value.
+     */
+    protected double min, max;
+	
+    /**
+     * Whether the parsed value is a range/percentage.
+     */
+    protected boolean range = false, percentage = false;
+
+    protected DoubleCondition(boolean supportsRanges, boolean supportsNegatives, boolean supportsPercentages) {
+        this.supportsRanges = supportsRanges;
+        this.supportsNegatives = supportsNegatives;
+        this.supportsPercentages = supportsPercentages;
+    }
+
+    /**
+	 * Converts the given context to a double to compare the parsed value to.
+     * @param context context to retrieve the compared value from
+	 * @return the double value associated with the given context
+     */
+    protected double getValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+	/**
+	 * Converts the given context to a max double to be used when percentages are enabled.
+     * @param context context to retrieve the max value from
+	 * @return the max double value associated with the given context
+     */
+    protected double getPercentageTotalValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        String strValue = value.value();
+        if (supportsPercentages && (percentage = strValue.contains("%")))
+            strValue = strValue.replace("%", "");
+
+        try {
+            if (range = supportsRanges) {
+                if (supportsNegatives) {
+                    switch (strValue.length() - strValue.replace("-", "").length()) { // dashesCount
+                        case 0 -> {
+                            range = false;
+                            min = parseDouble(strValue);
+                        }
+                        case 1 -> {
+                            if (strValue.startsWith("-")) {
+                                range = false;
+                                min = parseDouble(strValue);
+                            } else if (strValue.endsWith("-")) {
+                                min = parseDouble(strValue.substring(0, strValue.length() - 1));
+                                max = MAX_VALUE;
+                            } else {
+                                String[] split = strValue.split("-");
+                                min = parseDouble(split[0]);
+                                max = parseDouble(split[1]);
+                            }
+                        }
+                        case 2 -> {
+                            if (strValue.startsWith("--")) {
+                                min = MIN_VALUE;
+                                max = parseDouble(strValue.substring(1));
+                            } else if (strValue.startsWith("-") && strValue.endsWith("-")) {
+                                min = parseDouble(strValue.substring(0, strValue.length() - 1));
+                                max = MAX_VALUE;
+                            } else if (strValue.startsWith("-") && !strValue.endsWith("-") && !strValue.contains("--")) {
+                                int lastDash = strValue.lastIndexOf('-');
+                                min = parseDouble(strValue.substring(0, lastDash));
+                                max = parseDouble(strValue.substring(lastDash + 1));
+                            } else
+                                throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+                        case 3 -> {
+                            if (!strValue.contains("---") && strValue.startsWith("-")) {
+                                String[] split = strValue.split("--");
+                                if (split.length != 2 || split[0].isEmpty() || split[1].isEmpty())
+                                    throw new CITParsingException("Could not parse range", properties, value.position());
+
+                                min = parseDouble(split[0]);
+                                max = -parseDouble(split[1]);
+                            } else
+                                throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+
+                        default -> throw new CITParsingException("Could not parse range", properties, value.position());
+                    }
+                } else {
+                    if (range = strValue.contains("-")) {
+                        if (strValue.contains("--"))
+                            throw new CITParsingException("Could not parse range", properties, value.position());
+                        String[] split = strValue.split("-");
+                        switch (split.length) {
+                            case 1 -> {
+                                min = parseDouble(split[0]);
+                                max = MAX_VALUE;
+                            }
+                            case 2 -> {
+                                if (strValue.endsWith("-"))
+                                    throw new CITParsingException("Could not parse range", properties, value.position());
+                                min = split[0].isEmpty() ? MIN_VALUE : parseDouble(split[0]);
+                                max = split[1].isEmpty() ? MAX_VALUE : parseDouble(split[1]);
+                            }
+                            default -> throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+                    } else
+                        min = parseDouble(strValue);
+                }
+            } else {
+                min = parseDouble(strValue);
+                if (!supportsNegatives && min < 0)
+                    throw new CITParsingException("Negatives are not allowed", properties, value.position());
+            }
+
+            if (range) {
+                if (min == max)
+                    range = false;
+                else if (min > max)
+                    throw new CITParsingException("Could not parse range", properties, value.position());
+            }
+        } catch (Exception e) {
+            throw e instanceof CITParsingException citE ? citE : new CITParsingException("Could not parse double", properties, value.position(), e);
+        }
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        double value = getValue(context);
+
+        if (percentage) {
+            double percentValue = 100d * value / getPercentageTotalValue(context);
+            return range ? min <= percentValue && percentValue <= max : percentValue == min;
+        } else
+            return range ? min <= value && value <= max : value == min;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/EnumCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/EnumCondition.java
new file mode 100644
index 0000000..ed69fed
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/EnumCondition.java
@@ -0,0 +1,77 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.util.function.Supplier;
+
+/**
+ * Common condition parser for enum values.
+ * @see EnumCondition.Aliased
+ */
+public abstract class EnumCondition<T extends Enum<? extends EnumCondition.Aliased>> extends CITCondition {
+    /**
+     * Fetches the all of the enum's parsable values.
+     */
+    protected final Supplier<T[]> values;
+
+    /**
+     * Should letter casing be ignored when parsing the enum value. (default true)
+     */
+    protected final boolean ignoreCase;
+
+    /**
+     * Parsed enum value.
+     */
+    protected T value;
+
+    /**
+	 * Converts the given context to an enum value to compare the parsed value to.
+     * @param context context to retrieve the compared value from
+	 * @return the enum value associated with the given context
+     */
+    protected T getValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+    protected EnumCondition(Supplier<T[]> values, boolean ignoreCase) {
+        this.values = values;
+        this.ignoreCase = ignoreCase;
+    }
+
+    protected EnumCondition(Supplier<T[]> values) {
+        this(values, true);
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        for (T enumConstant : values.get())
+            for (String alias : ((Aliased) enumConstant).getAliases())
+                if (ignoreCase ? alias.equalsIgnoreCase(value.value()) : alias.equals(value.value())) {
+                    this.value = enumConstant;
+                    return;
+                }
+
+        throw new CITParsingException("Unrecognized value", properties, value.position());
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        return getValue(context) == this.value;
+    }
+
+    /**
+     * Gives implementing enums the ability to have multiple aliased names for parsing.
+     */
+    public interface Aliased {
+        /**
+         * @return all possible names for this enum value
+         */
+        default String[] getAliases() {
+            return new String[] { ((Enum<?>) this).name() };
+        }
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/FloatCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/FloatCondition.java
new file mode 100644
index 0000000..aadaa76
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/FloatCondition.java
@@ -0,0 +1,157 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import static java.lang.Float.*;
+
+/**
+ * Common condition parser for floats with optional support for ranges, negatives and percentages.
+ */
+public abstract class FloatCondition extends CITCondition {
+	/**
+     * Whether this condition should accept given ranges/negatives/percentages.
+     */
+    protected final boolean supportsRanges, supportsNegatives, supportsPercentages;
+
+    /**
+     * If ranges are accepted, parsed minimum/maximum float. If not, minimum is the parsed value.
+     */
+    protected float min, max;
+	
+    /**
+     * Whether the parsed value is a range/percentage.
+     */
+    protected boolean range = false, percentage = false;
+
+    protected FloatCondition(boolean supportsRanges, boolean supportsNegatives, boolean supportsPercentages) {
+        this.supportsRanges = supportsRanges;
+        this.supportsNegatives = supportsNegatives;
+        this.supportsPercentages = supportsPercentages;
+    }
+
+    /**
+	 * Converts the given context to a float to compare the parsed value to.
+     * @param context context to retrieve the compared value from
+	 * @return the float value associated with the given context
+     */
+    protected float getValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+	/**
+	 * Converts the given context to a max float to be used when percentages are enabled.
+     * @param context context to retrieve the max value from
+	 * @return the max float value associated with the given context
+     */
+    protected float getPercentageTotalValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        String strValue = value.value();
+        if (supportsPercentages && (percentage = strValue.contains("%")))
+            strValue = strValue.replace("%", "");
+
+        try {
+            if (range = supportsRanges) {
+                if (supportsNegatives) {
+                    switch (strValue.length() - strValue.replace("-", "").length()) { // dashesCount
+                        case 0 -> {
+                            range = false;
+                            min = parseFloat(strValue);
+                        }
+                        case 1 -> {
+                            if (strValue.startsWith("-")) {
+                                range = false;
+                                min = parseFloat(strValue);
+                            } else if (strValue.endsWith("-")) {
+                                min = parseFloat(strValue.substring(0, strValue.length() - 1));
+                                max = MAX_VALUE;
+                            } else {
+                                String[] split = strValue.split("-");
+                                min = parseFloat(split[0]);
+                                max = parseFloat(split[1]);
+                            }
+                        }
+                        case 2 -> {
+                            if (strValue.startsWith("--")) {
+                                min = MIN_VALUE;
+                                max = parseFloat(strValue.substring(1));
+                            } else if (strValue.startsWith("-") && strValue.endsWith("-")) {
+                                min = parseFloat(strValue.substring(0, strValue.length() - 1));
+                                max = MAX_VALUE;
+                            } else if (strValue.startsWith("-") && !strValue.endsWith("-") && !strValue.contains("--")) {
+                                int lastDash = strValue.lastIndexOf('-');
+                                min = parseFloat(strValue.substring(0, lastDash));
+                                max = parseFloat(strValue.substring(lastDash + 1));
+                            } else
+                                throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+                        case 3 -> {
+                            if (!strValue.contains("---") && strValue.startsWith("-")) {
+                                String[] split = strValue.split("--");
+                                if (split.length != 2 || split[0].isEmpty() || split[1].isEmpty())
+                                    throw new CITParsingException("Could not parse range", properties, value.position());
+
+                                min = parseFloat(split[0]);
+                                max = -parseFloat(split[1]);
+                            } else
+                                throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+
+                        default -> throw new CITParsingException("Could not parse range", properties, value.position());
+                    }
+                } else {
+                    if (range = strValue.contains("-")) {
+                        if (strValue.contains("--"))
+                            throw new CITParsingException("Could not parse range", properties, value.position());
+                        String[] split = strValue.split("-");
+                        switch (split.length) {
+                            case 1 -> {
+                                min = parseFloat(split[0]);
+                                max = MAX_VALUE;
+                            }
+                            case 2 -> {
+                                if (strValue.endsWith("-"))
+                                    throw new CITParsingException("Could not parse range", properties, value.position());
+                                min = split[0].isEmpty() ? MIN_VALUE : parseFloat(split[0]);
+                                max = split[1].isEmpty() ? MAX_VALUE : parseFloat(split[1]);
+                            }
+                            default -> throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+                    } else
+                        min = parseFloat(strValue);
+                }
+            } else {
+                min = parseFloat(strValue);
+                if (!supportsNegatives && min < 0)
+                    throw new CITParsingException("Negatives are not allowed", properties, value.position());
+            }
+
+            if (range) {
+                if (min == max)
+                    range = false;
+                else if (min > max)
+                    throw new CITParsingException("Could not parse range", properties, value.position());
+            }
+        } catch (Exception e) {
+            throw e instanceof CITParsingException citE ? citE : new CITParsingException("Could not parse float", properties, value.position(), e);
+        }
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        float value = getValue(context);
+
+        if (percentage) {
+            float percentValue = 100f * value / getPercentageTotalValue(context);
+            return range ? min <= percentValue && percentValue <= max : percentValue == min;
+        } else
+            return range ? min <= value && value <= max : value == min;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/IdentifierCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/IdentifierCondition.java
new file mode 100644
index 0000000..4d04b76
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/IdentifierCondition.java
@@ -0,0 +1,42 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import net.minecraft.util.Identifier;
+import net.minecraft.util.InvalidIdentifierException;
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+/**
+ * Common condition parser for identifiers.
+ */
+public abstract class IdentifierCondition extends CITCondition {
+    /**
+     * Parsed identifier.
+     */
+    protected Identifier value;
+
+    /**
+	 * Converts the given context to an identifier to compare the parsed value to.
+     * @param context context to retrieve the compared value from
+	 * @return the identifier value associated with the given context
+     */
+    protected Identifier getValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        try {
+            this.value = new Identifier(value.value());
+        } catch (InvalidIdentifierException e) {
+            throw new CITParsingException(e.getMessage(), properties, value.position());
+        }
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        return this.value.equals(getValue(context));
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/IntegerCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/IntegerCondition.java
new file mode 100644
index 0000000..80937f5
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/IntegerCondition.java
@@ -0,0 +1,157 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import static java.lang.Integer.*;
+
+/**
+ * Common condition parser for integers with optional support for ranges, negatives and percentages.
+ */
+public abstract class IntegerCondition extends CITCondition {
+    /**
+     * Whether this condition should accept given ranges/negatives/percentages.
+     */
+    protected final boolean supportsRanges, supportsNegatives, supportsPercentages;
+
+    /**
+     * If ranges are accepted, parsed minimum/maximum integers. If not, minimum is the parsed value.
+     */
+    protected int min, max;
+
+    /**
+     * Whether the parsed value is a range/percentage.
+     */
+    protected boolean range = false, percentage = false;
+
+    protected IntegerCondition(boolean supportsRanges, boolean supportsNegatives, boolean supportsPercentages) {
+        this.supportsRanges = supportsRanges;
+        this.supportsNegatives = supportsNegatives;
+        this.supportsPercentages = supportsPercentages;
+    }
+
+    /**
+	 * Converts the given context to an integer to compare the parsed value to.
+     * @param context context to retrieve the compared value from
+	 * @return the integer value associated with the given context
+     */
+    protected int getValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+	/**
+	 * Converts the given context to a max integer to be used when percentages are enabled.
+     * @param context context to retrieve the max value from
+	 * @return the max integer value associated with the given context
+     */
+    protected int getPercentageTotalValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        String strValue = value.value();
+        if (supportsPercentages && (percentage = strValue.contains("%")))
+            strValue = strValue.replace("%", "");
+
+        try {
+            if (range = supportsRanges) {
+                if (supportsNegatives) {
+                    switch (strValue.length() - strValue.replace("-", "").length()) { // dashesCount
+                        case 0 -> {
+                            range = false;
+                            min = parseInt(strValue);
+                        }
+                        case 1 -> {
+                            if (strValue.startsWith("-")) {
+                                range = false;
+                                min = parseInt(strValue);
+                            } else if (strValue.endsWith("-")) {
+                                min = parseInt(strValue.substring(0, strValue.length() - 1));
+                                max = MAX_VALUE;
+                            } else {
+                                String[] split = strValue.split("-");
+                                min = parseInt(split[0]);
+                                max = parseInt(split[1]);
+                            }
+                        }
+                        case 2 -> {
+                            if (strValue.startsWith("--")) {
+                                min = MIN_VALUE;
+                                max = parseInt(strValue.substring(1));
+                            } else if (strValue.startsWith("-") && strValue.endsWith("-")) {
+                                min = parseInt(strValue.substring(0, strValue.length() - 1));
+                                max = MAX_VALUE;
+                            } else if (strValue.startsWith("-") && !strValue.endsWith("-") && !strValue.contains("--")) {
+                                int lastDash = strValue.lastIndexOf('-');
+                                min = parseInt(strValue.substring(0, lastDash));
+                                max = parseInt(strValue.substring(lastDash + 1));
+                            } else
+                                throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+                        case 3 -> {
+                            if (!strValue.contains("---") && strValue.startsWith("-")) {
+                                String[] split = strValue.split("--");
+                                if (split.length != 2 || split[0].isEmpty() || split[1].isEmpty())
+                                    throw new CITParsingException("Could not parse range", properties, value.position());
+
+                                min = parseInt(split[0]);
+                                max = -parseInt(split[1]);
+                            } else
+                                throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+
+                        default -> throw new CITParsingException("Could not parse range", properties, value.position());
+                    }
+                } else {
+                    if (range = strValue.contains("-")) {
+                        if (strValue.contains("--"))
+                            throw new CITParsingException("Could not parse range", properties, value.position());
+                        String[] split = strValue.split("-");
+                        switch (split.length) {
+                            case 1 -> {
+                                min = parseInt(split[0]);
+                                max = MAX_VALUE;
+                            }
+                            case 2 -> {
+                                if (strValue.endsWith("-"))
+                                    throw new CITParsingException("Could not parse range", properties, value.position());
+                                min = split[0].isEmpty() ? MIN_VALUE : parseInt(split[0]);
+                                max = split[1].isEmpty() ? MAX_VALUE : parseInt(split[1]);
+                            }
+                            default -> throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+                    } else
+                        min = parseInt(strValue);
+                }
+            } else {
+                min = parseInt(strValue);
+                if (!supportsNegatives && min < 0)
+                    throw new CITParsingException("Negatives are not allowed", properties, value.position());
+            }
+
+            if (range) {
+                if (min == max)
+                    range = false;
+                else if (min > max)
+                    throw new CITParsingException("Could not parse range", properties, value.position());
+            }
+        } catch (Exception e) {
+            throw e instanceof CITParsingException citE ? citE : new CITParsingException("Could not parse integer", properties, value.position(), e);
+        }
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        int value = getValue(context);
+
+        if (percentage) {
+            double percentValue = 100d * (double) value / (double) getPercentageTotalValue(context);
+            return range ? min <= percentValue && percentValue <= max : percentValue == (double) min;
+        } else
+            return range ? min <= value && value <= max : value == min;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/ListCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/ListCondition.java
new file mode 100644
index 0000000..e264b27
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/ListCondition.java
@@ -0,0 +1,116 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+
+/**
+ * Common condition parser for multiple values separated by any regex expression.
+ */
+public abstract class ListCondition<T extends CITCondition> extends CITCondition {
+    /**
+     * Regex pattern for any amount of whitespace.
+     */
+    public static final Pattern PATTERN_WHITESPACE = Pattern.compile("\\p{Zs}+");
+
+    /**
+     * Enum class type associated with this condition.
+     */
+    private final Class<T> conditionType;
+
+    /**
+     * Determines how testing the conditions should work(either in OR checks or AND checks).
+	 * @see ListCondition.Type
+     */
+    protected final Type listType;
+
+    /**
+     * Regex pattern to use to separate given input into conditions.
+     */
+    protected final Pattern delimiter;
+
+    /**
+     * Constructor for new parsed conditions.
+     */
+    protected final Supplier<T> conditionSupplier;
+
+    /**
+     * Parsed conditions.
+     */
+    protected T[] conditions;
+
+    protected ListCondition(Class<T> conditionType, Type listType, Pattern delimiter, Supplier<T> conditionSupplier) {
+        this.conditionType = conditionType;
+        this.listType = listType;
+        this.delimiter = delimiter;
+        this.conditionSupplier = conditionSupplier;
+    }
+
+    protected ListCondition(Class<T> conditionType, Supplier<T> conditionSupplier) {
+        this(conditionType, Type.OR, PATTERN_WHITESPACE, conditionSupplier);
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        List<T> conditions = new ArrayList<>();
+
+        for (String conditionValue : delimiter.split(value.value())) {
+            T condition = conditionSupplier.get();
+            condition.load(new PropertyValue(value.keyMetadata(), conditionValue, value.separator(), value.position(), value.propertiesIdentifier(), value.packName()), properties);
+            conditions.add(condition);
+        }
+
+        //noinspection unchecked
+        this.conditions = conditions.toArray((T[]) Array.newInstance(conditionType, 0));
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        return listType.test(conditions, context);
+    }
+
+    /**
+     * Provides OR and AND gates for all of the list's conditions.
+     */
+    public enum Type {
+        /**
+         * Testing passes if any of the conditions pass and fails otherwise.
+         */
+        OR {
+            @Override
+            public boolean test(CITCondition[] conditions, CITContext context) {
+                for (CITCondition condition : conditions)
+                    if (condition.test(context))
+                        return true;
+
+                return false;
+            }
+        },
+        /**
+         * Testing passes if all of the conditions pass and fails otherwise.
+         */
+        AND {
+            @Override
+            public boolean test(CITCondition[] conditions, CITContext context) {
+                for (CITCondition condition : conditions)
+                    if (!condition.test(context))
+                        return false;
+
+                return true;
+            }
+        };
+
+        /**
+         * Tests the given context against all of the conditions.
+         */
+        public abstract boolean test(CITCondition[] conditions, CITContext context);
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/LongCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/LongCondition.java
new file mode 100644
index 0000000..da68bd8
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/LongCondition.java
@@ -0,0 +1,157 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import static java.lang.Long.*;
+
+/**
+ * Common condition parser for longs with optional support for ranges, negatives and percentages.
+ */
+public abstract class LongCondition extends CITCondition {
+	/**
+     * Whether this condition should accept given ranges/negatives/percentages.
+     */
+    protected final boolean supportsRanges, supportsNegatives, supportsPercentages;
+
+    /**
+     * If ranges are accepted, parsed minimum/maximum longs. If not, minimum is the parsed value.
+     */
+    protected long min, max;
+	
+    /**
+     * Whether the parsed value is a range/percentage.
+     */
+    protected boolean range = false, percentage = false;
+
+    protected LongCondition(boolean supportsRanges, boolean supportsNegatives, boolean supportsPercentages) {
+        this.supportsRanges = supportsRanges;
+        this.supportsNegatives = supportsNegatives;
+        this.supportsPercentages = supportsPercentages;
+    }
+
+    /**
+	 * Converts the given context to a long to compare the parsed value to.
+     * @param context context to retrieve the compared value from
+	 * @return the long value associated with the given context
+     */
+    protected long getValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+	/**
+	 * Converts the given context to a max long to be used when percentages are enabled.
+     * @param context context to retrieve the max value from
+	 * @return the max llong value associated with the given context
+     */
+    protected long getPercentageTotalValue(CITContext context) {
+        throw new AssertionError("Not implemented by this condition");
+    }
+
+    @Override
+    public void load(PropertyValue value, PropertyGroup properties) throws CITParsingException {
+        String strValue = value.value();
+        if (supportsPercentages && (percentage = strValue.contains("%")))
+            strValue = strValue.replace("%", "");
+
+        try {
+            if (range = supportsRanges) {
+                if (supportsNegatives) {
+                    switch (strValue.length() - strValue.replace("-", "").length()) { // dashesCount
+                        case 0 -> {
+                            range = false;
+                            min = parseLong(strValue);
+                        }
+                        case 1 -> {
+                            if (strValue.startsWith("-")) {
+                                range = false;
+                                min = parseLong(strValue);
+                            } else if (strValue.endsWith("-")) {
+                                min = parseLong(strValue.substring(0, strValue.length() - 1));
+                                max = MAX_VALUE;
+                            } else {
+                                String[] split = strValue.split("-");
+                                min = parseLong(split[0]);
+                                max = parseLong(split[1]);
+                            }
+                        }
+                        case 2 -> {
+                            if (strValue.startsWith("--")) {
+                                min = MIN_VALUE;
+                                max = parseLong(strValue.substring(1));
+                            } else if (strValue.startsWith("-") && strValue.endsWith("-")) {
+                                min = parseLong(strValue.substring(0, strValue.length() - 1));
+                                max = MAX_VALUE;
+                            } else if (strValue.startsWith("-") && !strValue.endsWith("-") && !strValue.contains("--")) {
+                                int lastDash = strValue.lastIndexOf('-');
+                                min = parseLong(strValue.substring(0, lastDash));
+                                max = parseLong(strValue.substring(lastDash + 1));
+                            } else
+                                throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+                        case 3 -> {
+                            if (!strValue.contains("---") && strValue.startsWith("-")) {
+                                String[] split = strValue.split("--");
+                                if (split.length != 2 || split[0].isEmpty() || split[1].isEmpty())
+                                    throw new CITParsingException("Could not parse range", properties, value.position());
+
+                                min = parseLong(split[0]);
+                                max = -parseLong(split[1]);
+                            } else
+                                throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+
+                        default -> throw new CITParsingException("Could not parse range", properties, value.position());
+                    }
+                } else {
+                    if (range = strValue.contains("-")) {
+                        if (strValue.contains("--"))
+                            throw new CITParsingException("Could not parse range", properties, value.position());
+                        String[] split = strValue.split("-");
+                        switch (split.length) {
+                            case 1 -> {
+                                min = parseLong(split[0]);
+                                max = MAX_VALUE;
+                            }
+                            case 2 -> {
+                                if (strValue.endsWith("-"))
+                                    throw new CITParsingException("Could not parse range", properties, value.position());
+                                min = split[0].isEmpty() ? MIN_VALUE : parseLong(split[0]);
+                                max = split[1].isEmpty() ? MAX_VALUE : parseLong(split[1]);
+                            }
+                            default -> throw new CITParsingException("Could not parse range", properties, value.position());
+                        }
+                    } else
+                        min = parseLong(strValue);
+                }
+            } else {
+                min = parseLong(strValue);
+                if (!supportsNegatives && min < 0)
+                    throw new CITParsingException("Negatives are not allowed", properties, value.position());
+            }
+
+            if (range) {
+                if (min == max)
+                    range = false;
+                else if (min > max)
+                    throw new CITParsingException("Could not parse range", properties, value.position());
+            }
+        } catch (Exception e) {
+            throw e instanceof CITParsingException citE ? citE : new CITParsingException("Could not parse long", properties, value.position(), e);
+        }
+    }
+
+    @Override
+    public boolean test(CITContext context) {
+        long value = getValue(context);
+
+        if (percentage) {
+            double percentValue = 100d * (double) value / (double) getPercentageTotalValue(context);
+            return range ? min <= percentValue && percentValue <= max : percentValue == (double) min;
+        } else
+            return range ? min <= value && value <= max : value == min;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/WeightCondition.java b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/WeightCondition.java
new file mode 100644
index 0000000..a53e019
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/cit/builtin/conditions/WeightCondition.java
@@ -0,0 +1,32 @@
+package shcm.shsupercm.fabric.citresewn.cit.builtin.conditions;
+
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
+import shcm.shsupercm.fabric.citresewn.api.CITConditionContainer;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITContext;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+/**
+ * Internal condition used to determine the priority CITs get tested in.<br>
+ * Weights default to 0 and higher weights get chosen over lower weights.<br>
+ * When two conflicting CITs have the same weight, their path in the resourcepack is used as a tie breaker.
+ */
+public class WeightCondition extends IntegerCondition {
+    @Entrypoint(CITConditionContainer.ENTRYPOINT)
+    public static final CITConditionContainer<WeightCondition> CONTAINER = new CITConditionContainer<>(WeightCondition.class, WeightCondition::new,
+            "weight");
+
+    public WeightCondition() {
+        super(false, true, false);
+    }
+
+    public int getWeight() {
+        return this.min;
+    }
+
+    public void setWeight(int weight) {
+        this.min = weight;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/config/BrokenPaths.java b/src/main/java/shcm/shsupercm/fabric/citresewn/config/BrokenPaths.java
new file mode 100644
index 0000000..f4b2c65
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/config/BrokenPaths.java
@@ -0,0 +1,23 @@
+package shcm.shsupercm.fabric.citresewn.config;
+
+import net.minecraft.util.Identifier;
+import shcm.shsupercm.fabric.citresewn.mixin.broken_paths.*;
+
+/**
+ * Broken paths are resourcepack file paths that do not follow {@link Identifier}'s specifications.<br>
+ * When enabled in config, CIT Resewn will forcibly allow broken paths to load.<br>
+ * If not enabled, broken paths has no effect on the game.
+ * @see CITResewnConfig#broken_paths
+ * @see CITResewnMixinConfiguration#broken_paths
+ * @see ReloadableResourceManagerImplMixin
+ * @see IdentifierMixin
+ * @see AbstractFileResourcePackMixin
+ */
+public class BrokenPaths {
+    /**
+     * When enabled, {@link Identifier}s will not check for their path's validity.
+     * @see ReloadableResourceManagerImplMixin
+     * @see IdentifierMixin
+     */
+    public static boolean processingBrokenPaths = false;
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnConfig.java b/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnConfig.java
index 04b3166..cd66fed 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnConfig.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnConfig.java
@@ -2,26 +2,54 @@ package shcm.shsupercm.fabric.citresewn.config;
 
 import com.google.gson.Gson;
 import com.google.gson.stream.JsonWriter;
+import net.fabricmc.loader.api.FabricLoader;
 import org.apache.commons.io.IOUtils;
 import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.pack.CITParser;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITItem;
 
 import java.io.*;
 
+/**
+ * Contains runtime representation of CIT Resewn's config, encoded using GSON.
+ */
 public class CITResewnConfig {
+    /**
+     * Whether CIT Resewn should work or not.<br>
+     * Requires a restart.
+     */
     public boolean enabled = true;
+    /**
+     * Mutes pack loading errors from logs.
+     */
     public boolean mute_errors = false;
+    /**
+     * Mutes pack loading warnings from logs.
+     */
     public boolean mute_warns = false;
-    public float citenchantment_scroll_multiplier = 8f;
+    /**
+     * Invalidating interval for CITs' caches in milliseconds. Set to 0 to disable caching.
+     */
     public int cache_ms = 50;
+    /**
+     * Should broken paths be allowed in resourcepacks. Requires a restart.
+     * @see BrokenPaths
+     */
     public boolean broken_paths = false;
 
-    private static final File FILE = new File("config/citresewn.json");
-    public static CITResewnConfig INSTANCE() {
-        return CITResewn.INSTANCE.config;
-    }
+    /**
+     * CIT Resewn's config storage file.
+     */
+    private static final File FILE = new File(FabricLoader.getInstance().getConfigDir().toFile(), "citresewn.json");
+
+    /**
+     * Active instance of the current config.
+     */
+    public static final CITResewnConfig INSTANCE = read();
 
+    /**
+     * Reads the stored config.
+     * @see #FILE
+     * @return the read config
+     */
     public static CITResewnConfig read() {
         if (!FILE.exists())
             return new CITResewnConfig().write();
@@ -37,6 +65,11 @@ public class CITResewnConfig {
         }
     }
 
+    /**
+     * Saves this config to file.
+     * @see #FILE
+     * @return this
+     */
     public CITResewnConfig write() {
         Gson gson = new Gson();
         JsonWriter writer = null;
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnConfigScreenFactory.java b/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnConfigScreenFactory.java
index 055c976..c1c35b2 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnConfigScreenFactory.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnConfigScreenFactory.java
@@ -3,15 +3,33 @@ package shcm.shsupercm.fabric.citresewn.config;
 import me.shedaniel.clothconfig2.api.ConfigBuilder;
 import me.shedaniel.clothconfig2.api.ConfigCategory;
 import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
+import net.fabricmc.loader.api.FabricLoader;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.text.LiteralText;
 import net.minecraft.text.TranslatableText;
 import net.minecraft.util.Formatting;
 
+import java.util.function.Function;
+
+/**
+ * Cloth Config integration to CIT Resewn's config
+ * @see CITResewnConfig
+ */
 public class CITResewnConfigScreenFactory {
+    /**
+     * Used to get CIT Resewn - Defaults's Cloth Config implementation.
+     */
+    public static final String DEFAULTS_CONFIG_ENTRYPOINT = "citresewn-defaults:config_screen";
+
+    /**
+     * Creates a Cloth Config screen for the current active config instance.
+     * @param parent parent to return to from the config screen
+     * @return the config screen
+     * @throws NoClassDefFoundError if Cloth Config is not present
+     */
     public static Screen create(Screen parent) {
-        CITResewnConfig currentConfig = CITResewnConfig.INSTANCE(), defaultConfig = new CITResewnConfig();
+        CITResewnConfig currentConfig = CITResewnConfig.INSTANCE, defaultConfig = new CITResewnConfig();
 
         ConfigBuilder builder = ConfigBuilder.create()
                 .setParentScreen(parent)
@@ -32,6 +50,24 @@ public class CITResewnConfigScreenFactory {
                 .setDefaultValue(defaultConfig.enabled)
                 .build());
 
+        if (FabricLoader.getInstance().isModLoaded("citresewn-defaults")) {
+            class CurrentScreen { boolean prevToggle = false; } final CurrentScreen currentScreen = new CurrentScreen();
+            category.addEntry(entryBuilder.startBooleanToggle(new TranslatableText("config.citresewn-defaults.title"), false)
+                    .setTooltip(new TranslatableText("config.citresewn-defaults.tooltip"))
+
+                    .setYesNoTextSupplier((b) -> {
+                        if (b != currentScreen.prevToggle) {
+                            //noinspection unchecked
+                            MinecraftClient.getInstance().setScreen((Screen) FabricLoader.getInstance().getEntrypoints(DEFAULTS_CONFIG_ENTRYPOINT, Function.class).stream().findAny().orElseThrow().apply(create(parent)));
+
+                            currentScreen.prevToggle = b;
+                        }
+
+                        return new TranslatableText("config.citresewn.configure");
+                    })
+                    .build());
+        }
+
         category.addEntry(entryBuilder.startBooleanToggle(new TranslatableText("config.citresewn.mute_errors.title"), currentConfig.mute_errors)
                 .setTooltip(new TranslatableText("config.citresewn.mute_errors.tooltip"))
                 .setSaveConsumer(newConfig -> currentConfig.mute_errors = newConfig)
@@ -44,17 +80,10 @@ public class CITResewnConfigScreenFactory {
                 .setDefaultValue(defaultConfig.mute_warns)
                 .build());
 
-        category.addEntry(entryBuilder.startFloatField(new TranslatableText("config.citresewn.citenchantment_scroll_multiplier.title"), currentConfig.citenchantment_scroll_multiplier)
-                .setTooltip(new TranslatableText("config.citresewn.citenchantment_scroll_multiplier.tooltip"))
-                .setSaveConsumer(newConfig -> currentConfig.citenchantment_scroll_multiplier = newConfig)
-                .setDefaultValue(defaultConfig.citenchantment_scroll_multiplier)
-                .setMin(0f)
-                .build());
-
         category.addEntry(entryBuilder.startIntSlider(new TranslatableText("config.citresewn.cache_ms.title"), currentConfig.cache_ms / 50, 0, 5 * 20)
                 .setTooltip(new TranslatableText("config.citresewn.cache_ms.tooltip"))
                 .setSaveConsumer(newConfig -> currentConfig.cache_ms = newConfig * 50)
-                .setDefaultValue(currentConfig.cache_ms / 50)
+                .setDefaultValue(defaultConfig.cache_ms / 50)
                 .setTextGetter(ticks -> {
                     if (ticks <= 1)
                         return new TranslatableText("config.citresewn.cache_ms.ticks." + ticks).formatted(Formatting.AQUA);
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnMixinConfiguration.java b/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnMixinConfiguration.java
index 4247494..6e4d2ce 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnMixinConfiguration.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnMixinConfiguration.java
@@ -1,23 +1,42 @@
 package shcm.shsupercm.fabric.citresewn.config;
 
 import net.fabricmc.loader.api.FabricLoader;
+import net.fabricmc.loader.api.ModContainer;
 import org.objectweb.asm.tree.ClassNode;
 import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
 import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
+import shcm.shsupercm.fabric.citresewn.CITResewn;
 
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
+/**
+ * Mixin configuration for CIT Resewn's mixins.
+ */
 public class CITResewnMixinConfiguration implements IMixinConfigPlugin {
     private static final String MIXINS_ROOT = "shcm.shsupercm.fabric.citresewn.mixin";
 
+    /**
+     * Is Broken Paths enabled in config.
+     * @see BrokenPaths
+     * @see CITResewnConfig#broken_paths
+     */
     private boolean broken_paths;
 
+    /**
+     * Slightly modified mod ids for loaded mods and mods with compat mixins.
+     */
+    private final Set<String> mods = new HashSet<>(), compatMods = new HashSet<>();
+
     @Override
     public void onLoad(String mixinPackage) {
         CITResewnConfig launchConfig = CITResewnConfig.read();
 
         this.broken_paths = launchConfig.broken_paths;
+
+        for (ModContainer mod : FabricLoader.getInstance().getAllMods())
+            mods.add(mod.getMetadata().getId().replace('-', '_'));
     }
 
     @Override
@@ -29,8 +48,17 @@ public class CITResewnMixinConfiguration implements IMixinConfigPlugin {
         if (mixinClassName.startsWith("broken_paths"))
             return broken_paths;
 
-        if (mixinClassName.equals("core.GroupResourcePackAccessor"))
-            return FabricLoader.getInstance().isModLoaded("fabric-resource-loader-v0");
+        if (mixinClassName.startsWith("compat.")) {
+            mixinClassName = mixinClassName.substring(7);
+            String modid = mixinClassName.substring(0, mixinClassName.indexOf('.'));
+            if (mods.contains(modid)) {
+                if (compatMods.add(modid))
+                    CITResewn.info("Loading compatibility for " + modid);
+
+                return true;
+            }
+            return false;
+        }
 
         return true;
     }
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnModMenu.java b/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnModMenu.java
index 7a4954c..095f0cb 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnModMenu.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/config/CITResewnModMenu.java
@@ -2,12 +2,22 @@ package shcm.shsupercm.fabric.citresewn.config;
 
 import com.terraformersmc.modmenu.api.ConfigScreenFactory;
 import com.terraformersmc.modmenu.api.ModMenuApi;
+import io.shcm.shsupercm.fabric.fletchingtable.api.Entrypoint;
 import net.fabricmc.loader.api.FabricLoader;
-import shcm.shsupercm.fabric.citresewn.OptionalCompat;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.NoticeScreen;
+import net.minecraft.text.Text;
 
+/**
+ * Mod Menu config button integration.
+ */
+@Entrypoint("modmenu")
 public class CITResewnModMenu implements ModMenuApi {
     @Override
     public ConfigScreenFactory<?> getModConfigScreenFactory() {
-        return OptionalCompat.getModConfigScreenFactory()::apply;
+        if (FabricLoader.getInstance().isModLoaded("cloth-config2"))
+            return CITResewnConfigScreenFactory::create;
+
+        return parent -> new NoticeScreen(() -> MinecraftClient.getInstance().setScreen(parent), Text.of("CIT Resewn"), Text.of("CIT Resewn requires Cloth Config to be able to show the config."));
     }
 }
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITLoadException.java b/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITLoadException.java
deleted file mode 100644
index c40bc80..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITLoadException.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.ex;
-
-import net.minecraft.resource.ResourcePack;
-import net.minecraft.util.Identifier;
-
-/**
- * Thrown when a cit failed to be loaded
- */
-public class CITLoadException extends Exception {
-    public CITLoadException(ResourcePack resourcePack, Identifier identifier, String message) {
-        super("Couldn't load CIT: " + message + " in " + resourcePack.getName() + " -> " + identifier.toString());
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITParseException.java b/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITParseException.java
deleted file mode 100644
index 95bc386..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITParseException.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.ex;
-
-import net.minecraft.resource.ResourcePack;
-import net.minecraft.util.Identifier;
-
-/**
- * Thrown when a cit failed to be parsed
- */
-public class CITParseException extends Exception {
-    public CITParseException(ResourcePack resourcePack, Identifier identifier, String message) {
-        super("Skipped CIT: " + message + " in " + resourcePack.getName() + " -> " + identifier.toString());
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITParsingException.java b/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITParsingException.java
new file mode 100644
index 0000000..f897ba7
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/ex/CITParsingException.java
@@ -0,0 +1,17 @@
+package shcm.shsupercm.fabric.citresewn.ex;
+
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+
+/**
+ * Thrown if errored while parsing the properties of a {@link PropertyGroup}.
+ * @see PropertyGroup#messageWithDescriptorOf(String, int)
+ */
+public class CITParsingException extends Exception {
+    public CITParsingException(String message, PropertyGroup propertyGroup, int position, Throwable throwable) {
+        super("Errored while parsing CIT: " + propertyGroup.messageWithDescriptorOf(message, position), throwable);
+    }
+
+    public CITParsingException(String message, PropertyGroup propertyGroup, int position) {
+        super("Errored while parsing CIT: " + propertyGroup.messageWithDescriptorOf(message, position));
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/ex/UnknownCITTypeException.java b/src/main/java/shcm/shsupercm/fabric/citresewn/ex/UnknownCITTypeException.java
new file mode 100644
index 0000000..23f9c82
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/ex/UnknownCITTypeException.java
@@ -0,0 +1,12 @@
+package shcm.shsupercm.fabric.citresewn.ex;
+
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+
+/**
+ * Thrown when a property group contains an unrecognized value associated with the "type" key.
+ */
+public class UnknownCITTypeException extends CITParsingException {
+    public UnknownCITTypeException(PropertyGroup propertyGroup, int position) {
+        super("Unknown type", propertyGroup, position);
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/ChatScreenMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/ChatScreenMixin.java
new file mode 100644
index 0000000..c79143b
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/ChatScreenMixin.java
@@ -0,0 +1,38 @@
+package shcm.shsupercm.fabric.citresewn.mixin;
+
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.ChatScreen;
+import net.minecraft.client.gui.screen.NoticeScreen;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.Text;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.ModifyArg;
+import shcm.shsupercm.fabric.citresewn.CITResewnCommand;
+import shcm.shsupercm.fabric.citresewn.config.CITResewnConfigScreenFactory;
+
+import static shcm.shsupercm.fabric.citresewn.CITResewnCommand.openConfig;
+
+/**
+ * Opens the config screen when running the "/citresewn config" command.
+ * @see CITResewnCommand#openConfig
+ */
+@Mixin(ChatScreen.class)
+public class ChatScreenMixin {
+    /**
+     * If {@link CITResewnCommand#openConfig} is true, changes the screen that's opened when the chat is closed to the config screen.
+     * @see CITResewnCommand#openConfig
+     */
+    @ModifyArg(method = "keyPressed", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/MinecraftClient;setScreen(Lnet/minecraft/client/gui/screen/Screen;)V"))
+    public Screen citresewn$redirectConfigScreen(Screen original) {
+        if (openConfig) {
+            openConfig = false;
+            return FabricLoader.getInstance().isModLoaded("cloth-config2") ?
+                    CITResewnConfigScreenFactory.create(null) :
+                    new NoticeScreen(() -> MinecraftClient.getInstance().setScreen(null), Text.of("CIT Resewn"), Text.of("CIT Resewn requires Cloth Config to be able to show the config."));
+        }
+
+        return original;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/ModelLoaderMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/ModelLoaderMixin.java
new file mode 100644
index 0000000..df11ac9
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/ModelLoaderMixin.java
@@ -0,0 +1,29 @@
+package shcm.shsupercm.fabric.citresewn.mixin;
+
+import net.minecraft.client.color.block.BlockColors;
+import net.minecraft.client.render.model.ModelLoader;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.profiler.Profiler;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import shcm.shsupercm.fabric.citresewn.cit.ActiveCITs;
+
+/**
+ * Initializes the (re)loading of active cits in the resource manager.
+ * @see ActiveCITs
+ */
+@Mixin(ModelLoader.class)
+public class ModelLoaderMixin {
+    /**
+     * @see ActiveCITs#load(ResourceManager, Profiler)
+     */
+    @Inject(method = "<init>", at =
+    @At(value = "INVOKE", ordinal = 0, target = "Lnet/minecraft/util/profiler/Profiler;push(Ljava/lang/String;)V"))
+    private void citresewn$loadCITs(ResourceManager resourceManager, BlockColors blockColors, Profiler profiler, int i, CallbackInfo ci) {
+        profiler.push("citresewn:reloading_cits");
+        ActiveCITs.load(resourceManager, profiler);
+        profiler.pop();
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/AbstractFileResourcePackMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/AbstractFileResourcePackMixin.java
index 281150b..b241fff 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/AbstractFileResourcePackMixin.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/AbstractFileResourcePackMixin.java
@@ -14,33 +14,43 @@ import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.config.BrokenPaths;
 
 import java.io.File;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.zip.ZipFile;
 
-/* if (CITResewnConfig.read().broken_paths) */ @Mixin(AbstractFileResourcePack.class)
+/**
+ * Adds a resourcepack compatibility error message when broken paths are enabled and are detected in a pack.
+ * @see BrokenPaths
+ * @see ResourcePackCompatibilityMixin
+ */
+@Mixin(AbstractFileResourcePack.class)
 public abstract class AbstractFileResourcePackMixin implements ResourcePack {
     @Shadow @Final protected File base;
 
     @SuppressWarnings({"unchecked", "ConstantConditions", "EqualsBetweenInconvertibleTypes"})
     @Inject(method = "parseMetadata(Lnet/minecraft/resource/metadata/ResourceMetadataReader;)Ljava/lang/Object;", cancellable = true, at = @At("RETURN"))
-    public <T extends PackResourceMetadata> void parseMetadata(ResourceMetadataReader<T> metaReader, CallbackInfoReturnable<T> cir) {
+    public <T extends PackResourceMetadata> void citresewn$brokenpaths$parseMetadata(ResourceMetadataReader<T> metaReader, CallbackInfoReturnable<T> cir) {
         if (cir.getReturnValue() != null)
             try {
                 if (this.getClass().equals(ZipResourcePack.class)) {
                     try (ZipFile zipFile = new ZipFile(base)) {
                         zipFile.stream()
                                 .forEach(entry -> {
-                                    if (entry.getName().startsWith("assets"))
+                                    if (entry.getName().startsWith("assets") && !entry.getName().endsWith(".DS_Store"))
                                         new Identifier("minecraft", entry.getName());
                                 });
                     }
                 } else if (this.getClass().equals(DirectoryResourcePack.class)) {
                     final Path assets = new File(base, "assets").toPath();
                     Files.walk(assets)
-                            .forEach(path -> new Identifier("minecraft", assets.relativize(path).toString().replace('\\', '/')));
+                            .forEach(fullPath -> {
+                                String path = assets.relativize(fullPath).toString().replace('\\', '/');
+                                if (!path.endsWith(".DS_Store"))
+                                    new Identifier("minecraft", path);
+                            });
                 }
             } catch (InvalidIdentifierException e) {
                 cir.setReturnValue((T) new PackResourceMetadata(cir.getReturnValue().getDescription(), Integer.MAX_VALUE - 53));
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/IdentifierMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/IdentifierMixin.java
index da9888f..0bc36c3 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/IdentifierMixin.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/IdentifierMixin.java
@@ -6,12 +6,25 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import shcm.shsupercm.fabric.citresewn.CITResewn;
+import shcm.shsupercm.fabric.citresewn.config.BrokenPaths;
 
-/* if (CITResewnConfig.read().broken_paths) */ @Mixin(Identifier.class)
+import static shcm.shsupercm.fabric.citresewn.config.BrokenPaths.processingBrokenPaths;
+
+/**
+ * Applies broken paths logic when active.
+ * @see BrokenPaths
+ * @see ReloadableResourceManagerImplMixin
+ */
+@Mixin(Identifier.class)
 public class IdentifierMixin {
-    @Inject(method = "isPathValid", cancellable = true, at = @At("HEAD"))
-    private static void processBrokenPaths(String path, CallbackInfoReturnable<Boolean> cir) {
-        if (CITResewn.INSTANCE != null && CITResewn.INSTANCE.processingBrokenPaths)
+    @Inject(method = "isPathValid", cancellable = true, at = @At("RETURN"))
+    private static void citresewn$brokenpaths$processBrokenPaths(String path, CallbackInfoReturnable<Boolean> cir) {
+        if (!processingBrokenPaths)
+            return;
+
+        if (!cir.getReturnValue()) {
+            CITResewn.logWarnLoading("Warning: Encountered broken path: \"" + path + "\"");
             cir.setReturnValue(true);
+        }
     }
 }
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/ReloadableResourceManagerImplMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/ReloadableResourceManagerImplMixin.java
index e2b193a..1d94285 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/ReloadableResourceManagerImplMixin.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/ReloadableResourceManagerImplMixin.java
@@ -12,20 +12,28 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import shcm.shsupercm.fabric.citresewn.CITResewn;
+import shcm.shsupercm.fabric.citresewn.config.BrokenPaths;
 
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 
-/* if (CITResewnConfig.read().broken_paths) */ @Mixin(ReloadableResourceManagerImpl.class)
+import static shcm.shsupercm.fabric.citresewn.config.BrokenPaths.processingBrokenPaths;
+
+/**
+ * Starts/Stops broken paths logic.
+ * @see BrokenPaths
+ * @see IdentifierMixin
+ */
+@Mixin(ReloadableResourceManagerImpl.class)
 public class ReloadableResourceManagerImplMixin {
     @Shadow @Final private ResourceType type;
 
     @Inject(method = "reload", at = @At("RETURN"))
-    public void onReload(Executor prepareExecutor, Executor applyExecutor, CompletableFuture<Unit> initialStage, List<ResourcePack> packs, CallbackInfoReturnable<ResourceReload> cir) {
-        if (CITResewn.INSTANCE.processingBrokenPaths = this.type == ResourceType.CLIENT_RESOURCES) {
+    public void citresewn$brokenpaths$onReload(Executor prepareExecutor, Executor applyExecutor, CompletableFuture<Unit> initialStage, List<ResourcePack> packs, CallbackInfoReturnable<ResourceReload> cir) {
+        if (processingBrokenPaths = this.type == ResourceType.CLIENT_RESOURCES) {
             CITResewn.LOG.error("[citresewn] Caution! Broken paths is enabled!");
-            cir.getReturnValue().whenComplete().thenRun(() -> CITResewn.INSTANCE.processingBrokenPaths = false);
+            cir.getReturnValue().whenComplete().thenRun(() -> processingBrokenPaths = false);
         }
     }
 }
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/ResourcePackCompatibilityMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/ResourcePackCompatibilityMixin.java
index f62221b..813eb3d 100644
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/ResourcePackCompatibilityMixin.java
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/broken_paths/ResourcePackCompatibilityMixin.java
@@ -7,8 +7,14 @@ import org.spongepowered.asm.mixin.gen.Invoker;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import shcm.shsupercm.fabric.citresewn.config.BrokenPaths;
 
-/* if (CITResewnConfig.read().broken_paths) */ @Mixin(ResourcePackCompatibility.class)
+/**
+ * Adds a resourcepack compatibility error message when broken paths are enabled and are detected in a pack.
+ * @see BrokenPaths
+ * @see AbstractFileResourcePackMixin
+ */
+@Mixin(ResourcePackCompatibility.class)
 public abstract class ResourcePackCompatibilityMixin {
     private static final ResourcePackCompatibility BROKEN_PATHS = ResourcePackCompatibility("BROKEN_PATHS", -1, "broken_paths");
 
@@ -19,7 +25,7 @@ public abstract class ResourcePackCompatibilityMixin {
     }
 
     @Inject(method = "from(ILnet/minecraft/resource/ResourceType;)Lnet/minecraft/resource/ResourcePackCompatibility;", cancellable = true, at = @At("HEAD"))
-    private static void redirectBrokenPathsCompatibility(int packVersion, ResourceType type, CallbackInfoReturnable<ResourcePackCompatibility> cir) {
+    private static void citresewn$brokenpaths$redirectBrokenPathsCompatibility(int packVersion, ResourceType type, CallbackInfoReturnable<ResourcePackCompatibility> cir) {
         if (packVersion == Integer.MAX_VALUE - 53)
             cir.setReturnValue(BROKEN_PATHS);
     }
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citarmor/ArmorFeatureRendererMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citarmor/ArmorFeatureRendererMixin.java
deleted file mode 100644
index 72a0ade..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citarmor/ArmorFeatureRendererMixin.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citarmor;
-
-import net.minecraft.client.render.VertexConsumerProvider;
-import net.minecraft.client.render.entity.feature.ArmorFeatureRenderer;
-import net.minecraft.client.render.entity.model.BipedEntityModel;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.EquipmentSlot;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.ArmorItem;
-import net.minecraft.item.ItemStack;
-import net.minecraft.util.Identifier;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.OptionalCompat;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-
-import java.lang.ref.WeakReference;
-import java.util.Map;
-
-@Mixin(ArmorFeatureRenderer.class)
-public class ArmorFeatureRendererMixin<T extends LivingEntity, M extends BipedEntityModel<T>, A extends BipedEntityModel<T>> {
-    private WeakReference<Map<String, Identifier>> armorTexturesCached = null;
-
-    @Inject(method = "renderArmor", at = @At("HEAD"))
-    private void renderArmor(MatrixStack matrices, VertexConsumerProvider vertexConsumers, T entity, EquipmentSlot armorSlot, int light, A model, CallbackInfo ci) {
-        if (!CITResewnConfig.INSTANCE().enabled || CITResewn.INSTANCE.activeCITs == null)
-            return;
-
-        ItemStack itemStack = entity.getEquippedStack(armorSlot);
-
-        //compat Cosmetic Armor
-        itemStack = OptionalCompat.getCosmeticArmor(itemStack, entity, armorSlot, false);
-
-        Map<String, Identifier> armorTextures = CITResewn.INSTANCE.activeCITs.getArmorTexturesCached(itemStack, entity.world, entity);
-        if (armorTextures != null) {
-            armorTexturesCached = new WeakReference<>(armorTextures);
-            return;
-        }
-
-        armorTexturesCached = null;
-    }
-
-    @Inject(method = "getArmorTexture", cancellable = true, at = @At("HEAD"))
-    private void getArmorTexture(ArmorItem item, boolean legs, String overlay, CallbackInfoReturnable<Identifier> cir) {
-        if (armorTexturesCached == null)
-            return;
-        Map<String, Identifier> armorTextures = armorTexturesCached.get();
-        if (armorTextures == null)
-            return;
-
-        Identifier identifier = armorTextures.get(item.getMaterial().getName() + "_layer_" + (legs ? "2" : "1") + (overlay == null ? "" : "_" + overlay));
-        if (identifier != null)
-            cir.setReturnValue(identifier);
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citarmor/ItemStackMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citarmor/ItemStackMixin.java
deleted file mode 100644
index 6041c9b..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citarmor/ItemStackMixin.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citarmor;
-
-import net.minecraft.item.ItemStack;
-import org.spongepowered.asm.mixin.Mixin;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITArmor;
-
-import java.lang.ref.WeakReference;
-import java.util.function.Supplier;
-
-@Mixin(ItemStack.class)
-public class ItemStackMixin implements CITArmor.Cached {
-    private WeakReference<CITArmor> citresewn_cachedCITArmor = new WeakReference<>(null);
-    private long citresewn_cacheTimeCITArmor = 0;
-
-    @Override
-    public CITArmor citresewn_getCachedCITArmor(Supplier<CITArmor> realtime) {
-        if (System.currentTimeMillis() - citresewn_cacheTimeCITArmor >= CITResewnConfig.INSTANCE().cache_ms) {
-            citresewn_cachedCITArmor = new WeakReference<>(realtime.get());
-            citresewn_cacheTimeCITArmor = System.currentTimeMillis();
-        }
-
-        return citresewn_cachedCITArmor.get();
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citelytra/ElytraFeatureRendererMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citelytra/ElytraFeatureRendererMixin.java
deleted file mode 100644
index b4151f8..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citelytra/ElytraFeatureRendererMixin.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citelytra;
-
-import net.minecraft.client.render.RenderLayer;
-import net.minecraft.client.render.VertexConsumerProvider;
-import net.minecraft.client.render.entity.feature.ElytraFeatureRenderer;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.EquipmentSlot;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.util.Identifier;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.OptionalCompat;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-
-import java.lang.ref.WeakReference;
-
-@Mixin(ElytraFeatureRenderer.class)
-public class ElytraFeatureRendererMixin {
-    private WeakReference<ItemStack> elytraItemCached = new WeakReference<>(null);
-    private WeakReference<LivingEntity> livingEntityCached = new WeakReference<>(null);
-
-    @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/entity/LivingEntity;FFFFFF)V", at =
-    @At("HEAD"))
-    private void render(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, LivingEntity livingEntity, float f, float g, float h, float j, float k, float l, CallbackInfo ci) {
-        if (!CITResewnConfig.INSTANCE().enabled || CITResewn.INSTANCE.activeCITs == null)
-            return;
-
-        ItemStack itemStack = livingEntity.getEquippedStack(EquipmentSlot.CHEST);
-
-        //compat Cosmetic Armor
-        itemStack = OptionalCompat.getCosmeticArmor(itemStack, livingEntity, EquipmentSlot.CHEST, true);
-
-        this.elytraItemCached = new WeakReference<>(itemStack);
-        this.livingEntityCached = new WeakReference<>(livingEntity);
-    }
-
-    @ModifyArg(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/entity/LivingEntity;FFFFFF)V", at =
-    @At(value = "INVOKE", target = "Lnet/minecraft/client/render/item/ItemRenderer;getArmorGlintConsumer(Lnet/minecraft/client/render/VertexConsumerProvider;Lnet/minecraft/client/render/RenderLayer;ZZ)Lnet/minecraft/client/render/VertexConsumer;"), index = 1)
-    private RenderLayer getArmorCutoutNoCull(RenderLayer original) {
-        if (CITResewnConfig.INSTANCE().enabled && CITResewn.INSTANCE.activeCITs != null) {
-            ItemStack itemStack = this.elytraItemCached.get();
-            LivingEntity livingEntity = this.livingEntityCached.get();
-            if (itemStack != null && itemStack.isOf(Items.ELYTRA) && livingEntity != null) {
-                Identifier elytraTexture = CITResewn.INSTANCE.activeCITs.getElytraTextureCached(itemStack, livingEntity.world, livingEntity);
-                this.elytraItemCached = new WeakReference<>(null);
-                this.livingEntityCached = new WeakReference<>(null);
-                if (elytraTexture != null)
-                    return RenderLayer.getArmorCutoutNoCull(elytraTexture);
-            }
-        }
-
-        return original;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citelytra/ItemStackMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citelytra/ItemStackMixin.java
deleted file mode 100644
index aaf4037..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citelytra/ItemStackMixin.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citelytra;
-
-import net.minecraft.item.ItemStack;
-import org.spongepowered.asm.mixin.Mixin;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITElytra;
-
-import java.lang.ref.WeakReference;
-import java.util.function.Supplier;
-
-@Mixin(ItemStack.class)
-public class ItemStackMixin implements CITElytra.Cached {
-    private WeakReference<CITElytra> citresewn_cachedCITElytra = new WeakReference<>(null);
-    private long citresewn_cacheTimeCITElytra = 0;
-
-    @Override
-    public CITElytra citresewn_getCachedCITElytra(Supplier<CITElytra> realtime) {
-        if (System.currentTimeMillis() - citresewn_cacheTimeCITElytra >= CITResewnConfig.INSTANCE().cache_ms) {
-            citresewn_cachedCITElytra = new WeakReference<>(realtime.get());
-            citresewn_cacheTimeCITElytra = System.currentTimeMillis();
-        }
-
-        return citresewn_cachedCITElytra.get();
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ArmorFeatureRendererMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ArmorFeatureRendererMixin.java
deleted file mode 100644
index b4d81c7..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ArmorFeatureRendererMixin.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citenchantment;
-
-import net.minecraft.client.render.VertexConsumerProvider;
-import net.minecraft.client.render.entity.feature.ArmorFeatureRenderer;
-import net.minecraft.client.render.entity.model.BipedEntityModel;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.EquipmentSlot;
-import net.minecraft.entity.LivingEntity;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITEnchantment;
-
-@Mixin(ArmorFeatureRenderer.class)
-public class ArmorFeatureRendererMixin<T extends LivingEntity, M extends BipedEntityModel<T>, A extends BipedEntityModel<T>> {
-    @Inject(method = "renderArmor", at = @At("HEAD"))
-    private void setAppliedContextAndStartApplyingArmor(MatrixStack matrices, VertexConsumerProvider vertexConsumers, T livingEntity, EquipmentSlot armorSlot, int light, A model, CallbackInfo ci) {
-        if (CITResewnConfig.INSTANCE().enabled && CITResewn.INSTANCE.activeCITs != null) {
-            CITResewn.INSTANCE.activeCITs.setEnchantmentAppliedContextCached(livingEntity.getEquippedStack(armorSlot), livingEntity.world, livingEntity);
-            CITEnchantment.shouldApply = true;
-        }
-    }
-
-    @Inject(method = "renderArmor", at = @At("RETURN"))
-    private void stopApplyingArmor(MatrixStack matrices, VertexConsumerProvider vertexConsumers, T livingEntity, EquipmentSlot armorSlot, int light, A model, CallbackInfo ci) {
-        CITEnchantment.shouldApply = false;
-        if (CITResewn.INSTANCE.activeCITs != null)
-            CITResewn.INSTANCE.activeCITs.setEnchantmentAppliedContextCached(null, null, null);
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ElytraFeatureRendererMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ElytraFeatureRendererMixin.java
deleted file mode 100644
index 03fb4c0..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ElytraFeatureRendererMixin.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citenchantment;
-
-import net.minecraft.client.render.VertexConsumerProvider;
-import net.minecraft.client.render.entity.feature.ElytraFeatureRenderer;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.EquipmentSlot;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.ItemStack;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITEnchantment;
-
-@Mixin(ElytraFeatureRenderer.class)
-public class ElytraFeatureRendererMixin {
-    @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/entity/LivingEntity;FFFFFF)V", at = @At("HEAD"))
-    private void setAppliedContextAndStartApplyingElytra(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, LivingEntity livingEntity, float f, float g, float h, float j, float k, float l, CallbackInfo ci) {
-        if (CITResewnConfig.INSTANCE().enabled && CITResewn.INSTANCE.activeCITs != null) {
-            CITResewn.INSTANCE.activeCITs.setEnchantmentAppliedContextCached(livingEntity.getEquippedStack(EquipmentSlot.CHEST), livingEntity.world, livingEntity);
-            CITEnchantment.shouldApply = true;
-        }
-    }
-
-    @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/entity/LivingEntity;FFFFFF)V", at = @At("RETURN"))
-    private void stopApplyingElytra(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, LivingEntity livingEntity, float f, float g, float h, float j, float k, float l, CallbackInfo ci) {
-        CITEnchantment.shouldApply = false;
-        if (CITResewn.INSTANCE.activeCITs != null)
-            CITResewn.INSTANCE.activeCITs.setEnchantmentAppliedContextCached(null, null, null);
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ItemRendererMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ItemRendererMixin.java
deleted file mode 100644
index 13d91c7..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ItemRendererMixin.java
+++ /dev/null
@@ -1,86 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citenchantment;
-
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.render.*;
-import net.minecraft.client.render.item.ItemRenderer;
-import net.minecraft.client.render.model.BakedModel;
-import net.minecraft.client.render.model.json.ModelTransformation;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITEnchantment;
-
-@Mixin(ItemRenderer.class)
-public class ItemRendererMixin {
-    @Inject(method = "getModel", at = @At("TAIL"))
-    private void setAppliedContext(ItemStack stack, World world, LivingEntity entity, int seed, CallbackInfoReturnable<BakedModel> cir) {
-        if (CITResewnConfig.INSTANCE().enabled && CITResewn.INSTANCE.activeCITs != null)
-            CITResewn.INSTANCE.activeCITs.setEnchantmentAppliedContextCached(stack, world, entity);
-    }
-
-    @Inject(method = "renderItem(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/render/model/json/ModelTransformation$Mode;ZLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/client/render/model/BakedModel;)V", at = @At("HEAD"))
-    private void startApplyingItem(ItemStack stack, ModelTransformation.Mode renderMode, boolean leftHanded, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, BakedModel model, CallbackInfo ci) {
-        if (CITResewnConfig.INSTANCE().enabled)
-            CITEnchantment.shouldApply = true;
-    }
-
-    @Inject(method = "renderItem(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/render/model/json/ModelTransformation$Mode;ZLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/client/render/model/BakedModel;)V", at = @At("TAIL"))
-    private void stopApplyingItem(ItemStack stack, ModelTransformation.Mode renderMode, boolean leftHanded, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, BakedModel model, CallbackInfo ci) {
-        CITEnchantment.shouldApply = false;
-        if (CITResewn.INSTANCE.activeCITs != null)
-            CITResewn.INSTANCE.activeCITs.setEnchantmentAppliedContextCached(null, null, null);
-    }
-
-    @Inject(method = "getArmorGlintConsumer", cancellable = true, at = @At("RETURN"))
-    private static void getArmorGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, boolean solid, boolean glint, CallbackInfoReturnable<VertexConsumer> cir) {
-        if (!CITEnchantment.shouldApply)
-            return;
-        VertexConsumer vertexConsumer = solid ? CITEnchantment.GlintRenderLayer.ARMOR_GLINT.tryApply(cir.getReturnValue(), layer, provider) : CITEnchantment.GlintRenderLayer.ARMOR_ENTITY_GLINT.tryApply(cir.getReturnValue(), layer, provider);
-        if (vertexConsumer != null)
-            cir.setReturnValue(vertexConsumer);
-    }
-
-    @Inject(method = "getCompassGlintConsumer", cancellable = true, at = @At("RETURN"))
-    private static void getCompassGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, MatrixStack.Entry entry, CallbackInfoReturnable<VertexConsumer> cir) {
-        if (!CITEnchantment.shouldApply)
-            return;
-        VertexConsumer vertexConsumer = CITEnchantment.GlintRenderLayer.GLINT.tryApply(null, layer, provider);
-        if (vertexConsumer != null)
-            cir.setReturnValue(VertexConsumers.union(new OverlayVertexConsumer(vertexConsumer, entry.getPositionMatrix(), entry.getNormalMatrix()), cir.getReturnValue()));
-    }
-
-    @Inject(method = "getDirectCompassGlintConsumer", cancellable = true, at = @At("RETURN"))
-    private static void getDirectCompassGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, MatrixStack.Entry entry, CallbackInfoReturnable<VertexConsumer> cir) {
-        if (!CITEnchantment.shouldApply)
-            return;
-        VertexConsumer vertexConsumer = CITEnchantment.GlintRenderLayer.DIRECT_GLINT.tryApply(null, layer, provider);
-        if (vertexConsumer != null)
-            cir.setReturnValue(VertexConsumers.union(new OverlayVertexConsumer(vertexConsumer, entry.getPositionMatrix(), entry.getNormalMatrix()), cir.getReturnValue()));
-    }
-
-    @Inject(method = "getItemGlintConsumer", cancellable = true, at = @At("RETURN"))
-    private static void getItemGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, boolean solid, boolean glint, CallbackInfoReturnable<VertexConsumer> cir) {
-        if (!CITEnchantment.shouldApply)
-            return;
-        VertexConsumer vertexConsumer = MinecraftClient.isFabulousGraphicsOrBetter() && layer == TexturedRenderLayers.getItemEntityTranslucentCull() ? CITEnchantment.GlintRenderLayer.GLINT_TRANSLUCENT.tryApply(cir.getReturnValue(), layer, provider) : (solid ? CITEnchantment.GlintRenderLayer.GLINT.tryApply(cir.getReturnValue(), layer, provider) : CITEnchantment.GlintRenderLayer.ENTITY_GLINT.tryApply(cir.getReturnValue(), layer, provider));
-        if (vertexConsumer != null)
-            cir.setReturnValue(vertexConsumer);
-    }
-
-    @Inject(method = "getDirectItemGlintConsumer", cancellable = true, at = @At("RETURN"))
-    private static void getDirectItemGlintConsumer(VertexConsumerProvider provider, RenderLayer layer, boolean solid, boolean glint, CallbackInfoReturnable<VertexConsumer> cir) {
-        if (!CITEnchantment.shouldApply)
-            return;
-        VertexConsumer vertexConsumer = solid ? CITEnchantment.GlintRenderLayer.DIRECT_GLINT.tryApply(cir.getReturnValue(), layer, provider) : CITEnchantment.GlintRenderLayer.DIRECT_ENTITY_GLINT.tryApply(cir.getReturnValue(), layer, provider);
-        if (vertexConsumer != null)
-            cir.setReturnValue(vertexConsumer);
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ItemStackMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ItemStackMixin.java
deleted file mode 100644
index 033bf8e..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/citenchantment/ItemStackMixin.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.citenchantment;
-
-import net.minecraft.item.ItemStack;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITEnchantment;
-
-import java.lang.ref.WeakReference;
-import java.util.List;
-import java.util.function.Supplier;
-
-@Mixin(ItemStack.class)
-public class ItemStackMixin implements CITEnchantment.Cached {
-    private WeakReference<List<CITEnchantment>> citresewn_cachedCITEnchantment = new WeakReference<>(null);
-    private long citresewn_cacheTimeCITEnchantment = 0;
-
-    @Override
-    public List<CITEnchantment> citresewn_getCachedCITEnchantment(Supplier<List<CITEnchantment>> realtime) {
-        if (System.currentTimeMillis() - citresewn_cacheTimeCITEnchantment >= CITResewnConfig.INSTANCE().cache_ms) {
-            citresewn_cachedCITEnchantment = new WeakReference<>(realtime.get());
-            citresewn_cacheTimeCITEnchantment = System.currentTimeMillis();
-        }
-
-        return citresewn_cachedCITEnchantment.get();
-    }
-
-    @Inject(method = "hasGlint", cancellable = true, at = @At("HEAD"))
-    private void disableDefaultGlint(CallbackInfoReturnable<Boolean> cir) {
-        if (CITResewn.INSTANCE.activeCITs != null && ((!CITResewn.INSTANCE.activeCITs.effectiveGlobalProperties.useGlint) || (CITEnchantment.appliedContext != null && CITEnchantment.shouldApply && !CITEnchantment.appliedContext.get(0).useGlint)))
-            cir.setReturnValue(false);
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ItemRendererMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ItemRendererMixin.java
deleted file mode 100644
index 2cb5662..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ItemRendererMixin.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.cititem;
-
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.render.VertexConsumerProvider;
-import net.minecraft.client.render.item.ItemModels;
-import net.minecraft.client.render.item.ItemRenderer;
-import net.minecraft.client.render.model.BakedModel;
-import net.minecraft.client.render.model.json.ModelTransformation;
-import net.minecraft.client.util.ModelIdentifier;
-import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.world.World;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.ModifyVariable;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITItem;
-
-import java.lang.ref.WeakReference;
-
-@Mixin(ItemRenderer.class)
-public class ItemRendererMixin {
-    @Shadow @Final private ItemModels models;
-
-    private static WeakReference<BakedModel> mojankCITModel = null;
-
-    @Inject(method = "getModel", cancellable = true, at = @At("HEAD"))
-    private void getItemModel(ItemStack stack, World world, LivingEntity entity, int seed, CallbackInfoReturnable<BakedModel> cir) {
-        if (!CITResewnConfig.INSTANCE().enabled || CITResewn.INSTANCE.activeCITs == null)
-            return;
-
-        BakedModel citModel = CITResewn.INSTANCE.activeCITs.getItemModelCached(stack, world == null ? MinecraftClient.getInstance().world : world, entity, seed);
-        if (citModel != null)
-            cir.setReturnValue(citModel);
-    }
-
-    @Inject(method = "renderItem(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/render/model/json/ModelTransformation$Mode;ZLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/client/render/model/BakedModel;)V", at = @At("HEAD"))
-    private void fixMojankCITsContext(ItemStack stack, ModelTransformation.Mode renderMode, boolean leftHanded, MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light, int overlay, BakedModel model, CallbackInfo ci) {
-        mojankCITModel = null;
-        if (((CITItem.Cached) (Object) stack).citresewn_isMojankCIT()) {
-            boolean bl = renderMode == ModelTransformation.Mode.GUI || renderMode == ModelTransformation.Mode.GROUND || renderMode == ModelTransformation.Mode.FIXED;
-            if (bl)
-                mojankCITModel = new WeakReference<>(model);
-            else { // rendered in hand model of trident/spyglass
-                if (stack.isOf(Items.TRIDENT))
-                    mojankCITModel = new WeakReference<>(this.models.getModelManager().getModel(new ModelIdentifier("minecraft:trident_in_hand#inventory")));
-                else if (stack.isOf(Items.SPYGLASS))
-                    mojankCITModel = new WeakReference<>(this.models.getModelManager().getModel(new ModelIdentifier("minecraft:spyglass_in_hand#inventory")));
-            }
-        } else
-            mojankCITModel = null;
-    }
-
-    @ModifyVariable(method = "renderItem(Lnet/minecraft/item/ItemStack;Lnet/minecraft/client/render/model/json/ModelTransformation$Mode;ZLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;IILnet/minecraft/client/render/model/BakedModel;)V", at = @At(value = "LOAD", ordinal = 0, target = "Lnet/minecraft/client/render/model/BakedModel;getTransformation()Lnet/minecraft/client/render/model/json/ModelTransformation;"), argsOnly = true)
-    private BakedModel fixMojankCITs(BakedModel original) {
-        if (mojankCITModel != null)
-            return mojankCITModel.get();
-
-        return original;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ItemStackMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ItemStackMixin.java
deleted file mode 100644
index 4c888d8..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ItemStackMixin.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.cititem;
-
-import net.minecraft.item.ItemStack;
-import org.spongepowered.asm.mixin.Mixin;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITItem;
-
-import java.lang.ref.WeakReference;
-import java.util.function.Supplier;
-
-@Mixin(ItemStack.class)
-public class ItemStackMixin implements CITItem.Cached {
-    private WeakReference<CITItem> citresewn_cachedCITItem = new WeakReference<>(null);
-    private long citresewn_cacheTimeCITItem = 0;
-
-    /**
-     * Used by tridents and spy glasses to force their unique overrides to be applied correctly
-     */
-    private boolean citresewn_mojankCIT = false;
-
-    @Override
-    public CITItem citresewn_getCachedCITItem(Supplier<CITItem> realtime) {
-        if (System.currentTimeMillis() - citresewn_cacheTimeCITItem >= CITResewnConfig.INSTANCE().cache_ms) {
-            citresewn_cachedCITItem = new WeakReference<>(realtime.get());
-            citresewn_cacheTimeCITItem = System.currentTimeMillis();
-        }
-
-        return citresewn_cachedCITItem.get();
-    }
-
-    @Override
-    public boolean citresewn_isMojankCIT() {
-        return citresewn_mojankCIT;
-    }
-
-    @Override
-    public void citresewn_setMojankCIT(boolean mojankCIT) {
-        citresewn_mojankCIT = mojankCIT;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ModelLoaderMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ModelLoaderMixin.java
deleted file mode 100644
index ec04910..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/cititem/ModelLoaderMixin.java
+++ /dev/null
@@ -1,165 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.cititem;
-
-import com.mojang.datafixers.util.Either;
-import net.minecraft.client.render.model.BakedModel;
-import net.minecraft.client.render.model.ModelLoader;
-import net.minecraft.client.render.model.SpriteAtlasManager;
-import net.minecraft.client.render.model.UnbakedModel;
-import net.minecraft.client.render.model.json.JsonUnbakedModel;
-import net.minecraft.client.render.model.json.ModelOverride;
-import net.minecraft.client.texture.TextureManager;
-import net.minecraft.client.util.ModelIdentifier;
-import net.minecraft.client.util.SpriteIdentifier;
-import net.minecraft.resource.Resource;
-import net.minecraft.resource.ResourceManager;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.profiler.Profiler;
-import org.apache.commons.io.IOUtils;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.pack.ResewnItemModelIdentifier;
-import shcm.shsupercm.fabric.citresewn.pack.ResewnTextureIdentifier;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CIT;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITItem;
-
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-import java.util.stream.Collectors;
-
-import static shcm.shsupercm.fabric.citresewn.CITResewn.info;
-
-@Mixin(ModelLoader.class)
-public class ModelLoaderMixin {
-    @Shadow @Final private ResourceManager resourceManager;
-    @Shadow @Final private Set<Identifier> modelsToLoad;
-    @Shadow @Final private Map<Identifier, UnbakedModel> modelsToBake;
-    @Shadow @Final private Map<Identifier, UnbakedModel> unbakedModels;
-    @Shadow @Final private Map<Identifier, BakedModel> bakedModels;
-
-    @Inject(method = "addModel", at = @At("TAIL"))
-    public void addCITItemModels(ModelIdentifier eventModelId, CallbackInfo ci) { if (eventModelId != ModelLoader.MISSING_ID) return;
-        if (CITResewn.INSTANCE.activeCITs == null)
-            return;
-
-        info("Loading CITItem models...");
-        CITResewn.INSTANCE.activeCITs.citItems.values().stream()
-                .flatMap(Collection::stream)
-                .distinct()
-                .forEach(citItem -> {
-                    try {
-                        citItem.loadUnbakedAssets(resourceManager);
-
-                        for (JsonUnbakedModel unbakedModel : citItem.unbakedAssets.values()) {
-                            ResewnItemModelIdentifier id = new ResewnItemModelIdentifier(unbakedModel.id);
-                            this.unbakedModels.put(id, unbakedModel);
-                            this.modelsToLoad.addAll(unbakedModel.getModelDependencies());
-                            this.modelsToBake.put(id, unbakedModel);
-                        }
-                    } catch (Exception e) {
-                        CITResewn.logErrorLoading(e.getMessage());
-                    }
-                });
-
-        CITItem.GENERATED_SUB_CITS_SEEN.clear();
-    }
-
-    @Inject(method = "upload", at = @At("RETURN"))
-    public void linkBakedCITItemModels(TextureManager textureManager, Profiler profiler, CallbackInfoReturnable<SpriteAtlasManager> cir) {
-        if (CITResewn.INSTANCE.activeCITs == null)
-            return;
-
-        profiler.push("citresewn_linking");
-        info("Linking baked models to CITItems...");
-
-        if (CITResewn.INSTANCE.activeCITs != null) {
-            for (CITItem citItem : CITResewn.INSTANCE.activeCITs.citItems.values().stream().flatMap(Collection::stream).distinct().collect(Collectors.toList())) {
-                for (Map.Entry<List<ModelOverride.Condition>, JsonUnbakedModel> citModelEntry : citItem.unbakedAssets.entrySet()) {
-                    if (citModelEntry.getKey() == null) {
-                        citItem.bakedModel = this.bakedModels.get(new ResewnItemModelIdentifier(citModelEntry.getValue().id));
-                    } else {
-                        BakedModel bakedModel = bakedModels.get(new ResewnItemModelIdentifier(citModelEntry.getValue().id));
-
-                        if (bakedModel == null)
-                            CITResewn.logWarnLoading("Skipping sub cit: Failed loading model for \"" + citModelEntry.getValue().id + "\" in " + citItem.pack.resourcePack.getName() + " -> " + citItem.propertiesIdentifier.getPath());
-                        else
-                            citItem.bakedSubModels.override(citModelEntry.getKey(), bakedModel);
-                    }
-                }
-                citItem.unbakedAssets = null;
-            }
-        }
-
-        profiler.pop();
-    }
-
-
-    @Inject(method = "loadModelFromJson", cancellable = true, at = @At("HEAD"))
-    public void forceLiteralResewnModelIdentifier(Identifier id, CallbackInfoReturnable<JsonUnbakedModel> cir) {
-        if (id instanceof ResewnItemModelIdentifier) {
-            InputStream is = null;
-            Resource resource = null;
-            try {
-                JsonUnbakedModel json = JsonUnbakedModel.deserialize(IOUtils.toString(is = (resource = resourceManager.getResource(id)).getInputStream(), StandardCharsets.UTF_8));
-                json.id = id.toString();
-                json.id = json.id.substring(0, json.id.length() - 5);
-
-                ((JsonUnbakedModelAccessor) json).getTextureMap().replaceAll((layer, original) -> {
-                    Optional<SpriteIdentifier> left = original.left();
-                    if (left.isPresent()) {
-                        String originalPath = left.get().getTextureId().getPath();
-                        String[] split = originalPath.split("/");
-                        if (originalPath.startsWith("./") || (split.length > 2 && split[1].equals("cit"))) {
-                            Identifier resolvedIdentifier = CIT.resolvePath(id, originalPath, ".png", identifier -> resourceManager.containsResource(identifier));
-                            if (resolvedIdentifier != null)
-                                return Either.left(new SpriteIdentifier(left.get().getAtlasId(), new ResewnTextureIdentifier(resolvedIdentifier)));
-                        }
-                    }
-                    return original;
-                });
-
-                Identifier parentId = ((JsonUnbakedModelAccessor) json).getParentId();
-                if (parentId != null) {
-                    String[] parentIdPathSplit = parentId.getPath().split("/");
-                    if (parentId.getPath().startsWith("./") || (parentIdPathSplit.length > 2 && parentIdPathSplit[1].equals("cit"))) {
-                        parentId = CIT.resolvePath(id, parentId.getPath(), ".json", identifier -> resourceManager.containsResource(identifier));
-                        if (parentId != null)
-                            ((JsonUnbakedModelAccessor) json).setParentId(new ResewnItemModelIdentifier(parentId));
-                    }
-                }
-
-                json.getOverrides().replaceAll(override -> {
-                    String[] modelIdPathSplit = override.getModelId().getPath().split("/");
-                    if (override.getModelId().getPath().startsWith("./") || (modelIdPathSplit.length > 2 && modelIdPathSplit[1].equals("cit"))) {
-                        Identifier resolvedOverridePath = CIT.resolvePath(id, override.getModelId().getPath(), ".json", identifier -> resourceManager.containsResource(identifier));
-                        if (resolvedOverridePath != null)
-                            return new ModelOverride(new ResewnItemModelIdentifier(resolvedOverridePath), override.streamConditions().collect(Collectors.toList()));
-                    }
-
-                    return override;
-                });
-
-                cir.setReturnValue(json);
-            } catch (Exception ignored) {
-            } finally {
-                IOUtils.closeQuietly(is, resource);
-            }
-        }
-    }
-
-    @ModifyArg(method = "loadModelFromJson", at =
-    @At(value = "INVOKE", target = "Lnet/minecraft/resource/ResourceManager;getResource(Lnet/minecraft/util/Identifier;)Lnet/minecraft/resource/Resource;"))
-    public Identifier fixDuplicatePrefixSuffix(Identifier original) {
-        if (original.getPath().startsWith("models/models/") && original.getPath().endsWith(".json.json") && original.getPath().contains("cit"))
-            return new Identifier(original.getNamespace(), original.getPath().substring(7, original.getPath().length() - 5));
-
-        return original;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/compat/lambdabettergrass/PackParserMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/compat/lambdabettergrass/PackParserMixin.java
new file mode 100644
index 0000000..69e432c
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/compat/lambdabettergrass/PackParserMixin.java
@@ -0,0 +1,26 @@
+package shcm.shsupercm.fabric.citresewn.mixin.compat.lambdabettergrass;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.ModifyVariable;
+import shcm.shsupercm.fabric.citresewn.pack.PackParser;
+
+import java.io.IOException;
+
+@SuppressWarnings("UnresolvedMixinReference")
+@Mixin(value = PackParser.class, remap = false)
+public class PackParserMixin {
+    @ModifyVariable(method = "loadGlobalProperties(Lnet/minecraft/resource/ResourceManager;Lshcm/shsupercm/fabric/citresewn/pack/GlobalProperties;)Lshcm/shsupercm/fabric/citresewn/pack/GlobalProperties;", at =
+    @At(value = "INVOKE", target = "shcm/shsupercm/fabric/citresewn/CITResewn.logErrorLoading(Ljava/lang/String;)V"))
+    private static IOException citresewn$compat$lambdabettergrass$muteStacktrace(IOException exception) {
+        if (exception.getMessage().contains("lambdabettergrass"))
+            return new IOException() {
+                @Override
+                public void printStackTrace() {
+                    //no
+                }
+            };
+
+        return exception;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ChatScreenMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ChatScreenMixin.java
deleted file mode 100644
index cdd9eb1..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ChatScreenMixin.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.core;
-
-import net.minecraft.client.gui.screen.ChatScreen;
-import net.minecraft.client.gui.screen.Screen;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
-import shcm.shsupercm.fabric.citresewn.OptionalCompat;
-
-import static shcm.shsupercm.fabric.citresewn.CITResewnCommand.openConfig;
-
-@Mixin(ChatScreen.class)
-public class ChatScreenMixin {
-    @ModifyArg(method = "keyPressed", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/MinecraftClient;setScreen(Lnet/minecraft/client/gui/screen/Screen;)V"))
-    public Screen redirectConfigScreen(Screen original) {
-        if (original == null && openConfig) {
-            openConfig = false;
-            return OptionalCompat.getModConfigScreenFactory().apply(null);
-        }
-
-        return original;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/GroupResourcePackAccessor.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/GroupResourcePackAccessor.java
deleted file mode 100644
index 7ab1c16..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/GroupResourcePackAccessor.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.core;
-
-import net.fabricmc.fabric.api.resource.ModResourcePack;
-import net.fabricmc.fabric.impl.resource.loader.GroupResourcePack;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-import java.util.List;
-
-/* if (FabricLoader.getInstance().isModLoaded("fabric-resource-loader-v0")) */ @Mixin(GroupResourcePack.class)
-public interface GroupResourcePackAccessor {
-    @Accessor
-    List<ModResourcePack> getPacks();
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ModelLoaderMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ModelLoaderMixin.java
deleted file mode 100644
index d65ffb8..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ModelLoaderMixin.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.core;
-
-import net.minecraft.client.render.model.ModelLoader;
-import net.minecraft.client.util.ModelIdentifier;
-import net.minecraft.resource.ResourceManager;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import shcm.shsupercm.fabric.citresewn.ActiveCITs;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.pack.CITPack;
-import shcm.shsupercm.fabric.citresewn.pack.CITParser;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CIT;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static shcm.shsupercm.fabric.citresewn.CITResewn.info;
-
-@Mixin(value = ModelLoader.class, priority = 999)
-public abstract class ModelLoaderMixin {
-    @Shadow @Final private ResourceManager resourceManager;
-
-    @Inject(method = "addModel", at = @At("TAIL"))
-    public void initCITs(ModelIdentifier eventModelId, CallbackInfo ci) { if (eventModelId != ModelLoader.MISSING_ID) return;
-        if (CITResewn.INSTANCE.activeCITs != null) {
-            info("Clearing active CITs..");
-            CITResewn.INSTANCE.activeCITs.dispose();
-            CITResewn.INSTANCE.activeCITs = null;
-        }
-
-        if (!CITResewnConfig.INSTANCE().enabled)
-            return;
-
-        info("Parsing CITs...");
-        List<CITPack> parsedPacks = CITParser.parseCITs(resourceManager.streamResourcePacks().collect(Collectors.toCollection(ArrayList::new)));
-        List<CIT> parsed = parsedPacks.stream().flatMap(pack -> pack.cits.stream()).collect(Collectors.toCollection(ArrayList::new));
-
-        if (parsed.size() > 0) {
-            info("Activating CITs...");
-            CITResewn.INSTANCE.activeCITs = new ActiveCITs(parsedPacks, parsed);
-        } else
-            info("No cit packs found.");
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/NbtCompoundAccessor.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/NbtCompoundAccessor.java
deleted file mode 100644
index 8ced305..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/NbtCompoundAccessor.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.core;
-
-import net.minecraft.nbt.NbtCompound;
-import net.minecraft.nbt.NbtElement;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-import java.util.Map;
-
-@Mixin(NbtCompound.class)
-public interface NbtCompoundAccessor {
-    @Accessor
-    Map<String, NbtElement> getEntries();
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ZipResourcePackMixin.java b/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ZipResourcePackMixin.java
deleted file mode 100644
index 7acbcb7..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/mixin/core/ZipResourcePackMixin.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.mixin.core;
-
-import com.google.common.collect.Lists;
-import net.minecraft.resource.ResourceType;
-import net.minecraft.resource.ZipResourcePack;
-import net.minecraft.util.Identifier;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.io.IOException;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.function.Predicate;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
-
-@Mixin(ZipResourcePack.class)
-public abstract class ZipResourcePackMixin {
-    @Shadow protected abstract ZipFile getZipFile() throws IOException;
-
-    @Inject(method = "findResources", cancellable = true, at = @At("HEAD"))
-    public void fixDepthBug(ResourceType type, String namespace, String prefix, int maxDepth, Predicate<String> pathFilter, CallbackInfoReturnable<Collection<Identifier>> cir) {
-        if (maxDepth != Integer.MAX_VALUE - 53)
-            return;
-
-        ZipFile zipFile2;
-        try {
-            zipFile2 = this.getZipFile();
-        } catch (IOException var15) {
-            cir.setReturnValue(Collections.emptySet()); return;
-        }
-
-        Enumeration<? extends ZipEntry> enumeration = zipFile2.entries();
-        List<Identifier> list = Lists.newArrayList();
-        String var10000 = type.getDirectory();
-        String string = var10000 + "/" + namespace + "/";
-        String string2 = string + prefix + "/";
-
-        while(enumeration.hasMoreElements()) {
-            ZipEntry zipEntry = enumeration.nextElement();
-            if (!zipEntry.isDirectory()) {
-                String string3 = zipEntry.getName();
-                if (!string3.endsWith(".mcmeta") && string3.startsWith(string2)) {
-                    String string4 = string3.substring(string.length());
-                    String[] strings = string4.split("/");
-                    if (pathFilter.test(strings[strings.length - 1])) {
-                        list.add(new Identifier(namespace, string4));
-                    }
-                }
-            }
-        }
-
-        cir.setReturnValue(list); return;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/CITPack.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/CITPack.java
deleted file mode 100644
index aadf518..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/CITPack.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.pack;
-
-import net.minecraft.resource.ResourcePack;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CIT;
-import shcm.shsupercm.fabric.citresewn.pack.cits.CITEnchantment;
-
-import java.util.*;
-
-public class CITPack {
-    public final ResourcePack resourcePack;
-    public final Collection<CIT> cits = new ArrayList<>();
-
-    public CITEnchantment.MergeMethod method = CITEnchantment.MergeMethod.AVERAGE;
-    public Integer cap = 8;
-    public Float fade = 0.5f;
-    public Boolean useGlint = true;
-
-    public CITPack(ResourcePack resourcePack) {
-        this.resourcePack = resourcePack;
-    }
-
-    public void loadGlobalProperties(Properties properties) throws Exception {
-        try {
-            this.method = properties.containsKey("method") ? CITEnchantment.MergeMethod.valueOf(properties.getProperty("method").toUpperCase(Locale.ENGLISH)) : null;
-
-            if (properties.containsKey("cap")) {
-                this.cap = Integer.parseInt(properties.getProperty("cap"));
-                if (this.cap < 0)
-                    throw new Exception("cap cannot be negative");
-            } else
-                this.cap = null;
-
-            if (properties.containsKey("fade")) {
-                this.fade = Float.parseFloat(properties.getProperty("fade"));
-                if (this.fade < 0f)
-                    throw new Exception("fade cannot be negative");
-            } else
-                this.fade = null;
-
-            this.useGlint = properties.containsKey("useGlint") ? switch (properties.getProperty("useGlint").toLowerCase(Locale.ENGLISH)) {
-                case "true" -> true;
-                case "false" -> false;
-                default -> throw new Exception("useGlint is not a boolean");
-            } : null;
-        } catch (Exception e) {
-            this.method = null;
-            this.cap = null;
-            this.fade = null;
-            this.useGlint = null;
-            throw e;
-        }
-    }
-
-    public void loadGlobalProperties(CITPack properties) {
-        if (properties.method != null)
-            this.method = properties.method;
-        if (properties.cap != null)
-            this.cap = properties.cap;
-        if (properties.fade != null)
-            this.fade = properties.fade;
-        if (properties.useGlint != null)
-            this.useGlint = properties.useGlint;
-    }
-
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/CITParser.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/CITParser.java
deleted file mode 100644
index 974d2ec..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/CITParser.java
+++ /dev/null
@@ -1,119 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.pack;
-
-import net.fabricmc.fabric.impl.resource.loader.GroupResourcePack;
-import net.minecraft.resource.ResourcePack;
-import net.minecraft.resource.ResourceType;
-import net.minecraft.util.Identifier;
-import org.apache.commons.lang3.StringUtils;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.ex.CITParseException;
-import shcm.shsupercm.fabric.citresewn.mixin.core.GroupResourcePackAccessor;
-import shcm.shsupercm.fabric.citresewn.pack.cits.*;
-
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-/**
- * Parses cits from resourcepacks
- */
-public final class CITParser { private CITParser() {}
-    /**
-     * CIT type registry.
-     */
-    public static final Map<String, CITConstructor> REGISTRY = new HashMap<>();
-    static {
-        REGISTRY.put("item", CITItem::new);
-        REGISTRY.put("armor", CITArmor::new);
-        REGISTRY.put("elytra", CITElytra::new);
-        REGISTRY.put("enchantment", CITEnchantment::new);
-    }
-
-    /**
-     * Parses cit entries from an ordered collection of resourcepacks.
-     * @param packs packs to parse
-     * @return a collection of parsed CITs
-     */
-    public static List<CITPack> parseCITs(Collection<ResourcePack> packs) {
-        return packs.stream()
-                .map(CITParser::parse)
-                .flatMap(Collection::stream)
-                .collect(Collectors.toList());
-    }
-
-    /**
-     * Parses a resourcepack into a possible collection of citpacks that are contained within.
-     * @param resourcePack pack to parse
-     * @return a collection of CITPacks or an empty collection if resourcepack contains none
-     */
-    public static Collection<CITPack> parse(ResourcePack resourcePack) {
-        if (resourcePack instanceof GroupResourcePack)
-            return ((GroupResourcePackAccessor) resourcePack).getPacks().stream()
-                    .map(CITParser::parse)
-                    .flatMap(Collection::stream)
-                    .collect(Collectors.toList());
-
-        final CITPack citPack = new CITPack(resourcePack);
-
-        Collection<Identifier> packProperties = new ArrayList<>();
-        for (String namespace : resourcePack.getNamespaces(ResourceType.CLIENT_RESOURCES))
-            if (Identifier.isValid(namespace))
-                for (String citRoot : new String[] { "citresewn", "optifine", "mcpatcher" }) {
-                    packProperties.addAll(resourcePack.findResources(ResourceType.CLIENT_RESOURCES, namespace, citRoot + "/cit", Integer.MAX_VALUE - 53, s -> s.endsWith(".properties")));
-                    Identifier global = new Identifier(namespace, citRoot + "/cit.properties");
-                    if (resourcePack.contains(ResourceType.CLIENT_RESOURCES, global))
-                        packProperties.add(global);
-                }
-
-        boolean readGlobalProperties = false;
-        for (Iterator<Identifier> iterator = packProperties.iterator(); iterator.hasNext(); ) {
-            Identifier propertiesIdentifier = iterator.next();
-            try {
-                if (StringUtils.countMatches(propertiesIdentifier.getPath(), '/') <= 2 && propertiesIdentifier.getPath().endsWith("cit.properties")) {
-                    iterator.remove();
-                    if (!readGlobalProperties)
-                        try (InputStream is = resourcePack.open(ResourceType.CLIENT_RESOURCES, propertiesIdentifier)) {
-                            Properties citProperties = new Properties();
-                            citProperties.load(is);
-                            citPack.loadGlobalProperties(citProperties);
-                            readGlobalProperties = true;
-                        }
-                }
-            } catch (Exception e) {
-                CITResewn.logErrorLoading("Skipped global properties: " + e.getMessage() + " in " + resourcePack.getName() + " -> " + propertiesIdentifier);
-            }
-        }
-
-        packProperties.stream()
-                .flatMap(citIdentifier -> {
-                    try (InputStream is = resourcePack.open(ResourceType.CLIENT_RESOURCES, citIdentifier)) {
-                        Properties citProperties = new Properties();
-                        citProperties.load(new InputStreamReader(is, StandardCharsets.UTF_8));
-
-                        CITConstructor type = REGISTRY.get(citProperties.getProperty("type", "item"));
-                        if (type == null)
-                            throw new CITParseException(citPack.resourcePack, citIdentifier, "Unknown cit type \"" + citProperties.getProperty("type") + "\"");
-
-                        return Stream.of(type.cit(citPack, citIdentifier, citProperties));
-                    } catch (Exception e) {
-                        CITResewn.logErrorLoading(e.getMessage());
-                        return Stream.empty();
-                    }
-                })
-                .collect(Collectors.toCollection(() -> citPack.cits));
-
-        if (citPack.cits.isEmpty())
-            return Collections.emptySet();
-        else {
-            CITResewn.info("Found " + citPack.cits.size() + " CIT" + (citPack.cits.size() == 1 ? "" : "s") + " in " + resourcePack.getName());
-            return Collections.singleton(citPack);
-        }
-    }
-
-    public interface CITConstructor {
-        CIT cit(CITPack pack, Identifier identifier, Properties properties) throws CITParseException;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/GlobalProperties.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/GlobalProperties.java
new file mode 100644
index 0000000..3e93b07
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/GlobalProperties.java
@@ -0,0 +1,72 @@
+package shcm.shsupercm.fabric.citresewn.pack;
+
+import net.fabricmc.loader.api.FabricLoader;
+import net.fabricmc.loader.api.entrypoint.EntrypointContainer;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.InvalidIdentifierException;
+import shcm.shsupercm.fabric.citresewn.CITResewn;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+import shcm.shsupercm.fabric.citresewn.api.CITGlobalProperties;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Property group representation of the global cit.properties file.
+ * @see CITGlobalProperties
+ * @see PackParser#loadGlobalProperties(ResourceManager, GlobalProperties)
+ */
+public class GlobalProperties extends PropertyGroup {
+    public GlobalProperties() {
+        super("global_properties", new Identifier("citresewn", "global_properties"));
+    }
+
+    @Override
+    public String getExtension() {
+        return ".properties";
+    }
+
+    @Override
+    public PropertyGroup load(String packName, Identifier identifier, InputStream is) throws IOException, InvalidIdentifierException {
+        PropertyGroup group = PropertyGroup.tryParseGroup(packName, identifier, is);
+        if (group != null)
+            for (Map.Entry<PropertyKey, Set<PropertyValue>> entry : group.properties.entrySet())
+                this.properties.computeIfAbsent(entry.getKey(), key -> new LinkedHashSet<>()).addAll(entry.getValue());
+
+        return this;
+    }
+
+    /**
+     * Calls all {@link CITGlobalProperties} handler entrypoints for every global property they're associated with.<br>
+     * Global properties are matched to their entrypoints by mod id and it's the handler responsibility to filter the properties.
+     *
+     * @see CITGlobalProperties
+     */
+    public void callHandlers() {
+        for (EntrypointContainer<CITGlobalProperties> container : FabricLoader.getInstance().getEntrypointContainers(CITGlobalProperties.ENTRYPOINT, CITGlobalProperties.class)) {
+            String containerNamespace = container.getProvider().getMetadata().getId();
+            if (containerNamespace.equals("citresewn-defaults"))
+                containerNamespace = "citresewn";
+
+            for (Map.Entry<PropertyKey, Set<PropertyValue>> entry : properties.entrySet())
+                if (entry.getKey().namespace().equals(containerNamespace)) {
+                    PropertyValue lastValue = null;
+                    for (PropertyValue value : entry.getValue())
+                        lastValue = value;
+
+                    try {
+                        container.getEntrypoint().globalProperty(entry.getKey().path(), lastValue);
+                    } catch (Exception e) {
+                        CITResewn.logErrorLoading(lastValue == null ? "Errored while disposing global properties" : "Errored while parsing global properties: Line " + lastValue.position() + " of " + lastValue.propertiesIdentifier() + " in " + lastValue.packName());
+                        e.printStackTrace();
+                    }
+                }
+        }
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/PackParser.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/PackParser.java
new file mode 100644
index 0000000..9f57760
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/PackParser.java
@@ -0,0 +1,128 @@
+package shcm.shsupercm.fabric.citresewn.pack;
+
+import net.minecraft.resource.Resource;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.resource.ResourcePack;
+import net.minecraft.resource.ResourceType;
+import net.minecraft.util.Identifier;
+import shcm.shsupercm.fabric.citresewn.CITResewn;
+import shcm.shsupercm.fabric.citresewn.cit.builtin.conditions.WeightCondition;
+import shcm.shsupercm.fabric.citresewn.ex.CITParsingException;
+import shcm.shsupercm.fabric.citresewn.cit.CIT;
+import shcm.shsupercm.fabric.citresewn.cit.CITCondition;
+import shcm.shsupercm.fabric.citresewn.cit.CITRegistry;
+import shcm.shsupercm.fabric.citresewn.cit.CITType;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyGroup;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyKey;
+import shcm.shsupercm.fabric.citresewn.pack.format.PropertyValue;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * Utility parsing methods for packs.
+ */
+public final class PackParser { private PackParser() {}
+    /**
+     * Possible CIT roots in resourcepacks ordered in increasing order of priority.
+     */
+    private static final String[] ROOTS = new String[] { "mcpatcher", "optifine", "citresewn" };
+
+    /**
+     * Loads a merged global property group from loaded packs making sure to respect order.
+     *
+     * @see GlobalProperties#callHandlers()
+     * @param resourceManager the manager that contains the packs
+     * @param globalProperties global property group to parse into
+     * @return globalProperties
+     */
+    public static GlobalProperties loadGlobalProperties(ResourceManager resourceManager, GlobalProperties globalProperties) {
+        for (ResourcePack pack : resourceManager.streamResourcePacks().collect(Collectors.toList()))
+            for (String namespace : pack.getNamespaces(ResourceType.CLIENT_RESOURCES))
+                for (String root : ROOTS) {
+                    Identifier identifier = new Identifier(namespace, root + "/cit.properties");
+                    try {
+                        globalProperties.load(pack.getName(), identifier, pack.open(ResourceType.CLIENT_RESOURCES, identifier));
+                    } catch (FileNotFoundException ignored) {
+                    } catch (IOException e) {
+                        CITResewn.logErrorLoading("Errored while loading global properties: " + identifier + " from " + pack.getName());
+                        e.printStackTrace();
+                    }
+                }
+        return globalProperties;
+    }
+
+    /**
+     * Attempts parsing all CITs out of all loaded packs.
+     * @param resourceManager the manager that contains the packs
+     * @return unordered list of successfully parsed CITs
+     */
+    public static List<CIT<?>> parseCITs(ResourceManager resourceManager) {
+        List<CIT<?>> cits = new ArrayList<>();
+
+        for (String root : ROOTS)
+            for (Identifier identifier : resourceManager.findResources(root + "/cit", s -> s.endsWith(".properties"))) {
+                String packName = null;
+                try (Resource resource = resourceManager.getResource(identifier)) {
+                    cits.add(parseCIT(PropertyGroup.tryParseGroup(packName = resource.getResourcePackName(), identifier, resource.getInputStream()), resourceManager));
+                } catch (CITParsingException e) {
+                    CITResewn.logErrorLoading(e.getMessage());
+                } catch (Exception e) {
+                    CITResewn.logErrorLoading("Errored while loading cit: " + identifier + (packName == null ? "" : " from " + packName));
+                    e.printStackTrace();
+                }
+            }
+
+        return cits;
+    }
+
+    /**
+     * Attempts parsing a CIT from a property group.
+     * @param properties property group representation of the CIT
+     * @param resourceManager the manager that contains the the property group, used to resolve relative assets
+     * @return the successfully parsed CIT
+     * @throws CITParsingException if the CIT failed parsing for any reason
+     */
+    public static CIT<?> parseCIT(PropertyGroup properties, ResourceManager resourceManager) throws CITParsingException {
+        CITType citType = CITRegistry.parseType(properties);
+
+        List<CITCondition> conditions = new ArrayList<>();
+
+        Set<PropertyKey> ignoredProperties = citType.typeProperties();
+
+        for (Map.Entry<PropertyKey, Set<PropertyValue>> entry : properties.properties.entrySet()) {
+            if (entry.getKey().path().equals("type") && entry.getKey().namespace().equals("citresewn"))
+                continue;
+            if (ignoredProperties.contains(entry.getKey()))
+                continue;
+
+            for (PropertyValue value : entry.getValue())
+                conditions.add(CITRegistry.parseCondition(entry.getKey(), value, properties));
+        }
+
+        for (CITCondition condition : new ArrayList<>(conditions))
+            if (condition != null)
+                for (Class<? extends CITCondition> siblingConditionType : condition.siblingConditions())
+                    conditions.replaceAll(
+                            siblingCondition -> siblingCondition != null && siblingConditionType == siblingCondition.getClass() ?
+                                    condition.modifySibling(siblingCondition) :
+                                    siblingCondition);
+
+        WeightCondition weight = new WeightCondition();
+
+        conditions.removeIf(condition -> {
+            if (condition instanceof WeightCondition weightCondition) {
+                weight.setWeight(weightCondition.getWeight());
+                return true;
+            }
+
+            return condition == null;
+        });
+
+        citType.load(conditions, properties, resourceManager);
+
+        return new CIT<>(properties.identifier, properties.packName, citType, conditions.toArray(new CITCondition[0]), weight.getWeight());
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CIT.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CIT.java
deleted file mode 100644
index a58c946..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CIT.java
+++ /dev/null
@@ -1,435 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.pack.cits;
-
-import net.minecraft.enchantment.EnchantmentHelper;
-import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.EnchantedBookItem;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.nbt.*;
-import net.minecraft.text.Text;
-import net.minecraft.util.Hand;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.Pair;
-import net.minecraft.util.registry.Registry;
-import net.minecraft.world.World;
-import shcm.shsupercm.fabric.citresewn.CITResewn;
-import shcm.shsupercm.fabric.citresewn.ex.CITParseException;
-import shcm.shsupercm.fabric.citresewn.mixin.core.NbtCompoundAccessor;
-import shcm.shsupercm.fabric.citresewn.pack.CITPack;
-
-import java.util.*;
-import java.util.function.Predicate;
-import java.util.regex.Pattern;
-
-public abstract class CIT {
-    public final CITPack pack;
-    public final Identifier propertiesIdentifier;
-
-    public final Set<Item> items = new HashSet<>();
-
-    public final int damageMin, damageMax;
-    public final boolean damageAny, damageRange, damagePercentage;
-    public final Integer damageMask;
-
-    public final int stackMin, stackMax;
-    public final boolean stackAny, stackRange;
-
-    public final Set<Identifier> enchantments = new HashSet<>();
-    public final List<Pair<Integer, Integer>> enchantmentLevels = new ArrayList<>();
-    public final boolean enchantmentsAny, enchantmentLevelsAny;
-
-    public final Hand hand;
-
-    public final Predicate<NbtCompound> nbt;
-
-    public final int weight;
-
-    public CIT(CITPack pack, Identifier identifier, Properties properties) throws CITParseException {
-        this.pack = pack;
-        this.propertiesIdentifier = identifier;
-        try {
-            for (String itemId : (properties.getProperty("items", properties.getProperty("matchItems", " "))).split(" "))
-                if (!itemId.isEmpty()) {
-                    Identifier itemIdentifier = new Identifier(itemId);
-                    if (!Registry.ITEM.containsId(itemIdentifier))
-                        throw new Exception("Unknown item " + itemId);
-                    this.items.add(Registry.ITEM.get(itemIdentifier));
-                }
-            if (this.items.isEmpty())
-                try {
-                    String id = propertiesIdentifier.getPath().substring(0, propertiesIdentifier.getPath().length() - 11);
-                    String[] split = id.split("/");
-                    id = split[split.length - 1];
-                    Identifier itemId = new Identifier(propertiesIdentifier.getNamespace(), id);
-                    if (Registry.ITEM.containsId(itemId))
-                        this.items.add(Registry.ITEM.get(itemId));
-                } catch (Exception ignored) { }
-
-            String damage = properties.getProperty("damage");
-            if (damageAny = damage == null) {
-                this.damageRange = false;
-                this.damagePercentage = false;
-                this.damageMin = 0;
-                this.damageMax = 0;
-            } else {
-                if (this.damagePercentage = damage.contains("%"))
-                    damage = damage.replace("%", "");
-
-                if (damage.contains("-")) {
-                    String[] split = damage.split("-");
-                    if (split.length > 2)
-                        throw new Exception("damage range must have up to 2 numbers");
-
-                    this.damageMin = split[0].isEmpty() ? Integer.MIN_VALUE : Integer.parseInt(split[0]);
-                    this.damageMax = split.length == 1 ? Integer.MAX_VALUE : Integer.parseInt(split[1]);
-
-                    if (this.damageMin > this.damageMax)
-                        throw new Exception("damage range min is higher than max");
-
-                    this.damageRange = this.damageMin < this.damageMax;
-                } else {
-                    this.damageRange = false;
-                    this.damageMin = this.damageMax = Integer.parseInt(damage);
-                }
-            }
-
-            this.damageMask = properties.containsKey("damageMask") ? Integer.parseInt(properties.getProperty("damageMask")) : null;
-
-            String stackSize = properties.getProperty("stackSize");
-            if (stackAny = stackSize == null) {
-                this.stackRange = false;
-                this.stackMin = 0;
-                this.stackMax = 0;
-            } else {
-                if (stackSize.contains("-")) {
-                    String[] split = stackSize.split("-");
-                    if (split.length > 2)
-                        throw new Exception("stackSize range must have up to 2 numbers");
-
-                    this.stackMin = split[0].isEmpty() ? Integer.MIN_VALUE : Integer.parseInt(split[0]);
-                    this.stackMax = split.length == 1 ? Integer.MAX_VALUE : Integer.parseInt(split[1]);
-
-                    if (this.stackMin > this.stackMax)
-                        throw new Exception("stackSize range min is higher than max");
-
-                    this.stackRange = this.stackMin < this.stackMax;
-                } else {
-                    this.stackRange = false;
-                    this.stackMin = this.stackMax = Integer.parseInt(stackSize);
-                }
-            }
-
-            String enchantmentIDs = properties.getProperty("enchantments", properties.getProperty("enchantmentIDs"));
-            if (!(this.enchantmentsAny = enchantmentIDs == null)) {
-                for (String ench : enchantmentIDs.split(" ")) {
-                    Identifier enchIdentifier = new Identifier(ench);
-                    if (!Registry.ENCHANTMENT.containsId(enchIdentifier))
-                        CITResewn.logWarnLoading("CIT Warning: Unknown enchantment " + enchIdentifier);
-                    this.enchantments.add(enchIdentifier);
-                }
-            }
-
-            String enchantmentLevelsProp = properties.getProperty("enchantmentLevels");
-            if (!(this.enchantmentLevelsAny = enchantmentLevelsProp == null)) {
-                for (String range : enchantmentLevelsProp.split(" ")) {
-                    if (range.contains("-")) {
-                        if (range.startsWith("-")) {
-                            range = range.substring(1);
-                            if (range.contains("-"))
-                                throw new Exception("enchantmentLevels ranges must have up to 2 numbers each");
-                            this.enchantmentLevels.add(new Pair<>(0, Integer.parseInt(range)));
-                        } else if (range.endsWith("-")) {
-                            range = range.substring(0, range.length() - 1);
-                            if (range.contains("-"))
-                                throw new Exception("enchantmentLevels ranges must have up to 2 numbers each");
-                            this.enchantmentLevels.add(new Pair<>(Integer.parseInt(range), Integer.MAX_VALUE));
-                        } else {
-                            String[] split = range.split("-");
-                            if (split.length != 2)
-                                throw new Exception("enchantmentLevels ranges must have up to 2 numbers each");
-                            Pair<Integer, Integer> minMaxPair = new Pair<>(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
-                            if (minMaxPair.getLeft() > minMaxPair.getRight())
-                                throw new Exception("enchantmentLevels range min is higher than max");
-                            this.enchantmentLevels.add(minMaxPair);
-                        }
-                    } else {
-                        int level = Integer.parseInt(range);
-                        this.enchantmentLevels.add(new Pair<>(level, level));
-                    }
-                }
-            }
-
-            this.hand = switch (properties.getProperty("hand", "any")) {
-                case "main" -> Hand.MAIN_HAND;
-                case "off" -> Hand.OFF_HAND;
-                default -> null;
-            };
-
-            List<Predicate<NbtCompound>> nbtPredicates = new ArrayList<>();
-            for (Object o : properties.keySet())
-                if (o instanceof String property && property.startsWith("nbt.")) {
-                    String matchProperty = properties.getProperty(property);
-                    final String[] path = property.substring(4).split("\\.");
-                    final Predicate<String> match;
-                    final boolean caseSensitive = !matchProperty.startsWith("i");
-
-                    if (matchProperty.startsWith(caseSensitive ? "pattern:" : "ipattern:")) {
-                        matchProperty = caseSensitive ? matchProperty.substring(8) : matchProperty.substring(9).toLowerCase(Locale.ENGLISH);
-                        final String pattern = matchProperty;
-                        match = s -> matchesPattern(caseSensitive ? s : s.toLowerCase(), pattern, 0, s.length(), 0, pattern.length());
-                    } else if (matchProperty.startsWith(caseSensitive ? "regex:" : "iregex:")) {
-                        matchProperty = caseSensitive ? matchProperty.substring(6) : matchProperty.substring(7).toLowerCase(Locale.ENGLISH);
-                        final Pattern pattern = Pattern.compile(matchProperty);
-                        match = s -> pattern.matcher(caseSensitive ? s : s.toLowerCase()).matches();
-                    } else {
-                        if (property.equals("nbt.display.color") && matchProperty.startsWith("#"))
-                            try {
-                                matchProperty = String.valueOf(Integer.parseInt(matchProperty.substring(1).toLowerCase(Locale.ENGLISH), 16));
-                            } catch (Exception ignored) { }
-
-                        final String pattern = matchProperty;
-                        match = s -> s.equals(pattern);
-                    }
-
-                    final boolean checkJson = (path[path.length - 1].equals("Name") || (path.length >= 2 && path[path.length - 2].equals("Lore"))) && !((matchProperty.startsWith("{") || matchProperty.startsWith("\\{")) && matchProperty.endsWith("}"));
-
-                    nbtPredicates.add(new Predicate<NbtCompound>() {
-                        public boolean test(NbtElement nbtElement, int index) {
-                            if (index >= path.length) {
-                                if (nbtElement instanceof NbtString nbtString) {
-                                    String text = nbtString.asString();
-                                    if (checkJson)
-                                        try {
-                                            //noinspection ConstantConditions
-                                            text = Text.Serializer.fromJson(text).getString();
-                                        } catch (Exception ignored) { }
-
-                                    return match.test(text);
-                                } else if (nbtElement instanceof AbstractNbtNumber nbtNumber)
-                                    return match.test(String.valueOf(nbtNumber.numberValue()));
-                            } else {
-                                String name = path[index];
-                                if (name.equals("*")) {
-                                    if (nbtElement instanceof NbtCompound nbtCompound) {
-                                        for (NbtElement subElement : ((NbtCompoundAccessor) nbtCompound).getEntries().values())
-                                            if (test(subElement, index + 1))
-                                                return true;
-                                    } else if (nbtElement instanceof NbtList nbtList) {
-                                        for (NbtElement subElement : nbtList)
-                                            if (test(subElement, index + 1))
-                                                return true;
-                                    }
-                                } else {
-                                    if (nbtElement instanceof NbtCompound nbtCompound) {
-                                        NbtElement subElement = nbtCompound.get(name);
-                                        return subElement != null && test(subElement, index + 1);
-                                    } else if (nbtElement instanceof NbtList nbtList) {
-                                        try {
-                                            NbtElement subElement = nbtList.get(Integer.parseInt(name));
-                                            return subElement != null && test(subElement, index + 1);
-                                        } catch (Exception ignored) {
-                                            return false;
-                                        }
-                                    }
-                                }
-                            }
-                            return false;
-                        }
-
-                        @Override
-                        public boolean test(NbtCompound nbtCompound) {
-                            return test(nbtCompound, 0);
-                        }
-                    });
-                }
-            this.nbt = nbtCompound -> {
-                for (Predicate<NbtCompound> predicate : nbtPredicates)
-                    if(!predicate.test(nbtCompound))
-                        return false;
-                return true;
-            };
-
-            this.weight = Integer.parseInt(properties.getProperty("weight", "0"));
-        } catch (Exception e) {
-            throw new CITParseException(pack.resourcePack, identifier, (e.getClass() == Exception.class ? "" : e.getClass().getSimpleName() + ": ") + e.getMessage());
-        }
-    }
-
-    public boolean test(ItemStack stack, Hand hand, World world, LivingEntity entity, boolean ignoreItemType) {
-        if (!ignoreItemType && !items.isEmpty() && !items.contains(stack.getItem()))
-            return false;
-
-        if (!damageAny && stack.getItem().isDamageable()) {
-            int damage = stack.getDamage();
-            if (damageMask != null)
-                damage &= damageMask;
-            if (damagePercentage)
-                damage = Math.round(100f * (float) stack.getDamage() / (float) stack.getMaxDamage());
-            if (damageRange ? (damage < damageMin || damage > damageMax) : (damage != damageMin))
-                return false;
-        }
-
-        if (!stackAny) {
-            int count = stack.getCount();
-            if (stackRange ? (count < stackMin || count > stackMax) : (count != stackMin))
-                return false;
-        }
-
-        if (this.hand != null && this.hand != hand)
-            return false;
-
-        if (!enchantmentsAny) {
-            Map<Identifier, Integer> stackEnchantments = new LinkedHashMap<>();
-            for (NbtElement nbtElement : stack.isOf(Items.ENCHANTED_BOOK) ? EnchantedBookItem.getEnchantmentNbt(stack) : stack.getEnchantments())
-                stackEnchantments.put(EnchantmentHelper.getIdFromNbt((NbtCompound) nbtElement), EnchantmentHelper.getLevelFromNbt((NbtCompound) nbtElement));
-
-            boolean matches = false;
-            for (Identifier enchantment : enchantments) {
-                Integer level = stackEnchantments.get(enchantment);
-                if (level != null)
-                    if (enchantmentLevelsAny) {
-                        if (level > 0) {
-                            matches = true;
-                            break;
-                        }
-                    } else
-                        for (Pair<Integer, Integer> levelRange : enchantmentLevels)
-                            if (level >= levelRange.getLeft() && level <= levelRange.getRight()) {
-                                matches = true;
-                                break;
-                            }
-            }
-
-            if (!matches)
-                return false;
-        } else if (!enchantmentLevelsAny) {
-            Collection<Integer> levels = new ArrayList<>();
-            levels.add(0);
-            for (NbtElement nbtElement : stack.isOf(Items.ENCHANTED_BOOK) ? EnchantedBookItem.getEnchantmentNbt(stack) : stack.getEnchantments())
-                levels.add(EnchantmentHelper.getLevelFromNbt((NbtCompound) nbtElement));
-
-            boolean matches = false;
-
-            l: for (Integer level : levels) {
-                for (Pair<Integer, Integer> levelRange : enchantmentLevels) {
-                    if (level >= levelRange.getLeft() && level <= levelRange.getRight()) {
-                        matches = true;
-                        break l;
-                    }
-                }
-            }
-
-            if (!matches)
-                return false;
-        }
-
-        return nbt == null || nbt.test(stack.getNbt());
-    }
-
-    public void dispose() {
-        //stub
-    }
-
-    /**
-     * Takes a defined path and resolves it to an identifier pointing to the resourcepack's path of the specified extension(returns null if no path can be resolved).<br>
-     * If definedPath is null, will try to resolve a relative file with the same name as the propertyIdentifier with the extension, otherwise: <br>
-     * definedPath will be formatted to replace "\\" with "/" the extension will be appended if not there already. <br>
-     * It will first try using definedPath as an absolute path, if it cant resolve(or definedPath starts with ./), definedPath will be considered relative. <br>
-     * Relative paths support going to parent directories using "..".
-     */
-    public static Identifier resolvePath(Identifier propertyIdentifier, String path, String extension, Predicate<Identifier> packContains) {
-        if (path == null) {
-            path = propertyIdentifier.getPath().substring(0, propertyIdentifier.getPath().length() - 11);
-            if (!path.endsWith(extension))
-                path = path + extension;
-            Identifier pathIdentifier = new Identifier(propertyIdentifier.getNamespace(), path);
-            return packContains.test(pathIdentifier) ? pathIdentifier : null;
-        }
-
-        Identifier pathIdentifier = new Identifier(path);
-
-        path = pathIdentifier.getPath().replace('\\', '/');
-        if (!path.endsWith(extension))
-            path = path + extension;
-
-        if (path.startsWith("./"))
-            path = path.substring(2);
-        else if (!path.contains("..")) {
-            pathIdentifier = new Identifier(pathIdentifier.getNamespace(), path);
-            if (packContains.test(pathIdentifier))
-                return pathIdentifier;
-            else if (path.startsWith("assets/")) {
-                path = path.substring(7);
-                int sep = path.indexOf('/');
-                pathIdentifier = new Identifier(path.substring(0, sep), path.substring(sep + 1));
-                if (packContains.test(pathIdentifier))
-                    return pathIdentifier;
-            }
-            pathIdentifier = new Identifier(pathIdentifier.getNamespace(), switch (extension) {
-                case ".png" -> "textures/";
-                case ".json" -> "models/";
-
-                /* UNREACHABLE FAILSAFE */
-                default -> "";
-            } + path);
-            if (packContains.test(pathIdentifier))
-                return pathIdentifier;
-        }
-
-        LinkedList<String> pathParts = new LinkedList<>(Arrays.asList(propertyIdentifier.getPath().split("/")));
-        pathParts.removeLast();
-
-        if (path.contains("/")) {
-            for (String part : path.split("/")) {
-                if (part.equals("..")) {
-                    if (pathParts.size() == 0)
-                        return null;
-                    pathParts.removeLast();
-                } else
-                    pathParts.addLast(part);
-            }
-        } else
-            pathParts.addLast(path);
-        path = String.join("/", pathParts);
-
-        pathIdentifier = new Identifier(propertyIdentifier.getNamespace(), path);
-
-        return packContains.test(pathIdentifier) ? pathIdentifier : null;
-    }
-
-    /**
-     * Author: Paul "prupe" Rupe<br>
-     * Taken from MCPatcher under public domain licensing.<br>
-     * https://bitbucket.org/prupe/mcpatcher/src/1aa45839b2cd029143809edfa60ec59e5ef75f80/newcode/src/com/prupe/mcpatcher/mal/nbt/NBTRule.java#lines-269:301
-     */
-    public static boolean matchesPattern(String value, String pattern, int curV, int maxV, int curG, int maxG) {
-        for (; curG < maxG; curG++, curV++) {
-            char g = pattern.charAt(curG);
-            if (g == '*') {
-                while (true) {
-                    if (matchesPattern(value, pattern, curV, maxV, curG + 1, maxG)) {
-                        return true;
-                    }
-                    if (curV >= maxV) {
-                        break;
-                    }
-                    curV++;
-                }
-                return false;
-            } else if (curV >= maxV) {
-                break;
-            } else if (g == '?') {
-                continue;
-            }
-            if (g == '\\' && curG + 1 < maxG) {
-                curG++;
-                g = pattern.charAt(curG);
-            }
-
-            if (g != value.charAt(curV))
-                return false;
-        }
-        return curG == maxG && curV == maxV;
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITArmor.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITArmor.java
deleted file mode 100644
index e919a86..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITArmor.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.pack.cits;
-
-import net.minecraft.item.ArmorItem;
-import net.minecraft.item.Item;
-import net.minecraft.resource.ResourceType;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.registry.Registry;
-import shcm.shsupercm.fabric.citresewn.ex.CITParseException;
-import shcm.shsupercm.fabric.citresewn.pack.CITPack;
-
-import java.util.*;
-import java.util.function.Supplier;
-
-public class CITArmor extends CIT {
-    public final Map<String, Identifier> textures = new HashMap<>();
-
-    public CITArmor(CITPack pack, Identifier identifier, Properties properties) throws CITParseException {
-        super(pack, identifier, properties);
-        try {
-            if (this.items.size() == 0)
-                throw new Exception("CIT must target at least one item type");
-            for (Item item : this.items)
-                if (!(item instanceof ArmorItem))
-                    throw new Exception("Armor CIT must target armor items only(" + Registry.ITEM.getId(item) + " is not armor)");
-
-            for (Object o : properties.keySet())
-                if (o instanceof String property && property.startsWith("texture.")) {
-                    Identifier textureIdentifier = resolvePath(identifier, properties.getProperty(property), ".png", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-                    if (textureIdentifier == null)
-                        throw new Exception("Cannot resolve path for " + property);
-
-                    this.textures.put(property.substring(8), textureIdentifier);
-                }
-        } catch (Exception e) {
-            throw new CITParseException(pack.resourcePack, identifier, (e.getClass() == Exception.class ? "" : e.getClass().getSimpleName() + ": ") + e.getMessage());
-        }
-    }
-
-    public interface Cached {
-        CITArmor citresewn_getCachedCITArmor(Supplier<CITArmor> realtime);
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITElytra.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITElytra.java
deleted file mode 100644
index 5c9aa1a..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITElytra.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.pack.cits;
-
-import net.minecraft.resource.ResourceType;
-import net.minecraft.util.Identifier;
-import shcm.shsupercm.fabric.citresewn.ex.CITParseException;
-import shcm.shsupercm.fabric.citresewn.pack.CITPack;
-
-import java.util.Properties;
-import java.util.function.Supplier;
-
-public class CITElytra extends CIT {
-    public final Identifier textureIdentifier;
-
-    public CITElytra(CITPack pack, Identifier identifier, Properties properties) throws CITParseException {
-        super(pack, identifier, properties);
-        try {
-            textureIdentifier = resolvePath(identifier, properties.getProperty("texture"), ".png", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-            if (textureIdentifier == null)
-                throw new Exception("Cannot resolve texture");
-        } catch (Exception e) {
-            throw new CITParseException(pack.resourcePack, identifier, (e.getClass() == Exception.class ? "" : e.getClass().getSimpleName() + ": ") + e.getMessage());
-        }
-    }
-
-    public interface Cached {
-        CITElytra citresewn_getCachedCITElytra(Supplier<CITElytra> realtime);
-    }
-}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITEnchantment.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITEnchantment.java
deleted file mode 100644
index 7c4fa94..0000000
--- a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/cits/CITEnchantment.java
+++ /dev/null
@@ -1,371 +0,0 @@
-package shcm.shsupercm.fabric.citresewn.pack.cits;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.render.*;
-import net.minecraft.enchantment.EnchantmentHelper;
-import net.minecraft.item.EnchantedBookItem;
-import net.minecraft.item.ItemStack;
-import net.minecraft.item.Items;
-import net.minecraft.nbt.NbtCompound;
-import net.minecraft.nbt.NbtElement;
-import net.minecraft.resource.ResourceType;
-import net.minecraft.util.Identifier;
-import net.minecraft.util.Util;
-import net.minecraft.util.math.Matrix4f;
-import net.minecraft.util.math.Vec3f;
-import org.lwjgl.opengl.GL11;
-import shcm.shsupercm.fabric.citresewn.config.CITResewnConfig;
-import shcm.shsupercm.fabric.citresewn.ex.CITParseException;
-import shcm.shsupercm.fabric.citresewn.mixin.citenchantment.BufferBuilderStorageAccessor;
-import shcm.shsupercm.fabric.citresewn.mixin.citenchantment.RenderPhaseAccessor;
-import shcm.shsupercm.fabric.citresewn.pack.CITPack;
-
-import java.util.*;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-import static org.lwjgl.opengl.GL11.*;
-import static com.mojang.blaze3d.systems.RenderSystem.*;
-import static shcm.shsupercm.util.logic.Loops.statelessFadingLoop;
-
-public class CITEnchantment extends CIT {
-    public static List<CITEnchantment> appliedContext = null;
-    public static boolean shouldApply = false;
-
-    public final Identifier textureIdentifier;
-    public final float speed, rotation, duration, r, g, b, a;
-    public final int layer;
-    public final boolean useGlint, blur;
-    public final Blend blend;
-
-    private final WrappedMethodIntensity methodIntensity = new WrappedMethodIntensity();
-
-    public final Map<GlintRenderLayer, RenderLayer> renderLayers = new EnumMap<>(GlintRenderLayer.class);
-
-    public CITEnchantment(CITPack pack, Identifier identifier, Properties properties) throws CITParseException {
-        super(pack, identifier, properties);
-        try {
-            textureIdentifier = resolvePath(identifier, properties.getProperty("texture"), ".png", id -> pack.resourcePack.contains(ResourceType.CLIENT_RESOURCES, id));
-            if (textureIdentifier == null)
-                throw new Exception("Cannot resolve texture");
-
-            speed = Float.parseFloat(properties.getProperty("speed", "1"));
-
-            rotation = Float.parseFloat(properties.getProperty("rotation", "0"));
-
-            duration = Float.max(0f, Float.parseFloat(properties.getProperty("duration", "0")));
-
-            layer = Integer.parseInt(properties.getProperty("layer", "0"));
-
-            r = Math.max(0f, Float.parseFloat(properties.getProperty("r", "1")));
-            g = Math.max(0f, Float.parseFloat(properties.getProperty("g", "1")));
-            b = Math.max(0f, Float.parseFloat(properties.getProperty("b", "1")));
-            a = Math.max(0f, Float.parseFloat(properties.getProperty("a", "1")));
-
-            useGlint = switch (properties.getProperty("useGlint", "false").toLowerCase(Locale.ENGLISH)) {
-                case "true" -> true;
-                case "false" -> false;
-                default -> throw new Exception("useGlint is not a boolean");
-            };
-
-            blur = switch (properties.getProperty("blur", "true").toLowerCase(Locale.ENGLISH)) {
-                case "true" -> true;
-                case "false" -> false;
-                default -> throw new Exception("blur is not a boolean");
-            };
-
-            blend = Blend.getBlend(properties.getProperty("blend", "add"));
-        } catch (Exception e) {
-            throw new CITParseException(pack.resourcePack, identifier, (e.getClass() == Exception.class ? "" : e.getClass().getSimpleName() + ": ") + e.getMessage());
-        }
-    }
-
-    public void activate() {
-        for (GlintRenderLayer glintLayer : GlintRenderLayer.values()) {
-            RenderLayer renderLayer = glintLayer.build(this);
-
-            renderLayers.put(glintLayer, renderLayer);
-            ((BufferBuilderStorageAccessor) MinecraftClient.getInstance().getBufferBuilders()).entityBuilders().put(renderLayer, new BufferBuilder(renderLayer.getExpectedBufferSize()));
-        }
-    }
-
-    @Override
-    public void dispose() {
-        appliedContext = null;
-        for (RenderLayer renderLayer : renderLayers.values())
-            ((BufferBuilderStorageAccessor) MinecraftClient.getInstance().getBufferBuilders()).entityBuilders().remove(renderLayer);
-    }
-
-    public enum GlintRenderLayer {
-        ARMOR_GLINT("armor_glint", 8f, layer -> layer
-                .shader(RenderPhaseAccessor.ARMOR_GLINT_SHADER())
-                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
-                .cull(RenderPhaseAccessor.DISABLE_CULLING())
-                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())
-                .layering(RenderPhaseAccessor.VIEW_OFFSET_Z_LAYERING())),
-        ARMOR_ENTITY_GLINT("armor_entity_glint", 0.16f, layer -> layer
-                .shader(RenderPhaseAccessor.ARMOR_ENTITY_GLINT_SHADER())
-                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
-                .cull(RenderPhaseAccessor.DISABLE_CULLING())
-                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())
-                .layering(RenderPhaseAccessor.VIEW_OFFSET_Z_LAYERING())),
-        GLINT_TRANSLUCENT("glint_translucent", 8f, layer -> layer
-                .shader(RenderPhaseAccessor.TRANSLUCENT_GLINT_SHADER())
-                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
-                .cull(RenderPhaseAccessor.DISABLE_CULLING())
-                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())
-                .target(RenderPhaseAccessor.ITEM_TARGET())),
-        GLINT("glint", 8f, layer -> layer
-                .shader(RenderPhaseAccessor.GLINT_SHADER())
-                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
-                .cull(RenderPhaseAccessor.DISABLE_CULLING())
-                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())),
-        DIRECT_GLINT("glint_direct", 8f, layer -> layer
-                .shader(RenderPhaseAccessor.DIRECT_GLINT_SHADER())
-                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
-                .cull(RenderPhaseAccessor.DISABLE_CULLING())
-                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())),
-        ENTITY_GLINT("entity_glint", 0.16f, layer -> layer
-                .shader(RenderPhaseAccessor.ENTITY_GLINT_SHADER())
-                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
-                .cull(RenderPhaseAccessor.DISABLE_CULLING())
-                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST())
-                .target(RenderPhaseAccessor.ITEM_TARGET())),
-        DIRECT_ENTITY_GLINT("entity_glint_direct", 0.16f, layer -> layer
-                .shader(RenderPhaseAccessor.DIRECT_ENTITY_GLINT_SHADER())
-                .writeMaskState(RenderPhaseAccessor.COLOR_MASK())
-                .cull(RenderPhaseAccessor.DISABLE_CULLING())
-                .depthTest(RenderPhaseAccessor.EQUAL_DEPTH_TEST()));
-
-        public final String name;
-        private final Consumer<RenderLayer.MultiPhaseParameters.Builder> setup;
-        private final float scale;
-
-        GlintRenderLayer(String name, float scale, Consumer<RenderLayer.MultiPhaseParameters.Builder> setup) {
-            this.name = name;
-            this.scale = scale;
-            this.setup = setup;
-        }
-
-        public RenderLayer build(CITEnchantment enchantment) {
-            final float speed = enchantment.speed, rotation = enchantment.rotation, r = enchantment.r, g = enchantment.g, b = enchantment.b, a = enchantment.a;
-            final WrappedMethodIntensity methodIntensity = enchantment.methodIntensity;
-            //noinspection ConstantConditions
-            RenderLayer.MultiPhaseParameters.Builder layer = RenderLayer.MultiPhaseParameters.builder()
-                    .texture(new RenderPhase.Texture(enchantment.textureIdentifier, enchantment.blur, false))
-                    .texturing(new RenderPhase.Texturing("citresewn_glint_texturing", () -> {
-                        float l = Util.getMeasuringTimeMs() * CITResewnConfig.INSTANCE().citenchantment_scroll_multiplier * speed;
-                        float x = (l % 110000f) / 110000f;
-                        float y = (l % 30000f) / 30000f;
-                        Matrix4f matrix4f = Matrix4f.translate(-x, y, 0.0f);
-                        matrix4f.multiply(Vec3f.POSITIVE_Z.getDegreesQuaternion(rotation + 10f));
-                        matrix4f.multiply(Matrix4f.scale(scale, scale, scale));
-                        setTextureMatrix(matrix4f);
-
-                        setShaderColor(r, g, b, a * methodIntensity.intensity);
-                    }, () -> {
-                        RenderSystem.resetTextureMatrix();
-
-                        setShaderColor(1f, 1f, 1f, 1f);
-                    }))
-                    .transparency(enchantment.blend);
-
-            this.setup.accept(layer);
-
-            return RenderLayer.of("citresewn:enchantment_" + this.name + ":" + enchantment.propertiesIdentifier.toString(),
-                    VertexFormats.POSITION_TEXTURE,
-                    VertexFormat.DrawMode.QUADS,
-                    256,
-                    layer.build(false));
-        }
-
-        public VertexConsumer tryApply(VertexConsumer base, RenderLayer baseLayer, VertexConsumerProvider provider) {
-            if (!shouldApply || appliedContext == null || appliedContext.size() == 0)
-                return null;
-
-            VertexConsumer[] layers = new VertexConsumer[Math.min(appliedContext.size(), appliedContext.get(0).pack.cap)];
-
-            for (int i = 0; i < layers.length; i++)
-                layers[i] = provider.getBuffer(appliedContext.get(i).renderLayers.get(GlintRenderLayer.this));
-
-            provider.getBuffer(baseLayer); // refresh base layer for armor consumer
-
-            return base == null ? VertexConsumers.union(layers) : VertexConsumers.union(VertexConsumers.union(layers), base);
-        }
-    }
-
-    public static class Blend extends RenderPhase.Transparency {
-        private final int src, dst, srcAlpha, dstAlpha;
-
-        private Blend(String name, int src, int dst, int srcAlpha, int dstAlpha) {
-            super(name + "_glint_transparency", null, null);
-            this.src = src;
-            this.dst = dst;
-            this.srcAlpha = srcAlpha;
-            this.dstAlpha = dstAlpha;
-        }
-
-        private Blend(String name, int src, int dst) {
-            this(name, src, dst, GL_ZERO, GL_ONE);
-        }
-
-        @Override
-        public void startDrawing() {
-            enableBlend();
-            blendFuncSeparate(src, dst, srcAlpha, dstAlpha);
-        }
-
-        @Override
-        public void endDrawing() {
-            defaultBlendFunc();
-            disableBlend();
-        }
-
-        public static Blend getBlend(String blendString) throws BlendFormatException {
-            try { //check named blending function
-                return Named.valueOf(blendString.toUpperCase(Locale.ENGLISH)).blend;
-            } catch (IllegalArgumentException ignored) { // create custom blending function
-                try {
-                    String[] split = blendString.split(" ");
-                    int src, dst, srcAlpha, dstAlpha;
-                    if (split.length == 2) {
-                        src = parseGLConstant(split[0]);
-                        dst = parseGLConstant(split[1]);
-                        srcAlpha = GL_ZERO;
-                        dstAlpha = GL_ONE;
-                    } else if (split.length == 4) {
-                        src = parseGLConstant(split[0]);
-                        dst = parseGLConstant(split[1]);
-                        srcAlpha = parseGLConstant(split[2]);
-                        dstAlpha = parseGLConstant(split[3]);
-                    } else
-                        throw new Exception();
-
-                    return new Blend("custom_" + src + "_" + dst + "_" + srcAlpha + "_" + dstAlpha, src, dst, srcAlpha, dstAlpha);
-                } catch (Exception e) {
-                    throw new BlendFormatException();
-                }
-            }
-        }
-
-        private enum Named {
-            REPLACE(new Blend("replace", 0, 0) {
-                @Override
-                public void startDrawing() {
-                    disableBlend();
-                }
-            }),
-            GLINT(new Blend("glint", GL_SRC_COLOR, GL_ONE)),
-            ALPHA(new Blend("alpha", GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)),
-            ADD(new Blend("add", GL_SRC_ALPHA, GL_ONE)),
-            SUBTRACT(new Blend("subtract", GL_ONE_MINUS_DST_COLOR, GL_ZERO)),
-            MULTIPLY(new Blend("multiply", GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA)),
-            DODGE(new Blend("dodge", GL_ONE, GL_ONE)),
-            BURN(new Blend("burn", GL_ZERO, GL_ONE_MINUS_SRC_COLOR)),
-            SCREEN(new Blend("screen", GL_ONE, GL_ONE_MINUS_SRC_COLOR)),
-            OVERLAY(new Blend("overlay", GL_DST_COLOR, GL_SRC_COLOR));
-
-            public final Blend blend;
-
-            Named(Blend blend) {
-                this.blend = blend;
-            }
-        }
-
-        private static int parseGLConstant(String s) throws Exception {
-            try {
-                return GL11.class.getDeclaredField(s).getInt(null);
-            } catch (NoSuchFieldException ignored) { }
-
-            return s.startsWith("0x") ? Integer.parseInt(s.substring(2), 16) : Integer.parseInt(s);
-        }
-
-        public static class BlendFormatException extends Exception {
-            public BlendFormatException() {
-                super("Not a valid blending method");
-            }
-        }
-    }
-
-    public enum MergeMethod {
-        AVERAGE {
-            @Override
-            public void applyIntensity(Map<Identifier, Integer> stackEnchantments, CITEnchantment cit) {
-                Identifier enchantment = null;
-                for (Identifier enchantmentMatch : cit.enchantments)
-                    if (stackEnchantments.containsKey(enchantmentMatch)) {
-                        enchantment = enchantmentMatch;
-                        break;
-                    }
-
-                if (enchantment == null) {
-                    cit.methodIntensity.intensity = 0f;
-                } else {
-                    float sum = 0f;
-                    for (Integer value : stackEnchantments.values())
-                        sum += value;
-
-                    cit.methodIntensity.intensity = (float) stackEnchantments.get(enchantment) / sum;
-                }
-            }
-        },
-        LAYERED {
-            @Override
-            public void applyIntensity(Map<Identifier, Integer> stackEnchantments, CITEnchantment cit) {
-                Identifier enchantment = null;
-                for (Identifier enchantmentMatch : cit.enchantments)
-                    if (stackEnchantments.containsKey(enchantmentMatch)) {
-                        enchantment = enchantmentMatch;
-                        break;
-                    }
-                if (enchantment == null) {
-                    cit.methodIntensity.intensity = 0f;
-                    return;
-                }
-
-                float max = 0f;
-                for (Integer value : stackEnchantments.values())
-                    if (value > max)
-                        max = value;
-
-                cit.methodIntensity.intensity = (float) stackEnchantments.get(enchantment) / max;
-            }
-        },
-        CYCLE {
-            @Override
-            public void applyMethod(List<CITEnchantment> citEnchantments, ItemStack stack) {
-                List<Map.Entry<CITEnchantment, Float>> durations = new ArrayList<>();
-                for (CITEnchantment cit : citEnchantments)
-                    durations.add(new HashMap.SimpleEntry<>(cit, cit.duration));
-
-                for (Map.Entry<CITEnchantment, Float> intensity : statelessFadingLoop(durations, citEnchantments.get(0).pack.fade, ticks, 20).entrySet())
-                    intensity.getKey().methodIntensity.intensity = intensity.getValue();
-            }
-        };
-
-        public static int ticks = 0;
-
-        public void applyIntensity(Map<Identifier, Integer> stackEnchantments, CITEnchantment cit) {
-            cit.methodIntensity.intensity = 1f;
-        }
-
-        public void applyMethod(List<CITEnchantment> citEnchantments, ItemStack stack) {
-            Map<Identifier, Integer> stackEnchantments = new LinkedHashMap<>();
-            for (NbtElement nbtElement : stack.isOf(Items.ENCHANTED_BOOK) ? EnchantedBookItem.getEnchantmentNbt(stack) : stack.getEnchantments())
-                stackEnchantments.put(EnchantmentHelper.getIdFromNbt((NbtCompound) nbtElement), EnchantmentHelper.getLevelFromNbt((NbtCompound) nbtElement));
-
-            for (CITEnchantment cit : citEnchantments)
-                if (!cit.enchantmentsAny)
-                    applyIntensity(stackEnchantments, cit);
-        }
-    }
-
-    private static class WrappedMethodIntensity {
-        public float intensity = 1f;
-    }
-
-    public interface Cached {
-        List<CITEnchantment> citresewn_getCachedCITEnchantment(Supplier<List<CITEnchantment>> realtime);
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertiesGroupAdapter.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertiesGroupAdapter.java
new file mode 100644
index 0000000..0375079
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertiesGroupAdapter.java
@@ -0,0 +1,101 @@
+package shcm.shsupercm.fabric.citresewn.pack.format;
+
+import net.minecraft.util.Identifier;
+import net.minecraft.util.InvalidIdentifierException;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+
+public class PropertiesGroupAdapter extends PropertyGroup {
+    public static final String EXTENSION = ".properties";
+
+    protected PropertiesGroupAdapter(String packName, Identifier identifier) {
+        super(packName, identifier);
+    }
+
+    @Override
+    public String getExtension() {
+        return EXTENSION;
+    }
+
+    @Override
+    public PropertyGroup load(String packName, Identifier identifier, InputStream is) throws IOException, InvalidIdentifierException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
+            String line;
+            int linePos = 0, multilineSkip = 0;
+            while ((line = reader.readLine()) != null) {
+                linePos++;
+                line = line.stripLeading();
+                if (line.isEmpty() || line.startsWith("#") || line.startsWith("!"))
+                    continue;
+
+                while (line.endsWith("\\")) {
+                    String nextLine = reader.readLine();
+                    linePos++;
+                    multilineSkip++;
+                    if (nextLine == null)
+                        nextLine = "";
+                    nextLine = nextLine.stripLeading();
+
+                    if (nextLine.startsWith("#") || nextLine.startsWith("!"))
+                        continue;
+
+                    line = line.substring(0, line.length() - 1) + "\\n" + nextLine;
+                }
+
+                line = line.stripTrailing();
+
+                StringBuilder builder = new StringBuilder();
+
+                String key = null, keyMetadata = null;
+                final boolean checkColonSeparator = !line.contains("=");
+
+                for (int i = 0; i < line.length(); i++) {
+                    char c = line.charAt(i);
+
+                    if (c == '\\') { // escape
+                        c = switch (c = line.charAt(++i)) {
+                            case 'n' -> '\n';
+                            case 'r' -> '\r';
+                            case 'f' -> '\f';
+                            case 't' -> '\t';
+                            case 'u' -> {
+                                try {
+                                    i += 4;
+                                    yield (char) Integer.parseInt(line.substring(i - 3, i + 1), 16);
+                                } catch (ArrayIndexOutOfBoundsException | NumberFormatException e) {
+                                    throw new IOException("Malformatted escaped unicode character");
+                                }
+                            }
+
+                            default -> c;
+                        };
+
+                    } else if (key == null && (c == '=' || (checkColonSeparator && c == ':'))) {
+                        key = builder.toString().stripTrailing();
+                        int metadataIndex = key.indexOf('.');
+                        if (metadataIndex >= 0) {
+                            keyMetadata = key.substring(metadataIndex + 1);
+                            key = key.substring(0, metadataIndex);
+                        }
+
+                        builder = new StringBuilder();
+                        for (i++; i < line.length() && Character.isWhitespace(line.charAt(i)); i++);
+                        i--;
+                        continue;
+                    }
+
+                    builder.append(c);
+                }
+
+                if (key == null)
+                    throw new IOException("Missing separator in line " + linePos);
+
+                int pos = linePos - multilineSkip;
+                multilineSkip = 0;
+                this.put(pos, packName, identifier, key, keyMetadata, PropertySeparator.EQUALS, builder.toString());
+            }
+        }
+        return this;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyGroup.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyGroup.java
new file mode 100644
index 0000000..8d185fd
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyGroup.java
@@ -0,0 +1,157 @@
+package shcm.shsupercm.fabric.citresewn.pack.format;
+
+import net.minecraft.util.Identifier;
+import net.minecraft.util.InvalidIdentifierException;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.*;
+
+/**
+ * Storage agnostic map of keys and values.<br>
+ * Keys are stored as {@link PropertyKey}s holding the mod id of the property type.<br>
+ * A key can have multiple values associated with it as they are stored in an ordered set.
+ *
+ * @see PropertyKey
+ * @see PropertyValue
+ * @see PropertiesGroupAdapter
+ */
+public abstract class PropertyGroup {
+    /**
+     * The internal map that backs this property group.
+     */
+    public final Map<PropertyKey, Set<PropertyValue>> properties = new LinkedHashMap<>();
+
+    /**
+     * This group's location in its resourcepack.
+     */
+    public final Identifier identifier;
+
+    /**
+     * The file name of the resourcepack that this property group is in.
+     */
+    public final String packName;
+
+    protected PropertyGroup(String packName, Identifier identifier) {
+        this.packName = packName;
+        this.identifier = identifier;
+    }
+
+    /**
+     * Tries to parse a group out of a stream.
+     * @see #load(String, Identifier, InputStream)
+     * @see #getExtension()
+     * @see PropertiesGroupAdapter
+     * @param packName {@link #packName}
+     * @param identifier {@link #identifier}, needed for extension matching
+     * @param is a stream containing properties as specified by implementation
+     * @return the parsed group or null if could not match an adapter
+     * @throws IOException if errored while parsing the group
+     */
+    public static PropertyGroup tryParseGroup(String packName, Identifier identifier, InputStream is) throws IOException {
+        PropertyGroup group = null;
+        if (identifier.getPath().endsWith(PropertiesGroupAdapter.EXTENSION))
+            group = new PropertiesGroupAdapter(packName, identifier);
+
+        return group == null ? null : group.load(packName, identifier, is);
+    }
+
+    /**
+     * @return file suffix for this property group's implementation
+     */
+    public abstract String getExtension();
+
+    /**
+     * Reads the given input stream into the group.
+     * @param packName {@link #packName}
+     * @param identifier {@link #identifier}
+     * @param is a stream containing properties as specified by implementation
+     * @return this
+     * @throws IOException if errored while reading the stream
+     * @throws InvalidIdentifierException if encountered a malformed {@link Identifier} while reading
+     */
+    public abstract PropertyGroup load(String packName, Identifier identifier, InputStream is) throws IOException, InvalidIdentifierException;
+
+    /**
+     * Adds the given value to the group.
+     * @param position implementation specific interpretation of the value's position in the group, has no effect on internal order
+     * @param packName the value's resourcepack file name
+     * @param propertiesIdentifier the value's property group location identifier
+     * @param key the value's key name
+     * @param keyMetadata nullable, implementation specific metadata for this value's key
+     * @param separator implementation specific connection between the key and the value
+     * @param value string representation of the value to be parsed by the group's user
+     */
+    protected void put(int position, String packName, Identifier propertiesIdentifier, String key, String keyMetadata, PropertySeparator separator, String value) {
+        Objects.requireNonNull(key);
+        Objects.requireNonNull(value);
+
+        this.properties.computeIfAbsent(PropertyKey.of(key), id -> new LinkedHashSet<>()).add(new PropertyValue(keyMetadata, value, separator, position, propertiesIdentifier, packName));
+    }
+
+    /**
+     * @param namespace the key's namespace(should be the value type's modid by convention)
+     * @param pathAliases all key name aliases to check for
+     * @return all values associated with the given key by alias>insertion order
+     */
+    public Set<PropertyValue> get(String namespace, String... pathAliases) {
+        Set<PropertyValue> values = new LinkedHashSet<>();
+
+        for (String path : pathAliases) {
+            Set<PropertyValue> possibleValues = this.properties.get(new PropertyKey(namespace, path));
+            if (possibleValues != null)
+                values.addAll(possibleValues);
+        }
+
+        return values;
+    }
+
+    /**
+     * @see #getLastWithoutMetadataOrDefault(String, String, String...)
+     * @param namespace the key's namespace(should be the value type's modid by convention)
+     * @param pathAliases all key name aliases to check for
+     * @return the last value associated with the key(by insertion order) that has a null key metadata or null if the key is not present in the group
+     */
+    public PropertyValue getLastWithoutMetadata(String namespace, String... pathAliases) {
+        PropertyValue value = null;
+        for (PropertyValue next : get(namespace, pathAliases))
+            if (next.keyMetadata() == null)
+                value = next;
+
+        return value;
+    }
+
+    /**
+     * @see #getLastWithoutMetadata(String, String...)
+     * @param defaultValue the dummy value to return if not present in the group
+     * @param namespace the key's namespace(should be the value type's modid by convention)
+     * @param pathAliases all key name aliases to check for
+     * @return the last value associated with the key(by insertion order) that has a null key metadata or the wrapped default value if the key is not present in the group
+     */
+    public PropertyValue getLastWithoutMetadataOrDefault(String defaultValue, String namespace, String... pathAliases) {
+        PropertyValue property = getLastWithoutMetadata(namespace, pathAliases);
+        if (property == null)
+            property = new PropertyValue(null, defaultValue, PropertySeparator.EQUALS, -1, this.identifier, this.packName);
+
+        return property;
+    }
+
+    /**
+     * @see #getExtension()
+     * @see #identifier
+     * @return the name of this group without its path or extension
+     */
+    public String stripName() {
+        return identifier.getPath().substring(identifier.getPath().lastIndexOf('/') + 1, identifier.getPath().length() - getExtension().length());
+    }
+
+    /**
+     * Compiles a message with attached info on a value's origin.
+     * @param message message to add descriptor to
+     * @param position implementation specific position of
+     * @return the formatted message
+     */
+    public String messageWithDescriptorOf(String message, int position) {
+        return message + (position != -1 ? " @L" + position : "") + " in " + this.identifier.toString() + " from " + this.packName;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyKey.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyKey.java
new file mode 100644
index 0000000..7bc2cdc
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyKey.java
@@ -0,0 +1,31 @@
+package shcm.shsupercm.fabric.citresewn.pack.format;
+
+import net.minecraft.util.Identifier;
+
+/**
+ * Namespace/path pair of strings. Similar to {@link Identifier} but without validity restrictions.
+ * @see Identifier
+ */
+public record PropertyKey(String namespace, String path) {
+    /**
+     * Attempts to split a given string into a namespace and path by the first occurrence of a colon.<br>
+     * If a namespace cannot be extracted from the given string, "citresewn" is set instead.
+     * @param key key to parse
+     * @return parsed property key
+     */
+    public static PropertyKey of(String key) {
+        String[] split = new String[] {"citresewn", key};
+        int i = key.indexOf(':');
+        if (i >= 0) {
+            split[1] = key.substring(i + 1);
+            if (i >= 1)
+                split[0] = key.substring(0, i);
+        }
+        return new PropertyKey(split[0], split[1]);
+    }
+
+    @Override
+    public String toString() {
+        return namespace + ":" + path;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertySeparator.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertySeparator.java
new file mode 100644
index 0000000..ce4ebab
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertySeparator.java
@@ -0,0 +1,21 @@
+package shcm.shsupercm.fabric.citresewn.pack.format;
+
+/**
+ * Marker for the connection between a {@link PropertyKey} and its {@link PropertyValue}.
+ */
+public enum PropertySeparator {
+    /**
+     * Marks either a check for equality or an action to set a value.
+     */
+    EQUALS("=")
+    ;
+
+    /**
+     * String representation of the separator.
+     */
+    public final String separator;
+
+    PropertySeparator(String separator) {
+        this.separator = separator;
+    }
+}
diff --git a/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyValue.java b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyValue.java
new file mode 100644
index 0000000..f41119f
--- /dev/null
+++ b/src/main/java/shcm/shsupercm/fabric/citresewn/pack/format/PropertyValue.java
@@ -0,0 +1,20 @@
+package shcm.shsupercm.fabric.citresewn.pack.format;
+
+import net.minecraft.util.Identifier;
+
+/**
+ * Wrapped representation of a property group's value with additional attached metadata.
+ * @param keyMetadata nullable, implementation specific metadata for this value's key
+ * @param value string representation of the value to be parsed by the group's user
+ * @param separator implementation specific connection between the key and the value
+ * @param position implementation specific interpretation of the value's position in the group, has no effect on internal order
+ * @param propertiesIdentifier the value's property group location identifier
+ * @param packName the value's resourcepack file name
+ */
+public record PropertyValue(String keyMetadata,
+                            String value,
+                            PropertySeparator separator,
+                            int position,
+                            Identifier propertiesIdentifier,
+                            String packName) {
+}
diff --git a/src/main/resources/assets/citresewn/lang/en_us.json b/src/main/resources/assets/citresewn/lang/en_us.json
index 2f90a92..3164cb5 100644
--- a/src/main/resources/assets/citresewn/lang/en_us.json
+++ b/src/main/resources/assets/citresewn/lang/en_us.json
@@ -1,5 +1,6 @@
 {
   "config.citresewn.title": "CIT Resewn Configuration",
+  "config.citresewn.configure": "Configure",
 
   "config.citresewn.enabled.title": "Enabled",
   "config.citresewn.enabled.tooltip": "Should CIT Resewn load and inject cits from resourcepacks",
@@ -10,9 +11,6 @@
   "config.citresewn.mute_warns.title": "Mute loading warnings",
   "config.citresewn.mute_warns.tooltip": "Should CIT Resewn not log cit warnings",
 
-  "config.citresewn.citenchantment_scroll_multiplier.title": "CIT Enchantment: Scroll Multiplier",
-  "config.citresewn.citenchantment_scroll_multiplier.tooltip": "General multiplier for the scroll speed of the glint textures added by enchantment CITs.",
-
   "config.citresewn.broken_paths.title": "Allow broken paths in resourcepacks",
   "config.citresewn.broken_paths.tooltip": "Allows packs with illegal resource paths to load.\nMay cause issues!",
 
diff --git a/src/main/resources/citresewn.accesswidener b/src/main/resources/citresewn.accesswidener
index 33ad46d..dfde67a 100644
--- a/src/main/resources/citresewn.accesswidener
+++ b/src/main/resources/citresewn.accesswidener
@@ -1,29 +1 @@
-accessWidener v1 named
-
-# net.minecraft.client.render.model.json.ModelOverrideList
-accessible   class   net/minecraft/client/render/model/json/ModelOverrideList$BakedOverride
-accessible   class   net/minecraft/client/render/model/json/ModelOverrideList$InlinedCondition
-accessible   method  net/minecraft/client/render/model/json/ModelOverrideList <init> ()V
-accessible   method  net/minecraft/client/render/model/json/ModelOverrideList$BakedOverride <init> ([Lnet/minecraft/client/render/model/json/ModelOverrideList$InlinedCondition;Lnet/minecraft/client/render/model/BakedModel;)V
-accessible   method  net/minecraft/client/render/model/json/ModelOverrideList$InlinedCondition <init> (IF)V
-accessible   field   net/minecraft/client/render/model/json/ModelOverrideList overrides [Lnet/minecraft/client/render/model/json/ModelOverrideList$BakedOverride;
-mutable      field   net/minecraft/client/render/model/json/ModelOverrideList overrides [Lnet/minecraft/client/render/model/json/ModelOverrideList$BakedOverride;
-accessible   field   net/minecraft/client/render/model/json/ModelOverrideList conditionTypes [Lnet/minecraft/util/Identifier;
-mutable      field   net/minecraft/client/render/model/json/ModelOverrideList conditionTypes [Lnet/minecraft/util/Identifier;
-
-# net.minecraft.client.render.RenderLayer
-accessible   class   net/minecraft/client/render/RenderLayer$MultiPhaseParameters
-accessible   method  net/minecraft/client/render/RenderLayer of (Ljava/lang/String;Lnet/minecraft/client/render/VertexFormat;Lnet/minecraft/client/render/VertexFormat$DrawMode;ILnet/minecraft/client/render/RenderLayer$MultiPhaseParameters;)Lnet/minecraft/client/render/RenderLayer$MultiPhase;
-
-# net.minecraft.client.render.RenderPhase
-accessible   class   net/minecraft/client/render/RenderPhase$Shader
-accessible   class   net/minecraft/client/render/RenderPhase$Texturing
-accessible   class   net/minecraft/client/render/RenderPhase$Transparency
-accessible   class   net/minecraft/client/render/RenderPhase$Texture
-accessible   class   net/minecraft/client/render/RenderPhase$Lightmap
-accessible   class   net/minecraft/client/render/RenderPhase$Overlay
-accessible   class   net/minecraft/client/render/RenderPhase$Cull
-accessible   class   net/minecraft/client/render/RenderPhase$DepthTest
-accessible   class   net/minecraft/client/render/RenderPhase$WriteMaskState
-accessible   class   net/minecraft/client/render/RenderPhase$Layering
-accessible   class   net/minecraft/client/render/RenderPhase$Target
\ No newline at end of file
+accessWidener v1 named
\ No newline at end of file
diff --git a/src/main/resources/citresewn.mixins.json b/src/main/resources/citresewn.mixins.json
index e32c847..31b8216 100644
--- a/src/main/resources/citresewn.mixins.json
+++ b/src/main/resources/citresewn.mixins.json
@@ -2,35 +2,8 @@
   "required": true,
   "minVersion": "0.8",
   "package": "shcm.shsupercm.fabric.citresewn.mixin",
-  "compatibilityLevel": "JAVA_16",
   "plugin": "shcm.shsupercm.fabric.citresewn.config.CITResewnMixinConfiguration",
-  "mixins": [
-    "broken_paths.AbstractFileResourcePackMixin",
-    "broken_paths.IdentifierMixin",
-    "broken_paths.ReloadableResourceManagerImplMixin",
-    "broken_paths.ResourcePackCompatibilityMixin",
-    "citarmor.ArmorFeatureRendererMixin",
-    "citarmor.ItemStackMixin",
-    "citelytra.ElytraFeatureRendererMixin",
-    "citelytra.ItemStackMixin",
-    "citenchantment.ArmorFeatureRendererMixin",
-    "citenchantment.BufferBuilderStorageAccessor",
-    "citenchantment.ElytraFeatureRendererMixin",
-    "citenchantment.ItemRendererMixin",
-    "citenchantment.ItemStackMixin",
-    "citenchantment.RenderPhaseAccessor",
-    "citenchantment.MinecraftClientMixin",
-    "cititem.ItemRendererMixin",
-    "cititem.ItemStackMixin",
-    "cititem.JsonUnbakedModelAccessor",
-    "cititem.ModelLoaderMixin",
-    "core.ChatScreenMixin",
-    "core.GroupResourcePackAccessor",
-    "core.ModelLoaderMixin",
-    "core.NbtCompoundAccessor",
-    "core.SpriteAtlasTextureMixin",
-    "core.ZipResourcePackMixin"
-  ],
+  "compatibilityLevel": "JAVA_17",
   "injectors": {
     "defaultRequire": 1
   }
diff --git a/src/main/resources/fabric.mod.json b/src/main/resources/fabric.mod.json
index 3ab2b9b..a8e2234 100644
--- a/src/main/resources/fabric.mod.json
+++ b/src/main/resources/fabric.mod.json
@@ -2,23 +2,20 @@
   "schemaVersion": 1,
   "id": "citresewn",
   "version": "${version}",
-  "name": "CITResewn",
+  "name": "CIT Resewn",
   "description": "Re-implements MCPatcher's CIT",
   "authors": [
     "SHsuperCM"
   ],
   "license": "MIT",
   "icon": "assets/citresewn/logo.png",
+  "contact": {
+    "homepage": "https://citresewn.shcm.io/",
+    "sources": "https://github.com/SHsuperCM/CITResewn",
+    "issues": "https://github.com/SHsuperCM/CITResewn/issues"
+  },
 
   "environment": "client",
-  "entrypoints": {
-    "client": [
-      "shcm.shsupercm.fabric.citresewn.CITResewn"
-    ],
-    "modmenu": [
-      "shcm.shsupercm.fabric.citresewn.config.CITResewnModMenu"
-    ]
-  },
   "accessWidener" : "citresewn.accesswidener",
   "mixins": [
     "citresewn.mixins.json"
@@ -27,5 +24,12 @@
     "fabric": "*",
     "fabricloader": "*",
     "minecraft": "1.18.x"
+  },
+  "recommends": {
+    "modmenu": "*",
+    "cloth-config2": "*"
+  },
+  "breaks": {
+    "canvas": "*"
   }
 }