Merge pull request #1205 from VolmitSoftware/dev

3.6.11

README.md

@@ -15,17 +15,17 @@ Consider supporting our development by buying Iris on spigot! We work hard to ma
 
 ### Command Line Builds
 
-1. Install [Java JDK 17](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html)
+1. Install [Java JDK 21](https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html)
 2. Set the JDK installation path to `JAVA_HOME` as an environment variable.
     * Windows
         1. Start > Type `env` and press Enter
         2. Advanced > Environment Variables
         3. Under System Variables, click `New...`
         4. Variable Name: `JAVA_HOME`
-        5. Variable Value: `C:\Program Files\Java\jdk-17.0.1` (verify this exists after installing java don't just copy
+        5. Variable Value: `C:\Program Files\Java\jdk-21.0.1` (verify this exists after installing java don't just copy
            the example text)
     * MacOS
-        1. Run `/usr/libexec/java_home -V` and look for Java 17
+        1. Run `/usr/libexec/java_home -V` and look for Java 21
         2. Run `sudo nano ~/.zshenv`
         3. Add `export JAVA_HOME=$(/usr/libexec/java_home)` as a new line
         4. Use `CTRL + X`, then Press `Y`, Then `ENTER`
@@ -35,7 +35,7 @@ Consider supporting our development by buying Iris on spigot! We work hard to ma
 
 ### IDE Builds (for development)
 
-* Configure ITJ Gradle to use JDK 17 (in settings, search for gradle)
+* Configure ITJ Gradle to use JDK 21 (in settings, search for gradle)
 * Add a build line in the build.gradle for your own build task to directly compile Iris into your plugins folder if you
   prefer.
 * Resync the project & run your newly created task (under the development folder in gradle tasks!)

build.gradle

@@ -1,222 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2021 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-buildscript() {
-    repositories {
-        maven { url 'https://jitpack.io'}
-    }
-    dependencies {
-        classpath 'com.github.VolmitSoftware:NMSTools:1.0.1'
-    }
-}
-
-plugins {
-    id 'java'
-    id 'java-library'
-    id "io.github.goooler.shadow" version "8.1.7"
-    id "de.undercouch.download" version "5.0.1"
-}
-
-version '3.4.3-1.19.2-1.21.1'
-
-// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
-// ======================== WINDOWS =============================
-registerCustomOutputTask('Cyberpwn', 'C://Users/cyberpwn/Documents/development/server/plugins')
-registerCustomOutputTask('Psycho', 'C://Dan/MinecraftDevelopment/Server/plugins')
-registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/server/plugins')
-registerCustomOutputTask('Coco', 'D://mcsm/plugins')
-registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
-registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19.4/plugins')
-registerCustomOutputTask('CrazyDev22', 'C://Users/Julian/Desktop/server/plugins')
-registerCustomOutputTask('Pixel', 'C://Users/repix/Iris Dimension Engine/1.20.4 - Development/plugins')
-// ========================== UNIX ==============================
-registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
-registerCustomOutputTaskUnix('PsychoLT', '/Users/brianfopiano/Developer/RemoteGit/Server/plugins')
-registerCustomOutputTaskUnix('PixelMac', '/Users/test/Desktop/mcserver/plugins')
-registerCustomOutputTaskUnix('CrazyDev22LT', '/home/julian/Desktop/server/plugins')
-// ==============================================================
-
-def NMS_BINDINGS = Map.of(
-        "v1_21_R1", "1.21-R0.1-SNAPSHOT",
-        "v1_20_R4", "1.20.6-R0.1-SNAPSHOT",
-        "v1_20_R3", "1.20.4-R0.1-SNAPSHOT",
-        "v1_20_R2", "1.20.2-R0.1-SNAPSHOT",
-        "v1_20_R1", "1.20.1-R0.1-SNAPSHOT",
-        "v1_19_R3", "1.19.4-R0.1-SNAPSHOT",
-        "v1_19_R2", "1.19.3-R0.1-SNAPSHOT",
-        "v1_19_R1", "1.19.2-R0.1-SNAPSHOT"
-)
-def JVM_VERSION = Map.of(
-        "v1_21_R1", 21,
-        "v1_20_R4", 21,
-)
-NMS_BINDINGS.each { nms ->
-    project(":nms:${nms.key}") {
-        apply plugin: 'java'
-        apply plugin: 'com.volmit.nmstools'
-
-        nmsTools {
-            it.jvm = JVM_VERSION.getOrDefault(nms.key, 17)
-            it.version = nms.value
-        }
-
-        dependencies {
-            implementation project(":core")
-        }
-    }
-}
-
-shadowJar {
-    NMS_BINDINGS.each {
-        dependsOn(":nms:${it.key}:remap")
-        from("${project(":nms:${it.key}").layout.buildDirectory.asFile.get()}/libs/${it.key}-mapped.jar")
-    }
-
-    //minimize()
-    append("plugin.yml")
-    relocate 'com.dfsek.paralithic', 'com.volmit.iris.util.paralithic'
-    relocate 'io.papermc.lib', 'com.volmit.iris.util.paper'
-    relocate 'net.kyori', 'com.volmit.iris.util.kyori'
-    archiveFileName.set("Iris-${project.version}.jar")
-}
-
-dependencies {
-    implementation project(':core')
-}
-
-configurations.configureEach {
-    resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
-    resolutionStrategy.cacheDynamicVersionsFor 60, 'minutes'
-}
-
-allprojects {
-    apply plugin: 'java'
-
-    repositories {
-        mavenCentral()
-        maven { url "https://repo.papermc.io/repository/maven-public/"}
-        maven { url "https://repo.codemc.org/repository/maven-public" }
-        maven { url "https://mvn.lumine.io/repository/maven-public/" }
-        maven { url "https://jitpack.io"}
-
-        maven { url "https://s01.oss.sonatype.org/content/repositories/snapshots" }
-        maven { url "https://mvn.lumine.io/repository/maven/" }
-        maven { url "https://repo.triumphteam.dev/snapshots" }
-        maven { url "https://repo.mineinabyss.com/releases" }
-        maven { url 'https://hub.jeff-media.com/nexus/repository/jeff-media-public/' }
-        maven { url "https://repo.oraxen.com/releases" }
-    }
-
-    dependencies {
-        // Provided or Classpath
-        compileOnly 'org.projectlombok:lombok:1.18.24'
-        annotationProcessor 'org.projectlombok:lombok:1.18.24'
-
-        // Shaded
-        implementation 'com.dfsek:Paralithic:0.4.0'
-        implementation 'io.papermc:paperlib:1.0.5'
-        implementation "net.kyori:adventure-text-minimessage:4.17.0"
-        implementation 'net.kyori:adventure-platform-bukkit:4.3.4'
-        implementation 'net.kyori:adventure-api:4.17.0'
-        //implementation 'org.bytedeco:javacpp:1.5.10'
-        //implementation 'org.bytedeco:cuda-platform:12.3-8.9-1.5.10'
-        compileOnly 'io.lumine:Mythic-Dist:5.2.1'
-
-        // Dynamically Loaded
-        compileOnly 'io.timeandspace:smoothie-map:2.0.2'
-        compileOnly 'it.unimi.dsi:fastutil:8.5.8'
-        compileOnly 'com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2'
-        compileOnly 'org.zeroturnaround:zt-zip:1.14'
-        compileOnly 'com.google.code.gson:gson:2.10.1'
-        compileOnly 'org.ow2.asm:asm:9.2'
-        compileOnly 'com.google.guava:guava:33.0.0-jre'
-        compileOnly 'bsf:bsf:2.4.0'
-        compileOnly 'rhino:js:1.7R2'
-        compileOnly 'com.github.ben-manes.caffeine:caffeine:3.0.6'
-        compileOnly 'org.apache.commons:commons-lang3:3.12.0'
-    }
-
-    /**
-     * We need parameter meta for the decree command system
-     */
-    compileJava {
-        options.compilerArgs << '-parameters'
-        options.encoding = "UTF-8"
-    }
-}
-
-if (JavaVersion.current().toString() != "17") {
-    System.err.println()
-    System.err.println("=========================================================================================================")
-    System.err.println("You must run gradle on Java 17. You are using " + JavaVersion.current())
-    System.err.println()
-    System.err.println("=== For IDEs ===")
-    System.err.println("1. Configure the project for Java 17")
-    System.err.println("2. Configure the bundled gradle to use Java 17 in settings")
-    System.err.println()
-    System.err.println("=== For Command Line (gradlew) ===")
-    System.err.println("1. Install JDK 17 from https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html")
-    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:\\Program Files\\Java\\jdk-17.0.1")
-    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
-    System.err.println("=========================================================================================================")
-    System.err.println()
-    System.exit(69);
-}
-
-task iris(type: Copy) {
-    group "iris"
-    from new File(layout.buildDirectory.asFile.get(), "libs/Iris-${version}.jar")
-    into layout.buildDirectory.asFile.get()
-    dependsOn(build)
-}
-
-def registerCustomOutputTask(name, path) {
-    if (!System.properties['os.name'].toLowerCase().contains('windows')) {
-        return;
-    }
-
-    tasks.register('build' + name, Copy) {
-        group('development')
-        outputs.upToDateWhen { false }
-        dependsOn(iris)
-        from(new File(buildDir, "Iris-" + version + ".jar"))
-        into(file(path))
-        rename { String fileName ->
-            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
-        }
-    }
-}
-
-def registerCustomOutputTaskUnix(name, path) {
-    if (System.properties['os.name'].toLowerCase().contains('windows')) {
-        return;
-    }
-
-    tasks.register('build' + name, Copy) {
-        group('development')
-        outputs.upToDateWhen { false }
-        dependsOn(iris)
-        from(new File(buildDir, "Iris-" + version + ".jar"))
-        into(file(path))
-        rename { String fileName ->
-            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
-        }
-    }
-}
-
-tasks.build.dependsOn(shadowJar)

build.gradle.kts

@@ -0,0 +1,278 @@
+import com.volmit.nmstools.NMSToolsExtension
+import com.volmit.nmstools.NMSToolsPlugin
+import de.undercouch.gradle.tasks.download.Download
+import xyz.jpenilla.runpaper.task.RunServer
+import kotlin.system.exitProcess
+
+/*
+ * Iris is a World Generator for Minecraft Bukkit Servers
+ * Copyright (c) 2021 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+buildscript {
+    repositories.maven("https://jitpack.io")
+    dependencies.classpath("com.github.VolmitSoftware:NMSTools:c5cbc46ce6")
+}
+
+plugins {
+    java
+    `java-library`
+    id("com.gradleup.shadow") version "8.3.6"
+    id("de.undercouch.download") version "5.0.1"
+    id("xyz.jpenilla.run-paper") version "2.3.1"
+    id("io.sentry.jvm.gradle") version "5.7.0"
+}
+
+version = "3.6.10-1.20.1-1.21.5"
+
+// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
+// ======================== WINDOWS =============================
+registerCustomOutputTask("Cyberpwn", "C://Users/cyberpwn/Documents/development/server/plugins")
+registerCustomOutputTask("Psycho", "C://Dan/MinecraftDevelopment/Server/plugins")
+registerCustomOutputTask("ArcaneArts", "C://Users/arcane/Documents/development/server/plugins")
+registerCustomOutputTask("Coco", "D://mcsm/plugins")
+registerCustomOutputTask("Strange", "D://Servers/1.17 Test Server/plugins")
+registerCustomOutputTask("Vatuu", "D://Minecraft/Servers/1.19.4/plugins")
+registerCustomOutputTask("CrazyDev22", "C://Users/Julian/Desktop/server/plugins")
+registerCustomOutputTask("PixelFury", "C://Users/repix/workplace/Iris/1.21.3 - Development-Public-v3/plugins")
+registerCustomOutputTask("PixelFuryDev", "C://Users/repix/workplace/Iris/1.21 - Development-v3/plugins")
+// ========================== UNIX ==============================
+registerCustomOutputTaskUnix("CyberpwnLT", "/Users/danielmills/development/server/plugins")
+registerCustomOutputTaskUnix("PsychoLT", "/Users/brianfopiano/Developer/RemoteGit/Server/plugins")
+registerCustomOutputTaskUnix("PixelMac", "/Users/test/Desktop/mcserver/plugins")
+registerCustomOutputTaskUnix("CrazyDev22LT", "/home/julian/Desktop/server/plugins")
+// ==============================================================
+
+val serverMinHeap = "2G"
+val serverMaxHeap = "8G"
+//Valid values are: none, truecolor, indexed256, indexed16, indexed8
+val color = "truecolor"
+val errorReporting = false
+
+val nmsBindings = mapOf(
+        "v1_21_R4" to "1.21.5-R0.1-SNAPSHOT",
+        "v1_21_R3" to "1.21.4-R0.1-SNAPSHOT",
+        "v1_21_R2" to "1.21.3-R0.1-SNAPSHOT",
+        "v1_21_R1" to "1.21.1-R0.1-SNAPSHOT",
+        "v1_20_R4" to "1.20.6-R0.1-SNAPSHOT",
+        "v1_20_R3" to "1.20.4-R0.1-SNAPSHOT",
+        "v1_20_R2" to "1.20.2-R0.1-SNAPSHOT",
+        "v1_20_R1" to "1.20.1-R0.1-SNAPSHOT",
+)
+val jvmVersion = mapOf<String, Int>()
+nmsBindings.forEach { key, value ->
+    project(":nms:$key") {
+        apply<JavaPlugin>()
+        apply<NMSToolsPlugin>()
+
+        repositories {
+            maven("https://libraries.minecraft.net")
+        }
+
+        extensions.configure(NMSToolsExtension::class) {
+            jvm = jvmVersion.getOrDefault(key, 21)
+            version = value
+        }
+
+        dependencies {
+            compileOnly(project(":core"))
+            compileOnly("org.jetbrains:annotations:26.0.2")
+        }
+    }
+
+    tasks.register<RunServer>("runServer-$key") {
+        group = "servers"
+        minecraftVersion(value.split("-")[0])
+        minHeapSize = serverMinHeap
+        maxHeapSize = serverMaxHeap
+        pluginJars(tasks.jar.flatMap { it.archiveFile })
+        javaLauncher = javaToolchains.launcherFor { languageVersion = JavaLanguageVersion.of(jvmVersion.getOrDefault(key, 21))}
+        runDirectory.convention(layout.buildDirectory.dir("run/$key"))
+        systemProperty("disable.watchdog", "")
+        systemProperty("net.kyori.ansi.colorLevel", color)
+        systemProperty("com.mojang.eula.agree", true)
+        systemProperty("iris.errorReporting", errorReporting)
+    }
+}
+
+tasks {
+    jar {
+        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+        nmsBindings.forEach { key, _ ->
+            from(project(":nms:$key").tasks.named("remap").map { zipTree(it.outputs.files.singleFile) })
+        }
+        from(project(":core").tasks.shadowJar.flatMap { it.archiveFile }.map { zipTree(it) })
+        archiveFileName.set("Iris-${project.version}.jar")
+    }
+
+    register<Copy>("iris") {
+        group = "iris"
+        dependsOn("jar")
+        from(layout.buildDirectory.file("libs/Iris-${project.version}.jar"))
+        into(layout.buildDirectory)
+    }
+
+    register<Copy>("irisDev") {
+        group = "iris"
+        from(project(":core").layout.buildDirectory.files("libs/core-javadoc.jar", "libs/core-sources.jar"))
+        rename { it.replace("core", "Iris-${project.version}") }
+        into(layout.buildDirectory)
+        dependsOn(":core:sourcesJar")
+        dependsOn(":core:javadocJar")
+    }
+
+    val cli = file("sentry-cli.exe")
+    register<Download>("downloadCli") {
+        group = "io.sentry"
+        src("https://release-registry.services.sentry.io/apps/sentry-cli/latest?response=download&arch=x86_64&platform=${System.getProperty("os.name")}&package=sentry-cli")
+        dest(cli)
+
+        doLast {
+            cli.setExecutable(true)
+        }
+    }
+
+    register("release") {
+        group = "io.sentry"
+        dependsOn("downloadCli")
+        doLast {
+            val authToken = project.findProperty("sentry.auth.token") ?: System.getenv("SENTRY_AUTH_TOKEN")
+            val org = "volmit-software"
+            val projectName = "iris"
+            exec(cli, "releases", "new", "--auth-token", authToken, "-o", org, "-p", projectName, version)
+            exec(cli, "releases", "set-commits", "--auth-token", authToken, "-o", org, "-p", projectName, version, "--auto", "--ignore-missing")
+            exec(cli, "releases", "finalize", "--auth-token", authToken, "-o", org, "-p", projectName, version)
+            cli.delete()
+        }
+    }
+}
+
+fun exec(vararg command: Any) {
+    val p = ProcessBuilder(command.map { it.toString() })
+        .start()
+    p.inputStream.reader().useLines { it.forEach(::println) }
+    p.errorStream.reader().useLines { it.forEach(::println) }
+    p.waitFor()
+}
+
+dependencies {
+    implementation(project(":core"))
+}
+
+configurations.configureEach {
+    resolutionStrategy.cacheChangingModulesFor(60, "minutes")
+    resolutionStrategy.cacheDynamicVersionsFor(60, "minutes")
+}
+
+allprojects {
+    apply<JavaPlugin>()
+
+    repositories {
+        mavenCentral()
+        maven("https://repo.papermc.io/repository/maven-public/")
+        maven("https://repo.codemc.org/repository/maven-public/")
+        maven("https://mvn.lumine.io/repository/maven-public/")
+        maven("https://jitpack.io")
+
+        maven("https://s01.oss.sonatype.org/content/repositories/snapshots")
+        maven("https://mvn.lumine.io/repository/maven/")
+        maven("https://repo.triumphteam.dev/snapshots")
+        maven("https://repo.mineinabyss.com/releases")
+        maven("https://hub.jeff-media.com/nexus/repository/jeff-media-public/")
+        maven("https://repo.nexomc.com/releases/")
+    }
+
+    dependencies {
+        // Provided or Classpath
+        compileOnly("org.projectlombok:lombok:1.18.36")
+        annotationProcessor("org.projectlombok:lombok:1.18.36")
+    }
+
+    /**
+     * We need parameter meta for the decree command system
+     */
+    tasks {
+        compileJava {
+            options.compilerArgs.add("-parameters")
+            options.encoding = "UTF-8"
+        }
+
+        javadoc {
+            options.encoding = "UTF-8"
+            options.quiet()
+            //options.addStringOption("Xdoclint:none") // TODO: Re-enable this
+        }
+
+        register<Jar>("sourcesJar") {
+            archiveClassifier.set("sources")
+            from(sourceSets.main.map { it.allSource })
+        }
+
+        register<Jar>("javadocJar") {
+            archiveClassifier.set("javadoc")
+            from(javadoc.map { it.destinationDir!! })
+        }
+    }
+}
+
+if (JavaVersion.current().toString() != "21") {
+    System.err.println()
+    System.err.println("=========================================================================================================")
+    System.err.println("You must run gradle on Java 21. You are using " + JavaVersion.current())
+    System.err.println()
+    System.err.println("=== For IDEs ===")
+    System.err.println("1. Configure the project for Java 21")
+    System.err.println("2. Configure the bundled gradle to use Java 21 in settings")
+    System.err.println()
+    System.err.println("=== For Command Line (gradlew) ===")
+    System.err.println("1. Install JDK 21 from https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html")
+    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:\\Program Files\\Java\\jdk-21.0.4")
+    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
+    System.err.println("=========================================================================================================")
+    System.err.println()
+    exitProcess(69)
+}
+
+
+fun registerCustomOutputTask(name: String, path: String) {
+    if (!System.getProperty("os.name").lowercase().contains("windows")) {
+        return
+    }
+
+    tasks.register<Copy>("build$name") {
+        group = "development"
+        outputs.upToDateWhen { false }
+        dependsOn("iris")
+        from(layout.buildDirectory.file("Iris-${project.version}.jar"))
+        into(file(path))
+        rename { "Iris.jar" }
+    }
+}
+
+fun registerCustomOutputTaskUnix(name: String, path: String) {
+    if (System.getProperty("os.name").lowercase().contains("windows")) {
+        return
+    }
+
+    tasks.register<Copy>("build$name") {
+        group = "development"
+        outputs.upToDateWhen { false }
+        dependsOn("iris")
+        from(layout.buildDirectory.file("Iris-${project.version}.jar"))
+        into(file(path))
+        rename { "Iris.jar" }
+    }
+}

core/build.gradle

@@ -1,92 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2021 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-plugins {
-    id 'java'
-    id 'java-library'
-    id "io.freefair.lombok" version "8.6"
-}
-
-def apiVersion = '1.19'
-def main = 'com.volmit.iris.Iris'
-
-/**
- * We need parameter meta for the decree command system
- */
-compileJava {
-    options.compilerArgs << '-parameters'
-    options.encoding = "UTF-8"
-}
-
-repositories {
-    maven { url 'https://nexus.phoenixdevt.fr/repository/maven-public/'}
-    maven { url 'https://repo.auxilor.io/repository/maven-public/' }
-}
-
-/**
- * Dependencies.
- *
- * Provided or classpath dependencies are not shaded and are available on the runtime classpath
- *
- * Shaded dependencies are not available at runtime, nor are they available on mvn central so they
- * need to be shaded into the jar (increasing binary size)
- *
- * Dynamically loaded dependencies are defined in the plugin.yml (updating these must be updated in the
- * plugin.yml also, otherwise they wont be available). These do not increase binary size). Only declare
- * these dependencies if they are available on mvn central.
- */
-dependencies {
-    // Provided or Classpath
-    compileOnly 'org.spigotmc:spigot-api:1.20.1-R0.1-SNAPSHOT'
-    compileOnly 'org.apache.logging.log4j:log4j-api:2.19.0'
-    compileOnly 'org.apache.logging.log4j:log4j-core:2.19.0'
-    compileOnly 'commons-io:commons-io:2.13.0'
-    compileOnly 'commons-lang:commons-lang:2.6'
-    compileOnly 'com.github.oshi:oshi-core:5.8.5'
-    compileOnly 'org.lz4:lz4-java:1.8.0'
-
-    // Third Party Integrations
-    compileOnly 'com.ticxo.playeranimator:PlayerAnimator:R1.2.7'
-    compileOnly 'io.th0rgal:oraxen:1.173.0'
-    compileOnly 'com.github.LoneDev6:api-itemsadder:3.4.1-r4'
-    compileOnly 'com.github.PlaceholderAPI:placeholderapi:2.11.3'
-    compileOnly 'com.github.Ssomar-Developement:SCore:4.23.10.8'
-    compileOnly 'net.Indyuce:MMOItems-API:6.9.5-SNAPSHOT'
-    compileOnly 'com.willfp:EcoItems:5.44.0'
-    //implementation files('libs/CustomItems.jar')
-}
-
-
-/**
- * Gradle is weird sometimes, we need to delete the plugin yml from the build folder to actually filter properly.
- */
-file(jar.archiveFile.get().getAsFile().getParentFile().getParentFile().getParentFile().getAbsolutePath() + '/build/resources/main/plugin.yml').delete()
-
-/**
- * Expand properties into plugin yml
- */
-processResources {
-    filesMatching('**/plugin.yml') {
-        expand(
-                'name': rootProject.name.toString(),
-                'version': rootProject.version.toString(),
-                'main': main.toString(),
-                'apiversion': apiVersion.toString()
-        )
-    }
-}

core/build.gradle.kts

@@ -0,0 +1,151 @@
+/*
+ * Iris is a World Generator for Minecraft Bukkit Servers
+ * Copyright (c) 2021 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    java
+    `java-library`
+    id("com.gradleup.shadow")
+    id("io.sentry.jvm.gradle")
+}
+
+val apiVersion = "1.19"
+val main = "com.volmit.iris.Iris"
+
+repositories {
+    maven("https://nexus.phoenixdevt.fr/repository/maven-public/")
+    maven("https://repo.auxilor.io/repository/maven-public/")
+}
+
+/**
+ * Dependencies.
+ *
+ * Provided or classpath dependencies are not shaded and are available on the runtime classpath
+ *
+ * Shaded dependencies are not available at runtime, nor are they available on mvn central so they
+ * need to be shaded into the jar (increasing binary size)
+ *
+ * Dynamically loaded dependencies are defined in the plugin.yml (updating these must be updated in the
+ * plugin.yml also, otherwise they wont be available). These do not increase binary size). Only declare
+ * these dependencies if they are available on mvn central.
+ */
+dependencies {
+    // Provided or Classpath
+    compileOnly("org.spigotmc:spigot-api:1.20.1-R0.1-SNAPSHOT")
+    compileOnly("org.apache.logging.log4j:log4j-api:2.19.0")
+    compileOnly("org.apache.logging.log4j:log4j-core:2.19.0")
+    compileOnly("commons-io:commons-io:2.13.0")
+    compileOnly("commons-lang:commons-lang:2.6")
+    compileOnly("com.github.oshi:oshi-core:5.8.5")
+    compileOnly("org.lz4:lz4-java:1.8.0")
+
+    // Third Party Integrations
+    compileOnly("com.nexomc:nexo:1.6.0")
+    compileOnly("com.github.LoneDev6:api-itemsadder:3.4.1-r4")
+    compileOnly("com.github.PlaceholderAPI:placeholderapi:2.11.3")
+    compileOnly("com.github.Ssomar-Developement:SCore:4.23.10.8")
+    compileOnly("net.Indyuce:MMOItems-API:6.9.5-SNAPSHOT")
+    compileOnly("com.willfp:EcoItems:5.44.0")
+    //implementation files("libs/CustomItems.jar")
+
+
+    // Shaded
+    implementation("com.dfsek:paralithic:0.8.1")
+    implementation("io.papermc:paperlib:1.0.5")
+    implementation("net.kyori:adventure-text-minimessage:4.17.0")
+    implementation("net.kyori:adventure-platform-bukkit:4.3.4")
+    implementation("net.kyori:adventure-api:4.17.0")
+    implementation("org.bstats:bstats-bukkit:3.1.0")
+
+    //implementation("org.bytedeco:javacpp:1.5.10")
+    //implementation("org.bytedeco:cuda-platform:12.3-8.9-1.5.10")
+    compileOnly("io.lumine:Mythic-Dist:5.2.1")
+    compileOnly("io.lumine:MythicCrucible-Dist:2.0.0")
+
+    // Dynamically Loaded
+    compileOnly("io.timeandspace:smoothie-map:2.0.2")
+    compileOnly("it.unimi.dsi:fastutil:8.5.8")
+    compileOnly("com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2")
+    compileOnly("org.zeroturnaround:zt-zip:1.14")
+    compileOnly("com.google.code.gson:gson:2.10.1")
+    compileOnly("org.ow2.asm:asm:9.2")
+    compileOnly("com.google.guava:guava:33.0.0-jre")
+    compileOnly("bsf:bsf:2.4.0")
+    compileOnly("rhino:js:1.7R2")
+    compileOnly("com.github.ben-manes.caffeine:caffeine:3.0.6")
+    compileOnly("org.apache.commons:commons-lang3:3.12.0")
+    compileOnly("com.github.oshi:oshi-core:6.6.5")
+}
+
+java {
+    disableAutoTargetJvm()
+}
+
+sentry {
+    includeSourceContext = true
+
+    org = "volmit-software"
+    projectName = "iris"
+    authToken = findProperty("sentry.auth.token") as String? ?: System.getenv("SENTRY_AUTH_TOKEN")
+}
+
+tasks {
+    /**
+     * We need parameter meta for the decree command system
+     */
+    compileJava {
+        options.compilerArgs.add("-parameters")
+        options.encoding = "UTF-8"
+    }
+
+    /**
+     * Expand properties into plugin yml
+     */
+    processResources {
+        inputs.properties(
+            "name" to rootProject.name,
+            "version" to rootProject.version,
+            "apiVersion" to apiVersion,
+            "main" to main
+        )
+        filesMatching("**/plugin.yml") {
+            expand(inputs.properties)
+        }
+    }
+
+    shadowJar {
+        mergeServiceFiles()
+        relocate("com.dfsek.paralithic", "com.volmit.iris.util.paralithic")
+        relocate("io.papermc.lib", "com.volmit.iris.util.paper")
+        relocate("net.kyori", "com.volmit.iris.util.kyori")
+        relocate("org.bstats", "com.volmit.iris.util.metrics")
+        relocate("io.sentry", "com.volmit.iris.util.sentry")
+
+        //minimize()
+        dependencies {
+            exclude(dependency("org.ow2.asm:asm:"))
+            exclude(dependency("org.jetbrains:"))
+        }
+    }
+}
+
+/**
+ * Gradle is weird sometimes, we need to delete the plugin yml from the build folder to actually filter properly.
+ */
+afterEvaluate {
+    layout.buildDirectory.file("resources/main/plugin.yml").get().asFile.delete()
+}

core/src/main/java/com/volmit/iris/core/IrisSettings.java

@@ -23,9 +23,11 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONException;
 import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.misc.getHardware;
 import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.ChronoLatch;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.io.File;
 import java.io.IOException;
@@ -42,6 +44,9 @@ public class IrisSettings {
     private IrisSettingsConcurrency concurrency = new IrisSettingsConcurrency();
     private IrisSettingsStudio studio = new IrisSettingsStudio();
     private IrisSettingsPerformance performance = new IrisSettingsPerformance();
+    private IrisSettingsUpdater updater = new IrisSettingsUpdater();
+    private IrisSettingsPregen pregen = new IrisSettingsPregen();
+    private IrisSettingsSentry sentry = new IrisSettingsSentry();
 
     public static int getThreadCount(int c) {
         return switch (c) {
@@ -127,21 +132,70 @@ public class IrisSettings {
         public boolean markerEntitySpawningSystem = true;
         public boolean effectSystem = true;
         public boolean worldEditWandCUI = true;
+        public boolean globalPregenCache = false;
     }
 
     @Data
     public static class IrisSettingsConcurrency {
         public int parallelism = -1;
+        public int worldGenParallelism = -1;
+
+        public int getWorldGenThreads() {
+            return getThreadCount(worldGenParallelism);
+        }
+    }
+
+    @Data
+    public static class IrisSettingsPregen {
+        public boolean useCacheByDefault = true;
+        public boolean useHighPriority = false;
+        public boolean useVirtualThreads = false;
+        public boolean useTicketQueue = false;
+        public int maxConcurrency = 256;
     }
 
     @Data
     public static class IrisSettingsPerformance {
+        private IrisSettingsEngineSVC engineSVC = new IrisSettingsEngineSVC();
         public boolean trimMantleInStudio = false; 
         public int mantleKeepAlive = 30;
         public int cacheSize = 4_096;
         public int resourceLoaderCacheSize = 1_024;
         public int objectLoaderCacheSize = 4_096;
         public int scriptLoaderCacheSize = 512;
+        public int tectonicPlateSize = -1;
+        public int mantleCleanupDelay = 200;
+
+        public int getTectonicPlateSize() {
+            if (tectonicPlateSize > 0)
+                return tectonicPlateSize;
+
+            return (int) (getHardware.getProcessMemory() / 200L);
+        }
+    }
+
+    @Data
+    public static class IrisSettingsUpdater {
+        public double threadMultiplier = 2;
+        public double chunkLoadSensitivity = 0.7;
+        public MsRange emptyMsRange = new MsRange(80, 100);
+        public MsRange defaultMsRange = new MsRange(20, 40);
+
+        public double getThreadMultiplier() {
+            return Math.min(Math.abs(threadMultiplier), 0.1);
+        }
+
+        public double getChunkLoadSensitivity() {
+            return Math.min(chunkLoadSensitivity, 0.9);
+        }
+    }
+
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class MsRange {
+        public int min = 20;
+        public int max = 40;
     }
 
     @Data
@@ -149,11 +203,13 @@ public class IrisSettings {
         public boolean DoomsdayAnnihilationSelfDestructMode = false;
         public boolean commandSounds = true;
         public boolean debug = false;
+        public boolean dumpMantleOnError = false;
         public boolean disableNMS = false;
         public boolean pluginMetrics = true;
         public boolean splashLogoStartup = true;
         public boolean useConsoleCustomColors = true;
         public boolean useCustomColorsIngame = true;
+        public boolean adjustVanillaHeight = false;
         public String forceMainWorld = "";
         public int spinh = -20;
         public int spins = 7;
@@ -167,6 +223,13 @@ public class IrisSettings {
         }
     }
 
+    @Data
+    public static class IrisSettingsSentry {
+        public boolean includeServerId = true;
+        public boolean disableAutoReporting = false;
+        public boolean debug = false;
+    }
+
     @Data
     public static class IrisSettingsGUI {
         public boolean useServerLaunchedGuis = true;
@@ -188,4 +251,14 @@ public class IrisSettings {
         public boolean disableTimeAndWeather = true;
         public boolean autoStartDefaultStudio = false;
     }
+
+    @Data
+    public static class IrisSettingsEngineSVC {
+        public boolean useVirtualThreads = true;
+        public int priority = Thread.NORM_PRIORITY;
+
+        public int getPriority() {
+            return Math.max(Math.min(priority, Thread.MAX_PRIORITY), Thread.MIN_PRIORITY);
+        }
+    }
 }

core/src/main/java/com/volmit/iris/core/ServerConfigurator.java

@@ -28,20 +28,28 @@ import com.volmit.iris.engine.object.IrisBiomeCustom;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.object.IrisRange;
 import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.misc.ServerProperties;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
+import lombok.Data;
+import lombok.NonNull;
 import org.bukkit.Bukkit;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.List;
+import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+
+import static com.volmit.iris.core.nms.datapack.IDataFixer.Dimension.*;
 
 public class ServerConfigurator {
     public static void configure() {
@@ -63,10 +71,12 @@ public class ServerConfigurator {
         f.load(spigotConfig);
         long tt = f.getLong("settings.timeout-time");
 
-        if (tt < TimeUnit.MINUTES.toSeconds(5)) {
-            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + TimeUnit.MINUTES.toSeconds(20) + " (5 minutes)");
+        long spigotTimeout = TimeUnit.MINUTES.toSeconds(5);
+
+        if (tt < spigotTimeout) {
+            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + spigotTimeout + " (5 minutes)");
             Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
-            f.set("settings.timeout-time", TimeUnit.MINUTES.toSeconds(5));
+            f.set("settings.timeout-time", spigotTimeout);
             f.save(spigotConfig);
         }
     }
@@ -76,20 +86,22 @@ public class ServerConfigurator {
         f.load(spigotConfig);
         long tt = f.getLong("watchdog.early-warning-delay");
 
-        if (tt < TimeUnit.MINUTES.toMillis(3)) {
-            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + TimeUnit.MINUTES.toMillis(15) + " (3 minutes)");
+        long watchdog = TimeUnit.MINUTES.toMillis(3);
+        if (tt < watchdog) {
+            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + watchdog + " (3 minutes)");
             Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
-            f.set("watchdog.early-warning-delay", TimeUnit.MINUTES.toMillis(3));
+            f.set("watchdog.early-warning-delay", watchdog);
             f.save(spigotConfig);
         }
     }
 
-    private static List<File> getDatapacksFolder() {
+    private static KList<File> getDatapacksFolder() {
         if (!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
             return new KList<File>().qadd(new File(Bukkit.getWorldContainer(), IrisSettings.get().getGeneral().forceMainWorld + "/datapacks"));
         }
         KList<File> worlds = new KList<>();
         Bukkit.getServer().getWorlds().forEach(w -> worlds.add(new File(w.getWorldFolder(), "datapacks")));
+        if (worlds.isEmpty()) worlds.add(new File(Bukkit.getWorldContainer(), ServerProperties.LEVEL_NAME + "/datapacks"));
         return worlds;
     }
 
@@ -99,57 +111,17 @@ public class ServerConfigurator {
 
     public static void installDataPacks(IDataFixer fixer, boolean fullInstall) {
         Iris.info("Checking Data Packs...");
-        File packs = new File("plugins/Iris/packs");
-        double ultimateMaxHeight = 0;
-        double ultimateMinHeight = 0;
-        if (packs.exists() && packs.isDirectory()) {
-            for (File pack : packs.listFiles()) {
-                IrisData data = IrisData.get(pack);
-                if (pack.isDirectory()) {
-                    File dimensionsFolder = new File(pack, "dimensions");
-                    if (dimensionsFolder.exists() && dimensionsFolder.isDirectory()) {
-                        for (File file : dimensionsFolder.listFiles()) {
-                            if (file.isFile() && file.getName().endsWith(".json")) {
-                                IrisDimension dim = data.getDimensionLoader().load(file.getName().split("\\Q.\\E")[0]);
-                                if (ultimateMaxHeight < dim.getDimensionHeight().getMax()) {
-                                    ultimateMaxHeight = dim.getDimensionHeight().getMax();
-                                }
-                                if (ultimateMinHeight > dim.getDimensionHeight().getMin()) {
-                                    ultimateMinHeight = dim.getDimensionHeight().getMin();
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
+        DimensionHeight height = new DimensionHeight(fixer);
+        KList<File> folders = getDatapacksFolder();
+        KMap<String, KSet<String>> biomes = new KMap<>();
 
-        if (packs.exists()) {
-            for (File i : packs.listFiles()) {
-                if (i.isDirectory()) {
-                    Iris.verbose("Checking Pack: " + i.getPath());
-                    IrisData data = IrisData.get(i);
-                    File dims = new File(i, "dimensions");
-
-                    if (dims.exists()) {
-                        for (File j : dims.listFiles()) {
-                            if (j.getName().endsWith(".json")) {
-                                IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
-
-                                if (dim == null) {
-                                    continue;
-                                }
-
-                                Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
-                                for (File dpack : getDatapacksFolder()) {
-                                    dim.installDataPack(fixer, () -> data, dpack, ultimateMaxHeight, ultimateMinHeight);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
+        allPacks().flatMap(height::merge)
+                .parallel()
+                .forEach(dim -> {
+                    Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
+                    dim.installBiomes(fixer, dim::getLoader, folders, biomes.computeIfAbsent(dim.getLoadKey(), k -> new KSet<>()));
+                });
+        IrisDimension.writeShared(folders, height);
 
         Iris.info("Data Packs Setup!");
 
@@ -158,57 +130,40 @@ public class ServerConfigurator {
     }
 
     private static void verifyDataPacksPost(boolean allowRestarting) {
-        File packs = new File("plugins/Iris/packs");
+        boolean bad = allPacks()
+                .map(data -> {
+                    Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
+                    var loader = data.getDimensionLoader();
+                    return loader.loadAll(loader.getPossibleKeys())
+                            .stream()
+                            .map(ServerConfigurator::verifyDataPackInstalled)
+                            .toList()
+                            .contains(false);
+                })
+                .toList()
+                .contains(true);
+        if (!bad) return;
 
-        boolean bad = false;
-        if (packs.exists()) {
-            for (File i : packs.listFiles()) {
-                if (i.isDirectory()) {
-                    Iris.verbose("Checking Pack: " + i.getPath());
-                    IrisData data = IrisData.get(i);
-                    File dims = new File(i, "dimensions");
 
-                    if (dims.exists()) {
-                        for (File j : dims.listFiles()) {
-                            if (j.getName().endsWith(".json")) {
-                                IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
+        if (allowRestarting) {
+            restart();
+        } else if (INMS.get().supportsDataPacks()) {
+            Iris.error("============================================================================");
+            Iris.error(C.ITALIC + "You need to restart your server to properly generate custom biomes.");
+            Iris.error(C.ITALIC + "By continuing, Iris will use backup biomes in place of the custom biomes.");
+            Iris.error("----------------------------------------------------------------------------");
+            Iris.error(C.UNDERLINE + "IT IS HIGHLY RECOMMENDED YOU RESTART THE SERVER BEFORE GENERATING!");
+            Iris.error("============================================================================");
 
-                                if (dim == null) {
-                                    Iris.error("Failed to load " + j.getPath() + " ");
-                                    continue;
-                                }
-
-                                if (!verifyDataPackInstalled(dim)) {
-                                    bad = true;
-                                }
-                            }
-                        }
-                    }
+            for (Player i : Bukkit.getOnlinePlayers()) {
+                if (i.isOp() || i.hasPermission("iris.all")) {
+                    VolmitSender sender = new VolmitSender(i, Iris.instance.getTag("WARNING"));
+                    sender.sendMessage("There are some Iris Packs that have custom biomes in them");
+                    sender.sendMessage("You need to restart your server to use these packs.");
                 }
             }
-        }
 
-        if (bad) {
-            if (allowRestarting) {
-                restart();
-            } else if (INMS.get().supportsDataPacks()) {
-                Iris.error("============================================================================");
-                Iris.error(C.ITALIC + "You need to restart your server to properly generate custom biomes.");
-                Iris.error(C.ITALIC + "By continuing, Iris will use backup biomes in place of the custom biomes.");
-                Iris.error("----------------------------------------------------------------------------");
-                Iris.error(C.UNDERLINE + "IT IS HIGHLY RECOMMENDED YOU RESTART THE SERVER BEFORE GENERATING!");
-                Iris.error("============================================================================");
-
-                for (Player i : Bukkit.getOnlinePlayers()) {
-                    if (i.isOp() || i.hasPermission("iris.all")) {
-                        VolmitSender sender = new VolmitSender(i, Iris.instance.getTag("WARNING"));
-                        sender.sendMessage("There are some Iris Packs that have custom biomes in them");
-                        sender.sendMessage("You need to restart your server to use these packs.");
-                    }
-                }
-
-                J.sleep(3000);
-            }
+            J.sleep(3000);
         }
     }
 
@@ -218,7 +173,7 @@ public class ServerConfigurator {
             Iris.warn("This will only happen when your pack changes (updates/first time setup)");
             Iris.warn("(You can disable this auto restart in iris settings)");
             J.s(() -> {
-                Iris.warn("Looks like the restart command diddn't work. Stopping the server instead!");
+                Iris.warn("Looks like the restart command didn't work. Stopping the server instead!");
                 Bukkit.shutdown();
             }, 100);
             Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "restart");
@@ -226,22 +181,24 @@ public class ServerConfigurator {
     }
 
     public static boolean verifyDataPackInstalled(IrisDimension dimension) {
-        IrisData idm = IrisData.get(Iris.instance.getDataFolder("packs", dimension.getLoadKey()));
         KSet<String> keys = new KSet<>();
         boolean warn = false;
 
-        for (IrisBiome i : dimension.getAllBiomes(() -> idm)) {
+        for (IrisBiome i : dimension.getAllBiomes(dimension::getLoader)) {
             if (i.isCustom()) {
                 for (IrisBiomeCustom j : i.getCustomDerivitives()) {
                     keys.add(dimension.getLoadKey() + ":" + j.getId());
                 }
             }
         }
+        String key = getWorld(dimension.getLoader());
+        if (key == null) key = dimension.getLoadKey();
+        else key += "/" + dimension.getLoadKey();
 
         if (!INMS.get().supportsDataPacks()) {
             if (!keys.isEmpty()) {
                 Iris.warn("===================================================================================");
-                Iris.warn("Pack " + dimension.getLoadKey() + " has " + keys.size() + " custom biome(s). ");
+                Iris.warn("Pack " + key + " has " + keys.size() + " custom biome(s). ");
                 Iris.warn("Your server version does not yet support datapacks for iris.");
                 Iris.warn("The world will generate these biomes as backup biomes.");
                 Iris.warn("====================================================================================");
@@ -260,10 +217,74 @@ public class ServerConfigurator {
         }
 
         if (warn) {
-            Iris.error("The Pack " + dimension.getLoadKey() + " is INCAPABLE of generating custom biomes");
+            Iris.error("The Pack " + key + " is INCAPABLE of generating custom biomes");
             Iris.error("If not done automatically, restart your server before generating with this pack!");
         }
 
         return !warn;
     }
+
+    public static Stream<IrisData> allPacks() {
+        return Stream.concat(listFiles(new File("plugins/Iris/packs")),
+                        listFiles(Bukkit.getWorldContainer()).map(w -> new File(w, "iris/pack")))
+                .filter(File::isDirectory)
+                .map(IrisData::get);
+    }
+
+    @Nullable
+    public static String getWorld(@NonNull IrisData data) {
+        String worldContainer = Bukkit.getWorldContainer().getAbsolutePath();
+        if (!worldContainer.endsWith(File.separator)) worldContainer += File.separator;
+        
+        String path = data.getDataFolder().getAbsolutePath();
+        if (!path.startsWith(worldContainer)) return null;
+        int l = path.endsWith(File.separator) ? 11 : 10;
+        return path.substring(worldContainer.length(), path.length() - l);
+    }
+
+    private static Stream<File> listFiles(File parent) {
+        var files = parent.listFiles();
+        return files == null ? Stream.empty() : Arrays.stream(files);
+    }
+
+    @Data
+    public static class DimensionHeight {
+        private final IDataFixer fixer;
+        private IrisRange overworld = new IrisRange();
+        private IrisRange nether = new IrisRange();
+        private IrisRange end = new IrisRange();
+        private int logicalOverworld = 0;
+        private int logicalNether = 0;
+        private int logicalEnd = 0;
+
+        public Stream<IrisDimension> merge(IrisData data) {
+            Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
+            var loader = data.getDimensionLoader();
+            return loader.loadAll(loader.getPossibleKeys())
+                    .stream()
+                    .peek(this::merge);
+        }
+
+        public void merge(IrisDimension dimension) {
+            overworld.merge(dimension.getDimensionHeight());
+            nether.merge(dimension.getDimensionHeight());
+            end.merge(dimension.getDimensionHeight());
+
+            logicalOverworld = Math.max(logicalOverworld, dimension.getLogicalHeight());
+            logicalNether = Math.max(logicalNether, dimension.getLogicalHeightNether());
+            logicalEnd = Math.max(logicalEnd, dimension.getLogicalHeightEnd());
+        }
+
+        public String overworldType() {
+            return fixer.createDimension(OVERRWORLD, overworld, logicalOverworld).toString(4);
+        }
+
+        public String netherType() {
+            return fixer.createDimension(NETHER, nether, logicalNether).toString(4);
+        }
+
+        public String endType() {
+            return fixer.createDimension(THE_END, end, logicalEnd).toString(4);
+        }
+    }
 }

core/src/main/java/com/volmit/iris/core/commands/CommandDeepSearch.java

@@ -1,134 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.pregenerator.DeepSearchPregenerator;
-import com.volmit.iris.core.pregenerator.PregenTask;
-import com.volmit.iris.core.pregenerator.TurboPregenerator;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.util.data.Dimension;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.math.Position2;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.IOException;
-
-@Decree(name = "DeepSearch", aliases = "search", description = "Pregenerate your Iris worlds!")
-public class CommandDeepSearch implements DecreeExecutor {
-    public String worldName;
-    @Decree(description = "DeepSearch a world")
-    public void start(
-            @Param(description = "The radius of the pregen in blocks", aliases = "size")
-            int radius,
-            @Param(description = "The world to pregen", contextual = true)
-            World world,
-            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
-            Vector center
-            ) {
-
-        worldName = world.getName();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File TurboFile = new File(worldDirectory, "DeepSearch.json");
-        if (TurboFile.exists()) {
-            if (DeepSearchPregenerator.getInstance() != null) {
-                sender().sendMessage(C.BLUE + "DeepSearch is already in progress");
-                Iris.info(C.YELLOW + "DeepSearch is already in progress");
-                return;
-            } else {
-                try {
-                    TurboFile.delete();
-                } catch (Exception e){
-                   Iris.error("Failed to delete the old instance file of DeepSearch!");
-                   return;
-                }
-            }
-        }
-
-        try {
-            if (sender().isPlayer() && access() == null) {
-                sender().sendMessage(C.RED + "The engine access for this world is null!");
-                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
-            }
-
-            DeepSearchPregenerator.DeepSearchJob DeepSearchJob = DeepSearchPregenerator.DeepSearchJob.builder()
-                    .world(world)
-                    .radiusBlocks(radius)
-                    .position(0)
-                    .build();
-
-            File SearchGenFile = new File(worldDirectory, "DeepSearch.json");
-            DeepSearchPregenerator pregenerator = new DeepSearchPregenerator(DeepSearchJob, SearchGenFile);
-            pregenerator.start();
-
-            String msg = C.GREEN + "DeepSearch started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
-            sender().sendMessage(msg);
-            Iris.info(msg);
-        } catch (Throwable e) {
-            sender().sendMessage(C.RED + "Epic fail. See console.");
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Stop the active DeepSearch task", aliases = "x")
-    public void stop(@Param(aliases = "world", description = "The world to pause") World world) throws IOException {
-        DeepSearchPregenerator DeepSearchInstance = DeepSearchPregenerator.getInstance();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File turboFile = new File(worldDirectory, "DeepSearch.json");
-
-        if (DeepSearchInstance != null) {
-            DeepSearchInstance.shutdownInstance(world);
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
-        } else if (turboFile.exists() && turboFile.delete()) {
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
-        } else if (turboFile.exists()) {
-            Iris.error("Failed to delete the old instance file of Turbo Pregen!");
-        } else {
-            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
-        }
-    }
-
-    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
-    public void pause(
-            @Param(aliases = "world", description = "The world to pause")
-            World world
-    ) {
-        if (TurboPregenerator.getInstance() != null) {
-            TurboPregenerator.setPausedTurbo(world);
-            sender().sendMessage(C.GREEN + "Paused/unpaused Turbo Pregen, now: " + (TurboPregenerator.isPausedTurbo(world) ? "Paused" : "Running") + ".");
-        } else {
-            File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-            File TurboFile = new File(worldDirectory, "DeepSearch.json");
-            if (TurboFile.exists()){
-                TurboPregenerator.loadTurboGenerator(world.getName());
-                sender().sendMessage(C.YELLOW + "Started DeepSearch back up!");
-            } else {
-                sender().sendMessage(C.YELLOW + "No active DeepSearch tasks to pause/unpause.");
-            }
-
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java

@@ -20,37 +20,27 @@ package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.ServerConfigurator;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.nms.datapack.DataVersion;
-import com.volmit.iris.core.nms.v1X.NMSBinding1X;
-import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.service.IrisEngineSVC;
-import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.mantle.components.MantleObjectComponent;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisCave;
 import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisEntity;
-import com.volmit.iris.util.data.Dimension;
+import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.CountingDataInputStream;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.mantle.TectonicPlate;
-import com.volmit.iris.util.math.Spiraler;
-import com.volmit.iris.util.math.Vector3d;
+import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.nbt.mca.MCAFile;
 import com.volmit.iris.util.nbt.mca.MCAUtil;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.plugin.VolmitSender;
-import io.lumine.mythic.bukkit.adapters.BukkitEntity;
 import net.jpountz.lz4.LZ4BlockInputStream;
 import net.jpountz.lz4.LZ4BlockOutputStream;
 import net.jpountz.lz4.LZ4FrameInputStream;
@@ -58,10 +48,7 @@ import net.jpountz.lz4.LZ4FrameOutputStream;
 import org.apache.commons.lang.RandomStringUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
-import org.bukkit.Location;
 import org.bukkit.World;
-import org.bukkit.entity.Creeper;
-import org.bukkit.entity.EntityType;
 
 import java.io.*;
 import java.net.InetAddress;
@@ -76,57 +63,56 @@ import java.util.zip.GZIPOutputStream;
 @Decree(name = "Developer", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"dev"})
 public class CommandDeveloper implements DecreeExecutor {
     private CommandTurboPregen turboPregen;
+    private CommandLazyPregen lazyPregen;
     private CommandUpdater updater;
 
     @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, sync = true)
     public void EngineStatus() {
-        List<World> IrisWorlds = new ArrayList<>();
-        int TotalLoadedChunks = 0;
-        int TotalQueuedTectonicPlates = 0;
-        int TotalNotQueuedTectonicPlates = 0;
-        int TotalTectonicPlates = 0;
+        Iris.service(IrisEngineSVC.class)
+                .engineStatus(sender());
+    }
 
-        long lowestUnloadDuration = 0;
-        long highestUnloadDuration = 0;
+    @Decree(description = "Send a test exception to sentry")
+    public void Sentry() {
+        Engine engine = engine();
+        if (engine != null) IrisContext.getOr(engine);
+        Iris.reportError(new Exception("This is a test"));
+    }
 
-        for (World world : Bukkit.getWorlds()) {
-            try {
-                if (IrisToolbelt.access(world).getEngine() != null) {
-                    IrisWorlds.add(world);
+    @Decree(description = "Test")
+    public void dumpThreads() {
+        try {
+            File fi = Iris.instance.getDataFile("dump", "td-" + new java.sql.Date(M.ms()) + ".txt");
+            FileOutputStream fos = new FileOutputStream(fi);
+            Map<Thread, StackTraceElement[]> f = Thread.getAllStackTraces();
+            PrintWriter pw = new PrintWriter(fos);
+
+            pw.println(Thread.activeCount() + "/" + f.size());
+            var run = Runtime.getRuntime();
+            pw.println("Memory:");
+            pw.println("\tMax: " + run.maxMemory());
+            pw.println("\tTotal: " + run.totalMemory());
+            pw.println("\tFree: " + run.freeMemory());
+            pw.println("\tUsed: " + (run.totalMemory() - run.freeMemory()));
+
+            for (Thread i : f.keySet()) {
+                pw.println("========================================");
+                pw.println("Thread: '" + i.getName() + "' ID: " + i.getId() + " STATUS: " + i.getState().name());
+
+                for (StackTraceElement j : f.get(i)) {
+                    pw.println("    @ " + j.toString());
                 }
-            } catch (Exception e) {
-                // no
-            }
-        }
 
-        for (World world : IrisWorlds) {
-            Engine engine = IrisToolbelt.access(world).getEngine();
-            TotalQueuedTectonicPlates += (int) engine.getMantle().getToUnload();
-            TotalNotQueuedTectonicPlates += (int) engine.getMantle().getNotQueuedLoadedRegions();
-            TotalTectonicPlates += engine.getMantle().getLoadedRegionCount();
-            if (highestUnloadDuration <= (long) engine.getMantle().getTectonicDuration()) {
-                highestUnloadDuration = (long) engine.getMantle().getTectonicDuration();
-            }
-            if (lowestUnloadDuration >= (long) engine.getMantle().getTectonicDuration()) {
-                lowestUnloadDuration = (long) engine.getMantle().getTectonicDuration();
-            }
-            for (Chunk chunk : world.getLoadedChunks()) {
-                if (chunk.isLoaded()) {
-                    TotalLoadedChunks++;
-                }
+                pw.println("========================================");
+                pw.println();
+                pw.println();
             }
+
+            pw.close();
+            Iris.info("DUMPED! See " + fi.getAbsolutePath());
+        } catch (Throwable e) {
+            e.printStackTrace();
         }
-        Iris.info("-------------------------");
-        Iris.info(C.DARK_PURPLE + "Engine Status");
-        Iris.info(C.DARK_PURPLE + "Total Loaded Chunks: " + C.LIGHT_PURPLE + TotalLoadedChunks);
-        Iris.info(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + IrisEngineSVC.getTectonicLimit());
-        Iris.info(C.DARK_PURPLE + "Tectonic Total Plates: " + C.LIGHT_PURPLE + TotalTectonicPlates);
-        Iris.info(C.DARK_PURPLE + "Tectonic Active Plates: " + C.LIGHT_PURPLE + TotalNotQueuedTectonicPlates);
-        Iris.info(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + TotalQueuedTectonicPlates);
-        Iris.info(C.DARK_PURPLE + "Lowest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(lowestUnloadDuration));
-        Iris.info(C.DARK_PURPLE + "Highest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(highestUnloadDuration));
-        Iris.info(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
-        Iris.info("-------------------------");
     }
 
     @Decree(description = "Test")
@@ -142,7 +128,7 @@ public class CommandDeveloper implements DecreeExecutor {
 
         File tectonicplates = new File(folder, "mantle");
         for (File i : Objects.requireNonNull(tectonicplates.listFiles())) {
-            TectonicPlate.read(maxHeight, i);
+            TectonicPlate.read(maxHeight, i, true);
             c++;
             Iris.info("Loaded count: " + c );
 
@@ -152,12 +138,14 @@ public class CommandDeveloper implements DecreeExecutor {
 
     @Decree(description = "Test")
     public void packBenchmark(
-            @Param(description = "The pack to bench", aliases = {"pack"})
-            IrisDimension dimension
+            @Param(description = "The pack to bench", aliases = {"pack"}, defaultValue = "overworld")
+            IrisDimension dimension,
+            @Param(description = "Radius in regions", defaultValue = "2048")
+            int radius,
+            @Param(description = "Open GUI while benchmarking", defaultValue = "false")
+            boolean gui
     ) {
-        Iris.info("test");
-        IrisPackBenchmarking benchmark = new IrisPackBenchmarking(dimension, 1);
-
+        new IrisPackBenchmarking(dimension, radius, gui);
     }
 
     @Decree(description = "Upgrade to another Minecraft version")
@@ -246,7 +234,8 @@ public class CommandDeveloper implements DecreeExecutor {
             @Param(description = "base IrisWorld") World world,
             @Param(description = "raw TectonicPlate File") String path,
             @Param(description = "Algorithm to Test") String algorithm,
-            @Param(description = "Amount of Tests") int amount) {
+            @Param(description = "Amount of Tests") int amount,
+            @Param(description = "Is versioned", defaultValue = "false") boolean versioned) {
         if (!IrisToolbelt.isIrisWorld(world)) {
             sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
             return;
@@ -262,8 +251,8 @@ public class CommandDeveloper implements DecreeExecutor {
             VolmitSender sender = sender();
             service.submit(() -> {
                 try {
-                    DataInputStream raw = new DataInputStream(new FileInputStream(file));
-                    TectonicPlate plate = new TectonicPlate(height, raw);
+                    CountingDataInputStream raw = CountingDataInputStream.wrap(new FileInputStream(file));
+                    TectonicPlate plate = new TectonicPlate(height, raw, versioned);
                     raw.close();
 
                     double d1 = 0;
@@ -281,8 +270,8 @@ public class CommandDeveloper implements DecreeExecutor {
                         if (size == 0)
                             size = tmp.length();
                         start = System.currentTimeMillis();
-                        DataInputStream din = createInput(tmp, algorithm);
-                        new TectonicPlate(height, din);
+                        CountingDataInputStream din = createInput(tmp, algorithm);
+                        new TectonicPlate(height, din, true);
                         din.close();
                         d2 += System.currentTimeMillis() - start;
                         tmp.delete();
@@ -301,10 +290,10 @@ public class CommandDeveloper implements DecreeExecutor {
         }
     }
 
-    private DataInputStream createInput(File file, String algorithm) throws Throwable {
+    private CountingDataInputStream createInput(File file, String algorithm) throws Throwable {
         FileInputStream in = new FileInputStream(file);
 
-        return new DataInputStream(switch (algorithm) {
+        return CountingDataInputStream.wrap(switch (algorithm) {
             case "gzip" -> new GZIPInputStream(in);
             case "lz4f" -> new LZ4FrameInputStream(in);
             case "lz4b" -> new LZ4BlockInputStream(in);

core/src/main/java/com/volmit/iris/core/commands/CommandIris.java

@@ -20,12 +20,10 @@ package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.datapack.DataVersion;
+import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.tools.IrisBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisDimension;
@@ -43,9 +41,7 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
-import lombok.Getter;
 import org.bukkit.Bukkit;
-import org.bukkit.Difficulty;
 import org.bukkit.World;
 import org.bukkit.WorldCreator;
 import org.bukkit.configuration.ConfigurationSection;
@@ -55,16 +51,13 @@ import org.bukkit.entity.Player;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.scheduler.BukkitRunnable;
 
-import java.io.Console;
 import java.io.File;
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 import static com.volmit.iris.Iris.service;
 import static com.volmit.iris.core.service.EditSVC.deletingWorld;
-import static com.volmit.iris.core.tools.IrisBenchmarking.inProgress;
 import static com.volmit.iris.core.safeguard.IrisSafeguard.unstablemode;
 import static com.volmit.iris.core.safeguard.ServerBootSFG.incompatibilities;
 import static org.bukkit.Bukkit.getServer;
@@ -73,14 +66,12 @@ import static org.bukkit.Bukkit.getServer;
 public class CommandIris implements DecreeExecutor {
     private CommandStudio studio;
     private CommandPregen pregen;
-    private CommandLazyPregen lazyPregen;
     private CommandSettings settings;
     private CommandObject object;
     private CommandJigsaw jigsaw;
     private CommandWhat what;
     private CommandEdit edit;
     private CommandFind find;
-    private CommandSupport support;
     private CommandDeveloper developer;
     public static boolean worldCreation = false;
     String WorldEngine;
@@ -94,9 +85,7 @@ public class CommandIris implements DecreeExecutor {
             @Param(aliases = "dimension", description = "The dimension type to create the world with", defaultValue = "default")
             IrisDimension type,
             @Param(description = "The seed to generate the world with", defaultValue = "1337")
-            long seed,
-            @Param(description = "If it should convert the dimension to match the vanilla height system.", defaultValue = "false")
-            boolean vanillaheight
+            long seed
     ) {
         if(sender() instanceof Player) {
             if (incompatibilities.get("Multiverse-Core")) {
@@ -140,7 +129,6 @@ public class CommandIris implements DecreeExecutor {
                     .seed(seed)
                     .sender(sender())
                     .studio(false)
-                    .smartVanillaHeight(vanillaheight)
                     .create();
         } catch (Throwable e) {
             sender().sendMessage(C.RED + "Exception raised during creation. See the console for more details.");
@@ -183,16 +171,6 @@ public class CommandIris implements DecreeExecutor {
         sender().sendMessage(C.GREEN + "Iris v" + Iris.instance.getDescription().getVersion() + " by Volmit Software");
     }
 
-    //todo Move to React
-    @Decree(description = "Benchmark your server", origin = DecreeOrigin.CONSOLE)
-    public void serverbenchmark() throws InterruptedException {
-        if(!inProgress) {
-            IrisBenchmarking.runBenchmark();
-        } else {
-            Iris.info(C.RED + "Benchmark already is in progress.");
-        }
-    }
-
     /*
     /todo
     @Decree(description = "Benchmark a pack", origin = DecreeOrigin.CONSOLE)
@@ -274,6 +252,17 @@ public class CommandIris implements DecreeExecutor {
             return;
         }
         sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
+
+        if (!IrisToolbelt.evacuate(world)) {
+            sender().sendMessage(C.RED + "Failed to evacuate world: " + world.getName());
+            return;
+        }
+
+        if (!Bukkit.unloadWorld(world, false)) {
+            sender().sendMessage(C.RED + "Failed to unload world: " + world.getName());
+            return;
+        }
+
         try {
             if (IrisToolbelt.removeWorld(world)) {
                 sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
@@ -286,27 +275,32 @@ public class CommandIris implements DecreeExecutor {
         }
         IrisToolbelt.evacuate(world, "Deleting world");
         deletingWorld = true;
-        Bukkit.unloadWorld(world, false);
-        int retries = 12;
-        if (delete) {
+        if (!delete) {
+            deletingWorld = false;
+            return;
+        }
+        VolmitSender sender = sender();
+        J.a(() -> {
+            int retries = 12;
+
             if (deleteDirectory(world.getWorldFolder())) {
-                sender().sendMessage(C.GREEN + "Successfully removed world folder");
+                sender.sendMessage(C.GREEN + "Successfully removed world folder");
             } else {
                 while(true){
                     if (deleteDirectory(world.getWorldFolder())){
-                        sender().sendMessage(C.GREEN + "Successfully removed world folder");
+                        sender.sendMessage(C.GREEN + "Successfully removed world folder");
                         break;
                     }
                     retries--;
                     if (retries == 0){
-                        sender().sendMessage(C.RED + "Failed to remove world folder");
+                        sender.sendMessage(C.RED + "Failed to remove world folder");
                         break;
                     }
                     J.sleep(3000);
                 }
             }
-        }
-        deletingWorld = false;
+            deletingWorld = false;
+        });
     }
 
     public static boolean deleteDirectory(File dir) {
@@ -405,7 +399,7 @@ public class CommandIris implements DecreeExecutor {
     ) {
         sender().sendMessage(C.GREEN + "Downloading pack: " + pack + "/" + branch + (trim ? " trimmed" : "") + (overwrite ? " overwriting" : ""));
         if (pack.equals("overworld")) {
-            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + Iris.OVERWORLD_TAG + "/overworld.zip";
+            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + INMS.OVERWORLD_TAG + "/overworld.zip";
             Iris.service(StudioSVC.class).downloadRelease(sender(), url, trim, overwrite);
         } else {
             Iris.service(StudioSVC.class).downloadSearch(sender(), "IrisDimensions/" + pack + "/" + branch, trim, overwrite);
@@ -591,10 +585,10 @@ public class CommandIris implements DecreeExecutor {
                     continue;
                 }
                 Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
-                new WorldCreator(s)
+                WorldCreator c = new WorldCreator(s)
                         .generator(getDefaultWorldGenerator(s, generator))
-                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
-                        .createWorld();
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment());
+                INMS.get().createWorld(c);
                 Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
             }
         } catch (Throwable e) {
@@ -649,6 +643,6 @@ public class CommandIris implements DecreeExecutor {
             ff.mkdirs();
             service(StudioSVC.class).installIntoWorld(sender, dim.getLoadKey(), ff.getParentFile());
         }
-        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey(), false);
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
     }
 }

core/src/main/java/com/volmit/iris/core/commands/CommandJigsaw.java

@@ -60,7 +60,7 @@ public class CommandJigsaw implements DecreeExecutor {
         try {
             var world = world();
             WorldObjectPlacer placer = new WorldObjectPlacer(world);
-            PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation().add(0, world.getMinHeight(), 0)), new RNG());
+            PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation().add(0, world.getMinHeight(), 0)), new RNG(), true);
             VolmitSender sender = sender();
             sender.sendMessage(C.GREEN + "Generated " + ps.getPieces().size() + " pieces in " + Form.duration(p.getMilliseconds(), 2));
             ps.place(placer, failed -> sender.sendMessage(failed ? C.GREEN + "Placed the structure!" : C.RED + "Failed to place the structure!"));

core/src/main/java/com/volmit/iris/core/commands/CommandObject.java

@@ -28,6 +28,8 @@ import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.data.Cuboid;
+import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.registry.Materials;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -36,12 +38,9 @@ import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.Direction;
 import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.misc.E;
 import com.volmit.iris.util.scheduling.Queue;
 import org.bukkit.*;
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.Vector;
@@ -54,7 +53,7 @@ import java.util.*;
 @Decree(name = "object", aliases = "o", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris object manipulation")
 public class CommandObject implements DecreeExecutor {
 
-    private static final Set<Material> skipBlocks = Set.of(E.getOrDefault(Material.class, "GRASS", "SHORT_GRASS"), Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
+    private static final Set<Material> skipBlocks = Set.of(Materials.GRASS, Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
             Material.POPPY, Material.DANDELION);
 
     public static IObjectPlacer createPlacer(World world, Map<Block, BlockData> futureBlockChanges) {
@@ -79,7 +78,10 @@ public class CommandObject implements DecreeExecutor {
 
                 futureBlockChanges.put(block, block.getBlockData());
 
-                block.setBlockData(d);
+                if (d instanceof IrisCustomData data) {
+                    block.setBlockData(data.getBase());
+                    Iris.warn("Tried to place custom block at " + x + ", " + y + ", " + z + " which is not supported!");
+                } else block.setBlockData(d);
             }
 
             @Override
@@ -239,7 +241,8 @@ public class CommandObject implements DecreeExecutor {
 
 
         Location[] b = WandSVC.getCuboid(player());
-        if (b == null) {
+        if (b == null || b[0] == null || b[1] == null) {
+            sender().sendMessage("No area selected.");
             return;
         }
         Location a1 = b[0].clone();
@@ -376,9 +379,11 @@ public class CommandObject implements DecreeExecutor {
             @Param(description = "The file to store it in, can use / for subfolders")
             String name,
             @Param(description = "Overwrite existing object files", defaultValue = "false", aliases = "force")
-            boolean overwrite
+            boolean overwrite,
+            @Param(description = "Use legacy TileState serialization if possible", defaultValue = "true")
+            boolean legacy
     ) {
-        IrisObject o = WandSVC.createSchematic(player());
+        IrisObject o = WandSVC.createSchematic(player(), legacy);
 
         if (o == null) {
             sender().sendMessage(C.YELLOW + "You need to hold your wand!");
@@ -413,6 +418,10 @@ public class CommandObject implements DecreeExecutor {
         }
 
         Location[] b = WandSVC.getCuboid(player());
+        if (b == null || b[0] == null || b[1] == null) {
+            sender().sendMessage("No area selected.");
+            return;
+        }
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
@@ -473,6 +482,10 @@ public class CommandObject implements DecreeExecutor {
         }
 
         Location[] b = WandSVC.getCuboid(player());
+        if (b == null || b[0] == null || b[1] == null) {
+            sender().sendMessage("No area selected.");
+            return;
+        }
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Location a1x = b[0].clone();
@@ -520,6 +533,10 @@ public class CommandObject implements DecreeExecutor {
         }
 
         Location[] b = WandSVC.getCuboid(player());
+        if (b == null || b[0] == null || b[1] == null) {
+            sender().sendMessage("No area selected.");
+            return;
+        }
         b[0].add(new Vector(0, 1, 0));
         b[1].add(new Vector(0, 1, 0));
         Location a1 = b[0].clone();

core/src/main/java/com/volmit/iris/core/commands/CommandPregen.java

@@ -19,9 +19,7 @@
 package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.gui.PregeneratorJob;
-import com.volmit.iris.core.pregenerator.LazyPregenerator;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.util.decree.DecreeExecutor;
@@ -29,12 +27,9 @@ import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.Position2;
-import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.util.Vector;
 
-import java.io.File;
-
 @Decree(name = "pregen", aliases = "pregenerate", description = "Pregenerate your Iris worlds!")
 public class CommandPregen implements DecreeExecutor {
     @Decree(description = "Pregenerate a world")
@@ -44,7 +39,9 @@ public class CommandPregen implements DecreeExecutor {
             @Param(description = "The world to pregen", contextual = true)
             World world,
             @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
-            Vector center
+            Vector center,
+            @Param(description = "Open the Iris pregen gui", defaultValue = "true")
+            boolean gui
             ) {
         try {
             if (sender().isPlayer() && access() == null) {
@@ -52,13 +49,12 @@ public class CommandPregen implements DecreeExecutor {
                 sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
             }
             radius = Math.max(radius, 1024);
-            int w = (radius >> 9 + 1) * 2;
             IrisToolbelt.pregenerate(PregenTask
                     .builder()
-                    .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
-                    .gui(true)
-                    .width(w)
-                    .height(w)
+                    .center(new Position2(center.getBlockX(), center.getBlockZ()))
+                    .gui(gui)
+                    .radiusX(radius)
+                    .radiusZ(radius)
                     .build(), world);
             String msg = C.GREEN + "Pregen started in " + C.GOLD + world.getName() + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
             sender().sendMessage(msg);

core/src/main/java/com/volmit/iris/core/commands/CommandStudio.java

@@ -26,7 +26,6 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.service.ConversionSVC;
 import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
@@ -55,7 +54,6 @@ import com.volmit.iris.util.noise.CNG;
 import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.O;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
@@ -64,7 +62,6 @@ import io.papermc.lib.PaperLib;
 import org.bukkit.*;
 import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.inventory.Inventory;
-import org.bukkit.scheduler.BukkitRunnable;
 import org.bukkit.util.BlockVector;
 import org.bukkit.util.Vector;
 
@@ -79,7 +76,6 @@ import java.time.temporal.ChronoUnit;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -176,7 +172,7 @@ public class CommandStudio implements DecreeExecutor {
                     KList<Runnable> js = new KList<>();
                     BurstExecutor b = MultiBurst.burst.burst();
                     b.setMulticore(false);
-                    int rad = engine.getMantle().getRealRadius();
+                    int rad = engine.getMantle().getRadius();
                     for (int i = -(radius + rad); i <= radius + rad; i++) {
                         for (int j = -(radius + rad); j <= radius + rad; j++) {
                             engine.getMantle().getMantle().deleteChunk(i + cx.getX(), j + cx.getZ());
@@ -306,7 +302,7 @@ public class CommandStudio implements DecreeExecutor {
         Inventory inv = Bukkit.createInventory(null, 27 * 2);
 
         try {
-            engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
+            engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getWorld(), player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
         } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cannot add items to virtual inventory because of: " + e.getMessage());
@@ -329,7 +325,7 @@ public class CommandStudio implements DecreeExecutor {
                 inv.clear();
             }
 
-            engine().addItems(true, inv, new RNG(RNG.r.imax()), tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
+            engine().addItems(true, inv, new RNG(RNG.r.imax()), tables, InventorySlotType.STORAGE, player().getWorld(), player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
         }, 0, fast ? 5 : 35));
 
         sender().sendMessage(C.GREEN + "Opening inventory now!");

core/src/main/java/com/volmit/iris/core/commands/CommandSupport.java

@@ -1,82 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.pregenerator.ChunkUpdater;
-import com.volmit.iris.core.service.IrisEngineSVC;
-import com.volmit.iris.core.tools.IrisPackBenchmarking;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.mantle.TectonicPlate;
-import com.volmit.iris.util.misc.Hastebin;
-import com.volmit.iris.util.misc.Platform;
-import com.volmit.iris.util.misc.getHardware;
-import com.volmit.iris.util.nbt.mca.MCAFile;
-import com.volmit.iris.util.nbt.mca.MCAUtil;
-import com.volmit.iris.util.plugin.VolmitSender;
-import net.jpountz.lz4.LZ4BlockInputStream;
-import net.jpountz.lz4.LZ4BlockOutputStream;
-import net.jpountz.lz4.LZ4FrameInputStream;
-import net.jpountz.lz4.LZ4FrameOutputStream;
-import org.apache.commons.lang.RandomStringUtils;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.World;
-import oshi.SystemInfo;
-
-import java.io.*;
-import java.net.InetAddress;
-import java.net.NetworkInterface;
-import java.util.*;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;
-
-@Decree(name = "Support", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"support"})
-public class CommandSupport implements DecreeExecutor {
-
-    @Decree(description = "report")
-    public void report() {
-        try {
-            if (sender().isPlayer()) sender().sendMessage(C.GOLD + "Creating report..");
-            if (!sender().isPlayer()) Iris.info(C.GOLD + "Creating report..");
-            Hastebin.enviornment(sender());
-
-        } catch (Exception e) {
-            Iris.info(C.RED + "Something went wrong: ");
-            e.printStackTrace();
-        }
-    }
-
-
-}
-
-

core/src/main/java/com/volmit/iris/core/commands/CommandUpdater.java

@@ -43,6 +43,10 @@ public class CommandUpdater implements DecreeExecutor {
             sender().sendMessage(C.GOLD + "This is not an Iris world");
             return;
         }
+        if (chunkUpdater != null) {
+            chunkUpdater.stop();
+        }
+
         chunkUpdater = new ChunkUpdater(world);
         if (sender().isPlayer()) {
             sender().sendMessage(C.GREEN + "Updating " + world.getName()  + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
@@ -53,14 +57,7 @@ public class CommandUpdater implements DecreeExecutor {
     }
 
     @Decree(description = "Pause the updater")
-    public void pause(
-            @Param(description = "World to pause the Updater at")
-            World world
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.GOLD + "This is not an Iris world");
-            return;
-        }
+    public void pause( ) {
         if (chunkUpdater == null) {
             sender().sendMessage(C.GOLD + "You cant pause something that doesnt exist?");
             return;
@@ -68,40 +65,32 @@ public class CommandUpdater implements DecreeExecutor {
         boolean status = chunkUpdater.pause();
         if (sender().isPlayer()) {
             if (status) {
-                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
+                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
             } else {
-                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
+                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
             }
         } else {
             if (status) {
-                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
+                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
             } else {
-                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
+                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
             }
         }
     }
 
     @Decree(description = "Stops the updater")
-    public void stop(
-            @Param(description = "World to stop the Updater at")
-            World world
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.GOLD + "This is not an Iris world");
-            return;
-        }
+    public void stop() {
         if (chunkUpdater == null) {
             sender().sendMessage(C.GOLD + "You cant stop something that doesnt exist?");
             return;
         }
         if (sender().isPlayer()) {
-            sender().sendMessage("Stopping Updater for: " + C.GRAY + world.getName());
+            sender().sendMessage("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
         } else {
-            Iris.info("Stopping Updater for: " + C.GRAY + world.getName());
+            Iris.info("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
         }
         chunkUpdater.stop();
     }
-
 }
 
 

core/src/main/java/com/volmit/iris/core/events/IrisLootEvent.java

@@ -0,0 +1,113 @@
+package com.volmit.iris.core.events;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.InventorySlotType;
+import com.volmit.iris.engine.object.IrisLootTable;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.scheduling.J;
+import lombok.Getter;
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.world.LootGenerateEvent;
+
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.loot.LootContext;
+import org.bukkit.loot.LootTable;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+
+@Getter
+public class IrisLootEvent extends Event {
+    private static final HandlerList handlers = new HandlerList();
+    private static final LootTable EMPTY = new LootTable() {
+        @NotNull
+        @Override
+        public NamespacedKey getKey() {
+            return new NamespacedKey(Iris.instance, "empty");
+        }
+
+        @NotNull
+        @Override
+        public Collection<ItemStack> populateLoot(@Nullable Random random, @NotNull LootContext context) {
+            return List.of();
+        }
+
+        @Override
+        public void fillInventory(@NotNull Inventory inventory, @Nullable Random random, @NotNull LootContext context) {
+        }
+    };
+
+    private final Engine engine;
+    private final Block block;
+    private final InventorySlotType slot;
+    private final KList<IrisLootTable> tables;
+
+    /**
+     * Constructor for IrisLootEvent with mode selection.
+     *
+     * @param engine The engine instance.
+     * @param block The block associated with the event.
+     * @param slot The inventory slot type.
+     * @param tables The list of IrisLootTables. (mutable*)
+     */
+    public IrisLootEvent(Engine engine, Block block, InventorySlotType slot, KList<IrisLootTable> tables) {
+        this.engine = engine;
+        this.block = block;
+        this.slot = slot;
+        this.tables = tables;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    /**
+     * Required method to get the HandlerList for this event.
+     *
+     * @return The HandlerList.
+     */
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Triggers the corresponding Bukkit loot event.
+     * This method integrates your custom IrisLootTables with Bukkit's LootGenerateEvent,
+     * allowing other plugins to modify or cancel the loot generation.
+     *
+     * @return true when the event was canceled
+     */
+    public static boolean callLootEvent(KList<ItemStack> loot, Inventory inv, World world, int x, int y, int z) {
+        InventoryHolder holder = inv.getHolder();
+        Location loc = new Location(world, x, y, z);
+        if (holder == null) {
+            holder = new InventoryHolder() {
+                @NotNull
+                @Override
+                public Inventory getInventory() {
+                    return inv;
+                }
+            };
+        }
+
+        LootContext context = new LootContext.Builder(loc).build();
+        LootGenerateEvent event = new LootGenerateEvent(world, null, holder, EMPTY, context, loot, true);
+        if (!Bukkit.isPrimaryThread()) {
+            Iris.warn("LootGenerateEvent was not called on the main thread, please report this issue.");
+            Thread.dumpStack();
+            J.sfut(() -> Bukkit.getPluginManager().callEvent(event)).join();
+        } else Bukkit.getPluginManager().callEvent(event);
+
+        return event.isCancelled();
+    }
+}

core/src/main/java/com/volmit/iris/core/gui/NoiseExplorerGUI.java

@@ -276,9 +276,7 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
 
                         try {
                             //Color color = colorMode ? Color.getHSBColor((float) (n), 1f - (float) (n * n * n * n * n * n), 1f - (float) n) : Color.getHSBColor(0f, 0f, (float) n);
-                            //Color color = colorMode ? Color.getHSBColor((float) (n), (float) (n * n * n * n * n * n), (float) n) : Color.getHSBColor(0f, 0f, (float) n);
-                            Color color = colorMode ? Color.getHSBColor((float) n, (float) (n * n * n * n * n * n), (float) n) : Color.getHSBColor(0f, 0f, (float) n);
-
+                            Color color = colorMode ? Color.getHSBColor((float) (0.666f - n * 0.666f), 1f, (float) (1f - n * 0.8f)) : Color.getHSBColor(0f, 0f, (float) n);
                             int rgb = color.getRGB();
                             img.setRGB(xx, z, rgb);
                         } catch (Throwable ignored) {

core/src/main/java/com/volmit/iris/core/gui/PregeneratorJob.java

@@ -24,7 +24,6 @@ import com.volmit.iris.core.pregenerator.IrisPregenerator;
 import com.volmit.iris.core.pregenerator.PregenListener;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.pregenerator.PregeneratorMethod;
-import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.format.Form;
@@ -41,12 +40,13 @@ import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.awt.image.BufferedImage;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
 
-import static com.volmit.iris.core.tools.IrisPackBenchmarking.benchmarkInProgress;
-
 public class PregeneratorJob implements PregenListener {
     private static final Color COLOR_EXISTS = parseColor("#4d7d5b");
     private static final Color COLOR_BLACK = parseColor("#4d7d5b");
@@ -56,7 +56,7 @@ public class PregeneratorJob implements PregenListener {
     private static final Color COLOR_NETWORK_GENERATING = parseColor("#836b8c");
     private static final Color COLOR_GENERATED = parseColor("#65c295");
     private static final Color COLOR_CLEANED = parseColor("#34eb93");
-    public static PregeneratorJob instance;
+    private static final AtomicReference<PregeneratorJob> instance = new AtomicReference<>();
     private final MemoryMonitor monitor;
     private final PregenTask task;
     private final boolean saving;
@@ -67,26 +67,33 @@ public class PregeneratorJob implements PregenListener {
     private final Position2 max;
     private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
     private final Engine engine;
+    private final ExecutorService service;
     private JFrame frame;
     private PregenRenderer renderer;
     private int rgc = 0;
     private String[] info;
 
     public PregeneratorJob(PregenTask task, PregeneratorMethod method, Engine engine) {
+        instance.updateAndGet(old -> {
+            if (old != null) {
+                old.pregenerator.close();
+                old.close();
+            }
+            return this;
+        });
         this.engine = engine;
-        instance = this;
         monitor = new MemoryMonitor(50);
         saving = false;
         info = new String[]{"Initializing..."};
         this.task = task;
         this.pregenerator = new IrisPregenerator(task, method, this);
         max = new Position2(0, 0);
-        min = new Position2(0, 0);
-        task.iterateRegions((xx, zz) -> {
-            min.setX(Math.min(xx << 5, min.getX()));
-            min.setZ(Math.min(zz << 5, min.getZ()));
-            max.setX(Math.max((xx << 5) + 31, max.getX()));
-            max.setZ(Math.max((zz << 5) + 31, max.getZ()));
+        min = new Position2(Integer.MAX_VALUE, Integer.MAX_VALUE);
+        task.iterateAllChunks((xx, zz) -> {
+            min.setX(Math.min(xx, min.getX()));
+            min.setZ(Math.min(zz, min.getZ()));
+            max.setX(Math.max(xx, max.getX()));
+            max.setZ(Math.max(zz, max.getZ()));
         });
 
         if (IrisSettings.get().getGui().isUseServerLaunchedGuis() && task.isGui()) {
@@ -99,40 +106,44 @@ public class PregeneratorJob implements PregenListener {
         }, "Iris Pregenerator");
         t.setPriority(Thread.MIN_PRIORITY);
         t.start();
+        service = Executors.newVirtualThreadPerTaskExecutor();
     }
 
     public static boolean shutdownInstance() {
-        if (instance == null) {
+        PregeneratorJob inst = instance.get();
+        if (inst == null) {
             return false;
         }
 
-        J.a(() -> instance.pregenerator.close());
+        J.a(inst.pregenerator::close);
         return true;
     }
 
     public static PregeneratorJob getInstance() {
-        return instance;
+        return instance.get();
     }
 
     public static boolean pauseResume() {
-        if (instance == null) {
+        PregeneratorJob inst = instance.get();
+        if (inst == null) {
             return false;
         }
 
         if (isPaused()) {
-            instance.pregenerator.resume();
+            inst.pregenerator.resume();
         } else {
-            instance.pregenerator.pause();
+            inst.pregenerator.pause();
         }
         return true;
     }
 
     public static boolean isPaused() {
-        if (instance == null) {
+        PregeneratorJob inst = instance.get();
+        if (inst == null) {
             return true;
         }
 
-        return instance.paused();
+        return inst.paused();
     }
 
     private static Color parseColor(String c) {
@@ -162,7 +173,7 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public void drawRegion(int x, int z, Color color) {
-        J.a(() -> PregenTask.iterateRegion(x, z, (xx, zz) -> {
+        J.a(() -> task.iterateChunks(x, z, (xx, zz) -> {
             draw(xx, zz, color);
             J.sleep(3);
         }));
@@ -182,7 +193,7 @@ public class PregeneratorJob implements PregenListener {
         J.a(() -> {
             pregenerator.close();
             close();
-            instance = null;
+            instance.compareAndSet(this, null);
         });
     }
 
@@ -222,10 +233,10 @@ public class PregeneratorJob implements PregenListener {
     }
 
     @Override
-    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
+    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, long generated, long totalChunks, long chunksRemaining, long eta, long elapsed, String method, boolean cached) {
         info = new String[]{
                 (paused() ? "PAUSED" : (saving ? "Saving... " : "Generating")) + " " + Form.f(generated) + " of " + Form.f(totalChunks) + " (" + Form.pc(percent, 0) + " Complete)",
-                "Speed: " + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
+                "Speed: " + (cached ? "Cached " : "") + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
                 Form.duration(eta, 2) + " Remaining " + " (" + Form.duration(elapsed, 2) + " Elapsed)",
                 "Generation Method: " + method,
                 "Memory: " + Form.memSize(monitor.getUsedBytes(), 2) + " (" + Form.pc(monitor.getUsagePercent(), 0) + ") Pressure: " + Form.memSize(monitor.getPressure(), 0) + "/s",
@@ -243,13 +254,16 @@ public class PregeneratorJob implements PregenListener {
     }
 
     @Override
-    public void onChunkGenerated(int x, int z) {
-        if (engine != null) {
-            draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
-            return;
-        }
+    public void onChunkGenerated(int x, int z, boolean cached) {
+        if (renderer == null || frame == null || !frame.isVisible()) return;
+        service.submit(() -> {
+            if (engine != null) {
+                draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
+                return;
+            }
 
-        draw(x, z, COLOR_GENERATED);
+            draw(x, z, COLOR_GENERATED);
+        });
     }
 
     @Override
@@ -307,8 +321,9 @@ public class PregeneratorJob implements PregenListener {
     @Override
     public void onClose() {
         close();
-        instance = null;
+        instance.compareAndSet(this, null);
         whenDone.forEach(Runnable::run);
+        service.shutdownNow();
     }
 
     @Override

core/src/main/java/com/volmit/iris/core/gui/VisionGUI.java

@@ -30,6 +30,7 @@ import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.data.registry.Attributes;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.math.BlockPosition;
 import com.volmit.iris.util.math.M;
@@ -56,6 +57,8 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.BiFunction;
 
+import static com.volmit.iris.util.data.registry.Attributes.MAX_HEALTH;
+
 public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener, MouseMotionListener, MouseInputListener {
     private static final long serialVersionUID = 2094606939770332040L;
     private final KList<LivingEntity> lastEntities = new KList<>();
@@ -636,7 +639,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
                 k.add("Pos: " + h.getLocation().getBlockX() + ", " + h.getLocation().getBlockY() + ", " + h.getLocation().getBlockZ());
                 k.add("UUID: " + h.getUniqueId());
-                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue());
+                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(MAX_HEALTH).getValue());
 
                 drawCardTR(g, k);
             }

core/src/main/java/com/volmit/iris/core/gui/components/IrisRenderer.java

@@ -55,10 +55,10 @@ public class IrisRenderer {
                 IrisBiome b = renderer.getBiome((int) Math.round(x), renderer.getMaxHeight() - 1, (int) Math.round(z));
                 IrisBiomeGeneratorLink g = b.getGenerators().get(0);
                 Color c;
-                if (g.getMax(renderer) <= 0) {
+                if (g.getMax() <= 0) {
                     // Max is below water level, so it is most likely an ocean biome
                     c = Color.BLUE;
-                } else if (g.getMin(renderer) < 0) {
+                } else if (g.getMin() < 0) {
                     // Min is below water level, but max is not, so it is most likely a shore biome
                     c = Color.YELLOW;
                 } else {

core/src/main/java/com/volmit/iris/core/link/EcoItemsDataProvider.java

@@ -9,6 +9,7 @@ import com.willfp.ecoitems.items.EcoItems;
 import org.bukkit.NamespacedKey;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.MissingResourceException;
 
@@ -33,23 +34,27 @@ public class EcoItemsDataProvider extends ExternalDataProvider {
         }
     }
 
+    @NotNull
     @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
         throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
     }
 
+    @NotNull
     @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
         EcoItem item = EcoItems.INSTANCE.getByID(itemId.key());
         if (item == null) throw new MissingResourceException("Failed to find Item!", itemId.namespace(), itemId.key());
         return itemStack.get(item).clone();
     }
 
+    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         return new Identifier[0];
     }
 
+    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> names = new KList<>();
@@ -66,7 +71,7 @@ public class EcoItemsDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(Identifier id, boolean isItem) {
+    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
         return id.namespace().equalsIgnoreCase("ecoitems") && isItem;
     }
 }

core/src/main/java/com/volmit/iris/core/link/ExecutableItemsDataProvider.java

@@ -6,6 +6,7 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.MissingResourceException;
 import java.util.Optional;
@@ -20,23 +21,27 @@ public class ExecutableItemsDataProvider extends ExternalDataProvider {
         Iris.info("Setting up ExecutableItems Link...");
     }
 
+    @NotNull
     @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
         throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
     }
 
+    @NotNull
     @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
         return ExecutableItemsAPI.getExecutableItemsManager().getExecutableItem(itemId.key())
                 .map(item -> item.buildItem(1, Optional.empty()))
                 .orElseThrow(() -> new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key()));
     }
 
+    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         return new Identifier[0];
     }
 
+    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> names = new KList<>();
@@ -53,7 +58,7 @@ public class ExecutableItemsDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(Identifier key, boolean isItem) {
+    public boolean isValidProvider(@NotNull Identifier key, boolean isItem) {
         return key.namespace().equalsIgnoreCase("executable_items") && isItem;
     }
 }

core/src/main/java/com/volmit/iris/core/link/ExternalDataProvider.java

@@ -2,22 +2,28 @@ package com.volmit.iris.core.link;
 
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.IrisCustomData;
 import lombok.Getter;
+import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
 import org.bukkit.Bukkit;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.MissingResourceException;
 
+@Getter
 @RequiredArgsConstructor
 public abstract class ExternalDataProvider {
 
-    @Getter
+    @NonNull
     private final String pluginId;
 
+    @Nullable
     public Plugin getPlugin() {
         return Bukkit.getPluginManager().getPlugin(pluginId);
     }
@@ -28,23 +34,60 @@ public abstract class ExternalDataProvider {
 
     public abstract void init();
 
-    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+    /**
+     * @see ExternalDataProvider#getBlockData(Identifier, KMap)
+     */
+    @NotNull
+    public BlockData getBlockData(@NotNull Identifier blockId) throws MissingResourceException {
         return getBlockData(blockId, new KMap<>());
     }
 
-    public abstract BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException;
+    /**
+     * This method returns a {@link BlockData} corresponding to the blockID
+     * it is used in any place Iris accepts {@link BlockData}
+     *
+     * @param blockId The id of the block to get
+     * @param state The state of the block to get
+     * @return Corresponding {@link BlockData} to the blockId
+     *         may return {@link IrisCustomData} for blocks that need a world for placement
+     * @throws MissingResourceException when the blockId is invalid
+     */
+    @NotNull
+    public abstract BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException;
 
-    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+    /**
+     * @see ExternalDataProvider#getItemStack(Identifier)
+     */
+    @NotNull
+    public ItemStack getItemStack(@NotNull Identifier itemId) throws MissingResourceException {
         return getItemStack(itemId, new KMap<>());
     }
 
-    public abstract ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException;
+    /**
+     * This method returns a {@link ItemStack} corresponding to the itemID
+     * it is used in loot tables
+     *
+     * @param itemId The id of the item to get
+     * @param customNbt Custom nbt to apply to the item
+     * @return Corresponding {@link ItemStack} to the itemId
+     * @throws MissingResourceException when the itemId is invalid
+     */
+    @NotNull
+    public abstract ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException;
 
-    public void processUpdate(Engine engine, Block block, Identifier blockId) {}
+    /**
+     * This method is used for placing blocks that need to use the plugins api
+     * it will only be called when the {@link ExternalDataProvider#getBlockData(Identifier, KMap)} returned a {@link IrisCustomData}
+     *
+     * @param engine The engine of the world the block is being placed in
+     * @param block The block where the block should be placed
+     * @param blockId The blockId to place
+     */
+    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {}
 
-    public abstract Identifier[] getBlockTypes();
+    public abstract @NotNull Identifier[] getBlockTypes();
 
-    public abstract Identifier[] getItemTypes();
+    public abstract @NotNull Identifier[] getItemTypes();
 
-    public abstract boolean isValidProvider(Identifier id, boolean isItem);
+    public abstract boolean isValidProvider(@NotNull Identifier id, boolean isItem);
 }

core/src/main/java/com/volmit/iris/core/link/HMCLeavesDataProvider.java

@@ -6,7 +6,7 @@ import com.volmit.iris.core.service.ExternalDataSVC;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.IrisBlockData;
+import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.reflect.WrappedField;
 import com.volmit.iris.util.reflect.WrappedReturningMethod;
 import org.bukkit.Bukkit;
@@ -16,6 +16,7 @@ import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.type.Leaves;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Map;
 import java.util.MissingResourceException;
@@ -51,8 +52,9 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		}
 	}
 
+	@NotNull
 	@Override
-	public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+	public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
 		Object o = blockDataMap.get(blockId.key());
 		if (o == null)
 			throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
@@ -62,18 +64,19 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		BlockData blockData = Bukkit.createBlockData(material);
 		if (IrisSettings.get().getGenerator().preventLeafDecay && blockData instanceof Leaves leaves)
 			leaves.setPersistent(true);
-		return new IrisBlockData(blockData, ExternalDataSVC.buildState(blockId, state));
+		return new IrisCustomData(blockData, ExternalDataSVC.buildState(blockId, state));
 	}
 
+	@NotNull
 	@Override
-	public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+	public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
 		if (!itemDataField.containsKey(itemId.key()))
 			throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
 		return itemDataField.get(itemId.key()).get();
 	}
 
 	@Override
-	public void processUpdate(Engine engine, Block block, Identifier blockId) {
+	public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
 		var pair = ExternalDataSVC.parseState(blockId);
 		blockId = pair.getA();
 		Boolean result = setCustomBlock.invoke(apiInstance, new Object[]{block.getLocation(), blockId.key(), false});
@@ -86,6 +89,7 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		}
 	}
 
+	@NotNull
 	@Override
 	public Identifier[] getBlockTypes() {
 		KList<Identifier> names = new KList<>();
@@ -101,6 +105,7 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		return names.toArray(new Identifier[0]);
 	}
 
+	@NotNull
 	@Override
 	public Identifier[] getItemTypes() {
 		KList<Identifier> names = new KList<>();
@@ -117,7 +122,7 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 	}
 
 	@Override
-	public boolean isValidProvider(Identifier id, boolean isItem) {
+	public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
 		return (isItem ? itemDataField.keySet() : blockDataMap.keySet()).contains(id.key());
 	}
 

core/src/main/java/com/volmit/iris/core/link/ItemAdderDataProvider.java

@@ -7,6 +7,7 @@ import dev.lone.itemsadder.api.CustomBlock;
 import dev.lone.itemsadder.api.CustomStack;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.MissingResourceException;
 
@@ -32,13 +33,15 @@ public class ItemAdderDataProvider extends ExternalDataProvider {
         }
     }
 
+    @NotNull
     @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
         return CustomBlock.getBaseBlockData(blockId.toString());
     }
 
+    @NotNull
     @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
         CustomStack stack = CustomStack.getInstance(itemId.toString());
         if (stack == null) {
             throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
@@ -46,6 +49,7 @@ public class ItemAdderDataProvider extends ExternalDataProvider {
         return stack.getItemStack();
     }
 
+    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         KList<Identifier> keys = new KList<>();
@@ -55,6 +59,7 @@ public class ItemAdderDataProvider extends ExternalDataProvider {
         return keys.toArray(new Identifier[0]);
     }
 
+    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> keys = new KList<>();
@@ -65,7 +70,7 @@ public class ItemAdderDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(Identifier id, boolean isItem) {
+    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
         return isItem ? this.itemNamespaces.contains(id.namespace()) : this.blockNamespaces.contains(id.namespace());
     }
 }

core/src/main/java/com/volmit/iris/core/link/MMOItemsDataProvider.java

@@ -11,6 +11,7 @@ import net.Indyuce.mmoitems.api.block.CustomBlock;
 import org.bukkit.Bukkit;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.MissingResourceException;
 import java.util.concurrent.CompletableFuture;
@@ -27,8 +28,9 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
         Iris.info("Setting up MMOItems Link...");
     }
 
+    @NotNull
     @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
         int id = -1;
         try {
             id = Integer.parseInt(blockId.key());
@@ -38,8 +40,9 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
         return block.getState().getBlockData();
     }
 
+    @NotNull
     @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
         String[] parts = itemId.namespace().split("_", 2);
         if (parts.length != 2)
             throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
@@ -82,6 +85,7 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
         return item;
     }
 
+    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         KList<Identifier> names = new KList<>();
@@ -96,6 +100,7 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
         return names.toArray(new Identifier[0]);
     }
 
+    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> names = new KList<>();
@@ -124,7 +129,7 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(Identifier id, boolean isItem) {
+    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
         return isItem ? id.namespace().split("_", 2).length == 2 : id.namespace().equals("mmoitems");
     }
 

core/src/main/java/com/volmit/iris/core/link/MythicCrucibleDataProvider.java

@@ -0,0 +1,171 @@
+/*
+ * Iris is a World Generator for Minecraft Bukkit Servers
+ * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.container.BiomeColor;
+import com.volmit.iris.core.service.ExternalDataSVC;
+import com.volmit.iris.engine.data.cache.Cache;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.math.RNG;
+import io.lumine.mythic.bukkit.BukkitAdapter;
+import io.lumine.mythic.bukkit.utils.serialize.Chroma;
+import io.lumine.mythiccrucible.MythicCrucible;
+import io.lumine.mythiccrucible.items.CrucibleItem;
+import io.lumine.mythiccrucible.items.ItemManager;
+import io.lumine.mythiccrucible.items.blocks.CustomBlockItemContext;
+import io.lumine.mythiccrucible.items.furniture.FurnitureItemContext;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.MissingResourceException;
+import java.util.Optional;
+
+public class MythicCrucibleDataProvider extends ExternalDataProvider {
+
+    private ItemManager itemManager;
+
+    public MythicCrucibleDataProvider() {
+        super("MythicCrucible");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up MythicCrucible Link...");
+        try {
+            this.itemManager = MythicCrucible.inst().getItemManager();
+        } catch (Exception e) {
+            Iris.error("Failed to set up MythicCrucible Link: Unable to fetch MythicCrucible instance!");
+        }
+    }
+
+    @NotNull
+    @Override
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        CrucibleItem crucibleItem = this.itemManager.getItem(blockId.key())
+                .orElseThrow(() -> new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key()));
+        CustomBlockItemContext blockItemContext = crucibleItem.getBlockData();
+        FurnitureItemContext furnitureItemContext = crucibleItem.getFurnitureData();
+        if (furnitureItemContext != null) {
+            return new IrisCustomData(B.getAir(), ExternalDataSVC.buildState(blockId, state));
+        } else if (blockItemContext != null) {
+            return blockItemContext.getBlockData();
+        }
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
+
+    @NotNull
+    @Override
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        Optional<CrucibleItem> opt = this.itemManager.getItem(itemId.key());
+        return BukkitAdapter.adapt(opt.orElseThrow(() ->
+                new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key()))
+                .getMythicItem()
+                .generateItemStack(1));
+    }
+
+    @NotNull
+    @Override
+    public Identifier[] getBlockTypes() {
+        KList<Identifier> names = new KList<>();
+        for (CrucibleItem item : this.itemManager.getItems()) {
+            if (item.getBlockData() == null) continue;
+            try {
+                Identifier key = new Identifier("crucible", item.getInternalName());
+                if (getBlockData(key) != null) {
+                    Iris.info("getBlockTypes: Block loaded '" + item.getInternalName() + "'");
+                    names.add(key);
+                }
+            } catch (MissingResourceException ignored) {}
+        }
+        return names.toArray(new Identifier[0]);
+    }
+
+    @NotNull
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> names = new KList<>();
+        for (CrucibleItem item : this.itemManager.getItems()) {
+            try {
+                Identifier key = new Identifier("crucible", item.getInternalName());
+                if (getItemStack(key) != null) {
+                    Iris.info("getItemTypes: Item loaded '" + item.getInternalName() + "'");
+                    names.add(key);
+                }
+            } catch (MissingResourceException ignored) {}
+        }
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+        var pair = ExternalDataSVC.parseState(blockId);
+        var state = pair.getB();
+        blockId = pair.getA();
+
+        Optional<CrucibleItem> item = itemManager.getItem(blockId.key());
+        if (item.isEmpty()) return;
+        FurnitureItemContext furniture = item.get().getFurnitureData();
+        if (furniture == null) return;
+
+        float yaw = 0;
+        BlockFace face = BlockFace.NORTH;
+        long seed = engine.getSeedManager().getSeed() + Cache.key(block.getX(), block.getZ()) + block.getY();
+        RNG rng = new RNG(seed);
+        if ("true".equals(state.get("randomYaw"))) {
+            yaw = rng.f(0, 360);
+        } else if (state.containsKey("yaw")) {
+            yaw = Float.parseFloat(state.get("yaw"));
+        }
+        if ("true".equals(state.get("randomFace"))) {
+            BlockFace[] faces = BlockFace.values();
+            face = faces[rng.i(0, faces.length - 1)];
+        } else if (state.containsKey("face")) {
+            face = BlockFace.valueOf(state.get("face").toUpperCase());
+        }
+        if (face == BlockFace.SELF) {
+            face = BlockFace.NORTH;
+        }
+
+        BiomeColor type = null;
+        Chroma color = null;
+        try {
+            type = BiomeColor.valueOf(state.get("matchBiome").toUpperCase());
+        } catch (NullPointerException | IllegalArgumentException ignored) {}
+        if (type != null) {
+            var biomeColor = INMS.get().getBiomeColor(block.getLocation(), type);
+            if (biomeColor == null) return;
+            color = Chroma.of(biomeColor.getRGB());
+        }
+        furniture.place(block, face, yaw, color);
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier key, boolean isItem) {
+        return key.namespace().equalsIgnoreCase("crucible");
+    }
+}

core/src/main/java/com/volmit/iris/core/link/MythicMobsLink.java

@@ -18,19 +18,33 @@
 
 package com.volmit.iris.core.link;
 
+import com.google.common.collect.Sets;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import io.lumine.mythic.api.adapters.AbstractLocation;
+import io.lumine.mythic.api.config.MythicLineConfig;
+import io.lumine.mythic.api.skills.conditions.ILocationCondition;
 import io.lumine.mythic.bukkit.MythicBukkit;
+import io.lumine.mythic.bukkit.adapters.BukkitWorld;
+import io.lumine.mythic.bukkit.events.MythicConditionLoadEvent;
+import io.lumine.mythic.core.skills.SkillCondition;
+import io.lumine.mythic.core.utils.annotations.MythicCondition;
+import io.lumine.mythic.core.utils.annotations.MythicField;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
 import org.bukkit.plugin.Plugin;
 
 import javax.annotation.Nullable;
-import java.util.Collection;
+import java.util.*;
 
 public class MythicMobsLink {
 
     public MythicMobsLink() {
-
+        if (getPlugin() == null) return;
+        Iris.instance.registerListener(new ConditionListener());
     }
 
     public boolean isEnabled() {
@@ -48,12 +62,70 @@ public class MythicMobsLink {
      * @param location The location
      * @return The mob, or null if it can't be spawned
      */
-    public @Nullable
-    Entity spawnMob(String mob, Location location) {
+    public @Nullable Entity spawnMob(String mob, Location location) {
         return isEnabled() ? MythicBukkit.inst().getMobManager().spawnMob(mob, location).getEntity().getBukkitEntity() : null;
     }
 
     public Collection<String> getMythicMobTypes() {
-        return isEnabled() ? MythicBukkit.inst().getMobManager().getMobNames() : null;
+        return isEnabled() ? MythicBukkit.inst().getMobManager().getMobNames() : List.of();
+    }
+
+    private static class ConditionListener implements Listener {
+        @EventHandler
+        public void on(MythicConditionLoadEvent event) {
+            switch (event.getConditionName()) {
+                case "irisbiome" -> event.register(new IrisBiomeCondition(event.getConditionName(), event.getConfig()));
+                case "irisregion" -> event.register(new IrisRegionCondition(event.getConditionName(), event.getConfig()));
+            }
+        }
+    }
+
+    @MythicCondition(author = "CrazyDev22", name = "irisbiome", description = "Tests if the target is within the given list of biomes")
+    public static class IrisBiomeCondition extends SkillCondition implements ILocationCondition {
+        @MythicField(name = "biome", aliases = {"b"}, description = "A list of biomes to check")
+        private Set<String> biomes = Sets.newConcurrentHashSet();
+        @MythicField(name = "surface", aliases = {"s"}, description = "If the biome check should only be performed on the surface")
+        private boolean surface;
+
+        public IrisBiomeCondition(String line, MythicLineConfig mlc) {
+            super(line);
+            String b = mlc.getString(new String[]{"biome", "b"}, "");
+            biomes.addAll(Arrays.asList(b.split(",")));
+            surface = mlc.getBoolean(new String[]{"surface", "s"}, false);
+        }
+
+        @Override
+        public boolean check(AbstractLocation target) {
+            var access = IrisToolbelt.access(((BukkitWorld) target.getWorld()).getBukkitWorld());
+            if (access == null) return false;
+            var engine = access.getEngine();
+            if (engine == null) return false;
+            var biome = surface ?
+                    engine.getSurfaceBiome(target.getBlockX(), target.getBlockZ()) :
+                    engine.getBiomeOrMantle(target.getBlockX(), target.getBlockY() - engine.getMinHeight(), target.getBlockZ());
+            return biomes.contains(biome.getLoadKey());
+        }
+    }
+
+    @MythicCondition(author = "CrazyDev22", name = "irisbiome", description = "Tests if the target is within the given list of biomes")
+    public static class IrisRegionCondition extends SkillCondition implements ILocationCondition {
+        @MythicField(name = "region", aliases = {"r"}, description = "A list of regions to check")
+        private Set<String> regions = Sets.newConcurrentHashSet();
+
+        public IrisRegionCondition(String line, MythicLineConfig mlc) {
+            super(line);
+            String b = mlc.getString(new String[]{"region", "r"}, "");
+            regions.addAll(Arrays.asList(b.split(",")));
+        }
+
+        @Override
+        public boolean check(AbstractLocation target) {
+            var access = IrisToolbelt.access(((BukkitWorld) target.getWorld()).getBukkitWorld());
+            if (access == null) return false;
+            var engine = access.getEngine();
+            if (engine == null) return false;
+            var region = engine.getRegion(target.getBlockX(), target.getBlockZ());
+            return regions.contains(region.getLoadKey());
+        }
     }
 }

core/src/main/java/com/volmit/iris/core/link/NexoDataProvider.java

@@ -0,0 +1,164 @@
+package com.volmit.iris.core.link;
+
+import com.nexomc.nexo.api.NexoBlocks;
+import com.nexomc.nexo.api.NexoFurniture;
+import com.nexomc.nexo.api.NexoItems;
+import com.nexomc.nexo.items.ItemBuilder;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.container.BiomeColor;
+import com.volmit.iris.core.service.ExternalDataSVC;
+import com.volmit.iris.engine.data.cache.Cache;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.math.RNG;
+import org.bukkit.Color;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.ItemDisplay;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.MissingResourceException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class NexoDataProvider extends ExternalDataProvider {
+    private final AtomicBoolean failed = new AtomicBoolean(false);
+
+    public NexoDataProvider() {
+        super("Nexo");
+    }
+
+    @Override
+    public void init() {
+    }
+
+    @NotNull
+    @Override
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        if (!NexoItems.exists(blockId.key())) {
+            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        }
+
+        Identifier blockState = ExternalDataSVC.buildState(blockId, state);
+        if (NexoBlocks.isCustomBlock(blockId.key())) {
+            BlockData data = NexoBlocks.blockData(blockId.key());
+            if (data == null)
+                throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+            return new IrisCustomData(data, blockState);
+        } else if (NexoFurniture.isFurniture(blockId.key())) {
+            return new IrisCustomData(B.getAir(), blockState);
+        }
+
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
+
+    @NotNull
+    @Override
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        ItemBuilder builder = NexoItems.itemFromId(itemId.key());
+        if (builder == null) {
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        }
+        return builder.build();
+    }
+
+    @Override
+    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+        var pair = ExternalDataSVC.parseState(blockId);
+        var state = pair.getB();
+        blockId = pair.getA();
+
+        if (NexoBlocks.isCustomBlock(blockId.key())) {
+            NexoBlocks.place(blockId.key(), block.getLocation());
+            return;
+        }
+
+        if (!NexoFurniture.isFurniture(blockId.key()))
+            return;
+
+        float yaw = 0;
+        BlockFace face = BlockFace.NORTH;
+
+        long seed = engine.getSeedManager().getSeed() + Cache.key(block.getX(), block.getZ()) + block.getY();
+        RNG rng = new RNG(seed);
+        if ("true".equals(state.get("randomYaw"))) {
+            yaw = rng.f(0, 360);
+        } else if (state.containsKey("yaw")) {
+            yaw = Float.parseFloat(state.get("yaw"));
+        }
+        if ("true".equals(state.get("randomFace"))) {
+            BlockFace[] faces = BlockFace.values();
+            face = faces[rng.i(0, faces.length - 1)];
+        } else if (state.containsKey("face")) {
+            face = BlockFace.valueOf(state.get("face").toUpperCase());
+        }
+        if (face == BlockFace.SELF) {
+            face = BlockFace.NORTH;
+        }
+        ItemDisplay display = NexoFurniture.place(blockId.key(), block.getLocation(), yaw, face);
+        if (display == null) return;
+        ItemStack itemStack = display.getItemStack();
+        if (itemStack == null) return;
+
+        BiomeColor type = null;
+        try {
+            type = BiomeColor.valueOf(state.get("matchBiome").toUpperCase());
+        } catch (NullPointerException | IllegalArgumentException ignored) {}
+
+        if (type != null) {
+            var biomeColor = INMS.get().getBiomeColor(block.getLocation(), type);
+            if (biomeColor == null) return;
+            var potionColor = Color.fromARGB(biomeColor.getAlpha(), biomeColor.getRed(), biomeColor.getGreen(), biomeColor.getBlue());
+            if (itemStack.getItemMeta() instanceof PotionMeta meta) {
+                meta.setColor(potionColor);
+                itemStack.setItemMeta(meta);
+            }
+        }
+        display.setItemStack(itemStack);
+    }
+
+    @NotNull
+    @Override
+    public Identifier[] getBlockTypes() {
+        return NexoItems.itemNames().stream()
+                .map(i -> new Identifier("nexo", i))
+                .filter(i -> {
+                    try {
+                        return getBlockData(i) != null;
+                    } catch (MissingResourceException e) {
+                        return false;
+                    }
+                })
+                .toArray(Identifier[]::new);
+    }
+
+    @NotNull
+    @Override
+    public Identifier[] getItemTypes() {
+        return NexoItems.itemNames().stream()
+                .map(i -> new Identifier("nexo", i))
+                .filter(i -> {
+                    try {
+                        return getItemStack(i) != null;
+                    } catch (MissingResourceException e) {
+                        return false;
+                    }
+                })
+                .toArray(Identifier[]::new);
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
+        return "nexo".equalsIgnoreCase(id.namespace());
+    }
+
+    @Override
+    public boolean isReady() {
+        return super.isReady() && !failed.get();
+    }
+}

core/src/main/java/com/volmit/iris/core/link/OraxenDataProvider.java

@@ -1,213 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.service.ExternalDataSVC;
-import com.volmit.iris.engine.data.cache.Cache;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisBlockData;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.reflect.WrappedField;
-import io.th0rgal.oraxen.api.OraxenItems;
-import io.th0rgal.oraxen.items.ItemBuilder;
-import io.th0rgal.oraxen.mechanics.Mechanic;
-import io.th0rgal.oraxen.mechanics.MechanicFactory;
-import io.th0rgal.oraxen.mechanics.MechanicsManager;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.block.BlockMechanic;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.block.BlockMechanicFactory;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.furniture.FurnitureFactory;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.furniture.FurnitureMechanic;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.noteblock.NoteBlockMechanicFactory;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.stringblock.StringBlockMechanicFactory;
-import org.bukkit.Bukkit;
-import org.bukkit.Color;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.MultipleFacing;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.ItemDisplay;
-import org.bukkit.entity.ItemFrame;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.PotionMeta;
-
-import java.util.Map;
-import java.util.MissingResourceException;
-import java.util.Optional;
-import java.util.function.Consumer;
-
-public class OraxenDataProvider extends ExternalDataProvider {
-
-    private static final String FIELD_FACTORIES_MAP = "FACTORIES_BY_MECHANIC_ID";
-
-    private WrappedField<MechanicsManager, Map<String, MechanicFactory>> factories;
-
-    public OraxenDataProvider() {
-        super("Oraxen");
-    }
-
-    @Override
-    public void init() {
-        Iris.info("Setting up Oraxen Link...");
-        this.factories = new WrappedField<>(MechanicsManager.class, FIELD_FACTORIES_MAP);
-        if (this.factories.hasFailed()) {
-            Iris.error("Failed to set up Oraxen Link: Unable to fetch MechanicFactoriesMap!");
-        }
-    }
-
-    @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
-        MechanicFactory factory = getFactory(blockId);
-        if (factory instanceof NoteBlockMechanicFactory f)
-            return f.createNoteBlockData(blockId.key());
-        else if (factory instanceof BlockMechanicFactory f) {
-            MultipleFacing newBlockData = (MultipleFacing) Bukkit.createBlockData(Material.MUSHROOM_STEM);
-            BlockMechanic.setBlockFacing(newBlockData, ((BlockMechanic) f.getMechanic(blockId.key())).getCustomVariation());
-            return newBlockData;
-        } else if (factory instanceof StringBlockMechanicFactory f) {
-            return f.createTripwireData(blockId.key());
-        } else if (factory instanceof FurnitureFactory) {
-            return new IrisBlockData(B.getAir(), ExternalDataSVC.buildState(blockId, state));
-        } else
-            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-    }
-
-    @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
-        Optional<ItemBuilder> opt = OraxenItems.getOptionalItemById(itemId.key());
-        return opt.orElseThrow(() -> new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key())).build();
-    }
-
-    @Override
-    public void processUpdate(Engine engine, Block block, Identifier blockId) {
-        var pair = ExternalDataSVC.parseState(blockId);
-        var state = pair.getB();
-        blockId = pair.getA();
-        Mechanic mechanic = getFactory(blockId).getMechanic(blockId.key());
-        if (mechanic instanceof FurnitureMechanic f) {
-            float yaw = 0;
-            BlockFace face = BlockFace.NORTH;
-
-            long seed = engine.getSeedManager().getSeed() + Cache.key(block.getX(), block.getZ()) + block.getY();
-            RNG rng = new RNG(seed);
-            if ("true".equals(state.get("randomYaw"))) {
-                yaw = rng.f(0, 360);
-            } else if (state.containsKey("yaw")) {
-                yaw = Float.parseFloat(state.get("yaw"));
-            }
-            if ("true".equals(state.get("randomFace"))) {
-                BlockFace[] faces = BlockFace.values();
-                face = faces[rng.i(0, faces.length - 1)];
-            } else if (state.containsKey("face")) {
-                face = BlockFace.valueOf(state.get("face").toUpperCase());
-            }
-            if (face == BlockFace.SELF) {
-                face = BlockFace.NORTH;
-            }
-            ItemStack itemStack = OraxenItems.getItemById(f.getItemID()).build();
-            Entity entity = f.place(block.getLocation(), itemStack, yaw, face, false);
-
-            Consumer<ItemStack> setter = null;
-            if (entity instanceof ItemFrame frame) {
-                itemStack = frame.getItem();
-                setter = frame::setItem;
-            } else if (entity instanceof ItemDisplay display) {
-                itemStack = display.getItemStack();
-                setter = display::setItemStack;
-            }
-            if (setter == null || itemStack == null) return;
-
-            BiomeColor type = null;
-            try {
-                type = BiomeColor.valueOf(state.get("matchBiome").toUpperCase());
-            } catch (NullPointerException | IllegalArgumentException ignored) {}
-
-            if (type != null) {
-                var biomeColor = INMS.get().getBiomeColor(block.getLocation(), type);
-                if (biomeColor == null) return;
-                var potionColor = Color.fromARGB(biomeColor.getAlpha(), biomeColor.getRed(), biomeColor.getGreen(), biomeColor.getBlue());
-                if (itemStack.getItemMeta() instanceof PotionMeta meta) {
-                    meta.setColor(potionColor);
-                    itemStack.setItemMeta(meta);
-                }
-            }
-            setter.accept(itemStack);
-        }
-    }
-
-    @Override
-    public Identifier[] getBlockTypes() {
-        KList<Identifier> names = new KList<>();
-        for (String name : OraxenItems.getItemNames()) {
-            try {
-                Identifier key = new Identifier("oraxen", name);
-                if (getBlockData(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public Identifier[] getItemTypes() {
-        KList<Identifier> names = new KList<>();
-        for (String name : OraxenItems.getItemNames()) {
-            try {
-                Identifier key = new Identifier("oraxen", name);
-                if (getItemStack(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public boolean isReady() {
-        if (super.isReady()) {
-            if (factories == null) {
-                this.factories = new WrappedField<>(MechanicsManager.class, FIELD_FACTORIES_MAP);
-            }
-            return super.isReady() && !factories.hasFailed();
-        }
-        return false;
-    }
-
-    @Override
-    public boolean isValidProvider(Identifier key, boolean isItem) {
-        return key.namespace().equalsIgnoreCase("oraxen");
-    }
-
-    private MechanicFactory getFactory(Identifier key) throws MissingResourceException {
-        return factories.get().values().stream()
-                .filter(i -> i.getItems().contains(key.key()))
-                .findFirst()
-                .orElseThrow(() -> new MissingResourceException("Failed to find BlockData!", key.namespace(), key.key()));
-    }
-}

core/src/main/java/com/volmit/iris/core/link/WorldEditLink.java

@@ -47,6 +47,7 @@ public class WorldEditLink {
         } catch (Throwable e) {
             Iris.error("Could not get selection");
             e.printStackTrace();
+            Iris.reportError(e);
             active.reset();
             active.aquire(() -> false);
         }

core/src/main/java/com/volmit/iris/core/loader/IrisData.java

@@ -36,6 +36,7 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.reflect.OldEnum;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import lombok.Data;
@@ -299,6 +300,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
             return r;
         } catch (Throwable e) {
+            Iris.reportError(e);
             e.printStackTrace();
             Iris.error("Failed to create loader! " + registrant.getCanonicalName());
         }
@@ -337,6 +339,15 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         this.imageLoader = registerLoader(IrisImage.class);
         this.scriptLoader = registerLoader(IrisScript.class);
         this.matterObjectLoader = registerLoader(IrisMatterObject.class);
+        if (OldEnum.exists()) {
+            builder.registerTypeAdapterFactory(new TypeAdapterFactory() {
+                @Override
+                public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+                    return (TypeAdapter<T>) OldEnum.create(type.getRawType());
+                }
+            });
+        }
+
         gson = builder.create();
     }
 
@@ -434,6 +445,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
                     return adapter.read(reader);
                 } catch (Throwable e) {
                     Iris.error("Failed to read " + typeToken.getRawType().getCanonicalName() + "... faking objects a little to load the file at least.");
+                    Iris.reportError(e);
                     try {
                         return (T) typeToken.getRawType().getConstructor().newInstance();
                     } catch (Throwable ignored) {

core/src/main/java/com/volmit/iris/core/loader/ResourceLoader.java

@@ -45,6 +45,7 @@ import lombok.ToString;
 
 import java.io.*;
 import java.util.Locale;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
@@ -240,8 +241,10 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         for (String i : s) {
             burst.queue(() -> {
                 T t = load(i);
+                if (t == null)
+                    return;
 
-                if (t != null) {
+                synchronized (m) {
                     m.add(t);
                 }
             });

core/src/main/java/com/volmit/iris/core/nms/INMS.java

@@ -23,17 +23,29 @@ import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
 import org.bukkit.Bukkit;
 
+import java.util.List;
 import java.util.Map;
 
 public class INMS {
     private static final Map<String, String> REVISION = Map.of(
-        "1.20.5", "v1_20_R4",
-        "1.20.6", "v1_20_R4",
-        "1.21", "v1_21_R1",
-        "1.21.1", "v1_21_R1"
+            "1.20.5", "v1_20_R4",
+            "1.20.6", "v1_20_R4",
+            "1.21", "v1_21_R1",
+            "1.21.1", "v1_21_R1",
+            "1.21.2", "v1_21_R2",
+            "1.21.3", "v1_21_R2",
+            "1.21.4", "v1_21_R3",
+            "1.21.5", "v1_21_R4"
     );
+    private static final List<Version> PACKS = List.of(
+            new Version(21, 4, "31020"),
+            new Version(21, 2, "31000"),
+            new Version(20, 1, "3910")
+    );
+
     //@done
     private static final INMSBinding binding = bind();
+    public static final String OVERWORLD_TAG = getOverworldTag();
 
     public static INMSBinding get() {
         return binding;
@@ -84,4 +96,26 @@ public class INMS {
 
         return new NMSBinding1X();
     }
+
+    private static String getOverworldTag() {
+        var version = Bukkit.getServer().getBukkitVersion().split("-")[0].split("\\.", 3);
+        int major = 0;
+        int minor = 0;
+
+        if (version.length > 2) {
+            major = Integer.parseInt(version[1]);
+            minor = Integer.parseInt(version[2]);
+        } else if (version.length == 2) {
+            major = Integer.parseInt(version[1]);
+        }
+
+        for (var p : PACKS) {
+            if (p.major > major || p.minor > minor)
+                continue;
+            return p.tag;
+        }
+        return "3910";
+    }
+
+    private record Version(int major, int minor, String tag) {}
 }

core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java

@@ -18,6 +18,7 @@
 
 package com.volmit.iris.core.nms;
 
+import com.volmit.iris.core.nms.container.AutoClosing;
 import com.volmit.iris.core.nms.container.BiomeColor;
 import com.volmit.iris.core.nms.datapack.DataVersion;
 import com.volmit.iris.engine.framework.Engine;
@@ -30,15 +31,12 @@ import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
-import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.generator.structure.Structure;
 import org.bukkit.inventory.ItemStack;
 
-import java.awt.*;
 import java.awt.Color;
 
 public interface INMSBinding {
@@ -91,7 +89,13 @@ public interface INMSBinding {
     MCABiomeContainer newBiomeContainer(int min, int max);
 
     default World createWorld(WorldCreator c) {
-        return c.createWorld();
+        if (missingDimensionTypes(true, true, true))
+            throw new IllegalStateException("Missing dimenstion types to create world");
+
+        try (var ignored = injectLevelStems()) {
+            ignored.storeContext();
+            return c.createWorld();
+        }
     }
 
     int countCustomBiomes();
@@ -125,4 +129,14 @@ public interface INMSBinding {
     }
 
     KList<String> getStructureKeys();
+
+    AutoClosing injectLevelStems();
+
+    default AutoClosing injectUncached(boolean overworld, boolean nether, boolean end) {
+        return null;
+    }
+
+    boolean missingDimensionTypes(boolean overworld, boolean nether, boolean end);
+
+    void removeCustomDimensions(World world);
 }

core/src/main/java/com/volmit/iris/core/nms/container/AutoClosing.java

@@ -0,0 +1,39 @@
+package com.volmit.iris.core.nms.container;
+
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.function.NastyRunnable;
+import lombok.AllArgsConstructor;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+@AllArgsConstructor
+public class AutoClosing implements AutoCloseable {
+    private static final KMap<Thread, AutoClosing> CONTEXTS = new KMap<>();
+    private final AtomicBoolean closed = new AtomicBoolean();
+    private final NastyRunnable action;
+
+    @Override
+    public void close() {
+        if (closed.getAndSet(true)) return;
+        try {
+            removeContext();
+            action.run();
+        } catch (Throwable e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void storeContext() {
+        CONTEXTS.put(Thread.currentThread(), this);
+    }
+
+    public void removeContext() {
+        CONTEXTS.values().removeIf(c -> c == this);
+    }
+
+    public static void closeContext() {
+        AutoClosing closing = CONTEXTS.remove(Thread.currentThread());
+        if (closing == null) return;
+        closing.close();
+    }
+}

core/src/main/java/com/volmit/iris/core/nms/datapack/DataVersion.java

@@ -3,6 +3,7 @@ package com.volmit.iris.core.nms.datapack;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
 import com.volmit.iris.core.nms.datapack.v1206.DataFixerV1206;
+import com.volmit.iris.core.nms.datapack.v1213.DataFixerV1213;
 import com.volmit.iris.util.collection.KMap;
 import lombok.AccessLevel;
 import lombok.Getter;
@@ -13,7 +14,8 @@ import java.util.function.Supplier;
 @Getter
 public enum DataVersion {
     V1192("1.19.2", 10, DataFixerV1192::new),
-    V1205("1.20.6", 41, DataFixerV1206::new);
+    V1205("1.20.6", 41, DataFixerV1206::new),
+    V1213("1.21.3", 57, DataFixerV1213::new);
     private static final KMap<DataVersion, IDataFixer> cache = new KMap<>();
     @Getter(AccessLevel.NONE)
     private final Supplier<IDataFixer> constructor;

core/src/main/java/com/volmit/iris/core/nms/datapack/IDataFixer.java

@@ -1,11 +1,28 @@
 package com.volmit.iris.core.nms.datapack;
 
 import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.engine.object.IrisRange;
 import com.volmit.iris.util.json.JSONObject;
 
 public interface IDataFixer {
 
-    JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json);
+    default JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+        return json;
+    }
 
-    JSONObject fixDimension(JSONObject json);
+    JSONObject rawDimension(Dimension dimension);
+
+    default JSONObject createDimension(Dimension dimension, IrisRange height, int logicalHeight) {
+        JSONObject obj = rawDimension(dimension);
+        obj.put("min_y", height.getMin());
+        obj.put("height", height.getMax() - height.getMin());
+        obj.put("logical_height", logicalHeight);
+        return obj;
+    }
+
+    enum Dimension {
+        OVERRWORLD,
+        NETHER,
+        THE_END
+    }
 }

core/src/main/java/com/volmit/iris/core/nms/datapack/v1192/DataFixerV1192.java

@@ -1,18 +1,81 @@
 package com.volmit.iris.core.nms.datapack.v1192;
 
 import com.volmit.iris.core.nms.datapack.IDataFixer;
-import com.volmit.iris.engine.object.IrisBiomeCustom;
 import com.volmit.iris.util.json.JSONObject;
+import java.util.Map;
 
 public class DataFixerV1192 implements IDataFixer {
 
-    @Override
-    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
-        return json;
-    }
+    private static final Map<Dimension, String> DIMENSIONS = Map.of(
+            Dimension.OVERRWORLD, """
+            {
+              "ambient_light": 0.0,
+              "bed_works": true,
+              "coordinate_scale": 1.0,
+              "effects": "minecraft:overworld",
+              "has_ceiling": false,
+              "has_raids": true,
+              "has_skylight": true,
+              "infiniburn": "#minecraft:infiniburn_overworld",
+              "monster_spawn_block_light_limit": 0,
+              "monster_spawn_light_level": {
+                "type": "minecraft:uniform",
+                "value": {
+                  "max_inclusive": 7,
+                  "min_inclusive": 0
+                }
+              },
+              "natural": true,
+              "piglin_safe": false,
+              "respawn_anchor_works": false,
+              "ultrawarm": false
+            }""",
+            Dimension.NETHER, """
+            {
+              "ambient_light": 0.1,
+              "bed_works": false,
+              "coordinate_scale": 8.0,
+              "effects": "minecraft:the_nether",
+              "fixed_time": 18000,
+              "has_ceiling": true,
+              "has_raids": false,
+              "has_skylight": false,
+              "infiniburn": "#minecraft:infiniburn_nether",
+              "monster_spawn_block_light_limit": 15,
+              "monster_spawn_light_level": 7,
+              "natural": false,
+              "piglin_safe": true,
+              "respawn_anchor_works": true,
+              "ultrawarm": true
+            }""",
+            Dimension.THE_END, """
+            {
+              "ambient_light": 0.0,
+              "bed_works": false,
+              "coordinate_scale": 1.0,
+              "effects": "minecraft:the_end",
+              "fixed_time": 6000,
+              "has_ceiling": false,
+              "has_raids": true,
+              "has_skylight": false,
+              "infiniburn": "#minecraft:infiniburn_end",
+              "monster_spawn_block_light_limit": 0,
+              "monster_spawn_light_level": {
+                "type": "minecraft:uniform",
+                "value": {
+                  "max_inclusive": 7,
+                  "min_inclusive": 0
+                }
+              },
+              "natural": false,
+              "piglin_safe": false,
+              "respawn_anchor_works": false,
+              "ultrawarm": false
+            }"""
+    );
 
     @Override
-    public JSONObject fixDimension(JSONObject json) {
-        return json;
+    public JSONObject rawDimension(Dimension dimension) {
+        return new JSONObject(DIMENSIONS.get(dimension));
     }
 }

core/src/main/java/com/volmit/iris/core/nms/datapack/v1206/DataFixerV1206.java

@@ -1,6 +1,6 @@
 package com.volmit.iris.core.nms.datapack.v1206;
 
-import com.volmit.iris.core.nms.datapack.IDataFixer;
+import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
 import com.volmit.iris.engine.object.IrisBiomeCustom;
 import com.volmit.iris.engine.object.IrisBiomeCustomSpawn;
 import com.volmit.iris.engine.object.IrisBiomeCustomSpawnType;
@@ -10,12 +10,14 @@ import com.volmit.iris.util.json.JSONObject;
 
 import java.util.Locale;
 
-public class DataFixerV1206 implements IDataFixer {
+public class DataFixerV1206 extends DataFixerV1192 {
     @Override
     public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
         int spawnRarity = biome.getSpawnRarity();
         if (spawnRarity > 0) {
             json.put("creature_spawn_probability", Math.min(spawnRarity/20d, 0.9999999));
+        } else {
+            json.remove("creature_spawn_probability");
         }
 
         var spawns = biome.getSpawns();
@@ -26,10 +28,10 @@ public class DataFixerV1206 implements IDataFixer {
             for (IrisBiomeCustomSpawn i : spawns) {
                 JSONArray g = groups.computeIfAbsent(i.getGroup(), (k) -> new JSONArray());
                 JSONObject o = new JSONObject();
-                o.put("type", "minecraft:" + i.getType().name().toLowerCase());
+                o.put("type", i.getType().getKey());
                 o.put("weight", i.getWeight());
-                o.put("minCount", Math.min(i.getMinCount()/20d, 0));
-                o.put("maxCount", Math.min(i.getMaxCount()/20d, 0.9999999));
+                o.put("minCount", i.getMinCount());
+                o.put("maxCount", i.getMaxCount());
                 g.put(o);
             }
 
@@ -43,7 +45,8 @@ public class DataFixerV1206 implements IDataFixer {
     }
 
     @Override
-    public JSONObject fixDimension(JSONObject json) {
+    public JSONObject rawDimension(Dimension dimension) {
+        JSONObject json = super.rawDimension(dimension);
         if (!(json.get("monster_spawn_light_level") instanceof JSONObject lightLevel))
             return json;
         var value = (JSONObject) lightLevel.remove("value");

core/src/main/java/com/volmit/iris/core/nms/datapack/v1213/DataFixerV1213.java

@@ -0,0 +1,16 @@
+package com.volmit.iris.core.nms.datapack.v1213;
+
+import com.volmit.iris.core.nms.datapack.v1206.DataFixerV1206;
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.util.json.JSONArray;
+import com.volmit.iris.util.json.JSONObject;
+
+public class DataFixerV1213 extends DataFixerV1206 {
+
+    @Override
+    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+        json = super.fixCustomBiome(biome, json);
+        json.put("carvers", new JSONArray());
+        return json;
+    }
+}

core/src/main/java/com/volmit/iris/core/nms/v1X/NMSBinding1X.java

@@ -20,8 +20,9 @@ package com.volmit.iris.core.nms.v1X;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMSBinding;
+import com.volmit.iris.core.nms.container.AutoClosing;
 import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.BlockPos;
+import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
@@ -32,7 +33,6 @@ import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
-import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.event.entity.CreatureSpawnEvent;
@@ -40,8 +40,8 @@ import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.generator.structure.Structure;
 import org.bukkit.inventory.ItemStack;
 
-import java.awt.*;
 import java.awt.Color;
+import java.util.stream.StreamSupport;
 
 public class NMSBinding1X implements INMSBinding {
     private static final boolean supportsCustomHeight = testCustomHeight();
@@ -113,13 +113,33 @@ public class NMSBinding1X implements INMSBinding {
 
     @Override
     public KList<String> getStructureKeys() {
-        var list = Registry.STRUCTURE.stream()
+        var list = StreamSupport.stream(Registry.STRUCTURE.spliterator(), false)
                 .map(Structure::getKey)
                 .map(NamespacedKey::toString)
                 .toList();
         return new KList<>(list);
     }
 
+    @Override
+    public AutoClosing injectLevelStems() {
+        return new AutoClosing(() -> {});
+    }
+
+    @Override
+    public AutoClosing injectUncached(boolean overworld, boolean nether, boolean end) {
+        return injectLevelStems();
+    }
+
+    @Override
+    public boolean missingDimensionTypes(boolean overworld, boolean nether, boolean end) {
+        return false;
+    }
+
+    @Override
+    public void removeCustomDimensions(World world) {
+
+    }
+
     @Override
     public CompoundTag serializeEntity(Entity location) {
         return null;

core/src/main/java/com/volmit/iris/core/pregenerator/ChunkUpdater.java

@@ -1,16 +1,21 @@
 package com.volmit.iris.core.pregenerator;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RollingSequence;
-import com.volmit.iris.util.math.Spiraler;
+import com.volmit.iris.util.profile.LoadBalancer;
 import com.volmit.iris.util.scheduling.J;
 import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 
@@ -23,53 +28,41 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 public class ChunkUpdater {
-    private AtomicBoolean paused;
-    private AtomicBoolean cancelled;
-    private KMap<Chunk, Long> lastUse;
-    private final RollingSequence chunksPerSecond;
-    private final AtomicInteger worldheightsize;
-    private final AtomicInteger worldwidthsize;
-    private final AtomicInteger totalChunks;
-    private final AtomicInteger totalMaxChunks;
-    private final AtomicInteger totalMcaregions;
-    private final AtomicInteger position;
-    private AtomicInteger chunksProcessed;
-    private AtomicInteger chunksUpdated;
-    private AtomicLong startTime;
-    private ExecutorService executor;
-    private ExecutorService chunkExecutor;
-    private ScheduledExecutorService scheduler;
-    private CompletableFuture future;
-    private  CountDownLatch latch;
-    private final Object pauseLock;
+    private static final String REGION_PATH = "region" + File.separator + "r.";
+    private final AtomicBoolean paused = new AtomicBoolean();
+    private final AtomicBoolean cancelled = new AtomicBoolean();
+    private final KMap<Long, Pair<Long, AtomicInteger>> lastUse = new KMap<>();
+    private final RollingSequence chunksPerSecond = new RollingSequence(5);
+    private final AtomicInteger totalMaxChunks = new AtomicInteger();
+    private final AtomicInteger chunksProcessed = new AtomicInteger();
+    private final AtomicInteger chunksProcessedLast = new AtomicInteger();
+    private final AtomicInteger chunksUpdated = new AtomicInteger();
+    private final AtomicBoolean serverEmpty = new AtomicBoolean(true);
+    private final AtomicLong lastCpsTime = new AtomicLong(M.ms());
+    private final int coreLimit = (int) Math.max(Runtime.getRuntime().availableProcessors() * IrisSettings.get().getUpdater().getThreadMultiplier(), 1);
+    private final Semaphore semaphore = new Semaphore(256);
+    private final LoadBalancer loadBalancer = new LoadBalancer(semaphore, 256, IrisSettings.get().getUpdater().emptyMsRange);
+    private final AtomicLong startTime = new AtomicLong();
+    private final Dimensions dimensions;
+    private final PregenTask task;
+    private final ExecutorService executor = Executors.newFixedThreadPool(coreLimit);
+    private final ExecutorService chunkExecutor = Executors.newFixedThreadPool(coreLimit);
+    private final ScheduledExecutorService scheduler  = Executors.newScheduledThreadPool(1);
+    private final CountDownLatch latch;
     private final Engine engine;
     private final World world;
 
     public ChunkUpdater(World world) {
         this.engine = IrisToolbelt.access(world).getEngine();
-        this.chunksPerSecond = new RollingSequence(5);
         this.world = world;
-        this.lastUse = new KMap();
-        this.worldheightsize = new AtomicInteger(calculateWorldDimensions(new File(world.getWorldFolder(), "region"), 1));
-        this.worldwidthsize = new AtomicInteger(calculateWorldDimensions(new File(world.getWorldFolder(), "region"), 0));
-        int m = Math.max(worldheightsize.get(), worldwidthsize.get());
-        this.executor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors() / 3, 1));
-        this.chunkExecutor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors() / 3, 1));
-        this.scheduler = Executors.newScheduledThreadPool(1);
-        this.future = new CompletableFuture<>();
-        this.startTime = new AtomicLong();
-        this.worldheightsize.set(m);
-        this.worldwidthsize.set(m);
-        this.totalMaxChunks = new AtomicInteger((worldheightsize.get() / 16) * (worldwidthsize.get() / 16));
-        this.chunksProcessed = new AtomicInteger();
-        this.chunksUpdated = new AtomicInteger();
-        this.position = new AtomicInteger(0);
+        this.dimensions = calculateWorldDimensions(new File(world.getWorldFolder(), "region"));
+        this.task = dimensions.task();
+        this.totalMaxChunks.set(dimensions.count * 1024);
         this.latch = new CountDownLatch(totalMaxChunks.get());
-        this.paused = new AtomicBoolean(false);
-        this.pauseLock = new Object();
-        this.cancelled = new AtomicBoolean(false);
-        this.totalChunks = new AtomicInteger(0);
-        this.totalMcaregions = new AtomicInteger(0);
+    }
+
+    public String getName() {
+        return world.getName();
     }
 
     public int getChunks() {
@@ -97,7 +90,6 @@ public class ChunkUpdater {
         cancelled.set(true);
     }
 
-
     private void update() {
         Iris.info("Updating..");
         try {
@@ -106,49 +98,35 @@ public class ChunkUpdater {
                 try {
                     if (!paused.get()) {
                         long eta = computeETA();
-                        long elapsedSeconds = (System.currentTimeMillis() - startTime.get()) / 1000;
                         int processed = chunksProcessed.get();
-                        double cps = elapsedSeconds > 0 ? processed / (double) elapsedSeconds : 0;
+                        double last = processed - chunksProcessedLast.getAndSet(processed);
+                        double cps = last / ((M.ms() - lastCpsTime.getAndSet(M.ms())) / 1000d);
                         chunksPerSecond.put(cps);
-                        double percentage = ((double) chunksProcessed.get() / (double) totalMaxChunks.get()) * 100;
+                        double percentage = ((double) processed / (double) totalMaxChunks.get()) * 100;
                         if (!cancelled.get()) {
                             Iris.info("Updated: " + Form.f(processed) + " of " + Form.f(totalMaxChunks.get()) + " (%.0f%%) " + Form.f(chunksPerSecond.getAverage()) + "/s, ETA: " + Form.duration(eta,
                                     2), percentage);
                         }
                     }
                 } catch (Exception e) {
+                    Iris.reportError(e);
                     e.printStackTrace();
                 }
             }, 0, 3, TimeUnit.SECONDS);
+            scheduler.scheduleAtFixedRate(this::unloadChunks, 0, 1, TimeUnit.SECONDS);
+            scheduler.scheduleAtFixedRate(() -> {
+                boolean empty = Bukkit.getOnlinePlayers().isEmpty();
+                if (serverEmpty.getAndSet(empty) == empty)
+                    return;
+                loadBalancer.setRange(empty ? IrisSettings.get().getUpdater().emptyMsRange : IrisSettings.get().getUpdater().defaultMsRange);
+            }, 0, 10, TimeUnit.SECONDS);
 
-            CompletableFuture.runAsync(() -> {
-                for (int i = 0; i < totalMaxChunks.get(); i++) {
-                    if (paused.get()) {
-                        synchronized (pauseLock) {
-                            try {
-                                pauseLock.wait();
-                            } catch (InterruptedException e) {
-                                Iris.error("Interrupted while waiting for executor: ");
-                                e.printStackTrace();
-                                break;
-                            }
-                        }
-                    }
-                    executor.submit(() -> {
-                        if (!cancelled.get()) {
-                            processNextChunk();   
-                        }
-                        latch.countDown();
-                    });
-                }
-            }).thenRun(() -> {
-                try {
-                    latch.await();
-                    close();
-                } catch (Exception e) {
-                    Thread.currentThread().interrupt();
-                }
-            });
+            var t = new Thread(() -> {
+                run();
+                close();
+            }, "Iris Chunk Updater - " + world.getName());
+            t.setPriority(Thread.MAX_PRIORITY);
+            t.start();
 
         } catch (Exception e) {
             e.printStackTrace();
@@ -157,14 +135,16 @@ public class ChunkUpdater {
 
     public void close() {
         try {
-            unloadAndSaveAllChunks();
+            loadBalancer.close();
+            semaphore.acquire(256);
+
             executor.shutdown();
             executor.awaitTermination(5, TimeUnit.SECONDS);
             chunkExecutor.shutdown();
             chunkExecutor.awaitTermination(5, TimeUnit.SECONDS);
             scheduler.shutdownNow();
-        } catch (Exception ignored) {
-        }
+            unloadAndSaveAllChunks();
+        } catch (Exception ignored) {}
         if (cancelled.get()) {
             Iris.info("Updated: " + Form.f(chunksUpdated.get()) + " Chunks");
             Iris.info("Irritated: " + Form.f(chunksProcessed.get()) + " of " + Form.f(totalMaxChunks.get()));
@@ -175,18 +155,72 @@ public class ChunkUpdater {
         }
     }
 
-    private void processNextChunk() {
-        int pos = position.getAndIncrement();
-        int[] coords = getChunk(pos);
-        if (loadChunksIfGenerated(coords[0], coords[1])) {
-            Chunk c = world.getChunkAt(coords[0], coords[1]);
-            engine.updateChunk(c);
-            chunksUpdated.incrementAndGet();
+    private void run() {
+        task.iterateRegions((rX, rZ) -> {
+            if (cancelled.get())
+                return;
+
+            while (paused.get()) {
+                J.sleep(50);
+            }
+
+            if (rX < dimensions.min.getX() ||
+                    rX > dimensions.max.getX() ||
+                    rZ < dimensions.min.getZ() ||
+                    rZ > dimensions.max.getZ() ||
+                    !new File(world.getWorldFolder(), REGION_PATH + rX + "." + rZ + ".mca").exists()
+            ) return;
+
+            task.iterateChunks(rX, rZ, (x, z) -> {
+                while (paused.get() && !cancelled.get()) {
+                    J.sleep(50);
+                }
+
+                try {
+                    semaphore.acquire();
+                } catch (InterruptedException ignored) {
+                    return;
+                }
+                chunkExecutor.submit(() -> {
+                    try {
+                        if (!cancelled.get())
+                            processChunk(x, z);
+                    } finally {
+                        latch.countDown();
+                        semaphore.release();
+                    }
+                });
+            });
+        });
+    }
+
+    private void processChunk(int x, int z) {
+        if (!loadChunksIfGenerated(x, z)) {
+            chunksProcessed.getAndIncrement();
+            return;
+        }
+
+        try {
+            Chunk c = world.getChunkAt(x, z);
+            engine.getMantle().getMantle().getChunk(c);
+            engine.updateChunk(c);
+
+            for (int xx = -1; xx <= 1; xx++) {
+                for (int zz = -1; zz <= 1; zz++) {
+                    var counter = lastUse.get(Cache.key(x + xx, z + zz));
+                    if (counter != null) counter.getB().decrementAndGet();
+                }
+            }
+        } finally {
+            chunksUpdated.incrementAndGet();
+            chunksProcessed.getAndIncrement();
         }
-        chunksProcessed.getAndIncrement();
     }
 
     private boolean loadChunksIfGenerated(int x, int z) {
+        if (engine.getMantle().getMantle().hasFlag(x, z, MantleFlag.ETCHED))
+            return false;
+
         for (int dx = -1; dx <= 1; dx++) {
             for (int dz = -1; dz <= 1; dz++) {
                 if (!PaperLib.isChunkGenerated(world, x + dx, z + dz)) {
@@ -196,45 +230,79 @@ public class ChunkUpdater {
         }
 
         AtomicBoolean generated = new AtomicBoolean(true);
-        KList<Future<?>> futures = new KList<>(9);
+        CountDownLatch latch = new CountDownLatch(9);
         for (int dx = -1; dx <= 1; dx++) {
             for (int dz = -1; dz <= 1; dz++) {
                 int xx = x + dx;
                 int zz = z + dz;
-                futures.add(chunkExecutor.submit(() -> {
-                    Chunk c;
+                executor.submit(() -> {
                     try {
-                        c = PaperLib.getChunkAtAsync(world, xx, zz, false).get();
-                    } catch (InterruptedException | ExecutionException e) {
-                        generated.set(false);
-                        return;
-                    }
-                    if (!c.isLoaded()) {
-                        CountDownLatch latch = new CountDownLatch(1);
-                        J.s(() -> {
-                            c.load(false);
-                            latch.countDown();
-                        });
+                        Chunk c;
                         try {
-                            latch.await();
-                        } catch (InterruptedException ignored) {}
+                            c = PaperLib.getChunkAtAsync(world, xx, zz, false, true)
+                                    .thenApply(chunk -> {
+                                        if (chunk != null)
+                                            chunk.addPluginChunkTicket(Iris.instance);
+                                        return chunk;
+                                    }).get();
+                        } catch (InterruptedException | ExecutionException e) {
+                            generated.set(false);
+                            return;
+                        }
+
+                        if (c == null) {
+                            generated.set(false);
+                            return;
+                        }
+
+                        if (!c.isLoaded()) {
+                            var future = J.sfut(() -> c.load(false));
+                            if (future != null) future.join();
+                        }
+
+                        if (!PaperLib.isChunkGenerated(c.getWorld(), xx, zz))
+                            generated.set(false);
+
+                        var pair = lastUse.computeIfAbsent(Cache.key(c), k -> new Pair<>(0L, new AtomicInteger(-1)));
+                        pair.setA(M.ms());
+                        pair.getB().updateAndGet(i -> i == -1 ? 1 : ++i);
+                    } finally {
+                        latch.countDown();
                     }
-                    if (!c.isGenerated()) {
-                        generated.set(false);
-                    }
-                    lastUse.put(c, M.ms());
-                }));
+                });
             }
         }
-        while (!futures.isEmpty()) {
-            futures.removeIf(Future::isDone);
-            try {
-                Thread.sleep(50);
-            } catch (InterruptedException ignored) {}
+
+        try {
+            latch.await();
+        } catch (InterruptedException e) {
+            Iris.info("Interrupted while waiting for chunks to load");
         }
         return generated.get();
     }
 
+    private synchronized void unloadChunks() {
+        for (var key : new ArrayList<>(lastUse.keySet())) {
+            if (key == null) continue;
+            var pair = lastUse.get(key);
+            if (pair == null) continue;
+            var lastUseTime = pair.getA();
+            var counter = pair.getB();
+            if (lastUseTime == null || counter == null)
+                continue;
+
+            if (M.ms() - lastUseTime >= 5000 && counter.get() == 0) {
+                int x = Cache.keyX(key);
+                int z = Cache.keyZ(key);
+                J.s(() -> {
+                    world.removePluginChunkTicket(x, z, Iris.instance);
+                    world.unloadChunk(x, z);
+                    lastUse.remove(key);
+                });
+            }
+        }
+    }
+
     private void unloadAndSaveAllChunks() {
         try {
             J.sfut(() -> {
@@ -243,16 +311,11 @@ public class ChunkUpdater {
                     return;
                 }
 
-                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
-                    Long lastUseTime = lastUse.get(i);
-                    if (lastUseTime != null && M.ms() - lastUseTime >= 5000) {
-                        i.unload();
-                        lastUse.remove(i);
-                    }
-                }
+                unloadChunks();
                 world.save();
             }).get();
         } catch (Throwable e) {
+            Iris.reportError(e);
             e.printStackTrace();
         }
     }
@@ -266,7 +329,7 @@ public class ChunkUpdater {
         );
     }
 
-    public int calculateWorldDimensions(File regionDir, Integer o) {
+    private Dimensions calculateWorldDimensions(File regionDir) {
         File[] files = regionDir.listFiles((dir, name) -> name.endsWith(".mca"));
 
         int minX = Integer.MAX_VALUE;
@@ -279,40 +342,23 @@ public class ChunkUpdater {
             int x = Integer.parseInt(parts[1]);
             int z = Integer.parseInt(parts[2]);
 
-            if (x < minX) minX = x;
-            if (x > maxX) maxX = x;
-            if (z < minZ) minZ = z;
-            if (z > maxZ) maxZ = z;
+            minX = Math.min(minX, x);
+            maxX = Math.max(maxX, x);
+            minZ = Math.min(minZ, z);
+            maxZ = Math.max(maxZ, z);
         }
+        int oX = minX + ((maxX - minX) / 2);
+        int oZ = minZ + ((maxZ - minZ) / 2);
 
-        int height = (maxX - minX + 1) * 32 * 16;
-        int width = (maxZ - minZ + 1) * 32 * 16;
+        int height = maxX - minX + 1;
+        int width = maxZ - minZ + 1;
 
-        if (o == 1) {
-            return height;
-        }
-        if (o == 0) {
-            return width;
-        }
-        return 0;
+        return new Dimensions(new Position2(minX, minZ), new Position2(maxX, maxZ), height * width, PregenTask.builder()
+                .radiusZ((int) Math.ceil(width / 2d * 512))
+                .radiusX((int) Math.ceil(height / 2d * 512))
+                .center(new Position2(oX, oZ))
+                .build());
     }
 
-    public int[] getChunk(int position) {
-        int p = -1;
-        AtomicInteger xx = new AtomicInteger();
-        AtomicInteger zz = new AtomicInteger();
-        Spiraler s = new Spiraler(worldheightsize.get() * 2, worldwidthsize.get() * 2, (x, z) -> {
-            xx.set(x);
-            zz.set(z);
-        });
-
-        while (s.hasNext() && p++ < position) {
-            s.next();
-        }
-        int[] coords = new int[2];
-        coords[0] = xx.get();
-        coords[1] = zz.get();
-
-        return coords;
-    }
+    private record Dimensions(Position2 min, Position2 max, int count, PregenTask task) { }
 }

core/src/main/java/com/volmit/iris/core/pregenerator/DeepSearchPregenerator.java

@@ -15,7 +15,6 @@ import com.volmit.iris.util.math.RollingSequence;
 import com.volmit.iris.util.math.Spiraler;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
-import lombok.Builder;
 import lombok.Data;
 import lombok.Getter;
 import org.bukkit.Bukkit;
@@ -261,14 +260,14 @@ public class DeepSearchPregenerator extends Thread implements Listener {
     }
 
     @Data
-    @Builder
+    @lombok.Builder
     public static class DeepSearchJob {
         private World world;
-        @Builder.Default
+        @lombok.Builder.Default
         private int radiusBlocks = 5000;
-        @Builder.Default
+        @lombok.Builder.Default
         private int position = 0;
-        @Builder.Default
+        @lombok.Builder.Default
         boolean paused = false;
     }
 }

core/src/main/java/com/volmit/iris/core/pregenerator/IrisPregenerator.java

@@ -19,7 +19,6 @@
 package com.volmit.iris.core.pregenerator;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.pack.IrisPack;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KSet;
@@ -32,28 +31,33 @@ import com.volmit.iris.util.math.RollingSequence;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.Looper;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 
 
 public class IrisPregenerator {
+    private static final double INVALID = 9223372036854775807d;
     private final PregenTask task;
     private final PregeneratorMethod generator;
     private final PregenListener listener;
     private final Looper ticker;
     private final AtomicBoolean paused;
     private final AtomicBoolean shutdown;
+    private final RollingSequence cachedPerSecond;
     private final RollingSequence chunksPerSecond;
     private final RollingSequence chunksPerMinute;
     private final RollingSequence regionsPerMinute;
     private final KList<Integer> chunksPerSecondHistory;
-    private static AtomicInteger generated;
-    private final AtomicInteger generatedLast;
-    private final AtomicInteger generatedLastMinute;
-    private static AtomicInteger totalChunks;
+    private final AtomicLong generated;
+    private final AtomicLong generatedLast;
+    private final AtomicLong generatedLastMinute;
+    private final AtomicLong cached;
+    private final AtomicLong cachedLast;
+    private final AtomicLong cachedLastMinute;
+    private final AtomicLong totalChunks;
     private final AtomicLong startTime;
     private final ChronoLatch minuteLatch;
     private final AtomicReference<String> currentGeneratorMethod;
@@ -62,8 +66,10 @@ public class IrisPregenerator {
     private final KSet<Position2> net;
     private final ChronoLatch cl;
     private final ChronoLatch saveLatch = new ChronoLatch(30000);
+    private final IrisPackBenchmarking benchmarking;
 
     public IrisPregenerator(PregenTask task, PregeneratorMethod generator, PregenListener listener) {
+        benchmarking = IrisPackBenchmarking.getInstance();
         this.listener = listenify(listener);
         cl = new ChronoLatch(5000);
         generatedRegions = new KSet<>();
@@ -75,46 +81,71 @@ public class IrisPregenerator {
         net = new KSet<>();
         currentGeneratorMethod = new AtomicReference<>("Void");
         minuteLatch = new ChronoLatch(60000, false);
+        cachedPerSecond = new RollingSequence(5);
         chunksPerSecond = new RollingSequence(10);
         chunksPerMinute = new RollingSequence(10);
         regionsPerMinute = new RollingSequence(10);
         chunksPerSecondHistory = new KList<>();
-        generated = new AtomicInteger(0);
-        generatedLast = new AtomicInteger(0);
-        generatedLastMinute = new AtomicInteger(0);
-        totalChunks = new AtomicInteger(0);
-        task.iterateRegions((_a, _b) -> totalChunks.addAndGet(1024));
+        generated = new AtomicLong(0);
+        generatedLast = new AtomicLong(0);
+        generatedLastMinute = new AtomicLong(0);
+        cached = new AtomicLong();
+        cachedLast = new AtomicLong(0);
+        cachedLastMinute = new AtomicLong(0);
+        totalChunks = new AtomicLong(0);
+        task.iterateAllChunks((_a, _b) -> totalChunks.incrementAndGet());
         startTime = new AtomicLong(M.ms());
         ticker = new Looper() {
             @Override
             protected long loop() {
                 long eta = computeETA();
-                int secondGenerated = generated.get() - generatedLast.get();
-                generatedLast.set(generated.get());
-                chunksPerSecond.put(secondGenerated);
-                chunksPerSecondHistory.add(secondGenerated);
 
-                if (minuteLatch.flip()) {
-                    int minuteGenerated = generated.get() - generatedLastMinute.get();
-                    generatedLastMinute.set(generated.get());
-                    chunksPerMinute.put(minuteGenerated);
-                    regionsPerMinute.put((double) minuteGenerated / 1024D);
+                long secondCached = cached.get() - cachedLast.get();
+                cachedLast.set(cached.get());
+                cachedPerSecond.put(secondCached);
+
+                long secondGenerated = generated.get() - generatedLast.get() - secondCached;
+                generatedLast.set(generated.get());
+                if (secondCached == 0 || secondGenerated != 0) {
+                    chunksPerSecond.put(secondGenerated);
+                    chunksPerSecondHistory.add((int) secondGenerated);
                 }
 
-                listener.onTick(chunksPerSecond.getAverage(), chunksPerMinute.getAverage(),
+                if (minuteLatch.flip()) {
+                    long minuteCached = cached.get() - cachedLastMinute.get();
+                    cachedLastMinute.set(cached.get());
+
+                    long minuteGenerated = generated.get() - generatedLastMinute.get() - minuteCached;
+                    generatedLastMinute.set(generated.get());
+                    if (minuteCached == 0 || minuteGenerated != 0) {
+                        chunksPerMinute.put(minuteGenerated);
+                        regionsPerMinute.put((double) minuteGenerated / 1024D);
+                    }
+                }
+                boolean cached = cachedPerSecond.getAverage() != 0;
+
+                listener.onTick(
+                        cached ? cachedPerSecond.getAverage() : chunksPerSecond.getAverage(),
+                        chunksPerMinute.getAverage(),
                         regionsPerMinute.getAverage(),
-                        (double) generated.get() / (double) totalChunks.get(),
-                        generated.get(), totalChunks.get(),
-                        totalChunks.get() - generated.get(),
-                        eta, M.ms() - startTime.get(), currentGeneratorMethod.get());
+                        (double) generated.get() / (double) totalChunks.get(), generated.get(),
+                        totalChunks.get(),
+                        totalChunks.get() - generated.get(), eta, M.ms() - startTime.get(), currentGeneratorMethod.get(),
+                        cached);
 
                 if (cl.flip()) {
                     double percentage = ((double) generated.get() / (double) totalChunks.get()) * 100;
-                    if (!IrisPackBenchmarking.benchmarkInProgress) {
-                        Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration(eta, 2), percentage);
-                    } else {
-                        Iris.info("Benchmarking: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration(eta, 2), percentage);
-                    }
+
+                    Iris.info("%s: %s of %s (%.0f%%), %s/s ETA: %s",
+                            benchmarking != null ? "Benchmarking" : "Pregen",
+                            Form.f(generated.get()),
+                            Form.f(totalChunks.get()),
+                            percentage,
+                            cached ?
+                                    "Cached " + Form.f((int) cachedPerSecond.getAverage()) :
+                                    Form.f((int) chunksPerSecond.getAverage()),
+                            Form.duration(eta, 2)
+                    );
                 }
                 return 1000;
             }
@@ -122,12 +153,13 @@ public class IrisPregenerator {
     }
 
     private long computeETA() {
-        return (long) (totalChunks.get() > 1024 ? // Generated chunks exceed 1/8th of total?
+        double d = (long) (totalChunks.get() > 1024 ? // Generated chunks exceed 1/8th of total?
                 // If yes, use smooth function (which gets more accurate over time since its less sensitive to outliers)
-                ((totalChunks.get() - generated.get()) * ((double) (M.ms() - startTime.get()) / (double) generated.get())) :
+                ((totalChunks.get() - generated.get() - cached.get()) * ((double) (M.ms() - startTime.get()) / ((double) generated.get() - cached.get()))) :
                 // If no, use quick function (which is less accurate over time but responds better to the initial delay)
-                ((totalChunks.get() - generated.get()) / chunksPerSecond.getAverage()) * 1000
+                ((totalChunks.get() - generated.get() - cached.get()) / chunksPerSecond.getAverage()) * 1000
         );
+        return Double.isFinite(d) && d != INVALID ? (long) d : 0;
     }
 
 
@@ -139,13 +171,15 @@ public class IrisPregenerator {
         init();
         ticker.start();
         checkRegions();
+        var p = PrecisionStopwatch.start();
         task.iterateRegions((x, z) -> visitRegion(x, z, true));
         task.iterateRegions((x, z) -> visitRegion(x, z, false));
+        Iris.info("Pregen took " + Form.duration((long) p.getMilliseconds()));
         shutdown();
-        if (!IrisPackBenchmarking.benchmarkInProgress) {
+        if (benchmarking == null) {
             Iris.info(C.IRIS + "Pregen stopped.");
         } else {
-            IrisPackBenchmarking.instance.finishedBenchmark(chunksPerSecondHistory);
+            benchmarking.finishedBenchmark(chunksPerSecondHistory);
         }
     }
 
@@ -194,7 +228,7 @@ public class IrisPregenerator {
         } else if (!regions) {
             hit = true;
             listener.onRegionGenerating(x, z);
-            PregenTask.iterateRegion(x, z, (xx, zz) -> {
+            task.iterateChunks(x, z, (xx, zz) -> {
                 while (paused.get() && !shutdown.get()) {
                     J.sleep(50);
                 }
@@ -235,8 +269,8 @@ public class IrisPregenerator {
     private PregenListener listenify(PregenListener listener) {
         return new PregenListener() {
             @Override
-            public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
-                listener.onTick(chunksPerSecond, chunksPerMinute, regionsPerMinute, percent, generated, totalChunks, chunksRemaining, eta, elapsed, method);
+            public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, long generated, long totalChunks, long chunksRemaining, long eta, long elapsed, String method, boolean cached) {
+                listener.onTick(chunksPerSecond, chunksPerMinute, regionsPerMinute, percent, generated, totalChunks, chunksRemaining, eta, elapsed, method, cached);
             }
 
             @Override
@@ -245,9 +279,10 @@ public class IrisPregenerator {
             }
 
             @Override
-            public void onChunkGenerated(int x, int z) {
-                listener.onChunkGenerated(x, z);
+            public void onChunkGenerated(int x, int z, boolean c) {
+                listener.onChunkGenerated(x, z, c);
                 generated.addAndGet(1);
+                if (c) cached.addAndGet(1);
             }
 
             @Override

core/src/main/java/com/volmit/iris/core/pregenerator/LazyPregenerator.java

@@ -12,7 +12,6 @@ import com.volmit.iris.util.math.Spiraler;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import io.papermc.lib.PaperLib;
-import lombok.Builder;
 import lombok.Data;
 import lombok.Getter;
 import org.bukkit.Bukkit;
@@ -264,22 +263,22 @@ public class LazyPregenerator extends Thread implements Listener {
     }
 
     @Data
-    @Builder
+    @lombok.Builder
     public static class LazyPregenJob {
         private String world;
-        @Builder.Default
+        @lombok.Builder.Default
         private int healingPosition = 0;
-        @Builder.Default
+        @lombok.Builder.Default
         private boolean healing = false;
-        @Builder.Default
+        @lombok.Builder.Default
         private int chunksPerMinute = 32;
-        @Builder.Default
+        @lombok.Builder.Default
         private int radiusBlocks = 5000;
-        @Builder.Default
+        @lombok.Builder.Default
         private int position = 0;
-        @Builder.Default
+        @lombok.Builder.Default
         boolean silent = false;
-        @Builder.Default
+        @lombok.Builder.Default
         boolean paused = false;
     }
 }

core/src/main/java/com/volmit/iris/core/pregenerator/PregenListener.java

@@ -19,11 +19,15 @@
 package com.volmit.iris.core.pregenerator;
 
 public interface PregenListener {
-    void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method);
+    void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, long generated, long totalChunks, long chunksRemaining, long eta, long elapsed, String method, boolean cached);
 
     void onChunkGenerating(int x, int z);
 
-    void onChunkGenerated(int x, int z);
+    default void onChunkGenerated(int x, int z) {
+        onChunkGenerated(x, z, false);
+    }
+
+    void onChunkGenerated(int x, int z, boolean cached);
 
     void onRegionGenerated(int x, int z);
 

core/src/main/java/com/volmit/iris/core/pregenerator/PregenTask.java

@@ -32,17 +32,26 @@ import java.util.Comparator;
 @Data
 public class PregenTask {
     private static final Position2 ZERO = new Position2(0, 0);
-    private static final KList<Position2> ORDER_CENTER = computeChunkOrder();
     private static final KMap<Position2, KList<Position2>> ORDERS = new KMap<>();
 
     @Builder.Default
-    private boolean gui = false;
+    private final boolean gui = false;
     @Builder.Default
-    private Position2 center = new Position2(0, 0);
+    private final Position2 center = new Position2(0, 0);
     @Builder.Default
-    private int width = 1;
+    private final int radiusX = 1;
     @Builder.Default
-    private int height = 1;
+    private final int radiusZ = 1;
+
+    private final Bounds bounds = new Bounds();
+
+    protected PregenTask(boolean gui, Position2 center, int radiusX, int radiusZ) {
+        this.gui = gui;
+        this.center = new ProxiedPos(center);
+        this.radiusX = radiusX;
+        this.radiusZ = radiusZ;
+        bounds.update();
+    }
 
     public static void iterateRegion(int xr, int zr, Spiraled s, Position2 pull) {
         for (Position2 i : ORDERS.computeIfAbsent(pull, PregenTask::computeOrder)) {
@@ -70,29 +79,72 @@ public class PregenTask {
         return p;
     }
 
-    private static KList<Position2> computeChunkOrder() {
-        Position2 center = new Position2(15, 15);
-        KList<Position2> p = new KList<>();
-        new Spiraler(33, 33, (x, z) -> {
-            int xx = x + 15;
-            int zz = z + 15;
-            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
-                return;
-            }
-
-            p.add(new Position2(xx, zz));
-        }).drain();
-        p.sort(Comparator.comparing((i) -> i.distance(center)));
-        return p;
+    public void iterateRegions(Spiraled s) {
+        var bound = bounds.region();
+        new Spiraler(bound.sizeX, bound.sizeZ, ((x, z) -> {
+            if (bound.check(x, z)) s.on(x, z);
+        })).setOffset(center.getX() >> 9, center.getZ() >> 9).drain();
     }
 
-    public void iterateRegions(Spiraled s) {
-        new Spiraler(getWidth() * 2, getHeight() * 2, s)
-                .setOffset(center.getX(), center.getZ()).drain();
+    public void iterateChunks(int rX, int rZ, Spiraled s) {
+        var bound = bounds.chunk();
+        iterateRegion(rX, rZ, ((x, z) -> {
+            if (bound.check(x, z)) s.on(x, z);
+        }));
     }
 
     public void iterateAllChunks(Spiraled s) {
-        new Spiraler(getWidth() * 2, getHeight() * 2, (x, z) -> iterateRegion(x, z, s))
-                .setOffset(center.getX(), center.getZ()).drain();
+        iterateRegions(((rX, rZ) -> iterateChunks(rX, rZ, s)));
+    }
+
+    private class Bounds {
+        private Bound chunk = null;
+        private Bound region = null;
+
+        public void update() {
+            int maxX = center.getX() + radiusX;
+            int maxZ = center.getZ() + radiusZ;
+            int minX = center.getX() - radiusX;
+            int minZ = center.getZ() - radiusZ;
+
+            chunk = new Bound(minX >> 4, minZ >> 4, Math.ceilDiv(maxX, 16), Math.ceilDiv(maxZ, 16));
+            region = new Bound(minX >> 9, minZ >> 9, Math.ceilDiv(maxX, 512), Math.ceilDiv(maxZ, 512));
+        }
+
+        public Bound chunk() {
+            if (chunk == null) update();
+            return chunk;
+        }
+
+        public Bound region() {
+            if (region == null) update();
+            return region;
+        }
+    }
+
+    private record Bound(int minX, int maxX, int minZ, int maxZ, int sizeX, int sizeZ) {
+        private Bound(int minX, int minZ, int maxX, int maxZ) {
+            this(minX, maxX, minZ, maxZ, maxZ - minZ + 1, maxZ - minZ + 1);
+        }
+
+        boolean check(int x, int z) {
+            return x >= minX && x <= maxX && z >= minZ && z <= maxZ;
+        }
+    }
+
+    private static class ProxiedPos extends Position2 {
+        public ProxiedPos(Position2 p) {
+            super(p.getX(), p.getZ());
+        }
+
+        @Override
+        public void setX(int x) {
+            throw new IllegalStateException("This Position2 may not be modified");
+        }
+
+        @Override
+        public void setZ(int z) {
+            throw new IllegalStateException("This Position2 may not be modified");
+        }
     }
 }

core/src/main/java/com/volmit/iris/core/pregenerator/TurboPregenerator.java

@@ -18,7 +18,6 @@ import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import io.papermc.lib.PaperLib;
-import lombok.Builder;
 import lombok.Data;
 import lombok.Getter;
 import org.apache.logging.log4j.core.util.ExecutorServices;
@@ -328,14 +327,14 @@ public class TurboPregenerator extends Thread implements Listener {
     }
 
     @Data
-    @Builder
+    @lombok.Builder
     public static class TurboPregenJob {
         private String world;
-        @Builder.Default
+        @lombok.Builder.Default
         private int radiusBlocks = 5000;
-        @Builder.Default
+        @lombok.Builder.Default
         private int position = 0;
-        @Builder.Default
+        @lombok.Builder.Default
         boolean paused = false;
     }
 }

core/src/main/java/com/volmit/iris/core/pregenerator/cache/PregenCache.java

@@ -0,0 +1,70 @@
+package com.volmit.iris.core.pregenerator.cache;
+
+import com.volmit.iris.util.documentation.ChunkCoordinates;
+import com.volmit.iris.util.documentation.RegionCoordinates;
+
+import java.io.File;
+
+public interface PregenCache {
+    default boolean isThreadSafe() {
+        return false;
+    }
+
+    @ChunkCoordinates
+    boolean isChunkCached(int x, int z);
+
+    @RegionCoordinates
+    boolean isRegionCached(int x, int z);
+
+    @ChunkCoordinates
+    void cacheChunk(int x, int z);
+
+    @RegionCoordinates
+    void cacheRegion(int x, int z);
+
+    void write();
+
+    static PregenCache create(File directory) {
+        if (directory == null) return EMPTY;
+        return new PregenCacheImpl(directory);
+    }
+
+    default PregenCache sync() {
+        if (isThreadSafe()) return this;
+        return new SynchronizedCache(this);
+    }
+
+    PregenCache EMPTY = new PregenCache() {
+        @Override
+        public boolean isThreadSafe() {
+            return true;
+        }
+
+        @Override
+        public boolean isChunkCached(int x, int z) {
+            return false;
+        }
+
+        @Override
+        public boolean isRegionCached(int x, int z) {
+            return false;
+        }
+
+        @Override
+        public void cacheChunk(int x, int z) {
+
+        }
+
+        @Override
+        public void cacheRegion(int x, int z) {
+
+        }
+
+        @Override
+        public void write() {
+
+        }
+    };
+
+
+}

core/src/main/java/com/volmit/iris/core/pregenerator/cache/PregenCacheImpl.java

@@ -0,0 +1,218 @@
+package com.volmit.iris.core.pregenerator.cache;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
+import com.github.benmanes.caffeine.cache.RemovalCause;
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.data.Varint;
+import com.volmit.iris.util.documentation.ChunkCoordinates;
+import com.volmit.iris.util.documentation.RegionCoordinates;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.parallel.HyperLock;
+import lombok.RequiredArgsConstructor;
+import net.jpountz.lz4.LZ4BlockInputStream;
+import net.jpountz.lz4.LZ4BlockOutputStream;
+import org.jetbrains.annotations.Nullable;
+
+import javax.annotation.concurrent.NotThreadSafe;
+import java.io.*;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+
+@NotThreadSafe
+@RequiredArgsConstructor
+class PregenCacheImpl implements PregenCache {
+    private static final int SIZE = 32;
+    private final File directory;
+    private final HyperLock hyperLock = new HyperLock(SIZE * 2, true);
+    private final LoadingCache<Pos, Plate> cache = Caffeine.newBuilder()
+            .expireAfterAccess(10, TimeUnit.SECONDS)
+            .maximumSize(SIZE)
+            .removalListener(this::onRemoval)
+            .evictionListener(this::onRemoval)
+            .build(this::load);
+
+    @ChunkCoordinates
+    public boolean isChunkCached(int x, int z) {
+        var plate = cache.get(new Pos(x >> 10, z >> 10));
+        if (plate == null) return false;
+        return plate.isCached((x >> 5) & 31, (z >> 5) & 31, r -> r.isCached(x & 31, z & 31));
+    }
+
+    @RegionCoordinates
+    public boolean isRegionCached(int x, int z) {
+        var plate = cache.get(new Pos(x >> 5, z >> 5));
+        if (plate == null) return false;
+        return plate.isCached(x & 31, z & 31, Region::isCached);
+    }
+
+    @ChunkCoordinates
+    public void cacheChunk(int x, int z) {
+        var plate = cache.get(new Pos(x >> 10, z >> 10));
+        plate.cache((x >> 5) & 31, (z >> 5) & 31, r -> r.cache(x & 31, z & 31));
+    }
+
+    @RegionCoordinates
+    public void cacheRegion(int x, int z) {
+        var plate = cache.get(new Pos(x >> 5, z >> 5));
+        plate.cache(x & 31, z & 31, Region::cache);
+    }
+
+    public void write() {
+        cache.asMap().values().forEach(this::write);
+    }
+
+    private Plate load(Pos key) {
+        hyperLock.lock(key.x, key.z);
+        try {
+            File file = fileForPlate(key);
+            if (!file.exists()) return new Plate(key);
+            try (var in = new DataInputStream(new LZ4BlockInputStream(new FileInputStream(file)))) {
+                return new Plate(key, in);
+            } catch (IOException e){
+                Iris.error("Failed to read pregen cache " + file);
+                Iris.reportError(e);
+                e.printStackTrace();
+                return new Plate(key);
+            }
+        } finally {
+            hyperLock.unlock(key.x, key.z);
+        }
+    }
+
+    private void write(Plate plate) {
+        hyperLock.lock(plate.pos.x, plate.pos.z);
+        try {
+            File file = fileForPlate(plate.pos);
+            try {
+                IO.write(file, out -> new DataOutputStream(new LZ4BlockOutputStream(out)), plate::write);
+            } catch (IOException e) {
+                Iris.error("Failed to write pregen cache " + file);
+                Iris.reportError(e);
+                e.printStackTrace();
+            }
+        } finally {
+            hyperLock.unlock(plate.pos.x, plate.pos.z);
+        }
+    }
+
+    private void onRemoval(@Nullable Pos key, @Nullable Plate plate, RemovalCause cause) {
+        if (plate == null) return;
+        write(plate);
+    }
+
+    private File fileForPlate(Pos pos) {
+        if (!directory.exists() && !directory.mkdirs())
+            throw new IllegalStateException("Cannot create directory: " + directory.getAbsolutePath());
+        return new File(directory, "c." + pos.x + "." + pos.z + ".lz4b");
+    }
+
+    private static class Plate {
+        private final Pos pos;
+        private short count;
+        private Region[] regions;
+
+        public Plate(Pos pos) {
+            this.pos = pos;
+            count = 0;
+            regions = new Region[1024];
+        }
+
+        public Plate(Pos pos, DataInput in) throws IOException {
+            this.pos = pos;
+            count = (short) Varint.readSignedVarInt(in);
+            if (count == 1024) return;
+            regions = new Region[1024];
+            for (int i = 0; i < 1024; i++) {
+                if (in.readBoolean()) continue;
+                regions[i] = new Region(in);
+            }
+        }
+
+        public boolean isCached(int x, int z, Predicate<Region> predicate) {
+            if (count == 1024) return true;
+            Region region = regions[x * 32 + z];
+            if (region == null) return false;
+            return predicate.test(region);
+        }
+
+        public void cache(int x, int z, Predicate<Region> predicate) {
+            if (count == 1024) return;
+            Region region = regions[x * 32 + z];
+            if (region == null) regions[x * 32 + z] = region = new Region();
+            if (predicate.test(region)) count++;
+        }
+
+        public void write(DataOutput out) throws IOException {
+            Varint.writeSignedVarInt(count, out);
+            if (count == 1024) return;
+            for (Region region : regions) {
+                out.writeBoolean(region == null);
+                if (region == null) continue;
+                region.write(out);
+            }
+        }
+    }
+
+    private static class Region {
+        private short count;
+        private long[] words;
+
+        public Region() {
+            count = 0;
+            words = new long[64];
+        }
+
+        public Region(DataInput in) throws IOException {
+            count = (short) Varint.readSignedVarInt(in);
+            if (count == 1024) return;
+            words = new long[64];
+            for (int i = 0; i < 64; i++) {
+                words[i] = Varint.readUnsignedVarLong(in);
+            }
+        }
+
+        public boolean cache() {
+            if (count == 1024) return false;
+            count = 1024;
+            words = null;
+            return true;
+        }
+
+        public boolean cache(int x, int z) {
+            if (count == 1024) return false;
+
+            int i = x * 32 + z;
+            int w = i >> 6;
+            long b = 1L << (i & 63);
+
+            var cur = (words[w] & b) != 0;
+            if (cur) return false;
+
+            if (++count == 1024) {
+                words = null;
+                return true;
+            } else words[w] |= b;
+            return false;
+        }
+
+        public boolean isCached() {
+            return count == 1024;
+        }
+
+        public boolean isCached(int x, int z) {
+            int i = x * 32 + z;
+            return count == 1024 || (words[i >> 6] &  1L << (i & 63)) != 0;
+        }
+
+        public void write(DataOutput out) throws IOException {
+            Varint.writeSignedVarInt(count, out);
+            if (isCached()) return;
+            for (long word : words) {
+                Varint.writeUnsignedVarLong(word, out);
+            }
+        }
+    }
+
+    private record Pos(int x, int z) {}
+}

core/src/main/java/com/volmit/iris/core/pregenerator/cache/SynchronizedCache.java

@@ -0,0 +1,48 @@
+package com.volmit.iris.core.pregenerator.cache;
+
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor
+class SynchronizedCache implements PregenCache {
+    private final PregenCache cache;
+
+    @Override
+    public boolean isThreadSafe() {
+        return true;
+    }
+
+    @Override
+    public boolean isChunkCached(int x, int z) {
+        synchronized (cache) {
+            return cache.isChunkCached(x, z);
+        }
+    }
+
+    @Override
+    public boolean isRegionCached(int x, int z) {
+        synchronized (cache) {
+            return cache.isRegionCached(x, z);
+        }
+    }
+
+    @Override
+    public void cacheChunk(int x, int z) {
+        synchronized (cache) {
+            cache.cacheChunk(x, z);
+        }
+    }
+
+    @Override
+    public void cacheRegion(int x, int z) {
+        synchronized (cache) {
+            cache.cacheRegion(x, z);
+        }
+    }
+
+    @Override
+    public void write() {
+        synchronized (cache) {
+            cache.write();
+        }
+    }
+}

core/src/main/java/com/volmit/iris/core/pregenerator/methods/AsyncPregenMethod.java

@@ -19,10 +19,10 @@
 package com.volmit.iris.core.pregenerator.methods;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.pregenerator.PregenListener;
 import com.volmit.iris.core.pregenerator.PregeneratorMethod;
 import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.math.M;
@@ -32,24 +32,32 @@ import io.papermc.lib.PaperLib;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 
-import java.util.ArrayList;
+import java.lang.reflect.InvocationTargetException;
 import java.util.Map;
-import java.util.concurrent.Future;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class AsyncPregenMethod implements PregeneratorMethod {
+    private static final AtomicInteger THREAD_COUNT = new AtomicInteger();
     private final World world;
-    private final MultiBurst burst;
-    private final KList<Future<?>> future;
+    private final Executor executor;
+    private final Semaphore semaphore;
+    private final int threads;
+    private final boolean urgent;
     private final Map<Chunk, Long> lastUse;
 
-    public AsyncPregenMethod(World world, int threads) {
+    public AsyncPregenMethod(World world, int unusedThreads) {
         if (!PaperLib.isPaper()) {
             throw new UnsupportedOperationException("Cannot use PaperAsync on non paper!");
         }
 
         this.world = world;
-        burst = new MultiBurst("Iris Async Pregen", Thread.MIN_PRIORITY);
-        future = new KList<>(256);
+        this.executor = IrisSettings.get().getPregen().isUseTicketQueue() ? new TicketExecutor() : new ServiceExecutor();
+        this.threads = IrisSettings.get().getPregen().getMaxConcurrency();
+        this.semaphore = new Semaphore(this.threads, true);
+        this.urgent = IrisSettings.get().getPregen().useHighPriority;
         this.lastUse = new KMap<>();
     }
 
@@ -61,13 +69,18 @@ public class AsyncPregenMethod implements PregeneratorMethod {
                     return;
                 }
 
-                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
-                    Long lastUseTime = lastUse.get(i);
-                    if (lastUseTime != null && M.ms() - lastUseTime >= 10000) {
-                        i.unload();
-                        lastUse.remove(i);
+                long minTime = M.ms() - 10_000;
+                lastUse.entrySet().removeIf(i -> {
+                    final Chunk chunk = i.getKey();
+                    final Long lastUseTime = i.getValue();
+                    if (!chunk.isLoaded() || lastUseTime == null)
+                        return true;
+                    if (lastUseTime < minTime) {
+                        chunk.unload();
+                        return true;
                     }
-                }
+                    return false;
+                });
                 world.save();
             }).get();
         } catch (Throwable e) {
@@ -75,53 +88,10 @@ public class AsyncPregenMethod implements PregeneratorMethod {
         }
     }
 
-    private void completeChunk(int x, int z, PregenListener listener) {
-        try {
-            PaperLib.getChunkAtAsync(world, x, z, true).thenAccept((i) -> {
-                lastUse.put(i, M.ms());
-                listener.onChunkGenerated(x, z);
-                listener.onChunkCleaned(x, z);
-            }).get();
-        } catch (InterruptedException ignored) {
-        } catch (Throwable e) {
-            e.printStackTrace();
-        }
-    }
-
-    private void waitForChunksPartial(int maxWaiting) {
-        while (future.size() > maxWaiting) {
-            try {
-                Future<?> i = future.remove(0);
-
-                if (i == null) {
-                    continue;
-                }
-
-                i.get();
-            } catch (Throwable e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    private void waitForChunks() {
-        for (Future<?> i : future.copy()) {
-            if (i == null) {
-                continue;
-            }
-
-            try {
-                i.get();
-                future.remove(i);
-            } catch (Throwable e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
     @Override
     public void init() {
         unloadAndSaveAllChunks();
+        increaseWorkerThreads();
     }
 
     @Override
@@ -131,14 +101,14 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     @Override
     public void close() {
-        waitForChunks();
+        semaphore.acquireUninterruptibly(threads);
         unloadAndSaveAllChunks();
-        burst.close();
+        executor.shutdown();
+        resetWorkerThreads();
     }
 
     @Override
     public void save() {
-        waitForChunksPartial(256);
         unloadAndSaveAllChunks();
     }
 
@@ -155,10 +125,12 @@ public class AsyncPregenMethod implements PregeneratorMethod {
     @Override
     public void generateChunk(int x, int z, PregenListener listener) {
         listener.onChunkGenerating(x, z);
-        if (future.size() > 256) {
-            waitForChunksPartial(256);
+        try {
+            semaphore.acquire();
+        } catch (InterruptedException e) {
+            return;
         }
-        future.add(burst.complete(() -> completeChunk(x, z, listener)));
+        executor.generate(x, z, listener);
     }
 
     @Override
@@ -169,4 +141,100 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
         return null;
     }
+
+    public static void increaseWorkerThreads() {
+        THREAD_COUNT.updateAndGet(i -> {
+            if (i > 0) return 1;
+            var adjusted = IrisSettings.get().getConcurrency().getWorldGenThreads();
+            try {
+                var field = Class.forName("ca.spottedleaf.moonrise.common.util.MoonriseCommon").getDeclaredField("WORKER_POOL");
+                var pool = field.get(null);
+                var threads = ((Thread[]) pool.getClass().getDeclaredMethod("getCoreThreads").invoke(pool)).length;
+                if (threads >= adjusted) return 0;
+
+                pool.getClass().getDeclaredMethod("adjustThreadCount", int.class).invoke(pool, adjusted);
+                return threads;
+            } catch (Throwable e) {
+                Iris.warn("Failed to increase worker threads, if you are on paper or a fork of it please increase it manually to " + adjusted);
+                Iris.warn("For more information see https://docs.papermc.io/paper/reference/global-configuration#chunk_system_worker_threads");
+                if (e instanceof InvocationTargetException) {
+                    Iris.reportError(e);
+                    e.printStackTrace();
+                }
+            }
+            return 0;
+        });
+    }
+
+    public static void resetWorkerThreads() {
+        THREAD_COUNT.updateAndGet(i -> {
+            if (i == 0) return 0;
+            try {
+                var field = Class.forName("ca.spottedleaf.moonrise.common.util.MoonriseCommon").getDeclaredField("WORKER_POOL");
+                var pool = field.get(null);
+                var method = pool.getClass().getDeclaredMethod("adjustThreadCount", int.class);
+                method.invoke(pool, i);
+                return 0;
+            } catch (Throwable e) {
+                Iris.reportError(e);
+                Iris.error("Failed to reset worker threads");
+                e.printStackTrace();
+            }
+            return i;
+        });
+    }
+
+    private interface Executor {
+        void generate(int x, int z, PregenListener listener);
+        default void shutdown() {}
+    }
+
+    private class ServiceExecutor implements Executor {
+        private final ExecutorService service = IrisSettings.get().getPregen().isUseVirtualThreads() ?
+                Executors.newVirtualThreadPerTaskExecutor() :
+                new MultiBurst("Iris Async Pregen", Thread.MIN_PRIORITY);
+
+        public void generate(int x, int z, PregenListener listener) {
+            service.submit(() -> {
+                try {
+                    PaperLib.getChunkAtAsync(world, x, z, true, urgent).thenAccept((i) -> {
+                        listener.onChunkGenerated(x, z);
+                        listener.onChunkCleaned(x, z);
+                        if (i == null) return;
+                        lastUse.put(i, M.ms());
+                    }).get();
+                } catch (InterruptedException ignored) {
+                } catch (Throwable e) {
+                    Iris.reportError(e);
+                    e.printStackTrace();
+                } finally {
+                    semaphore.release();
+                }
+            });
+        }
+
+        @Override
+        public void shutdown() {
+            service.shutdown();
+        }
+    }
+
+    private class TicketExecutor implements Executor {
+        @Override
+        public void generate(int x, int z, PregenListener listener) {
+            PaperLib.getChunkAtAsync(world, x, z, true, urgent)
+                    .exceptionally(e -> {
+                        Iris.reportError(e);
+                        e.printStackTrace();
+                        return null;
+                    })
+                    .thenAccept(i -> {
+                        semaphore.release();
+                        listener.onChunkGenerated(x, z);
+                        listener.onChunkCleaned(x, z);
+                        if (i == null) return;
+                        lastUse.put(i, M.ms());
+                    });
+        }
+    }
 }

core/src/main/java/com/volmit/iris/core/pregenerator/methods/CachedPregenMethod.java

@@ -0,0 +1,86 @@
+package com.volmit.iris.core.pregenerator.methods;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.PregenListener;
+import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.core.pregenerator.cache.PregenCache;
+import com.volmit.iris.core.service.GlobalCacheSVC;
+import com.volmit.iris.util.mantle.Mantle;
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor
+public class CachedPregenMethod implements PregeneratorMethod {
+    private final PregeneratorMethod method;
+    private final PregenCache cache;
+
+    public CachedPregenMethod(PregeneratorMethod method, String worldName) {
+        this.method = method;
+        var cache = Iris.service(GlobalCacheSVC.class).get(worldName);
+        if (cache == null) {
+            Iris.debug("Could not find existing cache for " + worldName  + " creating fallback");
+            cache = GlobalCacheSVC.createDefault(worldName);
+        }
+        this.cache = cache;
+    }
+
+    @Override
+    public void init() {
+        method.init();
+    }
+
+    @Override
+    public void close() {
+        method.close();
+        cache.write();
+    }
+
+    @Override
+    public void save() {
+        method.save();
+        cache.write();
+    }
+
+    @Override
+    public boolean supportsRegions(int x, int z, PregenListener listener) {
+        return cache.isRegionCached(x, z) || method.supportsRegions(x, z, listener);
+    }
+
+    @Override
+    public String getMethod(int x, int z) {
+        return method.getMethod(x, z);
+    }
+
+    @Override
+    public void generateRegion(int x, int z, PregenListener listener) {
+        if (cache.isRegionCached(x, z)) {
+            listener.onRegionGenerated(x, z);
+
+            int rX = x << 5, rZ = z << 5;
+            for (int cX = 0; cX < 32; cX++) {
+                for (int cZ = 0; cZ < 32; cZ++) {
+                    listener.onChunkGenerated(rX + cX, rZ + cZ, true);
+                    listener.onChunkCleaned(rX + cX, rZ + cZ);
+                }
+            }
+            return;
+        }
+        method.generateRegion(x, z, listener);
+        cache.cacheRegion(x, z);
+    }
+
+    @Override
+    public void generateChunk(int x, int z, PregenListener listener) {
+        if (cache.isChunkCached(x, z)) {
+            listener.onChunkGenerated(x, z, true);
+            listener.onChunkCleaned(x, z);
+            return;
+        }
+        method.generateChunk(x, z, listener);
+        cache.cacheChunk(x, z);
+    }
+
+    @Override
+    public Mantle getMantle() {
+        return method.getMantle();
+    }
+}

core/src/main/java/com/volmit/iris/core/project/SchemaBuilder.java

@@ -22,21 +22,23 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.core.loader.ResourceLoader;
-import com.volmit.iris.engine.framework.ListFunction;
 import com.volmit.iris.engine.object.annotations.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.json.JSONArray;
 import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.reflect.OldEnum;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.potion.PotionEffectType;
+import org.jetbrains.annotations.NotNull;
 
 import java.awt.*;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 public class SchemaBuilder {
@@ -44,7 +46,6 @@ public class SchemaBuilder {
     private static final String SYMBOL_TYPE__N = "";
     private static final JSONArray POTION_TYPES = getPotionTypes();
     private static final JSONArray ENCHANT_TYPES = getEnchantTypes();
-    private static final JSONArray ITEM_TYPES = new JSONArray(B.getItemTypes());
     private static final JSONArray FONT_TYPES = new JSONArray(GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames());
     private final KMap<String, JSONObject> definitions;
     private final Class<?> root;
@@ -262,7 +263,7 @@ public class SchemaBuilder {
 
                     if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
-                        j.put("enum", ITEM_TYPES);
+                        j.put("enum", B.getItemTypes());
                         definitions.put(key, j);
                     }
 
@@ -342,38 +343,9 @@ public class SchemaBuilder {
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Potion Effect Type (use ctrl+space for auto complete!)");
 
                 } else if (k.getType().isEnum()) {
-                    fancyType = k.getType().getSimpleName().replaceAll("\\QIris\\E", "");
-                    JSONArray a = new JSONArray();
-                    boolean advanced = k.getType().isAnnotationPresent(Desc.class);
-                    for (Object gg : k.getType().getEnumConstants()) {
-                        if (advanced) {
-                            try {
-                                JSONObject j = new JSONObject();
-                                String name = ((Enum<?>) gg).name();
-                                j.put("const", name);
-                                Desc dd = k.getType().getField(name).getAnnotation(Desc.class);
-                                j.put("description", dd == null ? ("No Description for " + name) : dd.value());
-                                a.put(j);
-                            } catch (Throwable e) {
-                                Iris.reportError(e);
-                                e.printStackTrace();
-                            }
-                        } else {
-                            a.put(((Enum<?>) gg).name());
-                        }
-                    }
-
-                    String key = (advanced ? "oneof-" : "") + "enum-" + k.getType().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
-
-                    if (!definitions.containsKey(key)) {
-                        JSONObject j = new JSONObject();
-                        j.put(advanced ? "oneOf" : "enum", a);
-                        definitions.put(key, j);
-                    }
-
-                    prop.put("$ref", "#/definitions/" + key);
-                    description.add(SYMBOL_TYPE__N + "  Must be a valid " + k.getType().getSimpleName().replaceAll("\\QIris\\E", "") + " (use ctrl+space for auto complete!)");
-
+                    fancyType = addEnum(k.getType(), prop, description, k.getType().getEnumConstants(), o -> ((Enum<?>) o).name());
+                } else if (OldEnum.isOldEnum(k.getType())) {
+                    fancyType = addEnum(k.getType(), prop, description, OldEnum.values(k.getType()), OldEnum::name);
                 }
             }
             case "object" -> {
@@ -468,7 +440,7 @@ public class SchemaBuilder {
 
                                 if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
-                                    j.put("enum", ITEM_TYPES);
+                                    j.put("enum", B.getItemTypes());
                                     definitions.put(key, j);
                                 }
 
@@ -519,39 +491,9 @@ public class SchemaBuilder {
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Potion Effect Type (use ctrl+space for auto complete!)");
                             } else if (t.type().isEnum()) {
-                                fancyType = "List of " + t.type().getSimpleName().replaceAll("\\QIris\\E", "") + "s";
-                                JSONArray a = new JSONArray();
-                                boolean advanced = t.type().isAnnotationPresent(Desc.class);
-                                for (Object gg : t.type().getEnumConstants()) {
-                                    if (advanced) {
-                                        try {
-                                            JSONObject j = new JSONObject();
-                                            String name = ((Enum<?>) gg).name();
-                                            j.put("const", name);
-                                            Desc dd = t.type().getField(name).getAnnotation(Desc.class);
-                                            j.put("description", dd == null ? ("No Description for " + name) : dd.value());
-                                            a.put(j);
-                                        } catch (Throwable e) {
-                                            Iris.reportError(e);
-                                            e.printStackTrace();
-                                        }
-                                    } else {
-                                        a.put(((Enum<?>) gg).name());
-                                    }
-                                }
-
-                                String key = (advanced ? "oneof-" : "") + "enum-" + t.type().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
-
-                                if (!definitions.containsKey(key)) {
-                                    JSONObject j = new JSONObject();
-                                    j.put(advanced ? "oneOf" : "enum", a);
-                                    definitions.put(key, j);
-                                }
-
-                                JSONObject items = new JSONObject();
-                                items.put("$ref", "#/definitions/" + key);
-                                prop.put("items", items);
-                                description.add(SYMBOL_TYPE__N + "  Must be a valid " + t.type().getSimpleName().replaceAll("\\QIris\\E", "") + " (use ctrl+space for auto complete!)");
+                                fancyType = addEnumList(prop, description, t, t.type().getEnumConstants(), o -> ((Enum<?>) o).name());
+                            } else if (OldEnum.isOldEnum(t.type())) {
+                                fancyType = addEnumList(prop, description, t, OldEnum.values(t.type()), OldEnum::name);
                             }
                         }
                     }
@@ -584,7 +526,7 @@ public class SchemaBuilder {
                 if (value instanceof List) {
                     d.add("    ");
                     d.add("* Default Value is an empty list");
-                } else if (!cl.isPrimitive() && !(value instanceof Number) && !(value instanceof String) && !(cl.isEnum())) {
+                } else if (!cl.isPrimitive() && !(value instanceof Number) && !(value instanceof String) && !(cl.isEnum()) && !OldEnum.isOldEnum(cl)) {
                     d.add("    ");
                     d.add("* Default Value is a default object (create this object to see default properties)");
                 } else {
@@ -630,6 +572,50 @@ public class SchemaBuilder {
         return prop;
     }
 
+    @NotNull
+    private String addEnumList(JSONObject prop, KList<String> description, ArrayType t, Object[] values, Function<Object, String> function) {
+        JSONObject items = new JSONObject();
+        var s = addEnum(t.type(), items, description, values, function);
+        prop.put("items", items);
+
+        return "List of " + s + "s";
+    }
+
+    @NotNull
+    private String addEnum(Class<?> type, JSONObject prop, KList<String> description, Object[] values, Function<Object, String> function) {
+        JSONArray a = new JSONArray();
+        boolean advanced = type.isAnnotationPresent(Desc.class);
+        for (Object gg : values) {
+            if (advanced) {
+                try {
+                    JSONObject j = new JSONObject();
+                    String name = function.apply(gg);
+                    j.put("const", name);
+                    Desc dd = type.getField(name).getAnnotation(Desc.class);
+                    j.put("description", dd == null ? ("No Description for " + name) : dd.value());
+                    a.put(j);
+                } catch (Throwable e) {
+                    Iris.reportError(e);
+                    e.printStackTrace();
+                }
+            } else {
+                a.put(function.apply(gg));
+            }
+        }
+
+        String key = (advanced ? "oneof-" : "") + "enum-" + type.getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
+
+        if (!definitions.containsKey(key)) {
+            JSONObject j = new JSONObject();
+            j.put(advanced ? "oneOf" : "enum", a);
+            definitions.put(key, j);
+        }
+
+        prop.put("$ref", "#/definitions/" + key);
+        description.add(SYMBOL_TYPE__N + "  Must be a valid " + type.getSimpleName().replaceAll("\\QIris\\E", "") + " (use ctrl+space for auto complete!)");
+        return type.getSimpleName().replaceAll("\\QIris\\E", "");
+    }
+
     private String getType(Class<?> c) {
         if (c.equals(int.class) || c.equals(Integer.class) || c.equals(long.class) || c.equals(Long.class)) {
             return "integer";
@@ -643,7 +629,7 @@ public class SchemaBuilder {
             return "boolean";
         }
 
-        if (c.equals(String.class) || c.isEnum() || c.equals(Enchantment.class) || c.equals(PotionEffectType.class)) {
+        if (c.equals(String.class) || c.isEnum() || OldEnum.isOldEnum(c) || c.equals(Enchantment.class) || c.equals(PotionEffectType.class)) {
             return "string";
         }
 

core/src/main/java/com/volmit/iris/core/safeguard/IrisSafeguard.java

@@ -1,6 +1,7 @@
 package com.volmit.iris.core.safeguard;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 
 public class IrisSafeguard {
     public static boolean unstablemode = false;
@@ -11,5 +12,23 @@ public class IrisSafeguard {
         Iris.info("Enabled Iris SafeGuard");
         ServerBootSFG.BootCheck();
     }
+
+    public static void earlySplash() {
+        if (ServerBootSFG.safeguardPassed || IrisSettings.get().getGeneral().DoomsdayAnnihilationSelfDestructMode)
+            return;
+
+        Iris.instance.splash();
+        UtilsSFG.splash();
+    }
+
+    public static String mode() {
+        if (unstablemode) {
+            return "unstable";
+        } else if (warningmode) {
+            return "warning";
+        } else {
+            return "stable";
+        }
+    }
 }
 

core/src/main/java/com/volmit/iris/core/safeguard/ServerBootSFG.java

@@ -3,6 +3,7 @@ package com.volmit.iris.core.safeguard;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
+import com.volmit.iris.engine.object.IrisContextInjector;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
@@ -20,16 +21,16 @@ import java.util.Map;
 import java.util.StringJoiner;
 
 import static com.volmit.iris.Iris.getJavaVersion;
-import static com.volmit.iris.Iris.instance;
 import static com.volmit.iris.core.safeguard.IrisSafeguard.*;
 
 public class ServerBootSFG {
     public static final Map<String, Boolean> incompatibilities = new HashMap<>();
-    public static boolean isJDK17 = true;
+    public static boolean isCorrectJDK = true;
     public static boolean hasEnoughDiskSpace = true;
     public static boolean isJRE = false;
     public static boolean hasPrivileges = true;
     public static boolean unsuportedversion = false;
+    public static boolean missingDimensionTypes = false;
     protected static boolean safeguardPassed;
     public static boolean passedserversoftware = true;
     protected static int count;
@@ -87,8 +88,8 @@ public class ServerBootSFG {
             severityHigh++;
         }
 
-        if (!List.of(17, 21).contains(getJavaVersion())) {
-            isJDK17 = false;
+        if (!List.of(21).contains(getJavaVersion())) {
+            isCorrectJDK = false;
             joiner.add("Unsupported Java version");
             severityMedium++;
         }
@@ -111,6 +112,12 @@ public class ServerBootSFG {
             severityMedium++;
         }
 
+        if (IrisContextInjector.isMissingDimensionTypes()) {
+            missingDimensionTypes = true;
+            joiner.add("Missing Dimension Types");
+            severityHigh++;
+        }
+
         allIncompatibilities = joiner.toString();
 
         safeguardPassed = (severityHigh == 0 && severityMedium == 0 && severityLow == 0);
@@ -153,13 +160,9 @@ public class ServerBootSFG {
     }
 
     public static boolean enoughDiskSpace() {
-        File freeSpace = new File(Bukkit.getWorldContainer() + ".");
+        File freeSpace = Bukkit.getWorldContainer();
         double gigabytes = freeSpace.getFreeSpace() / (1024.0 * 1024.0 * 1024.0);
-        if (gigabytes > 3){
-            return true;
-        } else {
-            return false;
-        }
+        return gigabytes > 3;
     }
 
     private static boolean checkJavac(String path) {

core/src/main/java/com/volmit/iris/core/safeguard/UtilsSFG.java

@@ -37,7 +37,12 @@ public class UtilsSFG {
             }
             if (ServerBootSFG.unsuportedversion) {
                 Iris.safeguard(C.RED + "Server Version");
-                Iris.safeguard(C.RED + "- Iris only supports 1.19.2 > 1.21.1");
+                Iris.safeguard(C.RED + "- Iris only supports 1.20.1 > 1.21.4");
+            }
+            if (ServerBootSFG.missingDimensionTypes) {
+                Iris.safeguard(C.RED + "Dimension Types");
+                Iris.safeguard(C.RED + "- Required Iris dimension types were not loaded.");
+                Iris.safeguard(C.RED + "- If this still happens after a restart please contact support.");
             }
             if (!ServerBootSFG.passedserversoftware) {
                 Iris.safeguard(C.YELLOW + "Unsupported Server Software");
@@ -51,13 +56,13 @@ public class UtilsSFG {
                 Iris.safeguard(C.YELLOW + "Insufficient Disk Space");
                 Iris.safeguard(C.YELLOW + "- The server has insufficient Free DiskSpace to run iris required 3GB+.");
             }
-            if (!ServerBootSFG.isJDK17) {
+            if (!ServerBootSFG.isCorrectJDK) {
                 Iris.safeguard(C.YELLOW + "Unsupported java version");
-                Iris.safeguard(C.YELLOW + "- Please consider using JDK 17 (or 21 for 1.20.6) Instead of JDK " + Iris.getJavaVersion());
+                Iris.safeguard(C.YELLOW + "- Please consider using JDK 21 Instead of JDK " + Iris.getJavaVersion());
             }
             if (ServerBootSFG.isJRE) {
                 Iris.safeguard(C.YELLOW + "Unsupported Server JDK");
-                Iris.safeguard(C.YELLOW + "- Please consider using JDK 17 (or 21 for 1.20.6) Instead of JRE " + Iris.getJavaVersion());
+                Iris.safeguard(C.YELLOW + "- Please consider using JDK 21 Instead of JRE " + Iris.getJavaVersion());
             }
         }
     }

core/src/main/java/com/volmit/iris/core/service/BoardSVC.java

@@ -40,6 +40,7 @@ import org.bukkit.event.player.PlayerChangedWorldEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 
 import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
 
 public class BoardSVC implements IrisService, BoardProvider {
     private final KMap<Player, PlayerBoard> boards = new KMap<>();
@@ -104,11 +105,11 @@ public class BoardSVC implements IrisService, BoardProvider {
     @Data
     public static class PlayerBoard {
         private final Player player;
-        private final KList<String> lines;
+        private final CopyOnWriteArrayList<String> lines;
 
         public PlayerBoard(Player player) {
             this.player = player;
-            this.lines = new KList<>();
+            this.lines = new CopyOnWriteArrayList<>();
             update();
         }
 

core/src/main/java/com/volmit/iris/core/service/ExternalDataSVC.java

@@ -26,6 +26,7 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.plugin.IrisService;
 import lombok.Data;
+import lombok.NonNull;
 import org.bukkit.Bukkit;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
@@ -46,9 +47,13 @@ public class ExternalDataSVC implements IrisService {
         Iris.info("Loading ExternalDataProvider...");
         Bukkit.getPluginManager().registerEvents(this, Iris.instance);
 
-        providers.add(new OraxenDataProvider());
-        if (Bukkit.getPluginManager().getPlugin("Oraxen") != null) {
-            Iris.info("Oraxen found, loading OraxenDataProvider...");
+        providers.add(new NexoDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("Nexo") != null) {
+            Iris.info("Nexo found, loading NexoDataProvider...");
+        }
+        providers.add(new MythicCrucibleDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("MythicCrucible") != null) {
+            Iris.info("MythicCrucible found, loading MythicCrucibleDataProvider...");
         }
         providers.add(new ItemAdderDataProvider());
         if (Bukkit.getPluginManager().getPlugin("ItemAdder") != null) {
@@ -95,6 +100,18 @@ public class ExternalDataSVC implements IrisService {
         }
     }
 
+    public void registerProvider(@NonNull ExternalDataProvider provider) {
+        String plugin = provider.getPluginId();
+        if (providers.stream().map(ExternalDataProvider::getPluginId).anyMatch(plugin::equals))
+            throw new IllegalArgumentException("A provider with the same plugin id already exists.");
+
+        providers.add(provider);
+        if (provider.isReady()) {
+            activeProviders.add(provider);
+            provider.init();
+        }
+    }
+
     public Optional<BlockData> getBlockData(final Identifier key) {
         var pair = parseState(key);
         Identifier mod = pair.getA();

core/src/main/java/com/volmit/iris/core/service/GlobalCacheSVC.java

@@ -0,0 +1,108 @@
+package com.volmit.iris.core.service;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.pregenerator.cache.PregenCache;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.plugin.IrisService;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.event.world.WorldInitEvent;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.util.function.Function;
+
+public class GlobalCacheSVC implements IrisService {
+    private static final Cache<String, PregenCache> REFERENCE_CACHE = Caffeine.newBuilder().weakValues().build();
+    private final KMap<String, PregenCache> globalCache = new KMap<>();
+    private transient boolean lastState;
+    private static boolean disabled = true;
+
+    @Override
+    public void onEnable() {
+        disabled = false;
+        lastState = !IrisSettings.get().getWorld().isGlobalPregenCache();
+        if (lastState) return;
+        Bukkit.getWorlds().forEach(this::createCache);
+    }
+
+    @Override
+    public void onDisable() {
+        disabled = true;
+        globalCache.qclear((world, cache) -> cache.write());
+    }
+
+    @Nullable
+    public PregenCache get(@NonNull World world) {
+        return globalCache.get(world.getName());
+    }
+
+    @Nullable
+    public PregenCache get(@NonNull String world) {
+        return globalCache.get(world);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void on(WorldInitEvent event) {
+        if (isDisabled()) return;
+        createCache(event.getWorld());
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void on(WorldUnloadEvent event) {
+        var cache = globalCache.remove(event.getWorld().getName());
+        if (cache == null) return;
+        cache.write();
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void on(ChunkLoadEvent event) {
+        var cache = get(event.getWorld());
+        if (cache == null) return;
+        cache.cacheChunk(event.getChunk().getX(), event.getChunk().getZ());
+    }
+
+    private void createCache(World world) {
+        globalCache.computeIfAbsent(world.getName(), GlobalCacheSVC::createDefault);
+    }
+
+    private boolean isDisabled() {
+        boolean conf = IrisSettings.get().getWorld().isGlobalPregenCache();
+        if (lastState != conf)
+            return lastState;
+
+        if (conf) {
+            Bukkit.getWorlds().forEach(this::createCache);
+        } else {
+            globalCache.values().removeIf(cache -> {
+                cache.write();
+                return true;
+            });
+        }
+
+        return lastState = !conf;
+    }
+
+
+    @NonNull
+    public static PregenCache createCache(@NonNull String worldName, @NonNull Function<String, PregenCache> provider) {
+        return REFERENCE_CACHE.get(worldName, provider);
+    }
+
+    @NonNull
+    public static PregenCache createDefault(@NonNull String worldName) {
+        return createCache(worldName, GlobalCacheSVC::createDefault0);
+    }
+
+    private static PregenCache createDefault0(String worldName) {
+        if (disabled) return PregenCache.EMPTY;
+        return PregenCache.create(new File(Bukkit.getWorldContainer(), String.join(File.separator, worldName, "iris", "pregen"))).sync();
+    }
+}

core/src/main/java/com/volmit/iris/core/service/IrisEngineSVC.java

@@ -1,317 +1,246 @@
 package com.volmit.iris.core.service;
 
+import com.google.common.util.concurrent.AtomicDouble;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.mantle.TectonicPlate;
-import com.volmit.iris.util.misc.getHardware;
+import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.plugin.IrisService;
-import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.Looper;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import lombok.Synchronized;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.server.PluginDisableEvent;
-import org.bukkit.event.server.ServerLoadEvent;
 import org.bukkit.event.world.WorldLoadEvent;
 import org.bukkit.event.world.WorldUnloadEvent;
-import org.checkerframework.checker.units.qual.A;
+import org.jetbrains.annotations.Nullable;
 
-import java.util.*;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.Supplier;
 
 public class IrisEngineSVC implements IrisService {
-    public static IrisEngineSVC instance;
-    public boolean isServerShuttingDown = false;
-    public boolean isServerLoaded = false;
-    private static final AtomicInteger tectonicLimit = new AtomicInteger(30);
-    private ReentrantLock lastUseLock;
-    private KMap<World, Long> lastUse;
-    private List<World> IrisWorlds;
-    private Looper cacheTicker;
-    private Looper trimTicker;
-    private Looper unloadTicker;
+    private final AtomicInteger tectonicLimit = new AtomicInteger(30);
+    private final AtomicInteger tectonicPlates = new AtomicInteger();
+    private final AtomicInteger queuedTectonicPlates = new AtomicInteger();
+    private final AtomicInteger trimmerAlive = new AtomicInteger();
+    private final AtomicInteger unloaderAlive = new AtomicInteger();
+    private final AtomicInteger totalWorlds = new AtomicInteger();
+    private final AtomicDouble maxIdleDuration = new AtomicDouble();
+    private final AtomicDouble minIdleDuration = new AtomicDouble();
+    private final AtomicLong loadedChunks = new AtomicLong();
+    private final KMap<World, Registered> worlds = new KMap<>();
+    private ScheduledExecutorService service;
     private Looper updateTicker;
-    private PrecisionStopwatch trimAlive;
-    private PrecisionStopwatch unloadAlive;
-    public PrecisionStopwatch trimActiveAlive;
-    public PrecisionStopwatch unloadActiveAlive;
-    private AtomicInteger TotalTectonicPlates;
-    private AtomicInteger TotalQueuedTectonicPlates;
-    private AtomicInteger TotalNotQueuedTectonicPlates;
-    private AtomicBoolean IsUnloadAlive;
-    private AtomicBoolean IsTrimAlive;
-    ChronoLatch cl;
-
-    public List<World> corruptedIrisWorlds = new ArrayList<>();
 
     @Override
     public void onEnable() {
-        this.cl = new ChronoLatch(5000);
-        lastUse = new KMap<>();
-        lastUseLock = new ReentrantLock();
-        IrisWorlds = new ArrayList<>();
-        IsUnloadAlive = new AtomicBoolean(true);
-        IsTrimAlive = new AtomicBoolean(true);
-        trimActiveAlive = new PrecisionStopwatch();
-        unloadActiveAlive = new PrecisionStopwatch();
-        trimAlive = new PrecisionStopwatch();
-        unloadAlive = new PrecisionStopwatch();
-        TotalTectonicPlates = new AtomicInteger();
-        TotalQueuedTectonicPlates = new AtomicInteger();
-        TotalNotQueuedTectonicPlates = new AtomicInteger();
-        tectonicLimit.set(2);
-        long t = getHardware.getProcessMemory();
-        while (t > 200) {
-            tectonicLimit.getAndAdd(1);
-            t = t - 200;
-        }
-        this.setup();
-        this.TrimLogic();
-        this.UnloadLogic();
-
-        trimAlive.begin();
-        unloadAlive.begin();
-        trimActiveAlive.begin();
-        unloadActiveAlive.begin();
-
-        updateTicker.start();
-        cacheTicker.start();
-        //trimTicker.start();
-        //unloadTicker.start();
-        instance = this;
-
+        var settings = IrisSettings.get().getPerformance();
+        var engine = settings.getEngineSVC();
+        service = Executors.newScheduledThreadPool(0,
+                (engine.isUseVirtualThreads()
+                        ? Thread.ofVirtual()
+                        : Thread.ofPlatform().priority(engine.getPriority()))
+                        .name("Iris EngineSVC-", 0)
+                        .factory());
+        tectonicLimit.set(settings.getTectonicPlateSize());
+        Bukkit.getWorlds().forEach(this::add);
+        setup();
     }
 
-    public void engineStatus() {
-        boolean trimAlive = trimTicker.isAlive();
-        boolean unloadAlive = unloadTicker.isAlive();
-        Iris.info("Status:");
-        Iris.info("- Trim: " + trimAlive);
-        Iris.info("- Unload: " + unloadAlive);
-
+    @Override
+    public void onDisable() {
+        service.shutdown();
+        updateTicker.interrupt();
+        worlds.keySet().forEach(this::remove);
+        worlds.clear();
     }
 
-    public static int getTectonicLimit() {
-        return tectonicLimit.get();
+    public void engineStatus(VolmitSender sender) {
+        sender.sendMessage(C.DARK_PURPLE + "-------------------------");
+        sender.sendMessage(C.DARK_PURPLE + "Status:");
+        sender.sendMessage(C.DARK_PURPLE + "- Service: " + C.LIGHT_PURPLE + (service.isShutdown() ? "Shutdown" : "Running"));
+        sender.sendMessage(C.DARK_PURPLE + "- Updater: " + C.LIGHT_PURPLE + (updateTicker.isAlive() ? "Running" : "Stopped"));
+        sender.sendMessage(C.DARK_PURPLE + "- Trimmers: " + C.LIGHT_PURPLE + trimmerAlive.get());
+        sender.sendMessage(C.DARK_PURPLE + "- Unloaders: " + C.LIGHT_PURPLE + unloaderAlive.get());
+        sender.sendMessage(C.DARK_PURPLE + "Tectonic Plates:");
+        sender.sendMessage(C.DARK_PURPLE + "- Limit: " + C.LIGHT_PURPLE + tectonicLimit.get());
+        sender.sendMessage(C.DARK_PURPLE + "- Total: " + C.LIGHT_PURPLE + tectonicPlates.get());
+        sender.sendMessage(C.DARK_PURPLE + "- Queued: " + C.LIGHT_PURPLE + queuedTectonicPlates.get());
+        sender.sendMessage(C.DARK_PURPLE + "- Max Idle Duration: " + C.LIGHT_PURPLE + Form.duration(maxIdleDuration.get(), 2));
+        sender.sendMessage(C.DARK_PURPLE + "- Min Idle Duration: " + C.LIGHT_PURPLE + Form.duration(minIdleDuration.get(), 2));
+        sender.sendMessage(C.DARK_PURPLE + "Other:");
+        sender.sendMessage(C.DARK_PURPLE + "- Iris Worlds: " + C.LIGHT_PURPLE + totalWorlds.get());
+        sender.sendMessage(C.DARK_PURPLE + "- Loaded Chunks: " + C.LIGHT_PURPLE + loadedChunks.get());
+        sender.sendMessage(C.DARK_PURPLE + "- Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
+        sender.sendMessage(C.DARK_PURPLE + "-------------------------");
     }
 
     @EventHandler
     public void onWorldUnload(WorldUnloadEvent event) {
-        updateWorlds();
+        remove(event.getWorld());
     }
 
     @EventHandler
     public void onWorldLoad(WorldLoadEvent event) {
-        updateWorlds();
+        add(event.getWorld());
     }
 
-    @EventHandler
-    public void onServerBoot(ServerLoadEvent event) {
-        isServerLoaded = true;
+    private void remove(World world) {
+        var entry = worlds.remove(world);
+        if (entry == null) return;
+        entry.close();
     }
 
-    @EventHandler
-    public void onPluginDisable(PluginDisableEvent event) {
-        if (event.getPlugin().equals(Iris.instance)) {
-            isServerShuttingDown = true;
-        }
+    private void add(World world) {
+        var access = IrisToolbelt.access(world);
+        if (access == null) return;
+        worlds.put(world, new Registered(world.getName(), access));
     }
 
-    public void updateWorlds() {
-        for (World world : Bukkit.getWorlds()) {
-            try {
-                if (IrisToolbelt.access(world).getEngine() != null) {
-                    IrisWorlds.add(world);
-                }
-            } catch (Exception e) {
-                // no
-            }
-        }
-    }
-
-    private void setup() {
-        cacheTicker = new Looper() {
-            @Override
-            protected long loop() {
-                long now = System.currentTimeMillis();
-                lastUseLock.lock();
-                try {
-                    for (World key : new ArrayList<>(lastUse.keySet())) {
-                        Long last = lastUse.get(key);
-                        if (last == null)
-                            continue;
-                        if (now - last > 60000) {
-                            lastUse.remove(key);
-                        }
-                    }
-                } finally {
-                    lastUseLock.unlock();
-                }
-                return 1000;
-            }
-        };
+    private synchronized void setup() {
+        if (updateTicker != null && updateTicker.isAlive())
+            return;
 
         updateTicker = new Looper() {
             @Override
             protected long loop() {
                 try {
-                    TotalQueuedTectonicPlates.set(0);
-                    TotalNotQueuedTectonicPlates.set(0);
-                    TotalTectonicPlates.set(0);
-                    for (World world : IrisWorlds) {
-                        Engine engine = Objects.requireNonNull(IrisToolbelt.access(world)).getEngine();
-                        TotalQueuedTectonicPlates.addAndGet((int) engine.getMantle().getToUnload());
-                        TotalNotQueuedTectonicPlates.addAndGet((int) engine.getMantle().getNotQueuedLoadedRegions());
-                        TotalTectonicPlates.addAndGet(engine.getMantle().getLoadedRegionCount());
-                    }
-                    if (!isServerShuttingDown && isServerLoaded) {
-                        if (!trimTicker.isAlive()) {
-                            Iris.info(C.RED + "TrimTicker found dead! Booting it up!");
-                            try {
-                                TrimLogic();
-                            } catch (Exception e) {
-                                Iris.error("What happened?");
-                                e.printStackTrace();
-                            }
-                        }
+                    queuedTectonicPlates.set(0);
+                    tectonicPlates.set(0);
+                    loadedChunks.set(0);
+                    unloaderAlive.set(0);
+                    trimmerAlive.set(0);
+                    totalWorlds.set(0);
 
-                        if (!unloadTicker.isAlive()) {
-                            Iris.info(C.RED + "UnloadTicker found dead! Booting it up!");
-                            try {
-                               UnloadLogic();
-                            } catch (Exception e) {
-                                Iris.error("What happened?");
-                                e.printStackTrace();
-                            }
-                        }
-                    }
+                    double maxDuration = Long.MIN_VALUE;
+                    double minDuration = Long.MAX_VALUE;
+                    for (var entry : worlds.entrySet()) {
+                        var registered = entry.getValue();
+                        if (registered.closed) continue;
 
-                } catch (Exception e) {
-                    return -1;
+                        totalWorlds.incrementAndGet();
+                        unloaderAlive.addAndGet(registered.unloaderAlive() ? 1 : 0);
+                        trimmerAlive.addAndGet(registered.trimmerAlive() ? 1 : 0);
+
+                        var engine = registered.getEngine();
+                        if (engine == null) continue;
+
+                        queuedTectonicPlates.addAndGet((int) engine.getMantle().getUnloadRegionCount());
+                        tectonicPlates.addAndGet(engine.getMantle().getLoadedRegionCount());
+                        loadedChunks.addAndGet(entry.getKey().getLoadedChunks().length);
+
+                        double duration = engine.getMantle().getAdjustedIdleDuration();
+                        if (duration > maxDuration) maxDuration = duration;
+                        if (duration < minDuration) minDuration = duration;
+                    }
+                    maxIdleDuration.set(maxDuration);
+                    minIdleDuration.set(minDuration);
+
+                    worlds.values().forEach(Registered::update);
+                } catch (Throwable e) {
+                    e.printStackTrace();
                 }
                 return 1000;
             }
         };
+        updateTicker.start();
     }
-    public void TrimLogic() {
-        if (trimTicker == null || !trimTicker.isAlive()) {
-            trimTicker = new Looper() {
-                private final Supplier<Engine> supplier = createSupplier();
 
-                @Override
-                protected long loop() {
-                    long start = System.currentTimeMillis();
-                    trimAlive.reset();
+    private final class Registered {
+        private final String name;
+        private final PlatformChunkGenerator access;
+        private transient ScheduledFuture<?> trimmer;
+        private transient ScheduledFuture<?> unloader;
+        private transient boolean closed;
+
+        private Registered(String name, PlatformChunkGenerator access) {
+            this.name = name;
+            this.access = access;
+            update();
+        }
+
+        private boolean unloaderAlive() {
+            return unloader != null && !unloader.isDone() && !unloader.isCancelled();
+        }
+
+        private boolean trimmerAlive() {
+            return trimmer != null && !trimmer.isDone() && !trimmer.isCancelled();
+        }
+
+        @Synchronized
+        private void update() {
+            if (closed || service == null || service.isShutdown())
+                return;
+
+            if (trimmer == null || trimmer.isDone() || trimmer.isCancelled()) {
+                trimmer = service.scheduleAtFixedRate(() -> {
+                    Engine engine = getEngine();
+                    if (engine == null || !engine.getMantle().getMantle().shouldReduce(engine))
+                        return;
+
                     try {
-                        Engine engine = supplier.get();
-                        if (engine != null) {
-                            engine.getMantle().trim(tectonicLimit.get() / lastUse.size());
+                        engine.getMantle().trim(tectonicLimit());
+                    } catch (Throwable e) {
+                        Iris.reportError(e);
+                        Iris.error("EngineSVC: Failed to trim for " + name);
+                        e.printStackTrace();
+                    }
+                }, RNG.r.nextInt(1000), 1000, TimeUnit.MILLISECONDS);
+            }
+
+            if (unloader == null || unloader.isDone() || unloader.isCancelled()) {
+                unloader = service.scheduleAtFixedRate(() -> {
+                    Engine engine = getEngine();
+                    if (engine == null || !engine.getMantle().getMantle().shouldReduce(engine))
+                        return;
+
+                    try {
+                        long unloadStart = System.currentTimeMillis();
+                        int count = engine.getMantle().unloadTectonicPlate(tectonicLimit());
+                        if (count > 0) {
+                            Iris.debug(C.GOLD + "Unloaded " + C.YELLOW + count + " TectonicPlates in " + C.RED + Form.duration(System.currentTimeMillis() - unloadStart, 2));
                         }
                     } catch (Throwable e) {
                         Iris.reportError(e);
-                        Iris.info(C.RED + "EngineSVC: Failed to trim.");
+                        Iris.error("EngineSVC: Failed to unload for " + name);
                         e.printStackTrace();
-                        return -1;
                     }
-
-                    int size = lastUse.size();
-                    long time = (size > 0 ? 1000 / size : 1000) - (System.currentTimeMillis() - start);
-                    if (time <= 0)
-                        return 0;
-                    return time;
-                }
-            };
-            trimTicker.start();
-        }
-    }
-    public void UnloadLogic() {
-        if (unloadTicker == null || !unloadTicker.isAlive()) {
-            unloadTicker = new Looper() {
-                private final Supplier<Engine> supplier = createSupplier();
-
-                @Override
-                protected long loop() {
-                    long start = System.currentTimeMillis();
-                    unloadAlive.reset();
-                    try {
-                        Engine engine = supplier.get();
-                        if (engine != null) {
-                            long unloadStart = System.currentTimeMillis();
-                            int count = engine.getMantle().unloadTectonicPlate(tectonicLimit.get() / lastUse.size());
-                            if (count > 0) {
-                                Iris.debug(C.GOLD + "Unloaded " + C.YELLOW + count + " TectonicPlates in " + C.RED + Form.duration(System.currentTimeMillis() - unloadStart, 2));
-                            }
-                        }
-                    } catch (Throwable e) {
-                        Iris.reportError(e);
-                        Iris.info(C.RED + "EngineSVC: Failed to unload.");
-                        e.printStackTrace();
-                        return -1;
-                    }
-
-                    int size = lastUse.size();
-                    long time = (size > 0 ? 1000 / size : 1000) - (System.currentTimeMillis() - start);
-                    if (time <= 0)
-                        return 0;
-                    return time;
-                }
-            };
-            unloadTicker.start();
-        }
-    }
-
-    private Supplier<Engine> createSupplier() {
-        AtomicInteger i = new AtomicInteger();
-        return () -> {
-            List<World> worlds = Bukkit.getWorlds();
-            if (i.get() >= worlds.size()) {
-                i.set(0);
+                }, RNG.r.nextInt(1000), 1000, TimeUnit.MILLISECONDS);
             }
-            try {
-                for (int j = 0; j < worlds.size(); j++) {
-                    World world = worlds.get(i.getAndIncrement());
-                    PlatformChunkGenerator generator = IrisToolbelt.access(world);
-                    if (i.get() >= worlds.size()) {
-                        i.set(0);
-                    }
+        }
 
-                    if (generator != null) {
-                        Engine engine = generator.getEngine();
-                        boolean closed = engine.getMantle().getData().isClosed();
-                        if (engine != null && !engine.isStudio() && !closed) {
-                            lastUseLock.lock();
-                            lastUse.put(world, System.currentTimeMillis());
-                            lastUseLock.unlock();
-                            return engine;
-                        }
-                    }
-                }
-            } catch (Throwable e) {
-                Iris.info(C.RED + "EngineSVC: Failed to create supplier.");
-                e.printStackTrace();
-                Iris.reportError(e);
+        private int tectonicLimit() {
+            return tectonicLimit.get() / Math.max(worlds.size(), 1);
+        }
+
+        @Synchronized
+        private void close() {
+            if (closed) return;
+            closed = true;
+
+            if (trimmer != null) {
+                trimmer.cancel(false);
+                trimmer = null;
             }
-            return null;
-        };
-    }
 
-    @Override
-    public void onDisable() {
-        cacheTicker.interrupt();
-        trimTicker.interrupt();
-        unloadTicker.interrupt();
-        lastUse.clear();
+            if (unloader != null) {
+                unloader.cancel(false);
+                unloader = null;
+            }
+        }
+
+        @Nullable
+        private Engine getEngine() {
+            if (closed) return null;
+            return access.getEngine();
+        }
     }
 }

core/src/main/java/com/volmit/iris/core/service/StudioSVC.java

@@ -24,6 +24,7 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.pack.IrisPack;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.tools.IrisToolbelt;
@@ -63,7 +64,12 @@ public class StudioSVC implements IrisService {
 
             if (!f.exists()) {
                 Iris.info("Downloading Default Pack " + pack);
-                downloadSearch(Iris.getSender(), pack, false);
+                if (pack.equals("overworld")) {
+                    String url = "https://github.com/IrisDimensions/overworld/releases/download/" + INMS.OVERWORLD_TAG + "/overworld.zip";
+                    Iris.service(StudioSVC.class).downloadRelease(Iris.getSender(), url, false, false);
+                } else {
+                    downloadSearch(Iris.getSender(), pack, false);
+                }
             }
         });
     }

core/src/main/java/com/volmit/iris/core/service/TreeSVC.java

@@ -27,6 +27,7 @@ import com.volmit.iris.engine.platform.PlatformChunkGenerator;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.Cuboid;
+import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.math.BlockPosition;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.plugin.IrisService;
@@ -34,7 +35,6 @@ import com.volmit.iris.util.scheduling.J;
 import org.bukkit.*;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
-import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.type.Sapling;
 import org.bukkit.event.EventHandler;
@@ -142,7 +142,9 @@ public class TreeSVC implements IrisService {
             public void set(int x, int y, int z, BlockData d) {
                 Block b = event.getWorld().getBlockAt(x, y, z);
                 BlockState state = b.getState();
-                state.setBlockData(d);
+                if (d instanceof IrisCustomData data)
+                    state.setBlockData(data.getBase());
+                else state.setBlockData(d);
                 blockStateList.add(b.getState());
                 dataCache.put(new Location(event.getWorld(), x, y, z), d);
             }
@@ -213,12 +215,17 @@ public class TreeSVC implements IrisService {
             block = false;
 
             if (!iGrow.isCancelled()) {
-                for (BlockState block : iGrow.getBlocks()) {
-                    Location l = block.getLocation();
+                for (BlockState state : iGrow.getBlocks()) {
+                    Location l = state.getLocation();
 
-                    if (dataCache.containsKey(l)) {
-                        l.getBlock().setBlockData(dataCache.get(l), false);
-                    }
+                    BlockData d = dataCache.get(l);
+                    if (d == null) continue;
+                    Block block = l.getBlock();
+
+                    if (d instanceof IrisCustomData data) {
+                        block.setBlockData(data.getBase(), false);
+                        Iris.service(ExternalDataSVC.class).processUpdate(engine, block, data.getCustom());
+                    } else block.setBlockData(d);
                 }
             }
         });

core/src/main/java/com/volmit/iris/core/service/WandSVC.java

@@ -30,15 +30,12 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.matter.Matter;
 import com.volmit.iris.util.matter.WorldMatter;
-import com.volmit.iris.util.misc.E;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.S;
 import com.volmit.iris.util.scheduling.SR;
 import com.volmit.iris.util.scheduling.jobs.Job;
 import org.bukkit.*;
-import org.bukkit.block.Block;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -54,13 +51,14 @@ import org.bukkit.util.Vector;
 
 import java.awt.Color;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.atomic.AtomicInteger;
+
+import static com.volmit.iris.util.data.registry.Particles.CRIT_MAGIC;
+import static com.volmit.iris.util.data.registry.Particles.REDSTONE;
 
 public class WandSVC implements IrisService {
-    private static final Particle CRIT_MAGIC = E.getOrDefault(Particle.class, "CRIT_MAGIC", "CRIT");
-    private static final Particle REDSTONE = E.getOrDefault(Particle.class,  "REDSTONE", "DUST");
     private static final int MS_PER_TICK = Integer.parseInt(System.getProperty("iris.ms_per_tick", "30"));
 
     private static ItemStack dust;
@@ -76,13 +74,15 @@ public class WandSVC implements IrisService {
      * @param p The wand player
      * @return The new object
      */
-    public static IrisObject createSchematic(Player p) {
+    public static IrisObject createSchematic(Player p, boolean legacy) {
         if (!isHoldingWand(p)) {
             return null;
         }
 
         try {
             Location[] f = getCuboid(p);
+            if (f == null || f[0] == null || f[1] == null)
+                return null;
             Cuboid c = new Cuboid(f[0], f[1]);
             IrisObject s = new IrisObject(c.getSizeX(), c.getSizeY(), c.getSizeZ());
 
@@ -132,7 +132,7 @@ public class WandSVC implements IrisService {
                                         continue;
 
                                     BlockVector bv = b.getLocation().subtract(c.getLowerNE().toVector()).toVector().toBlockVector();
-                                    s.setUnsigned(bv.getBlockX(), bv.getBlockY(), bv.getBlockZ(), b);
+                                    s.setUnsigned(bv.getBlockX(), bv.getBlockY(), bv.getBlockZ(), b, legacy);
                                 } finally {
                                     i++;
                                 }
@@ -201,7 +201,9 @@ public class WandSVC implements IrisService {
     public static Location stringToLocation(String s) {
         try {
             String[] f = s.split("\\Q in \\E");
+            if (f.length != 2) return null;
             String[] g = f[0].split("\\Q,\\E");
+            if (g.length != 3) return null;
             return new Location(Bukkit.getWorld(f[1]), Integer.parseInt(g[0]), Integer.parseInt(g[1]), Integer.parseInt(g[2]));
         } catch (Throwable e) {
             Iris.reportError(e);
@@ -360,6 +362,7 @@ public class WandSVC implements IrisService {
             try {
                 if ((IrisSettings.get().getWorld().worldEditWandCUI && isHoldingWand(p)) || isWand(p.getInventory().getItemInMainHand())) {
                     Location[] d = getCuboid(p);
+                    if (d == null || d[0] == null || d[1] == null) return;
                     new WandSelection(new Cuboid(d[0], d[1]), p).draw();
                 }
             } catch (Throwable e) {

core/src/main/java/com/volmit/iris/core/tools/IrisBenchmarking.java

@@ -1,625 +0,0 @@
-package com.volmit.iris.core.tools;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.util.format.C;
-import oshi.SystemInfo;
-import oshi.hardware.CentralProcessor;
-import oshi.hardware.GlobalMemory;
-import oshi.hardware.HWDiskStore;
-import oshi.software.os.OperatingSystem;
-
-import java.io.*;
-import java.lang.management.ManagementFactory;
-import java.lang.management.MemoryMXBean;
-import java.lang.management.MemoryUsage;
-import java.security.SecureRandom;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Base64;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.stream.IntStream;
-import java.util.zip.Deflater;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-
-import static com.google.common.math.LongMath.isPrime;
-import static com.volmit.iris.util.misc.getHardware.getCPUModel;
-public class IrisBenchmarking {
-    static String ServerOS;
-    static String filePath = "benchmark.dat";
-    static double avgWriteSpeedMBps;
-    static double avgReadSpeedMBps;
-    static double highestWriteSpeedMBps;
-    static double highestReadSpeedMBps;
-    static double lowestWriteSpeedMBps;
-    static double lowestReadSpeedMBps;
-    static double calculateIntegerMath;
-    static double calculateFloatingPoint;
-    static double calculatePrimeNumbers;
-    static double calculateStringSorting;
-    static double calculateDataEncryption;
-    static double calculateDataCompression;
-    static String currentRunning = "None";
-    static int BenchmarksCompleted = 0;
-    static int BenchmarksTotal = 7;
-    static int totalTasks = 10;
-    static int currentTasks = 0;
-    static double WindowsCPUCompression;
-    static double WindowsCPUEncryption;
-    static double WindowsCPUCSHA1;
-    static double elapsedTimeNs;
-    static boolean Winsat = false;
-    static boolean WindowsDiskSpeed = false;
-    public static boolean inProgress = false;
-    static double startTime;
-    // Good enough for now. . .
-
-    public static void runBenchmark() throws InterruptedException {
-        inProgress = true;
-        getServerOS();
-        deleteTestFile(filePath);
-        AtomicReference<Double> doneCalculateDiskSpeed = new AtomicReference<>((double) 0);
-        startBenchmarkTimer();
-        Iris.info("Benchmark Started!");
-        Iris.warn("Although it may seem momentarily paused, it's actively processing.");
-        BenchmarksCompleted = 0;
-
-        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
-            currentRunning = "calculateDiskSpeed";
-            progressBar();
-            if (ServerOS.contains("Windows") && isRunningAsAdmin()) {
-                WindowsDiskSpeed = true;
-                WindowsDiskSpeedTest();
-            } else {
-                warningFallback();
-                try {
-                    Thread.sleep(10);
-                } catch (InterruptedException e) {
-                    throw new RuntimeException(e);
-                }
-                doneCalculateDiskSpeed.set(roundToTwoDecimalPlaces(calculateDiskSpeed()));
-                BenchmarksCompleted++;
-            }
-
-
-        }).thenRun(() -> {
-            currentRunning = "WindowsCpuSpeedTest";
-            progressBar();
-            if (ServerOS.contains("Windows") && isRunningAsAdmin()) {
-                Winsat = true;
-                WindowsCpuSpeedTest();
-            } else {
-                Iris.info("Skipping:" + C.BLUE + " Windows System Assessment Tool Benchmarks");
-                if (!ServerOS.contains("Windows")) {
-                    Iris.info("Required Software:" + C.BLUE + " Windows");
-                    BenchmarksTotal = 6;
-                }
-                if (!isRunningAsAdmin()) {
-                    Iris.info(C.RED + "ERROR: " + C.DARK_RED + "Elevated privileges missing");
-                    BenchmarksTotal = 6;
-                }
-            }
-
-        }).thenRun(() -> {
-            currentRunning = "calculateIntegerMath";
-            progressBar();
-            calculateIntegerMath = roundToTwoDecimalPlaces(calculateIntegerMath());
-            BenchmarksCompleted++;
-        }).thenRun(() -> {
-            currentRunning = "calculateFloatingPoint";
-            progressBar();
-            calculateFloatingPoint = roundToTwoDecimalPlaces(calculateFloatingPoint());
-            BenchmarksCompleted++;
-        }).thenRun(() -> {
-            currentRunning = "calculateStringSorting";
-            progressBar();
-            calculateStringSorting = roundToTwoDecimalPlaces(calculateStringSorting());
-            BenchmarksCompleted++;
-        }).thenRun(() -> {
-            currentRunning = "calculatePrimeNumbers";
-            progressBar();
-            calculatePrimeNumbers = roundToTwoDecimalPlaces(calculatePrimeNumbers());
-            BenchmarksCompleted++;
-        }).thenRun(() -> {
-            currentRunning = "calculateDataEncryption";
-            progressBar();
-            calculateDataEncryption = roundToTwoDecimalPlaces(calculateDataEncryption());
-            BenchmarksCompleted++;
-        }).thenRun(() -> {
-            currentRunning = "calculateDataCompression";
-            progressBar();
-            calculateDataCompression = roundToTwoDecimalPlaces(calculateDataCompression());
-            BenchmarksCompleted++;
-        }).thenRun(() -> {
-            elapsedTimeNs = stopBenchmarkTimer();
-            results();
-            inProgress = false;
-        });
-
-        try {
-            future.get();
-        } catch (InterruptedException | ExecutionException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static void progressBar() {
-        Iris.info("-----------------------------------------------------");
-        Iris.info("Currently Running: " + C.BLUE + currentRunning);
-        // Iris.info("Tasks: " + "Current Tasks: " + C.BLUE + currentTasks + C.WHITE + " / " + "Total Tasks: " + C.BLUE + totalTasks);
-        Iris.info("Benchmarks Completed: " + C.BLUE + BenchmarksCompleted + C.WHITE + " / " + "Total: " + C.BLUE + BenchmarksTotal);
-        Iris.info("-----------------------------------------------------");
-    }
-
-    public static void results() {
-
-        SystemInfo systemInfo = new SystemInfo();
-        GlobalMemory globalMemory = systemInfo.getHardware().getMemory();
-        long totalMemoryMB = globalMemory.getTotal() / (1024 * 1024);
-        long availableMemoryMB = globalMemory.getAvailable() / (1024 * 1024);
-        long totalPageSize = globalMemory.getPageSize() / (1024 * 1024);
-        long usedMemoryMB = totalMemoryMB - availableMemoryMB;
-        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
-
-        Iris.info("OS: " + ServerOS);
-        if (!isRunningAsAdmin() || !ServerOS.contains("Windows")) {
-            Iris.info(C.GOLD + "For the full results use Windows + Admin Rights..");
-        }
-        Iris.info("CPU Model: " + getCPUModel());
-        Iris.info("CPU Score: " + "WIP");
-        Iris.info("- Integer Math: " + calculateIntegerMath + " MOps/Sec");
-        Iris.info("- Floating Point Math: " + calculateFloatingPoint + " MOps/Sec");
-        Iris.info("- Find Prime Numbers: " + calculatePrimeNumbers + " Primes/Sec");
-        Iris.info("- Random String Sorting: " + calculateStringSorting + " Thousand Strings/Sec");
-        Iris.info("- Data Encryption: " + formatDouble(calculateDataEncryption) + " MBytes/Sec");
-        Iris.info("- Data Compression: " + formatDouble(calculateDataCompression) + " MBytes/Sec");
-
-        if (WindowsDiskSpeed) {
-            //Iris.info("Disk Model: " + getDiskModel());
-            Iris.info(C.BLUE + "- Running with Windows System Assessment Tool");
-            Iris.info("- Sequential 64.0 Write: " + C.BLUE + formatDouble(avgWriteSpeedMBps) + " Mbps");
-            Iris.info("- Sequential 64.0 Read: " + C.BLUE + formatDouble(avgReadSpeedMBps) + " Mbps");
-        } else {
-           // Iris.info("Disk Model: " + getDiskModel());
-            Iris.info(C.GREEN + "- Running in Native Mode");
-            Iris.info("- Average Write Speed: " + C.GREEN + formatDouble(avgWriteSpeedMBps) + " Mbps");
-            Iris.info("- Average Read Speed: " + C.GREEN + formatDouble(avgReadSpeedMBps) + " Mbps");
-            Iris.info("- Highest Write Speed: " + formatDouble(highestWriteSpeedMBps) + " Mbps");
-            Iris.info("- Highest Read Speed: " + formatDouble(highestReadSpeedMBps) + " Mbps");
-            Iris.info("- Lowest Write Speed: " + formatDouble(lowestWriteSpeedMBps) + " Mbps");
-            Iris.info("- Lowest Read Speed: " + formatDouble(lowestReadSpeedMBps) + " Mbps");
-        }
-        Iris.info("Ram Usage: ");
-        Iris.info("- Total Ram: " + totalMemoryMB + " MB");
-        Iris.info("- Used Ram: " + usedMemoryMB + " MB");
-        Iris.info("- Total Process Ram: " + C.BLUE + getMaxMemoryUsage() + " MB");
-        Iris.info("- Total Paging Size: " + totalPageSize + " MB");
-        if (Winsat) {
-            Iris.info(C.BLUE + "Windows System Assessment Tool: ");
-            Iris.info("- CPU LZW Compression:" + C.BLUE + formatDouble(WindowsCPUCompression) + " MB/s");
-            Iris.info("- CPU AES256 Encryption: " + C.BLUE + formatDouble(WindowsCPUEncryption) + " MB/s");
-            Iris.info("- CPU SHA1 Hash: " + C.BLUE + formatDouble(WindowsCPUCSHA1) + " MB/s");
-            Iris.info("Duration: " + roundToTwoDecimalPlaces(elapsedTimeNs) + " Seconds");
-        }
-
-    }
-
-    public static long getMaxMemoryUsage() {
-        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
-        MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
-        MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
-        long maxHeapMemory = heapMemoryUsage.getMax();
-        long maxNonHeapMemory = nonHeapMemoryUsage.getMax();
-        long maxMemoryUsageMB = (maxHeapMemory + maxNonHeapMemory) / (1024 * 1024);
-        return maxMemoryUsageMB;
-    }
-
-    public static void getServerOS() {
-        SystemInfo systemInfo = new SystemInfo();
-        OperatingSystem os = systemInfo.getOperatingSystem();
-        ServerOS = os.toString();
-    }
-
-    public static boolean isRunningAsAdmin() {
-        if (ServerOS.contains("Windows")) {
-            try {
-                Process process = Runtime.getRuntime().exec("winsat disk");
-                process.waitFor();
-                return process.exitValue() == 0;
-            } catch (IOException | InterruptedException e) {
-                // Hmm
-            }
-        }
-        return false;
-    }
-
-    public static void warningFallback() {
-        Iris.info(C.RED + "Using the " + C.DARK_RED + "FALLBACK" + C.RED + " method due to compatibility issues. ");
-        Iris.info(C.RED + "Please note that this may result in less accurate results.");
-    }
-
-    private static String formatDouble(double value) {
-        return String.format("%.2f", value);
-    }
-
-    private static void startBenchmarkTimer() {
-        startTime = System.nanoTime();
-    }
-
-    private static double stopBenchmarkTimer() {
-        long endTime = System.nanoTime();
-        return (endTime - startTime) / 1_000_000_000.0;
-    }
-
-    private static double calculateIntegerMath() {
-        final int numIterations = 1_000_000_000;
-        final int numRuns = 30;
-        double totalMopsPerSec = 0;
-
-        for (int run = 0; run < numRuns; run++) {
-            long startTime = System.nanoTime();
-            int result = 0;
-
-            for (int i = 0; i < numIterations; i++) {
-                result += i * 2;
-                result -= i / 2;
-                result ^= i;
-                result <<= 1;
-                result >>= 1;
-            }
-
-            long endTime = System.nanoTime();
-            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
-            double mopsPerSec = (numIterations / elapsedSeconds) / 1_000_000.0;
-
-            totalMopsPerSec += mopsPerSec;
-        }
-
-        double averageMopsPerSec = totalMopsPerSec / numRuns;
-        return averageMopsPerSec;
-    }
-
-    private static double calculateFloatingPoint() {
-        long numIterations = 85_000_000;
-        int numRuns = 30;
-        double totalMopsPerSec = 0;
-        for (int run = 0; run < numRuns; run++) {
-            double result = 0;
-            long startTime = System.nanoTime();
-
-            for (int i = 0; i < numIterations; i++) {
-                result += Math.sqrt(i) * Math.sin(i) / (i + 1);
-            }
-
-            long endTime = System.nanoTime();
-            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
-            double mopsPerSec = (numIterations / elapsedSeconds) / 1_000_000.0;
-
-            totalMopsPerSec += mopsPerSec;
-        }
-
-        double averageMopsPerSec = totalMopsPerSec / numRuns;
-        return averageMopsPerSec;
-    }
-
-    private static double calculatePrimeNumbers() {
-        int primeCount;
-        long numIterations = 1_000_000;
-        int numRuns = 30;
-        double totalMopsPerSec = 0;
-
-        for (int run = 0; run < numRuns; run++) {
-            primeCount = 0;
-            long startTime = System.nanoTime();
-
-            for (int num = 2; primeCount < numIterations; num++) {
-                if (isPrime(num)) {
-                    primeCount++;
-                }
-            }
-
-            long endTime = System.nanoTime();
-            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
-            double mopsPerSec = (primeCount / elapsedSeconds) / 1_000_000.0;
-
-            totalMopsPerSec += mopsPerSec;
-        }
-
-        double averageMopsPerSec = totalMopsPerSec / numRuns;
-        return averageMopsPerSec;
-    }
-
-    private static double calculateStringSorting() {
-        int stringCount = 1_000_000;
-        int stringLength = 100;
-        int numRuns = 30;
-        double totalMopsPerSec = 0;
-
-        for (int run = 0; run < numRuns; run++) {
-            List<String> randomStrings = generateRandomStrings(stringCount, stringLength);
-            long startTime = System.nanoTime();
-            randomStrings.sort(String::compareTo);
-            long endTime = System.nanoTime();
-
-            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
-            double mopsPerSec = (stringCount / elapsedSeconds) / 1_000.0;
-
-            totalMopsPerSec += mopsPerSec;
-        }
-
-        double averageMopsPerSec = totalMopsPerSec / numRuns;
-        return averageMopsPerSec;
-    }
-
-    public static double calculateDataEncryption() {
-        int dataSizeMB = 100;
-        byte[] dataToEncrypt = generateRandomData(dataSizeMB * 1024 * 1024);
-        int numRuns = 20;
-        double totalMBytesPerSec = 0;
-
-        for (int run = 0; run < numRuns; run++) {
-            long startTime = System.nanoTime();
-            byte[] encryptedData = performEncryption(dataToEncrypt, 1);
-
-            long endTime = System.nanoTime();
-            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
-            double mbytesPerSec = (dataToEncrypt.length / (1024 * 1024.0)) / elapsedSeconds;
-
-            totalMBytesPerSec += mbytesPerSec;
-        }
-
-        double averageMBytesPerSec = totalMBytesPerSec / numRuns;
-        return averageMBytesPerSec;
-    }
-
-    private static byte[] performEncryption(byte[] data, int numRuns) {
-        byte[] key = "MyEncryptionKey".getBytes();
-        byte[] result = Arrays.copyOf(data, data.length);
-        for (int run = 0; run < numRuns; run++) {
-            for (int i = 0; i < result.length; i++) {
-                result[i] ^= key[i % key.length];
-            }
-        }
-        return result;
-    }
-
-    public static double calculateDataCompression() {
-        int dataSizeMB = 500;
-        byte[] dataToCompress = generateRandomData(dataSizeMB * 1024 * 1024);
-        long startTime = System.nanoTime();
-        byte[] compressedData = performCompression(dataToCompress);
-        long endTime = System.nanoTime();
-
-        double elapsedSeconds = (endTime - startTime) / 1e9;
-        double mbytesPerSec = (compressedData.length / (1024.0 * 1024.0)) / elapsedSeconds;
-
-        return mbytesPerSec;
-    }
-
-    private static byte[] performCompression(byte[] data) {
-        Deflater deflater = new Deflater();
-        deflater.setInput(data);
-        deflater.finish();
-        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(data.length);
-
-        byte[] buffer = new byte[1024];
-        while (!deflater.finished()) {
-            int count = deflater.deflate(buffer);
-            outputStream.write(buffer, 0, count);
-        }
-
-        deflater.end();
-        return outputStream.toByteArray();
-    }
-
-    private static List<String> generateRandomStrings(int count, int length) {
-        SecureRandom random = new SecureRandom();
-        List<String> randomStrings = new ArrayList<>();
-
-        IntStream.range(0, count).forEach(i -> {
-            byte[] bytes = new byte[length];
-            random.nextBytes(bytes);
-            randomStrings.add(Base64.getEncoder().encodeToString(bytes));
-        });
-        return randomStrings;
-    }
-
-    private static byte[] generateRandomData(int size) {
-        SecureRandom random = new SecureRandom();
-        byte[] data = new byte[size];
-        random.nextBytes(data);
-        return data;
-    }
-
-    private static double roundToTwoDecimalPlaces(double value) {
-        return Double.parseDouble(String.format("%.2f", value));
-    }
-
-    private static double calculateCPUScore(long elapsedTimeNs) {
-        return 1.0 / (elapsedTimeNs / 1_000_000.0);
-    }
-
-    public static double calculateDiskSpeed() {
-        int numRuns = 10;
-        int fileSizeMB = 1000;
-
-        double[] writeSpeeds = new double[numRuns];
-        double[] readSpeeds = new double[numRuns];
-
-        for (int run = 0; run < numRuns; run++) {
-            long writeStartTime = System.nanoTime();
-            deleteTestFile(filePath);
-            createTestFile(filePath, fileSizeMB);
-            long writeEndTime = System.nanoTime();
-
-            long readStartTime = System.nanoTime();
-            readTestFile(filePath);
-            long readEndTime = System.nanoTime();
-
-            double writeSpeed = calculateDiskSpeedMBps(fileSizeMB, writeStartTime, writeEndTime);
-            double readSpeed = calculateDiskSpeedMBps(fileSizeMB, readStartTime, readEndTime);
-
-            writeSpeeds[run] = writeSpeed;
-            readSpeeds[run] = readSpeed;
-
-            if (run == 0) {
-                lowestWriteSpeedMBps = writeSpeed;
-                highestWriteSpeedMBps = writeSpeed;
-                lowestReadSpeedMBps = readSpeed;
-                highestReadSpeedMBps = readSpeed;
-            } else {
-                if (writeSpeed < lowestWriteSpeedMBps) {
-                    lowestWriteSpeedMBps = writeSpeed;
-                }
-                if (writeSpeed > highestWriteSpeedMBps) {
-                    highestWriteSpeedMBps = writeSpeed;
-                }
-                if (readSpeed < lowestReadSpeedMBps) {
-                    lowestReadSpeedMBps = readSpeed;
-                }
-                if (readSpeed > highestReadSpeedMBps) {
-                    highestReadSpeedMBps = readSpeed;
-                }
-            }
-        }
-        avgWriteSpeedMBps = calculateAverage(writeSpeeds);
-        avgReadSpeedMBps = calculateAverage(readSpeeds);
-        return 2;
-    }
-
-    public static void createTestFile(String filePath, int fileSizeMB) {
-        try {
-            File file = new File(filePath);
-            byte[] data = new byte[1024 * 1024];
-            Arrays.fill(data, (byte) 0);
-            FileOutputStream fos = new FileOutputStream(file);
-            for (int i = 0; i < fileSizeMB; i++) {
-                fos.write(data);
-            }
-            fos.close();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static void readTestFile(String filePath) {
-        try {
-            File file = new File(filePath);
-            FileInputStream fis = new FileInputStream(file);
-            byte[] buffer = new byte[1024];
-            while (fis.read(buffer) != -1) {
-            }
-            fis.close();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static void deleteTestFile(String filePath) {
-        File file = new File(filePath);
-        file.delete();
-    }
-
-    public static double calculateDiskSpeedMBps(int fileSizeMB, long startTime, long endTime) {
-        double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
-        double writeSpeed = (fileSizeMB / elapsedSeconds);
-        return writeSpeed;
-    }
-
-    public static double calculateAverage(double[] values) {
-        double sum = 0;
-        for (double value : values) {
-            sum += value;
-        }
-        return sum / values.length;
-    }
-
-    public static void WindowsDiskSpeedTest() {
-        try {
-            String command = "winsat disk";
-            Process process = Runtime.getRuntime().exec(command);
-            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
-            String line;
-
-            while ((line = reader.readLine()) != null) {
-                Iris.debug(line);
-
-                if (line.contains("Disk  Sequential 64.0 Read")) {
-                    avgReadSpeedMBps = extractSpeed(line);
-                } else if (line.contains("Disk  Sequential 64.0 Write")) {
-                    avgWriteSpeedMBps = extractSpeed(line);
-                }
-            }
-
-            process.waitFor();
-            process.destroy();
-
-            Iris.debug("Sequential Read Speed: " + avgReadSpeedMBps + " MB/s");
-            Iris.debug("Sequential Write Speed: " + avgWriteSpeedMBps + " MB/s");
-        } catch (IOException | InterruptedException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private static double extractSpeed(String line) {
-        String[] tokens = line.split("\\s+");
-        for (int i = 0; i < tokens.length; i++) {
-            if (tokens[i].endsWith("MB/s") && i > 0) {
-                try {
-                    return Double.parseDouble(tokens[i - 1]);
-                } catch (NumberFormatException e) {
-                    e.printStackTrace();
-                }
-            }
-        }
-        return 0.0;
-    }
-
-    public static void WindowsCpuSpeedTest() {
-        try {
-            String command = "winsat cpuformal";
-            Process process = Runtime.getRuntime().exec(command);
-            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
-            String line;
-
-            while ((line = reader.readLine()) != null) {
-                Iris.debug(line);
-
-                if (line.contains("CPU AES256 Encryption")) {
-                    WindowsCPUEncryption = extractCpuInfo(line);
-                }
-                if (line.contains("CPU LZW Compression")) {
-                    WindowsCPUCompression = extractCpuInfo(line);
-                }
-                if (line.contains("CPU SHA1 Hash")) {
-                    WindowsCPUCSHA1 = extractCpuInfo(line);
-                }
-            }
-            process.waitFor();
-            process.destroy();
-
-            Iris.debug("Winsat Encryption: " + WindowsCPUEncryption + " MB/s");
-        } catch (IOException | InterruptedException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private static double extractCpuInfo(String line) {
-        String[] tokens = line.split("\\s+");
-        for (int i = 0; i < tokens.length; i++) {
-            if (tokens[i].endsWith("MB/s") && i > 0) {
-                try {
-                    return Double.parseDouble(tokens[i - 1]);
-                } catch (NumberFormatException e) {
-                    e.printStackTrace();
-                }
-            }
-        }
-        return 0.0;
-    }
-
-}

core/src/main/java/com/volmit/iris/core/tools/IrisCreator.java

@@ -22,12 +22,11 @@ import com.google.common.util.concurrent.AtomicDouble;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.ServerConfigurator;
+import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import com.volmit.iris.core.safeguard.UtilsSFG;
 import com.volmit.iris.util.exceptions.IrisException;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
@@ -46,7 +45,6 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
-import static com.volmit.iris.core.safeguard.IrisSafeguard.unstablemode;
 
 /**
  * Makes it a lot easier to setup an engine, world, studio or whatever
@@ -86,7 +84,6 @@ public class IrisCreator {
      * Benchmark mode
      */
     private boolean benchmark = false;
-    private boolean smartVanillaHeight = false;
 
     public static boolean removeFromBukkitYml(String name) throws IOException {
         YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
@@ -126,14 +123,11 @@ public class IrisCreator {
         if (sender == null)
             sender = Iris.getSender();
 
-        if (!studio()) {
-            Iris.service(StudioSVC.class).installIntoWorld(sender, d.getLoadKey(), new File(Bukkit.getWorldContainer(), name()));
-        }
-        if (benchmark) {
+        if (!studio() || benchmark) {
             Iris.service(StudioSVC.class).installIntoWorld(sender, d.getLoadKey(), new File(Bukkit.getWorldContainer(), name()));
         }
 
-        PlatformChunkGenerator access = null;
+        PlatformChunkGenerator access;
         AtomicReference<World> world = new AtomicReference<>();
         AtomicDouble pp = new AtomicDouble(0);
         O<Boolean> done = new O<>();
@@ -143,7 +137,6 @@ public class IrisCreator {
                 .name(name)
                 .seed(seed)
                 .studio(studio)
-                .smartVanillaHeight(smartVanillaHeight)
                 .create();
         ServerConfigurator.installDataPacks(false);
 
@@ -178,7 +171,7 @@ public class IrisCreator {
 
         try {
             J.sfut(() -> {
-                world.set(wc.createWorld());
+                world.set(INMS.get().createWorld(wc));
             }).get();
         } catch (Throwable e) {
             e.printStackTrace();

core/src/main/java/com/volmit/iris/core/tools/IrisPackBenchmarking.java

@@ -9,72 +9,58 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.exceptions.IrisException;
 import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.math.Position2;
-
+import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import lombok.Getter;
 import org.bukkit.Bukkit;
 
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.nio.file.FileVisitResult;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
-import java.nio.file.attribute.BasicFileAttributes;
 import java.time.Clock;
 import java.time.LocalDateTime;
 import java.util.Collections;
-import java.util.concurrent.*;
 
 
 public class IrisPackBenchmarking {
-    @Getter
-    public static IrisPackBenchmarking instance;
-     public static boolean benchmarkInProgress = false;
-     private IrisDimension IrisDimension;
-     private int radius;
-     private boolean finished = false;
-    PrecisionStopwatch stopwatch;
+    private static final ThreadLocal<IrisPackBenchmarking> instance = new ThreadLocal<>();
+    private final PrecisionStopwatch stopwatch = new PrecisionStopwatch();
+    private final IrisDimension dimension;
+    private final int radius;
+    private final boolean gui;
 
-    public IrisPackBenchmarking(IrisDimension dimension, int r) {
-        instance = this;
-        this.IrisDimension = dimension;
-        this.radius = r;
+    public IrisPackBenchmarking(IrisDimension dimension, int radius, boolean gui) {
+        this.dimension = dimension;
+        this.radius = radius;
+        this.gui = gui;
         runBenchmark();
     }
 
-    private void runBenchmark() {
-        this.stopwatch = new PrecisionStopwatch();
-        ExecutorService service = Executors.newSingleThreadExecutor();
-        service.submit(() -> {
-            Iris.info("Setting up benchmark environment ");
-            benchmarkInProgress = true;
-            File file = new File("benchmark");
-            if (file.exists()) {
-                deleteDirectory(file.toPath());
-            }
-            createBenchmark();
-            while (!IrisToolbelt.isIrisWorld(Bukkit.getWorld("benchmark"))) {
-                J.sleep(1000);
-                Iris.debug("Iris PackBenchmark: Waiting...");
-            }
-            Iris.info("Starting Benchmark!");
-            stopwatch.begin();
-            startBenchmark();
-        });
-
+    public static IrisPackBenchmarking getInstance() {
+        return instance.get();
     }
 
-    public boolean getBenchmarkInProgress() {
-        return benchmarkInProgress;
+    private void runBenchmark() {
+        Thread.ofVirtual()
+                .name("PackBenchmarking")
+                .start(() -> {
+                    Iris.info("Setting up benchmark environment ");
+                    IO.delete(new File(Bukkit.getWorldContainer(), "benchmark"));
+                    createBenchmark();
+                    while (!IrisToolbelt.isIrisWorld(Bukkit.getWorld("benchmark"))) {
+                        J.sleep(1000);
+                        Iris.debug("Iris PackBenchmark: Waiting...");
+                    }
+                    Iris.info("Starting Benchmark!");
+                    stopwatch.begin();
+                    startBenchmark();
+                });
+
     }
 
     public void finishedBenchmark(KList<Integer> cps) {
         try {
-            String time = Form.duration(stopwatch.getMillis());
+            String time = Form.duration((long) stopwatch.getMilliseconds());
             Engine engine = IrisToolbelt.access(Bukkit.getWorld("benchmark")).getEngine();
             Iris.info("-----------------");
             Iris.info("Results:");
@@ -85,17 +71,13 @@ public class IrisPackBenchmarking {
             Iris.info("  - Lowest CPS: " + findLowest(cps));
             Iris.info("-----------------");
             Iris.info("Creating a report..");
-            File profilers = new File("plugins" + File.separator + "Iris" + File.separator + "packbenchmarks");
-            profilers.mkdir();
-
-            File results = new File("plugins " + File.separator + "Iris", IrisDimension.getName() + LocalDateTime.now(Clock.systemDefaultZone()) + ".txt");
-            results.createNewFile();
+            File results = Iris.instance.getDataFile("packbenchmarks", dimension.getName() + " " + LocalDateTime.now(Clock.systemDefaultZone()).toString().replace(':', '-') + ".txt");
             KMap<String, Double> metrics = engine.getMetrics().pull();
             try (FileWriter writer = new FileWriter(results)) {
                 writer.write("-----------------\n");
                 writer.write("Results:\n");
-                writer.write("Dimension: " + IrisDimension.getName() + "\n");
-                writer.write("- Date of Benchmark: " +  LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
+                writer.write("Dimension: " + dimension.getName() + "\n");
+                writer.write("- Date of Benchmark: " + LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
                 writer.write("\n");
                 writer.write("Metrics");
                 for (String m : metrics.k()) {
@@ -103,7 +85,7 @@ public class IrisPackBenchmarking {
                     writer.write("- " + m + ": " + i);
                 }
                 writer.write("- " + metrics);
-                writer.write("Benchmark: " +  LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
+                writer.write("Benchmark: " + LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
                 writer.write("- Total time: " + time + "\n");
                 writer.write("- Average CPS: " + calculateAverage(cps) + "\n");
                 writer.write("  - Median CPS: " + calculateMedian(cps) + "\n");
@@ -116,17 +98,24 @@ public class IrisPackBenchmarking {
                 e.printStackTrace();
             }
 
-            Bukkit.getServer().unloadWorld("benchmark", true);
+            J.s(() -> {
+                var world = Bukkit.getWorld("benchmark");
+                if (world == null) return;
+                IrisToolbelt.evacuate(world);
+                Bukkit.unloadWorld(world, true);
+            });
+
             stopwatch.end();
         } catch (Exception e) {
             Iris.error("Something has gone wrong!");
             e.printStackTrace();
         }
     }
-     private void createBenchmark(){
+
+    private void createBenchmark() {
         try {
             IrisToolbelt.createWorld()
-                    .dimension(IrisDimension.getName())
+                    .dimension(dimension.getLoadKey())
                     .name("benchmark")
                     .seed(1337)
                     .studio(false)
@@ -137,17 +126,19 @@ public class IrisPackBenchmarking {
         }
     }
 
-     private void startBenchmark(){
-        int x = 0;
-        int z = 0;
+    private void startBenchmark() {
+        try {
+            instance.set(this);
             IrisToolbelt.pregenerate(PregenTask
                     .builder()
-                    .gui(false)
-                    .center(new Position2(x, z))
-                    .width(5)
-                    .height(5)
+                    .gui(gui)
+                    .radiusX(radius)
+                    .radiusZ(radius)
                     .build(), Bukkit.getWorld("benchmark")
             );
+        } finally {
+            instance.remove();
+        }
     }
 
     private double calculateAverage(KList<Integer> list) {
@@ -176,26 +167,4 @@ public class IrisPackBenchmarking {
     private int findHighest(KList<Integer> list) {
         return Collections.max(list);
     }
-
-    private boolean deleteDirectory(Path dir) {
-        try {
-            Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
-                @Override
-                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
-                    Files.delete(file);
-                    return FileVisitResult.CONTINUE;
-                }
-
-                @Override
-                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
-                    Files.delete(dir);
-                    return FileVisitResult.CONTINUE;
-                }
-            });
-            return true;
-        } catch (IOException e) {
-            e.printStackTrace();
-            return false;
-        }
-    }
 }

core/src/main/java/com/volmit/iris/core/tools/IrisToolbelt.java

@@ -24,6 +24,7 @@ import com.volmit.iris.core.gui.PregeneratorJob;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.core.pregenerator.methods.CachedPregenMethod;
 import com.volmit.iris.core.pregenerator.methods.HybridPregenMethod;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.engine.framework.Engine;
@@ -141,7 +142,18 @@ public class IrisToolbelt {
      * @return the pregenerator job (already started)
      */
     public static PregeneratorJob pregenerate(PregenTask task, PregeneratorMethod method, Engine engine) {
-        return new PregeneratorJob(task, method, engine);
+        return pregenerate(task, method, engine, IrisSettings.get().getPregen().useCacheByDefault);
+    }
+
+    /**
+     * Start a pregenerator task
+     *
+     * @param task   the scheduled task
+     * @param method the method to execute the task
+     * @return the pregenerator job (already started)
+     */
+    public static PregeneratorJob pregenerate(PregenTask task, PregeneratorMethod method, Engine engine, boolean cached) {
+        return new PregeneratorJob(task, cached && engine != null ? new CachedPregenMethod(method, engine.getWorld().name()) : method, engine);
     }
 
     /**

core/src/main/java/com/volmit/iris/core/tools/IrisWorldCreator.java

@@ -21,10 +21,13 @@ package com.volmit.iris.core.tools;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.engine.platform.BukkitChunkGenerator;
+import com.volmit.iris.util.reflect.WrappedField;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.WorldCreator;
+import org.bukkit.WorldType;
 import org.bukkit.generator.ChunkGenerator;
+import sun.misc.Unsafe;
 
 import java.io.File;
 
@@ -32,7 +35,6 @@ public class IrisWorldCreator {
     private String name;
     private boolean studio = false;
     private String dimensionName = null;
-    private boolean smartVanillaHeight = false;
     private long seed = 1337;
 
     public IrisWorldCreator() {
@@ -64,11 +66,6 @@ public class IrisWorldCreator {
         return this;
     }
 
-    public IrisWorldCreator smartVanillaHeight(boolean smartVanillaHeight) {
-        this.smartVanillaHeight = smartVanillaHeight;
-        return this;
-    }
-
     public WorldCreator create() {
         IrisDimension dim = IrisData.loadAnyDimension(dimensionName);
 
@@ -82,7 +79,7 @@ public class IrisWorldCreator {
                 .build();
         ChunkGenerator g = new BukkitChunkGenerator(w, studio, studio
                 ? dim.getLoader().getDataFolder() :
-                new File(w.worldFolder(), "iris/pack"), dimensionName, smartVanillaHeight);
+                new File(w.worldFolder(), "iris/pack"), dimensionName);
 
 
         return new WorldCreator(name)

core/src/main/java/com/volmit/iris/core/wand/WandSelection.java

@@ -20,8 +20,6 @@ package com.volmit.iris.core.wand;
 
 import com.volmit.iris.util.data.Cuboid;
 import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.misc.E;
 import org.bukkit.Location;
 import org.bukkit.Particle;
 import org.bukkit.entity.Player;
@@ -29,8 +27,9 @@ import org.bukkit.util.Vector;
 
 import java.awt.*;
 
+import static com.volmit.iris.util.data.registry.Particles.REDSTONE;
+
 public class WandSelection {
-    private static final Particle REDSTONE = E.getOrDefault(Particle.class, "REDSTONE", "DUST");
     private final Cuboid c;
     private final Player p;
     private static final double STEP = 0.10;

core/src/main/java/com/volmit/iris/engine/IrisComplex.java

@@ -29,6 +29,7 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.data.DataProvider;
+import com.volmit.iris.util.interpolation.IrisInterpolation.NoiseKey;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.noise.CNG;
@@ -292,9 +293,11 @@ public class IrisComplex implements DataProvider {
             return 0;
         }
 
+        KMap<NoiseKey, IrisBiome> cache = new KMap<>();
         double hi = interpolator.interpolate(x, z, (xx, zz) -> {
             try {
                 IrisBiome bx = baseBiomeStream.get(xx, zz);
+                cache.put(new NoiseKey(xx, zz), bx);
                 double b = 0;
 
                 for (IrisGenerator gen : generators) {
@@ -313,7 +316,11 @@ public class IrisComplex implements DataProvider {
 
         double lo = interpolator.interpolate(x, z, (xx, zz) -> {
             try {
-                IrisBiome bx = baseBiomeStream.get(xx, zz);
+                IrisBiome bx = cache.get(new NoiseKey(xx, zz));
+                if (bx == null) {
+                    bx = baseBiomeStream.get(xx, zz);
+                    cache.put(new NoiseKey(xx, zz), bx);
+                }
                 double b = 0;
 
                 for (IrisGenerator gen : generators) {

core/src/main/java/com/volmit/iris/engine/IrisEngine.java

@@ -21,10 +21,10 @@ package com.volmit.iris.engine;
 import com.google.common.util.concurrent.AtomicDouble;
 import com.google.gson.Gson;
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.events.IrisEngineHotloadEvent;
 import com.volmit.iris.core.gui.PregeneratorJob;
+import com.volmit.iris.core.loader.ResourceLoader;
 import com.volmit.iris.core.nms.container.BlockPos;
 import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.core.project.IrisProject;
@@ -53,7 +53,6 @@ import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.ToString;
-import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -63,11 +62,10 @@ import java.io.File;
 import java.io.IOException;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 @Data
 @EqualsAndHashCode(exclude = "context")
@@ -92,12 +90,12 @@ public class IrisEngine implements Engine {
     private final AtomicBoolean cleaning;
     private final ChronoLatch cleanLatch;
     private final SeedManager seedManager;
+    private CompletableFuture<Long> hash32;
     private EngineMode mode;
     private EngineEffects effects;
     private EngineExecutionEnvironment execution;
     private EngineWorldManager worldManager;
     private volatile int parallelism;
-    private volatile int minHeight;
     private boolean failing;
     private boolean closed;
     private int cacheId;
@@ -130,7 +128,6 @@ public class IrisEngine implements Engine {
         getData().setEngine(this);
         getData().loadPrefetch(this);
         Iris.info("Initializing Engine: " + target.getWorld().name() + "/" + target.getDimension().getLoadKey() + " (" + target.getDimension().getDimensionHeight() + " height) Seed: " + getSeedManager().getSeed());
-        minHeight = 0;
         failing = false;
         closed = false;
         art = J.ar(this::tickRandomPlayer, 0);
@@ -174,8 +171,20 @@ public class IrisEngine implements Engine {
             complex = new IrisComplex(this);
             execution = new IrisExecutionEnvironment(this);
             effects = new IrisEngineEffects(this);
+            hash32 = new CompletableFuture<>();
             setupMode();
             J.a(this::computeBiomeMaxes);
+            J.a(() -> {
+                File[] roots = getData().getLoaders()
+                        .values()
+                        .stream()
+                        .map(ResourceLoader::getFolderName)
+                        .map(n -> new File(getData().getDataFolder(), n))
+                        .filter(File::exists)
+                        .filter(File::isDirectory)
+                        .toArray(File[]::new);
+                hash32.complete(IO.hashRecursive(roots));
+            });
         } catch (Throwable e) {
             Iris.error("FAILED TO SETUP ENGINE!");
             e.printStackTrace();
@@ -464,7 +473,7 @@ public class IrisEngine implements Engine {
         getEngineData().getStatistics().generatedChunk();
         try {
             PrecisionStopwatch p = PrecisionStopwatch.start();
-            Hunk<BlockData> blocks = vblocks.listen((xx, y, zz, t) -> catchBlockUpdates(x + xx, y + getMinHeight(), z + zz, t));
+            Hunk<BlockData> blocks = vblocks.listen((xx, y, zz, t) -> catchBlockUpdates(x + xx, y, z + zz, t));
 
             if (getDimension().isDebugChunkCrossSections() && ((x >> 4) % getDimension().getDebugCrossSectionsMod() == 0 || (z >> 4) % getDimension().getDebugCrossSectionsMod() == 0)) {
                 for (int i = 0; i < 16; i++) {

core/src/main/java/com/volmit/iris/engine/IrisEngineMantle.java

@@ -18,7 +18,7 @@
 
 package com.volmit.iris.engine;
 
-import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.mantle.EngineMantle;
@@ -27,23 +27,13 @@ import com.volmit.iris.engine.mantle.components.MantleCarvingComponent;
 import com.volmit.iris.engine.mantle.components.MantleFluidBodyComponent;
 import com.volmit.iris.engine.mantle.components.MantleJigsawComponent;
 import com.volmit.iris.engine.mantle.components.MantleObjectComponent;
-import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.mantle.Mantle;
-import com.volmit.iris.util.parallel.BurstExecutor;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.ToString;
-import org.bukkit.util.BlockVector;
+import lombok.*;
 
 import java.io.File;
-import java.io.IOException;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
 
 @Data
 @EqualsAndHashCode(exclude = "engine")
@@ -51,8 +41,9 @@ import java.util.concurrent.atomic.AtomicInteger;
 public class IrisEngineMantle implements EngineMantle {
     private final Engine engine;
     private final Mantle mantle;
-    private final KList<MantleComponent> components;
-    private final int radius;
+    @Getter(AccessLevel.NONE)
+    private final KMap<Integer, KList<MantleComponent>> components;
+    private final AtomicCache<KList<Pair<KList<MantleComponent>, Integer>>> componentsCache = new AtomicCache<>();
     private final AtomicCache<Integer> radCache = new AtomicCache<>();
     private final MantleObjectComponent object;
     private final MantleJigsawComponent jigsaw;
@@ -60,8 +51,7 @@ public class IrisEngineMantle implements EngineMantle {
     public IrisEngineMantle(Engine engine) {
         this.engine = engine;
         this.mantle = new Mantle(new File(engine.getWorld().worldFolder(), "mantle"), engine.getTarget().getHeight());
-        radius = radCache.aquire(this::computeParallaxSize);
-        components = new KList<>();
+        components = new KMap<>();
         registerComponent(new MantleCarvingComponent(this));
         registerComponent(new MantleFluidBodyComponent(this));
         jigsaw = new MantleJigsawComponent(this);
@@ -70,9 +60,49 @@ public class IrisEngineMantle implements EngineMantle {
         registerComponent(object);
     }
 
+    @Override
+    public int getRadius() {
+        if (components.isEmpty()) return 0;
+        return getComponents().getFirst().getB();
+    }
+
+    @Override
+    public int getRealRadius() {
+        if (components.isEmpty()) return 0;
+        return getComponents().getLast().getB();
+    }
+
+    @Override
+    public KList<Pair<KList<MantleComponent>, Integer>> getComponents() {
+        return componentsCache.aquire(() -> {
+            var list = components.keySet()
+                    .stream()
+                    .sorted()
+                    .map(components::get)
+                    .map(components -> {
+                        int radius = components.stream()
+                                .mapToInt(MantleComponent::getRadius)
+                                .max()
+                                .orElse(0);
+                        return new Pair<>(components, radius);
+                    })
+                    .collect(Collectors.toCollection(KList::new));
+
+
+            int radius = 0;
+            for (var pair : list.reversed()) {
+                radius += pair.getB();
+                pair.setB(Math.ceilDiv(radius, 16));
+            }
+
+            return list;
+        });
+    }
+
     @Override
     public void registerComponent(MantleComponent c) {
-        components.add(c);
+        components.computeIfAbsent(c.getPriority(), k -> new KList<>()).add(c);
+        componentsCache.reset();
     }
 
     @Override
@@ -84,243 +114,4 @@ public class IrisEngineMantle implements EngineMantle {
     public MantleObjectComponent getObjectComponent() {
         return object;
     }
-
-    private KList<IrisRegion> getAllRegions() {
-        KList<IrisRegion> r = new KList<>();
-
-        for (String i : getEngine().getDimension().getRegions()) {
-            r.add(getEngine().getData().getRegionLoader().load(i));
-        }
-
-        return r;
-    }
-
-    private KList<IrisBiome> getAllBiomes() {
-        KList<IrisBiome> r = new KList<>();
-
-        for (IrisRegion i : getAllRegions()) {
-            r.addAll(i.getAllBiomes(getEngine()));
-        }
-
-        return r;
-    }
-
-    private void warn(String ob, BlockVector bv) {
-        if (Math.max(bv.getBlockX(), bv.getBlockZ()) > 128) {
-            Iris.warn("Object " + ob + " has a large size (" + bv + ") and may increase memory usage!");
-        }
-    }
-
-    private void warnScaled(String ob, BlockVector bv, double ms) {
-        if (Math.max(bv.getBlockX(), bv.getBlockZ()) > 128) {
-            Iris.warn("Object " + ob + " has a large size (" + bv + ") and may increase memory usage! (Object scaled up to " + Form.pc(ms, 2) + ")");
-        }
-    }
-
-    private int computeParallaxSize() {
-        Iris.verbose("Calculating the Parallax Size in Parallel");
-        AtomicInteger xg = new AtomicInteger(0);
-        AtomicInteger zg = new AtomicInteger();
-        xg.set(0);
-        zg.set(0);
-        int jig = 0;
-        KSet<String> objects = new KSet<>();
-        KMap<IrisObjectScale, KList<String>> scalars = new KMap<>();
-        int x = xg.get();
-        int z = zg.get();
-
-        if (getEngine().getDimension().isUseMantle()) {
-            KList<IrisRegion> r = getAllRegions();
-            KList<IrisBiome> b = getAllBiomes();
-
-            for (IrisBiome i : b) {
-                for (IrisObjectPlacement j : i.getObjects()) {
-                    if (j.getScale().canScaleBeyond()) {
-                        scalars.put(j.getScale(), j.getPlace());
-                    } else {
-                        objects.addAll(j.getPlace());
-                    }
-                }
-
-                for (IrisJigsawStructurePlacement j : i.getJigsawStructures()) {
-                    jig = Math.max(jig, getData().getJigsawStructureLoader().load(j.getStructure()).getMaxDimension());
-                }
-            }
-
-            for (IrisRegion i : r) {
-                for (IrisObjectPlacement j : i.getObjects()) {
-                    if (j.getScale().canScaleBeyond()) {
-                        scalars.put(j.getScale(), j.getPlace());
-                    } else {
-                        objects.addAll(j.getPlace());
-                    }
-                }
-
-                for (IrisJigsawStructurePlacement j : i.getJigsawStructures()) {
-                    jig = Math.max(jig, getData().getJigsawStructureLoader().load(j.getStructure()).getMaxDimension());
-                }
-            }
-
-            for (IrisJigsawStructurePlacement j : getEngine().getDimension().getJigsawStructures()) {
-                jig = Math.max(jig, getData().getJigsawStructureLoader().load(j.getStructure()).getMaxDimension());
-            }
-
-            if (getEngine().getDimension().getStronghold() != null) {
-                try {
-                    jig = Math.max(jig, getData().getJigsawStructureLoader().load(getEngine().getDimension().getStronghold()).getMaxDimension());
-                } catch (Throwable e) {
-                    Iris.reportError(e);
-                    e.printStackTrace();
-                }
-            }
-
-            Iris.verbose("Checking sizes for " + Form.f(objects.size()) + " referenced objects.");
-            BurstExecutor e = getEngine().getTarget().getBurster().burst(objects.size());
-            KMap<String, BlockVector> sizeCache = new KMap<>();
-            for (String i : objects) {
-                e.queue(() -> {
-                    try {
-                        BlockVector bv = sizeCache.computeIfAbsent(i, (k) -> {
-                            try {
-                                return IrisObject.sampleSize(getData().getObjectLoader().findFile(i));
-                            } catch (IOException ex) {
-                                Iris.reportError(ex);
-                                ex.printStackTrace();
-                            }
-
-                            return null;
-                        });
-
-                        if (bv == null) {
-                            throw new RuntimeException();
-                        }
-
-                        warn(i, bv);
-
-                        synchronized (xg) {
-                            xg.getAndSet(Math.max(bv.getBlockX(), xg.get()));
-                        }
-
-                        synchronized (zg) {
-                            zg.getAndSet(Math.max(bv.getBlockZ(), zg.get()));
-                        }
-                    } catch (Throwable ed) {
-                        Iris.reportError(ed);
-
-                    }
-                });
-            }
-
-            for (Map.Entry<IrisObjectScale, KList<String>> entry : scalars.entrySet()) {
-                double ms = entry.getKey().getMaximumScale();
-                for (String j : entry.getValue()) {
-                    e.queue(() -> {
-                        try {
-                            BlockVector bv = sizeCache.computeIfAbsent(j, (k) -> {
-                                try {
-                                    return IrisObject.sampleSize(getData().getObjectLoader().findFile(j));
-                                } catch (IOException ioException) {
-                                    Iris.reportError(ioException);
-                                    ioException.printStackTrace();
-                                }
-
-                                return null;
-                            });
-
-                            if (bv == null) {
-                                throw new RuntimeException();
-                            }
-
-                            warnScaled(j, bv, ms);
-
-                            synchronized (xg) {
-                                xg.getAndSet((int) Math.max(Math.ceil(bv.getBlockX() * ms), xg.get()));
-                            }
-
-                            synchronized (zg) {
-                                zg.getAndSet((int) Math.max(Math.ceil(bv.getBlockZ() * ms), zg.get()));
-                            }
-                        } catch (Throwable ee) {
-                            Iris.reportError(ee);
-
-                        }
-                    });
-                }
-            }
-
-            e.complete();
-
-            x = xg.get();
-            z = zg.get();
-
-            for (IrisDepositGenerator i : getEngine().getDimension().getDeposits()) {
-                int max = i.getMaxDimension();
-                x = Math.max(max, x);
-                z = Math.max(max, z);
-            }
-
-            for (IrisRegion v : r) {
-                for (IrisDepositGenerator i : v.getDeposits()) {
-                    int max = i.getMaxDimension();
-                    x = Math.max(max, x);
-                    z = Math.max(max, z);
-                }
-            }
-
-            for (IrisBiome v : b) {
-                for (IrisDepositGenerator i : v.getDeposits()) {
-                    int max = i.getMaxDimension();
-                    x = Math.max(max, x);
-                    z = Math.max(max, z);
-                }
-            }
-        } else {
-            return 0;
-        }
-
-        x = Math.max(z, x);
-        int u = x;
-        int c = Math.max(computeCarvingRange(), computeBodyRange());
-        x = Math.max(jig, x);
-        x = Math.max(x, c);
-        x = (Math.max(x, 16) + 16) >> 4;
-        x = x % 2 == 0 ? x + 1 : x;
-        Iris.info("Mantle Size: " + x + " Chunks");
-        Iris.info("  Object Mantle Size: " + u + " (" + ((Math.max(u, 16) + 16) >> 4) + ")");
-        Iris.info("  Jigsaw Mantle Size: " + jig + " (" + ((Math.max(jig, 16) + 16) >> 4) + ")");
-        Iris.info("  Carving Mantle Size: " + c + " (" + ((Math.max(c, 16) + 16) >> 4) + ")");
-        return x;
-    }
-
-    private int computeBodyRange() {
-        int m = 0;
-
-        m = Math.max(m, getDimension().getFluidBodies().getMaxRange(getData()));
-
-        for (IrisRegion i : getDimension().getAllRegions(getEngine())) {
-            m = Math.max(m, i.getFluidBodies().getMaxRange(getData()));
-        }
-
-        for (IrisBiome i : getDimension().getAllBiomes(getEngine())) {
-            m = Math.max(m, i.getFluidBodies().getMaxRange(getData()));
-        }
-
-        return m;
-    }
-
-    private int computeCarvingRange() {
-        int m = 0;
-
-        m = Math.max(m, getDimension().getCarving().getMaxRange(getData()));
-
-        for (IrisRegion i : getDimension().getAllRegions(getEngine())) {
-            m = Math.max(m, i.getCarving().getMaxRange(getData()));
-        }
-
-        for (IrisBiome i : getDimension().getAllBiomes(getEngine())) {
-            m = Math.max(m, i.getCarving().getMaxRange(getData()));
-        }
-
-        return m;
-    }
 }

core/src/main/java/com/volmit/iris/engine/IrisWorldManager.java

@@ -55,6 +55,7 @@ import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.player.PlayerTeleportEvent;
 import org.bukkit.inventory.ItemStack;
 
+import java.lang.ref.WeakReference;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -62,6 +63,7 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -299,28 +301,6 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
             energy += 1.2;
         }
 
-        //@builder
-        IrisBiome biome = IrisSettings.get().getWorld().isAnbientEntitySpawningSystem()
-                ? getEngine().getSurfaceBiome(c) : null;
-        IrisEntitySpawn v = IrisSettings.get().getWorld().isAnbientEntitySpawningSystem()
-                ? spawnRandomly(Stream.concat(getData().getSpawnerLoader()
-                                .loadAll(getDimension().getEntitySpawners())
-                                .shuffleCopy(RNG.r).stream()
-                                .filter(this::canSpawn)
-                                .filter((i) -> i.isValid(biome))
-                                .flatMap((i) -> stream(i, initial)),
-                        Stream.concat(getData().getSpawnerLoader()
-                                        .loadAll(getEngine().getRegion(c.getX() << 4, c.getZ() << 4).getEntitySpawners())
-                                        .shuffleCopy(RNG.r).stream().filter(this::canSpawn)
-                                        .flatMap((i) -> stream(i, initial)),
-                                getData().getSpawnerLoader()
-                                        .loadAll(getEngine().getSurfaceBiome(c.getX() << 4, c.getZ() << 4).getEntitySpawners())
-                                        .shuffleCopy(RNG.r).stream().filter(this::canSpawn)
-                                        .flatMap((i) -> stream(i, initial))))
-                .collect(Collectors.toList()))
-                .popRandom(RNG.r) : null;
-        //@done
-
         if (IrisSettings.get().getWorld().isMarkerEntitySpawningSystem()) {
             getSpawnersFromMarkers(c).forEach((blockf, spawners) -> {
                 if (spawners.isEmpty()) {
@@ -335,94 +315,67 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
             });
         }
 
-        if (v != null && v.getReferenceSpawner() != null) {
-            int maxEntCount = v.getReferenceSpawner().getMaxEntitiesPerChunk();
+        if (!IrisSettings.get().getWorld().isAnbientEntitySpawningSystem()) {
+            return;
+        }
 
-            for (Entity i : c.getEntities()) {
-                if (i instanceof LivingEntity) {
-                    if (-maxEntCount <= 0) {
-                        return;
-                    }
-                }
-            }
+        //@builder
+        Predicate<IrisSpawner> filter = i -> i.canSpawn(getEngine(), c.getX(), c.getZ());
+        ChunkCounter counter = new ChunkCounter(c.getEntities());
 
-            try {
-                spawn(c, v);
-            } catch (Throwable e) {
-                J.s(() -> spawn(c, v));
-            }
+        IrisBiome biome = getEngine().getSurfaceBiome(c);
+        IrisEntitySpawn v = spawnRandomly(Stream.concat(getData().getSpawnerLoader()
+                                .loadAll(getDimension().getEntitySpawners())
+                                .shuffleCopy(RNG.r)
+                                .stream()
+                                .filter(filter)
+                                .filter((i) -> i.isValid(biome)),
+                        Stream.concat(getData()
+                                        .getSpawnerLoader()
+                                        .loadAll(getEngine().getRegion(c.getX() << 4, c.getZ() << 4).getEntitySpawners())
+                                        .shuffleCopy(RNG.r)
+                                        .stream()
+                                        .filter(filter),
+                                getData().getSpawnerLoader()
+                                        .loadAll(getEngine().getSurfaceBiome(c.getX() << 4, c.getZ() << 4).getEntitySpawners())
+                                        .shuffleCopy(RNG.r)
+                                        .stream()
+                                        .filter(filter)))
+                .filter(counter)
+                .flatMap((i) -> stream(i, initial))
+                .collect(Collectors.toList()))
+                .getRandom();
+        //@done
+        if (v == null || v.getReferenceSpawner() == null)
+            return;
+
+        try {
+            spawn(c, v);
+        } catch (Throwable e) {
+            J.s(() -> spawn(c, v));
         }
     }
 
     private void spawn(Chunk c, IrisEntitySpawn i) {
-        boolean allow = true;
-
-        if (!i.getReferenceSpawner().getMaximumRatePerChunk().isInfinite()) {
-            allow = false;
-            IrisEngineChunkData cd = getEngine().getEngineData().getChunk(c.getX(), c.getZ());
-            IrisEngineSpawnerCooldown sc = null;
-            for (IrisEngineSpawnerCooldown j : cd.getCooldowns()) {
-                if (j.getSpawner().equals(i.getReferenceSpawner().getLoadKey())) {
-                    sc = j;
-                    break;
-                }
-            }
-
-            if (sc == null) {
-                sc = new IrisEngineSpawnerCooldown();
-                sc.setSpawner(i.getReferenceSpawner().getLoadKey());
-                cd.getCooldowns().add(sc);
-            }
-
-            if (sc.canSpawn(i.getReferenceSpawner().getMaximumRatePerChunk())) {
-                sc.spawn(getEngine());
-                allow = true;
-            }
-        }
-
-        if (allow) {
-            int s = i.spawn(getEngine(), c, RNG.r);
-            actuallySpawned += s;
-            if (s > 0) {
-                getCooldown(i.getReferenceSpawner()).spawn(getEngine());
-                energy -= s * ((i.getEnergyMultiplier() * i.getReferenceSpawner().getEnergyMultiplier() * 1));
-            }
+        IrisSpawner ref = i.getReferenceSpawner();
+        int s = i.spawn(getEngine(), c, RNG.r);
+        actuallySpawned += s;
+        if (s > 0) {
+            ref.spawn(getEngine(), c.getX(), c.getZ());
+            energy -= s * ((i.getEnergyMultiplier() * ref.getEnergyMultiplier() * 1));
         }
     }
 
-    private void spawn(IrisPosition c, IrisEntitySpawn i) {
-        boolean allow = true;
+    private void spawn(IrisPosition pos, IrisEntitySpawn i) {
+        IrisSpawner ref = i.getReferenceSpawner();
+        if (!ref.canSpawn(getEngine(), pos.getX() >> 4, pos.getZ() >> 4))
+            return;
 
-        if (!i.getReferenceSpawner().getMaximumRatePerChunk().isInfinite()) {
-            allow = false;
-            IrisEngineChunkData cd = getEngine().getEngineData().getChunk(c.getX() >> 4, c.getZ() >> 4);
-            IrisEngineSpawnerCooldown sc = null;
-            for (IrisEngineSpawnerCooldown j : cd.getCooldowns()) {
-                if (j.getSpawner().equals(i.getReferenceSpawner().getLoadKey())) {
-                    sc = j;
-                    break;
-                }
-            }
-
-            if (sc == null) {
-                sc = new IrisEngineSpawnerCooldown();
-                sc.setSpawner(i.getReferenceSpawner().getLoadKey());
-                cd.getCooldowns().add(sc);
-            }
-
-            if (sc.canSpawn(i.getReferenceSpawner().getMaximumRatePerChunk())) {
-                sc.spawn(getEngine());
-                allow = true;
-            }
-        }
-
-        if (allow) {
-            int s = i.spawn(getEngine(), c, RNG.r);
-            actuallySpawned += s;
-            if (s > 0) {
-                getCooldown(i.getReferenceSpawner()).spawn(getEngine());
-                energy -= s * ((i.getEnergyMultiplier() * i.getReferenceSpawner().getEnergyMultiplier() * 1));
-            }
+        int s = i.spawn(getEngine(), pos, RNG.r);
+        actuallySpawned += s;
+        if (s > 0) {
+            ref.spawn(getEngine(), pos.getX() >> 4, pos.getZ() >> 4);
+            energy -= s * ((i.getEnergyMultiplier() * ref.getEnergyMultiplier() * 1));
         }
     }
 
@@ -450,31 +403,6 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
         return rarityTypes;
     }
 
-    public boolean canSpawn(IrisSpawner i) {
-        return i.isValid(getEngine().getWorld().realWorld())
-                && getCooldown(i).canSpawn(i.getMaximumRate());
-    }
-
-    private IrisEngineSpawnerCooldown getCooldown(IrisSpawner i) {
-        IrisEngineData ed = getEngine().getEngineData();
-        IrisEngineSpawnerCooldown cd = null;
-
-        for (IrisEngineSpawnerCooldown j : ed.getSpawnerCooldowns()) {
-            if (j.getSpawner().equals(i.getLoadKey())) {
-                cd = j;
-            }
-        }
-
-        if (cd == null) {
-            cd = new IrisEngineSpawnerCooldown();
-            cd.setSpawner(i.getLoadKey());
-            cd.setLastSpawn(M.ms() - i.getMaximumRate().getInterval());
-            ed.getSpawnerCooldowns().add(cd);
-        }
-
-        return cd;
-    }
-
     @Override
     public void onTick() {
 
@@ -495,9 +423,16 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
             return;
         }
 
-        energy += 0.3;
-        fixEnergy();
-        getEngine().cleanupMantleChunk(e.getX(), e.getZ());
+        var ref = new WeakReference<>(e.getWorld());
+        int x = e.getX(), z = e.getZ();
+        J.s(() -> {
+            World world = ref.get();
+            if (world == null || !world.isChunkLoaded(x, z))
+                return;
+            energy += 0.3;
+            fixEnergy();
+            getEngine().cleanupMantleChunk(x, z);
+        }, IrisSettings.get().getPerformance().mantleCleanupDelay);
 
         if (generated) {
             //INMS.get().injectBiomesFromMantle(e, getMantle());
@@ -708,4 +643,27 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
 
         return (double) entityCount / (getEngine().getWorld().realWorld().getLoadedChunks().length + 1) * 1.28;
     }
+
+    @Data
+    private static class ChunkCounter implements Predicate<IrisSpawner> {
+        private final Entity[] entities;
+        private transient int index = 0;
+        private transient int count = 0;
+
+        @Override
+        public boolean test(IrisSpawner spawner) {
+            int max = spawner.getMaxEntitiesPerChunk();
+            if (max <= count)
+                return false;
+
+            while (index < entities.length) {
+                if (entities[index++] instanceof LivingEntity) {
+                    if (++count >= max)
+                        return false;
+                }
+            }
+
+            return true;
+        }
+    }
 }

core/src/main/java/com/volmit/iris/engine/data/chunk/LinkedTerrainChunk.java

@@ -21,7 +21,7 @@ package com.volmit.iris.engine.data.chunk;
 import com.volmit.iris.core.nms.BiomeBaseInjector;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.util.data.IrisBiomeStorage;
-import com.volmit.iris.util.data.IrisBlockData;
+import com.volmit.iris.util.data.IrisCustomData;
 import lombok.Setter;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
@@ -121,7 +121,7 @@ public class LinkedTerrainChunk implements TerrainChunk {
 
     @Override
     public synchronized void setBlock(int x, int y, int z, BlockData blockData) {
-        if (blockData instanceof IrisBlockData d)
+        if (blockData instanceof IrisCustomData d)
             blockData = d.getBase();
         rawChunkData.setBlock(x, y, z, blockData);
     }

core/src/main/java/com/volmit/iris/engine/data/chunk/MCATerrainChunk.java

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.data.chunk;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.BiomeBaseInjector;
-import com.volmit.iris.util.data.IrisBlockData;
+import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.nbt.mca.Chunk;
 import com.volmit.iris.util.nbt.mca.NBTWorld;
 import lombok.AllArgsConstructor;
@@ -89,7 +89,7 @@ public class MCATerrainChunk implements TerrainChunk {
         if (blockData == null) {
             Iris.error("NULL BD");
         }
-        if (blockData instanceof IrisBlockData data)
+        if (blockData instanceof IrisCustomData data)
             blockData = data.getBase();
 
         mcaChunk.setBlockStateAt(xx, y, zz, NBTWorld.getCompound(blockData), false);

core/src/main/java/com/volmit/iris/engine/decorator/IrisCeilingDecorator.java

@@ -18,18 +18,16 @@
 
 package com.volmit.iris.engine.decorator;
 
-import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
-import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
+import com.volmit.iris.util.math.RNG;
 import org.bukkit.Material;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.MultipleFacing;
 import org.bukkit.block.data.type.PointedDripstone;
 
 public class IrisCeilingDecorator extends IrisEngineDecorator {
@@ -40,20 +38,14 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
     @BlockCoordinates
     @Override
     public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
-        IrisDecorator decorator = getDecorator(biome, realX, realZ);
+        RNG rng = getRNG(realX, realZ);
+        IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
+
         if (decorator != null) {
             if (!decorator.isStacking()) {
-                if (height >= 0 || height < getEngine().getHeight()) {
-                    if (null != decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData())) {
-                        data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
-                        height--;
-                        data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
-                    } else {
-                        data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
-                    }
-                }
+                data.set(x, height, z, fixFaces(decorator.getBlockData100(biome, rng, realX, height, realZ, getData()), data, x, z, realX, height, realZ));
             } else {
-                int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
+                int stack = decorator.getHeight(rng, realX, realZ, getData());
                 if (decorator.isScaleStack()) {
                     stack = Math.min((int) Math.ceil((double) max * ((double) stack / 100)), decorator.getAbsoluteMaxStack());
                 } else {
@@ -61,7 +53,7 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
                 }
 
                 if (stack == 1) {
-                    data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
                     return;
                 }
 
@@ -74,8 +66,8 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
                     double threshold = (((double) i) / (double) (stack - 1));
 
                     BlockData bd = threshold >= decorator.getTopThreshold() ?
-                            decorator.getBlockDataForTop(biome, getRng(), realX, h, realZ, getData()) :
-                            decorator.getBlockData100(biome, getRng(), realX, h, realZ, getData());
+                            decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
+                            decorator.getBlockData100(biome, rng, realX, h, realZ, getData());
 
                     if (bd instanceof PointedDripstone) {
                         PointedDripstone.Thickness th = PointedDripstone.Thickness.BASE;
@@ -105,24 +97,4 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
             }
         }
     }
-
-    private BlockData fixFaces(BlockData b, int x, int y, int z) {
-        if (B.isVineBlock(b)) {
-            MultipleFacing data = (MultipleFacing) b.clone();
-            boolean found = false;
-            for (BlockFace f : BlockFace.values()) {
-                if (!f.isCartesian())
-                    continue;
-                Material m = getEngine().getMantle().get(x + f.getModX(), y + f.getModY(), z + f.getModZ()).getMaterial();
-                if (m.isSolid()) {
-                    found = true;
-                    data.setFace(f, m.isSolid());
-                }
-            }
-            if (!found)
-                data.setFace(BlockFace.UP, true);
-            return data;
-        }
-        return b;
-    }
 }

core/src/main/java/com/volmit/iris/engine/decorator/IrisEngineDecorator.java

@@ -19,7 +19,6 @@
 package com.volmit.iris.engine.decorator;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineAssignedComponent;
 import com.volmit.iris.engine.framework.EngineDecorator;
@@ -27,30 +26,42 @@ import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.hunk.Hunk;
+import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.math.RNG;
 import lombok.Getter;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.BlockSupport;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.MultipleFacing;
 
 public abstract class IrisEngineDecorator extends EngineAssignedComponent implements EngineDecorator {
-
-    @Getter
-    private final RNG rng;
-
     @Getter
     private final IrisDecorationPart part;
+    private final long seed;
+    private final long modX, modZ;
 
     public IrisEngineDecorator(Engine engine, String name, IrisDecorationPart part) {
         super(engine, name + " Decorator");
         this.part = part;
-        this.rng = new RNG(getSeed() + 29356788 - (part.ordinal() * 10439677L));
+        this.seed = getSeed() + 29356788 - (part.ordinal() * 10439677L);
+        this.modX = 29356788 ^ (part.ordinal() + 6);
+        this.modZ = 10439677 ^ (part.ordinal() + 1);
     }
 
-    protected IrisDecorator getDecorator(IrisBiome biome, double realX, double realZ) {
-        KList<IrisDecorator> v = new KList<>();
-        RNG rng = new RNG(Cache.key((int) realX, (int) realZ));
+    @BlockCoordinates
+    protected RNG getRNG(int x, int z) {
+        return new RNG(x * modX + z * modZ + seed);
+    }
 
+    protected IrisDecorator getDecorator(RNG rng, IrisBiome biome, double realX, double realZ) {
+        KList<IrisDecorator> v = new KList<>();
+
+        RNG gRNG = new RNG(seed);
         for (IrisDecorator i : biome.getDecorators()) {
             try {
-                if (i.getPartOf().equals(part) && i.getBlockData(biome, this.rng, realX, realZ, getData()) != null) {
+                if (i.getPartOf().equals(part) && i.getBlockData(biome, gRNG, realX, realZ, getData()) != null) {
                     v.add(i);
                 }
             } catch (Throwable e) {
@@ -65,4 +76,40 @@ public abstract class IrisEngineDecorator extends EngineAssignedComponent implem
 
         return null;
     }
+
+    protected BlockData fixFaces(BlockData b, Hunk<BlockData> hunk, int rX, int rZ, int x, int y, int z) {
+        if (B.isVineBlock(b)) {
+            MultipleFacing data = (MultipleFacing) b.clone();
+            data.getFaces().forEach(f -> data.setFace(f, false));
+
+            boolean found = false;
+            for (BlockFace f : BlockFace.values()) {
+                if (!f.isCartesian())
+                    continue;
+                int yy = y + f.getModY();
+
+                BlockData r = getEngine().getMantle().get(x + f.getModX(), yy, z + f.getModZ());
+                if (r.isFaceSturdy(f.getOppositeFace(), BlockSupport.FULL)) {
+                    found = true;
+                    data.setFace(f, true);
+                    continue;
+                }
+
+                int xx = rX + f.getModX();
+                int zz = rZ + f.getModZ();
+                if (xx < 0 || xx > 15 || zz < 0 || zz > 15 || yy < 0 || yy > hunk.getHeight())
+                    continue;
+
+                r = hunk.get(xx, yy, zz);
+                if (r.isFaceSturdy(f.getOppositeFace(), BlockSupport.FULL)) {
+                    found = true;
+                    data.setFace(f, true);
+                }
+            }
+            if (!found)
+                data.setFace(BlockFace.DOWN, true);
+            return data;
+        }
+        return b;
+    }
 }

core/src/main/java/com/volmit/iris/engine/decorator/IrisSeaFloorDecorator.java

@@ -18,13 +18,13 @@
 
 package com.volmit.iris.engine.decorator;
 
-import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
+import com.volmit.iris.util.math.RNG;
 import org.bukkit.block.data.BlockData;
 
 public class IrisSeaFloorDecorator extends IrisEngineDecorator {
@@ -35,7 +35,8 @@ public class IrisSeaFloorDecorator extends IrisEngineDecorator {
     @BlockCoordinates
     @Override
     public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
-        IrisDecorator decorator = getDecorator(biome, realX, realZ);
+        RNG rng = getRNG(realX, realZ);
+        IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
 
         if (decorator != null) {
             if (!decorator.isStacking()) {
@@ -44,25 +45,17 @@ public class IrisSeaFloorDecorator extends IrisEngineDecorator {
                     return;
                 }
                 if (height >= 0 || height < getEngine().getHeight()) {
-                    if (null != decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData())) {
-                        if (height == getDimension().getFluidHeight() - 1) {
-                            data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
-                            height++;
-                            data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
-                        }
-                    } else {
-                        data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
-                    }
+                    data.set(x, height, z, decorator.getBlockData100(biome, rng, realX, height, realZ, getData()));
                 }
             } else {
-                int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
+                int stack = decorator.getHeight(rng, realX, realZ, getData());
                 if (decorator.isScaleStack()) {
                     int maxStack = max - height;
                     stack = (int) Math.ceil((double) maxStack * ((double) stack / 100));
                 } else stack = Math.min(stack, max - height);
 
                 if (stack == 1) {
-                    data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
                     return;
                 }
 
@@ -74,8 +67,8 @@ public class IrisSeaFloorDecorator extends IrisEngineDecorator {
 
                     double threshold = ((double) i) / (stack - 1);
                     data.set(x, h, z, threshold >= decorator.getTopThreshold() ?
-                            decorator.getBlockDataForTop(biome, getRng(), realX, h, realZ, getData()) :
-                            decorator.getBlockData100(biome, getRng(), realX, h, realZ, getData()));
+                            decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
+                            decorator.getBlockData100(biome, rng, realX, h, realZ, getData()));
                 }
             }
         }

core/src/main/java/com/volmit/iris/engine/decorator/IrisSeaSurfaceDecorator.java

@@ -18,13 +18,13 @@
 
 package com.volmit.iris.engine.decorator;
 
-import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
+import com.volmit.iris.util.math.RNG;
 import org.bukkit.block.data.BlockData;
 
 public class IrisSeaSurfaceDecorator extends IrisEngineDecorator {
@@ -35,28 +35,23 @@ public class IrisSeaSurfaceDecorator extends IrisEngineDecorator {
     @BlockCoordinates
     @Override
     public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
-        IrisDecorator decorator = getDecorator(biome, realX, realZ);
+        RNG rng = getRNG(realX, realZ);
+        IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
 
         if (decorator != null) {
             if (!decorator.isStacking()) {
                 if (height >= 0 || height < getEngine().getHeight()) {
-                    if (null != decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData())) {
-                        data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
-                        height++;
-                        data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
-                    } else {
-                        data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
-                    }
+                    data.set(x, height + 1, z, decorator.getBlockData100(biome, rng, realX, height, realZ, getData()));
                 }
             } else {
-                int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
+                int stack = decorator.getHeight(rng, realX, realZ, getData());
                 if (decorator.isScaleStack()) {
                     int maxStack = max - height;
                     stack = (int) Math.ceil((double) maxStack * ((double) stack / 100));
                 }
 
                 if (stack == 1) {
-                    data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
                     return;
                 }
 
@@ -68,8 +63,8 @@ public class IrisSeaSurfaceDecorator extends IrisEngineDecorator {
 
                     double threshold = ((double) i) / (stack - 1);
                     data.set(x, h + 1, z, threshold >= decorator.getTopThreshold() ?
-                            decorator.getBlockDataForTop(biome, getRng().nextParallelRNG(i), realX, h, realZ, getData()) :
-                            decorator.getBlockData100(biome, getRng().nextParallelRNG(i), realX, h, realZ, getData()));
+                            decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
+                            decorator.getBlockData100(biome, rng, realX, h, realZ, getData()));
                 }
             }
         }

core/src/main/java/com/volmit/iris/engine/decorator/IrisShoreLineDecorator.java

@@ -18,13 +18,13 @@
 
 package com.volmit.iris.engine.decorator;
 
-import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
+import com.volmit.iris.util.math.RNG;
 import org.bukkit.block.data.BlockData;
 
 public class IrisShoreLineDecorator extends IrisEngineDecorator {
@@ -42,7 +42,8 @@ public class IrisShoreLineDecorator extends IrisEngineDecorator {
                     Math.round(getComplex().getHeightStream().get(realX, realZ1)) < getComplex().getFluidHeight() ||
                     Math.round(getComplex().getHeightStream().get(realX, realZ_1)) < getComplex().getFluidHeight()
             ) {
-                IrisDecorator decorator = getDecorator(biome, realX, realZ);
+                RNG rng = getRNG(realX, realZ);
+                IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
 
                 if (decorator != null) {
                     if (!decorator.isForcePlace() && !decorator.getSlopeCondition().isDefault()
@@ -51,22 +52,16 @@ public class IrisShoreLineDecorator extends IrisEngineDecorator {
                     }
 
                     if (!decorator.isStacking()) {
-                        if (null != decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData())) {
-                            data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
-                            height++;
-                            data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
-                        } else {
-                            data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
-                        }
+                        data.set(x, height + 1, z, decorator.getBlockData100(biome, rng, realX, height, realZ, getData()));
                     } else {
-                        int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
+                        int stack = decorator.getHeight(rng, realX, realZ, getData());
                         if (decorator.isScaleStack()) {
                             int maxStack = max - height;
                             stack = (int) Math.ceil((double) maxStack * ((double) stack / 100));
                         } else stack = Math.min(max - height, stack);
 
                         if (stack == 1) {
-                            data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
+                            data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
                             return;
                         }
 
@@ -74,8 +69,8 @@ public class IrisShoreLineDecorator extends IrisEngineDecorator {
                             int h = height + i;
                             double threshold = ((double) i) / (stack - 1);
                             data.set(x, h + 1, z, threshold >= decorator.getTopThreshold() ?
-                                    decorator.getBlockDataForTop(biome, getRng(), realX, h, realZ, getData()) :
-                                    decorator.getBlockData100(biome, getRng(), realX, h, realZ, getData()));
+                                    decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
+                                    decorator.getBlockData100(biome, rng, realX, h, realZ, getData()));
                         }
                     }
                 }

core/src/main/java/com/volmit/iris/engine/decorator/IrisSurfaceDecorator.java

@@ -19,7 +19,6 @@
 package com.volmit.iris.engine.decorator;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.InferredType;
 import com.volmit.iris.engine.object.IrisBiome;
@@ -28,11 +27,11 @@ import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
+import com.volmit.iris.util.math.RNG;
 import org.bukkit.Material;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.data.Bisected;
 import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.MultipleFacing;
 import org.bukkit.block.data.type.PointedDripstone;
 
 public class IrisSurfaceDecorator extends IrisEngineDecorator {
@@ -48,7 +47,8 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
         }
 
         BlockData bd, bdx;
-        IrisDecorator decorator = getDecorator(biome, realX, realZ);
+        RNG rng = getRNG(realX, realZ);
+        IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
         bdx = data.get(x, height, z);
         boolean underwater = height < getDimension().getFluidHeight();
 
@@ -59,7 +59,7 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
             }
 
             if (!decorator.isStacking()) {
-                bd = decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData());
+                bd = decorator.getBlockData100(biome, rng, realX, height, realZ, getData());
 
                 if (!underwater) {
                     if (!canGoOn(bd, bdx) && (!decorator.isForcePlace() && decorator.getForceBlock() == null)) {
@@ -68,12 +68,12 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
                 }
 
                 if (decorator.getForceBlock() != null) {
-                    data.set(x, height, z, fixFaces(decorator.getForceBlock().getBlockData(getData()), x, height, z));
+                    data.set(x, height, z, fixFaces(decorator.getForceBlock().getBlockData(getData()), data, x, z, realX, height, realZ));
                 } else if (!decorator.isForcePlace()) {
                     if (decorator.getWhitelist() != null && decorator.getWhitelist().stream().noneMatch(d -> d.getBlockData(getData()).equals(bdx))) {
                         return;
                     }
-                    if (decorator.getBlacklist() != null && decorator.getWhitelist().stream().anyMatch(d -> d.getBlockData(getData()).equals(bdx))) {
+                    if (decorator.getBlacklist() != null && decorator.getBlacklist().stream().anyMatch(d -> d.getBlockData(getData()).equals(bdx))) {
                         return;
                     }
                 }
@@ -91,14 +91,14 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
                 }
 
                 if (B.isAir(data.get(x, height + 1, z))) {
-                    data.set(x, height + 1, z, fixFaces(bd, x, height + 1, z));
+                    data.set(x, height + 1, z, fixFaces(bd, data, x, z, realX, height + 1, realZ));
                 }
             } else {
                 if (height < getDimension().getFluidHeight()) {
                     max = getDimension().getFluidHeight();
                 }
 
-                int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
+                int stack = decorator.getHeight(rng, realX, realZ, getData());
 
                 if (decorator.isScaleStack()) {
                     stack = Math.min((int) Math.ceil((double) max * ((double) stack / 100)), decorator.getAbsoluteMaxStack());
@@ -107,7 +107,7 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
                 }
 
                 if (stack == 1) {
-                    data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
                     return;
                 }
 
@@ -115,8 +115,8 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
                     int h = height + i;
                     double threshold = ((double) i) / (stack - 1);
                     bd = threshold >= decorator.getTopThreshold() ?
-                            decorator.getBlockDataForTop(biome, getRng(), realX, h, realZ, getData()) :
-                            decorator.getBlockData100(biome, getRng(), realX, h, realZ, getData());
+                            decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
+                            decorator.getBlockData100(biome, rng, realX, h, realZ, getData());
 
                     if (bd == null) {
                         break;
@@ -158,24 +158,4 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
             }
         }
     }
-
-    private BlockData fixFaces(BlockData b, int x, int y, int z) {
-        if (B.isVineBlock(b)) {
-            MultipleFacing data = (MultipleFacing) b.clone();
-            boolean found = false;
-            for (BlockFace f : BlockFace.values()) {
-                if (!f.isCartesian())
-                    continue;
-                Material m = getEngine().getMantle().get(x + f.getModX(), y + f.getModY(), z + f.getModZ()).getMaterial();
-                if (m.isSolid()) {
-                    found = true;
-                    data.setFace(f, m.isSolid());
-                }
-            }
-            if (!found)
-                data.setFace(BlockFace.UP, true);
-            return data;
-        }
-        return b;
-    }
 }

core/src/main/java/com/volmit/iris/engine/framework/Engine.java

@@ -20,6 +20,7 @@ package com.volmit.iris.engine.framework;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.events.IrisLootEvent;
 import com.volmit.iris.core.gui.components.RenderType;
 import com.volmit.iris.core.gui.components.Renderer;
 import com.volmit.iris.core.link.Identifier;
@@ -27,6 +28,7 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.core.nms.container.BlockPos;
 import com.volmit.iris.core.nms.container.Pair;
+import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.service.ExternalDataSVC;
 import com.volmit.iris.engine.IrisComplex;
 import com.volmit.iris.engine.data.cache.Cache;
@@ -40,7 +42,7 @@ import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.data.DataProvider;
-import com.volmit.iris.util.data.IrisBlockData;
+import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.format.C;
@@ -57,15 +59,13 @@ import com.volmit.iris.util.matter.TileWrapper;
 import com.volmit.iris.util.matter.slices.container.JigsawPieceContainer;
 import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.reflect.W;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import com.volmit.iris.util.stream.ProceduralStream;
 import io.papermc.lib.PaperLib;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.Location;
-import org.bukkit.Material;
+import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
@@ -75,11 +75,13 @@ import org.bukkit.entity.Player;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.Nullable;
 
-import java.awt.*;
-import java.util.Arrays;
+import java.awt.Color;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
@@ -138,7 +140,9 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
         return getTarget().getWorld().minHeight();
     }
 
-    void setMinHeight(int min);
+    default void setMinHeight(int min) {
+        getTarget().getWorld().minHeight(min);
+    }
 
     @BlockCoordinates
     default void generate(int x, int z, TerrainChunk tc, boolean multicore) throws WrongEngineBroException {
@@ -257,10 +261,8 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
         if (B.isUpdatable(data)) {
             getMantle().updateBlock(x, y, z);
         }
-        if (data instanceof IrisBlockData d) {
-            getMantle().getMantle().set(x, y, z, d.getCustom());
-        } else {
-            getMantle().getMantle().remove(x, y, z, Identifier.class);
+        if (data instanceof IrisCustomData) {
+            getMantle().getMantle().flag(x >> 4, z >> 4, MantleFlag.CUSTOM, true);
         }
     }
 
@@ -273,76 +275,105 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
             for (int z = -1; z <= 1; z++) {
                 if (c.getWorld().isChunkLoaded(c.getX() + x, c.getZ() + z))
                     continue;
-                Iris.debug("Chunk %s, %s [%s, %s] is not loaded".formatted(c.getX() + x, c.getZ() + z, x, z));
+                var msg = "Chunk %s, %s [%s, %s] is not loaded".formatted(c.getX() + x, c.getZ() + z, x, z);
+                if (W.getStack().getCallerClass().equals(ChunkUpdater.class)) Iris.warn(msg);
+                else Iris.debug(msg);
                 return;
             }
         }
-        if (!getMantle().getMantle().isLoaded(c)) {
-            Iris.debug("Mantle Chunk " + c.getX() + c.getX() + " is not loaded");
+        var mantle = getMantle().getMantle();
+        if (!mantle.isLoaded(c)) {
+            var msg = "Mantle Chunk " + c.getX() + c.getX() + " is not loaded";
+            if (W.getStack().getCallerClass().equals(ChunkUpdater.class)) Iris.warn(msg);
+            else Iris.debug(msg);
             return;
         }
 
-        getMantle().getMantle().raiseFlag(c.getX(), c.getZ(), MantleFlag.TILE, () -> J.s(() -> {
-            getMantle().getMantle().iterateChunk(c.getX(), c.getZ(), TileWrapper.class, (x, y, z, v) -> {
-                int betterY = y + getWorld().minHeight();
-                if (!TileData.setTileState(c.getBlock(x, betterY, z), v.getData()))
-                    Iris.warn("Failed to set tile entity data at [%d %d %d | %s] for tile %s!", x, betterY, z, c.getBlock(x, betterY, z).getBlockData().getMaterial().getKey(), v.getData().getMaterial().name());
-            });
-        }));
-        getMantle().getMantle().raiseFlag(c.getX(), c.getZ(), MantleFlag.CUSTOM, () -> J.s(() -> {
-            getMantle().getMantle().iterateChunk(c.getX(), c.getZ(), Identifier.class, (x, y, z, v) -> {
-                Iris.service(ExternalDataSVC.class).processUpdate(this, c.getBlock(x & 15, y + getWorld().minHeight(), z & 15), v);
-            });
-        }));
+        var chunk = mantle.getChunk(c).use();
+        try {
+            Semaphore semaphore = new Semaphore(3);
+            chunk.raiseFlag(MantleFlag.ETCHED, () -> {
+                chunk.raiseFlag(MantleFlag.TILE, run(semaphore, () -> J.s(() -> {
+                    mantle.iterateChunk(c.getX(), c.getZ(), TileWrapper.class, (x, y, z, v) -> {
+                        int betterY = y + getWorld().minHeight();
+                        if (!TileData.setTileState(c.getBlock(x, betterY, z), v.getData()))
+                            Iris.warn("Failed to set tile entity data at [%d %d %d | %s] for tile %s!", x, betterY, z, c.getBlock(x, betterY, z).getBlockData().getMaterial().getKey(), v.getData().getMaterial().name());
+                    });
+                })));
+                chunk.raiseFlag(MantleFlag.CUSTOM, run(semaphore, () -> J.s(() -> {
+                    mantle.iterateChunk(c.getX(), c.getZ(), Identifier.class, (x, y, z, v) -> {
+                        Iris.service(ExternalDataSVC.class).processUpdate(this, c.getBlock(x & 15, y + getWorld().minHeight(), z & 15), v);
+                    });
+                })));
 
-        getMantle().getMantle().raiseFlag(c.getX(), c.getZ(), MantleFlag.UPDATE, () -> J.s(() -> {
-            PrecisionStopwatch p = PrecisionStopwatch.start();
-            KMap<Long, Integer> updates = new KMap<>();
-            RNG r = new RNG(Cache.key(c.getX(), c.getZ()));
-            getMantle().getMantle().iterateChunk(c.getX(), c.getZ(), MatterCavern.class, (x, yf, z, v) -> {
-                int y = yf + getWorld().minHeight();
-                if (!B.isFluid(c.getBlock(x & 15, y, z & 15).getBlockData())) {
-                    return;
-                }
-                boolean u = false;
-                if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.DOWN).getBlockData())) {
-                    u = true;
-                } else if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.WEST).getBlockData())) {
-                    u = true;
-                } else if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.EAST).getBlockData())) {
-                    u = true;
-                } else if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.SOUTH).getBlockData())) {
-                    u = true;
-                } else if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.NORTH).getBlockData())) {
-                    u = true;
-                }
-
-                if (u) {
-                    updates.compute(Cache.key(x & 15, z & 15), (k, vv) -> {
-                        if (vv != null) {
-                            return Math.max(vv, y);
+                chunk.raiseFlag(MantleFlag.UPDATE, run(semaphore, () -> J.s(() -> {
+                    PrecisionStopwatch p = PrecisionStopwatch.start();
+                    KMap<Long, Integer> updates = new KMap<>();
+                    RNG r = new RNG(Cache.key(c.getX(), c.getZ()));
+                    mantle.iterateChunk(c.getX(), c.getZ(), MatterCavern.class, (x, yf, z, v) -> {
+                        int y = yf + getWorld().minHeight();
+                        if (!B.isFluid(c.getBlock(x & 15, y, z & 15).getBlockData())) {
+                            return;
+                        }
+                        boolean u = false;
+                        if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.DOWN).getBlockData())) {
+                            u = true;
+                        } else if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.WEST).getBlockData())) {
+                            u = true;
+                        } else if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.EAST).getBlockData())) {
+                            u = true;
+                        } else if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.SOUTH).getBlockData())) {
+                            u = true;
+                        } else if (B.isAir(c.getBlock(x & 15, y, z & 15).getRelative(BlockFace.NORTH).getBlockData())) {
+                            u = true;
                         }
 
-                        return y;
+                        if (u) {
+                            updates.compute(Cache.key(x & 15, z & 15), (k, vv) -> {
+                                if (vv != null) {
+                                    return Math.max(vv, y);
+                                }
+
+                                return y;
+                            });
+                        }
                     });
-                }
+
+                    updates.forEach((k, v) -> update(Cache.keyX(k), v, Cache.keyZ(k), c, r));
+                    mantle.iterateChunk(c.getX(), c.getZ(), MatterUpdate.class, (x, yf, z, v) -> {
+                        int y = yf + getWorld().minHeight();
+                        if (v != null && v.isUpdate()) {
+                            int vx = x & 15;
+                            int vz = z & 15;
+                            update(x, y, z, c, new RNG(Cache.key(c.getX(), c.getZ())));
+                            if (vx > 0 && vx < 15 && vz > 0 && vz < 15) {
+                                updateLighting(x, y, z, c);
+                            }
+                        }
+                    });
+                    mantle.deleteChunkSlice(c.getX(), c.getZ(), MatterUpdate.class);
+                    getMetrics().getUpdates().put(p.getMilliseconds());
+                }, RNG.r.i(0, 20))));
             });
 
-            updates.forEach((k, v) -> update(Cache.keyX(k), v, Cache.keyZ(k), c, r));
-            getMantle().getMantle().iterateChunk(c.getX(), c.getZ(), MatterUpdate.class, (x, yf, z, v) -> {
-                int y = yf + getWorld().minHeight();
-                if (v != null && v.isUpdate()) {
-                    int vx = x & 15;
-                    int vz = z & 15;
-                    update(x, y, z, c, new RNG(Cache.key(c.getX(), c.getZ())));
-                    if (vx > 0 && vx < 15 && vz > 0 && vz < 15) {
-                        updateLighting(x, y, z, c);
-                    }
-                }
-            });
-            getMantle().getMantle().deleteChunkSlice(c.getX(), c.getZ(), MatterUpdate.class);
-            getMetrics().getUpdates().put(p.getMilliseconds());
-        }, RNG.r.i(0, 20)));
+            try {
+                semaphore.acquire(3);
+            } catch (InterruptedException ignored) {}
+        } finally {
+            chunk.release();
+        }
+    }
+
+    private static Runnable run(Semaphore semaphore, Runnable runnable) {
+        return () -> {
+            if (!semaphore.tryAcquire())
+                return;
+            try {
+                runnable.run();
+            } finally {
+                semaphore.release();
+            }
+        };
     }
 
     @BlockCoordinates
@@ -388,7 +419,7 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
                     if (tables.isEmpty())
                         return;
                     InventoryHolder m = (InventoryHolder) block.getState();
-                    addItems(false, m.getInventory(), rx, tables, slot, x, y, z, 15);
+                    addItems(false, m.getInventory(), rx, tables, slot, c.getWorld(), x, y, z, 15);
 
                 } catch (Throwable e) {
                     Iris.reportError(e);
@@ -427,21 +458,21 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
             }
         }
 
-        for (int i = 0; i < 4; i++) {
-            try {
-                Arrays.parallelSort(nitems, (a, b) -> rng.nextInt());
-                break;
-            } catch (Throwable e) {
-                Iris.reportError(e);
-
-            }
+        for (int i = nitems.length; i > 1; i--) {
+            int j = rng.nextInt(i);
+            ItemStack tmp = nitems[i - 1];
+            nitems[i - 1] = nitems[j];
+            nitems[j] = tmp;
         }
 
         inventory.setContents(nitems);
     }
 
     @Override
-    default void injectTables(KList<IrisLootTable> list, IrisLootReference r) {
+    default void injectTables(KList<IrisLootTable> list, IrisLootReference r, boolean fallback) {
+        if (r.getMode().equals(IrisLootMode.FALLBACK) && !fallback)
+            return;
+
         if (r.getMode().equals(IrisLootMode.CLEAR) || r.getMode().equals(IrisLootMode.REPLACE)) {
             list.clear();
         }
@@ -476,10 +507,11 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
         IrisBiome biomeUnder = ry < he ? getComplex().getCaveBiomeStream().get(rx, rz) : biomeSurface;
 
         double multiplier = 1D * getDimension().getLoot().getMultiplier() * region.getLoot().getMultiplier() * biomeSurface.getLoot().getMultiplier() * biomeUnder.getLoot().getMultiplier();
-        injectTables(tables, getDimension().getLoot());
-        injectTables(tables, region.getLoot());
-        injectTables(tables, biomeSurface.getLoot());
-        injectTables(tables, biomeUnder.getLoot());
+        boolean fallback = tables.isEmpty();
+        injectTables(tables, getDimension().getLoot(), fallback);
+        injectTables(tables, region.getLoot(), fallback);
+        injectTables(tables, biomeSurface.getLoot(), fallback);
+        injectTables(tables, biomeUnder.getLoot(), fallback);
 
         if (tables.isNotEmpty()) {
             int target = (int) Math.round(tables.size() * multiplier);
@@ -497,16 +529,16 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
     }
 
     @Override
-    default void addItems(boolean debug, Inventory inv, RNG rng, KList<IrisLootTable> tables, InventorySlotType slot, int x, int y, int z, int mgf) {
+    default void addItems(boolean debug, Inventory inv, RNG rng, KList<IrisLootTable> tables, InventorySlotType slot, World world, int x, int y, int z, int mgf) {
         KList<ItemStack> items = new KList<>();
 
-        int b = 4;
         for (IrisLootTable i : tables) {
             if (i == null)
                 continue;
-            b++;
-            items.addAll(i.getLoot(debug, rng, slot, x, y, z));
+            items.addAll(i.getLoot(debug, rng, slot, world, x, y, z));
         }
+        if (IrisLootEvent.callLootEvent(items, inv, world, x, y, z))
+            return;
 
         if (PaperLib.isPaper() && getWorld().hasRealWorld()) {
             PaperLib.getChunkAtAsync(getWorld().realWorld(), x >> 4, z >> 4).thenAccept((c) -> {
@@ -580,6 +612,8 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
 
     int getGenerated();
 
+    CompletableFuture<Long> getHash32();
+
     default <T> IrisPosition lookForStreamResult(T find, ProceduralStream<T> stream, Function2<T, T, Boolean> matcher, long timeout) {
         AtomicInteger checked = new AtomicInteger();
         AtomicLong time = new AtomicLong(M.ms());
@@ -820,6 +854,25 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
         return getBiomeOrMantle(l.getBlockX(), l.getBlockY(), l.getBlockZ());
     }
 
+    @Nullable
+    @BlockCoordinates
+    default Position2 getNearestStronghold(Position2 pos) {
+        KList<Position2> p = getDimension().getStrongholds(getSeedManager().getMantle());
+        if (p.isEmpty()) return null;
+
+        Position2 pr = null;
+        double d = Double.MAX_VALUE;
+
+        for (Position2 i : p) {
+            double dx = i.distance(pos);
+            if (dx < d) {
+                d = dx;
+                pr = i;
+            }
+        }
+        return pr;
+    }
+
     default void gotoBiome(IrisBiome biome, Player player, boolean teleport) {
         Set<String> regionKeys = getDimension()
                 .getAllRegions(this).stream()
@@ -840,31 +893,10 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
 
     default void gotoJigsaw(IrisJigsawStructure s, Player player, boolean teleport) {
         if (s.getLoadKey().equals(getDimension().getStronghold())) {
-            KList<Position2> p = getDimension().getStrongholds(getSeedManager().getMantle());
-
-            if (p.isEmpty()) {
+            Position2 pr = getNearestStronghold(new Position2(player.getLocation().getBlockX(), player.getLocation().getBlockZ()));
+            if (pr == null) {
                 player.sendMessage(C.GOLD + "No strongholds in world.");
-            }
-
-            Position2 px = new Position2(player.getLocation().getBlockX(), player.getLocation().getBlockZ());
-            Position2 pr = null;
-            double d = Double.MAX_VALUE;
-
-            Iris.debug("Ps: " + p.size());
-
-            for (Position2 i : p) {
-                Iris.debug("- " + i.getX() + " " + i.getZ());
-            }
-
-            for (Position2 i : p) {
-                double dx = i.distance(px);
-                if (dx < d) {
-                    d = dx;
-                    pr = i;
-                }
-            }
-
-            if (pr != null) {
+            } else {
                 Location ll = new Location(player.getWorld(), pr.getX(), 40, pr.getZ());
                 J.s(() -> player.teleport(ll));
             }

core/src/main/java/com/volmit/iris/engine/framework/EngineAssignedWorldManager.java

@@ -97,51 +97,6 @@ public abstract class EngineAssignedWorldManager extends EngineAssignedComponent
         }
     }
 
-    @EventHandler
-    public void onItemUse(PlayerInteractEvent e) {
-        if (e.getItem() == null || e.getHand() != EquipmentSlot.HAND) {
-            return;
-        }
-        if (e.getAction() == Action.LEFT_CLICK_BLOCK || e.getAction() == Action.LEFT_CLICK_AIR) {
-            return;
-        }
-        if (e.getPlayer().getWorld().equals(getTarget().getWorld().realWorld()) && e.getItem().getType() == Material.ENDER_EYE) {
-            if (e.getClickedBlock() != null && e.getClickedBlock().getType() == Material.END_PORTAL_FRAME) {
-                return;
-            }
-
-            KList<Position2> positions = getEngine().getDimension().getStrongholds(getEngine().getSeedManager().getMantle());
-            if (positions.isEmpty()) {
-                return;
-            }
-
-            Position2 playerPos = new Position2(e.getPlayer().getLocation().getBlockX(), e.getPlayer().getLocation().getBlockZ());
-            Position2 pr = positions.get(0);
-            double d = pr.distance(playerPos);
-
-            for (Position2 pos : positions) {
-                double distance = pos.distance(playerPos);
-                if (distance < d) {
-                    d = distance;
-                    pr = pos;
-                }
-            }
-
-            if (e.getPlayer().getGameMode() != GameMode.CREATIVE) {
-                if (e.getItem().getAmount() > 1) {
-                    e.getPlayer().getInventory().getItemInMainHand().setAmount(e.getItem().getAmount() - 1);
-                } else {
-                    e.getPlayer().getInventory().setItemInMainHand(null);
-                }
-            }
-
-            EnderSignal eye = e.getPlayer().getWorld().spawn(e.getPlayer().getLocation().clone().add(0, 0.5F, 0), EnderSignal.class);
-            eye.setTargetLocation(new Location(e.getPlayer().getWorld(), pr.getX(), 40, pr.getZ()));
-            eye.getWorld().playSound(eye, Sound.ENTITY_ENDER_EYE_LAUNCH, 1, 1);
-            Iris.debug("ESignal: " + eye.getTargetLocation().getBlockX() + " " + eye.getTargetLocation().getBlockX());
-        }
-    }
-
     @EventHandler
     public void on(WorldUnloadEvent e) {
         if (e.getWorld().equals(getTarget().getWorld().realWorld())) {

core/src/main/java/com/volmit/iris/engine/framework/EnginePlayer.java

@@ -47,9 +47,7 @@ public class EnginePlayer {
     }
 
     public void tick() {
-        sample();
-
-        if (!IrisSettings.get().getWorld().isEffectSystem())
+        if (sample() || !IrisSettings.get().getWorld().isEffectSystem())
             return;
 
         J.a(() -> {
@@ -81,22 +79,22 @@ public class EnginePlayer {
         return M.ms() - lastSample;
     }
 
-    public void sample() {
+    public boolean sample() {
+        Location current = player.getLocation().clone();
+        if (current.getWorld() != engine.getWorld().realWorld())
+            return true;
         try {
-            if (ticksSinceLastSample() > 55 && player.getLocation().distanceSquared(lastLocation) > 9 * 9) {
-                lastLocation = player.getLocation().clone();
+            if (ticksSinceLastSample() > 55 && current.distanceSquared(lastLocation) > 9 * 9) {
+                lastLocation = current;
                 lastSample = M.ms();
-                sampleBiomeRegion();
+                biome = engine.getBiome(current);
+                region = engine.getRegion(current);
             }
+            return false;
         } catch (Throwable e) {
             Iris.reportError(e);
 
         }
-    }
-
-    private void sampleBiomeRegion() {
-        Location l = player.getLocation();
-        biome = engine.getBiome(l);
-        region = engine.getRegion(l);
+        return true;
     }
 }

core/src/main/java/com/volmit/iris/engine/framework/IrisLootEvent.java

@@ -1,32 +0,0 @@
-package com.volmit.iris.engine.framework;
-
-import com.volmit.iris.engine.object.InventorySlotType;
-import com.volmit.iris.engine.object.IrisLootTable;
-import com.volmit.iris.util.collection.KList;
-import lombok.Getter;
-import org.bukkit.block.Block;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
-@Getter
-public class IrisLootEvent extends Event {
-    private static final HandlerList handlers = new HandlerList();
-    private final Engine engine;
-    private final Block block;
-    private final InventorySlotType slot;
-    private final KList<IrisLootTable> tables;
-
-    public IrisLootEvent(Engine engine, Block block, InventorySlotType slot, KList<IrisLootTable> tables) {
-        this.engine = engine;
-        this.block = block;
-        this.slot = slot;
-        this.tables = tables;
-    }
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-}

core/src/main/java/com/volmit/iris/engine/framework/ListFunction.java

@@ -1,8 +1,10 @@
 package com.volmit.iris.engine.framework;
 
+import com.volmit.iris.core.loader.IrisData;
+
 import java.util.function.Function;
 
-public interface ListFunction<T, R> extends Function<T, R> {
+public interface ListFunction<R> extends Function<IrisData, R> {
     String key();
     String fancyName();
 }

core/src/main/java/com/volmit/iris/engine/framework/LootProvider.java

@@ -23,15 +23,16 @@ import com.volmit.iris.engine.object.IrisLootReference;
 import com.volmit.iris.engine.object.IrisLootTable;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.math.RNG;
+import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.inventory.Inventory;
 
 public interface LootProvider {
     void scramble(Inventory inventory, RNG rng);
 
-    void injectTables(KList<IrisLootTable> list, IrisLootReference r);
+    void injectTables(KList<IrisLootTable> list, IrisLootReference r, boolean fallback);
 
     KList<IrisLootTable> getLootTables(RNG rng, Block b);
 
-    void addItems(boolean debug, Inventory inv, RNG rng, KList<IrisLootTable> tables, InventorySlotType slot, int x, int y, int z, int mgf);
+    void addItems(boolean debug, Inventory inv, RNG rng, KList<IrisLootTable> tables, InventorySlotType slot, World world, int x, int y, int z, int mgf);
 }

core/src/main/java/com/volmit/iris/engine/framework/placer/WorldObjectPlacer.java

@@ -5,7 +5,7 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.framework.IrisLootEvent;
+import com.volmit.iris.core.events.IrisLootEvent;
 import com.volmit.iris.engine.mantle.EngineMantle;
 import com.volmit.iris.engine.object.IObjectPlacer;
 import com.volmit.iris.engine.object.InventorySlotType;
@@ -13,6 +13,7 @@ import com.volmit.iris.engine.object.IrisLootTable;
 import com.volmit.iris.engine.object.TileData;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.math.RNG;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
@@ -20,8 +21,6 @@ import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.InventoryHolder;
 
@@ -74,13 +73,17 @@ public class WorldObjectPlacer implements IObjectPlacer {
                 if (tables.isEmpty())
                     return;
                 InventoryHolder m = (InventoryHolder) block.getState();
-                engine.addItems(false, m.getInventory(), rx, tables, slot, x, y, z, 15);
+                engine.addItems(false, m.getInventory(), rx, tables, slot, world, x, y, z, 15);
             } catch (Throwable e) {
                 Iris.reportError(e);
             }
         }
 
-        block.setBlockData(d);
+
+        if (d instanceof IrisCustomData data) {
+            block.setBlockData(data.getBase());
+            Iris.warn("Tried to place custom block at " + x + ", " + y + ", " + z + " which is not supported!");
+        } else block.setBlockData(d);
     }
 
     @Override

core/src/main/java/com/volmit/iris/engine/jigsaw/PlannedStructure.java

@@ -25,7 +25,6 @@ import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.placer.WorldObjectPlacer;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
@@ -50,16 +49,18 @@ public class PlannedStructure {
     private IrisPosition position;
     private IrisData data;
     private RNG rng;
+    private boolean forcePlace;
     private boolean verbose;
     private boolean terminating;
 
-    public PlannedStructure(IrisJigsawStructure structure, IrisPosition position, RNG rng) {
+    public PlannedStructure(IrisJigsawStructure structure, IrisPosition position, RNG rng, boolean forcePlace) {
         terminating = false;
         verbose = true;
         this.pieces = new KList<>();
         this.structure = structure;
         this.position = position;
         this.rng = rng;
+        this.forcePlace = forcePlace || structure.isForcePlace();
         this.data = structure.getLoader();
         generateStartPiece();
 
@@ -108,6 +109,9 @@ public class PlannedStructure {
         } else {
             options.setMode(i.getPiece().getPlaceMode());
         }
+        if (forcePlace) {
+            options.setForcePlace(true);
+        }
 
         IrisObject v = i.getObject();
         int sx = (v.getW() / 2);
@@ -150,9 +154,6 @@ public class PlannedStructure {
         return v.place(xx, height, zz, placer, options, rng, (b, data) -> {
             e.set(b.getX(), b.getY(), b.getZ(), v.getLoadKey() + "@" + id);
             e.set(b.getX(), b.getY(), b.getZ(), container);
-            if (data instanceof IrisBlockData d) {
-                e.set(b.getX(), b.getY(), b.getZ(), d.getCustom());
-            }
         }, null, getData().getEngine() != null ? getData() : eng.getData()) != -1;
     }
 

core/src/main/java/com/volmit/iris/engine/mantle/EngineMantle.java

@@ -20,10 +20,10 @@ package com.volmit.iris.engine.mantle;
 
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.engine.IrisComplex;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineTarget;
-import com.volmit.iris.engine.framework.SeedManager;
 import com.volmit.iris.engine.mantle.components.MantleJigsawComponent;
 import com.volmit.iris.engine.mantle.components.MantleObjectComponent;
 import com.volmit.iris.engine.object.IObjectPlacer;
@@ -34,6 +34,7 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
@@ -44,7 +45,6 @@ import com.volmit.iris.util.matter.*;
 import com.volmit.iris.util.matter.slices.UpdateMatter;
 import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
-import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 
 import java.util.concurrent.TimeUnit;
@@ -59,7 +59,9 @@ public interface EngineMantle extends IObjectPlacer {
 
     int getRadius();
 
-    KList<MantleComponent> getComponents();
+    int getRealRadius();
+
+    KList<Pair<KList<MantleComponent>, Integer>> getComponents();
 
     void registerComponent(MantleComponent c);
 
@@ -103,7 +105,10 @@ public interface EngineMantle extends IObjectPlacer {
 
     @Override
     default void set(int x, int y, int z, BlockData d) {
-        getMantle().set(x, y, z, d == null ? AIR : d);
+        if (d instanceof IrisCustomData data) {
+            getMantle().set(x, y, z, data.getBase());
+            getMantle().set(x, y, z, data.getCustom());
+        } else getMantle().set(x, y, z, d == null ? AIR : d);
     }
 
     @Override
@@ -187,39 +192,37 @@ public interface EngineMantle extends IObjectPlacer {
         return getEngine().burst();
     }
 
-    default int getRealRadius() {
-        return (int) Math.ceil(getRadius() / 2D);
-    }
-
-
     @ChunkCoordinates
     default void generateMatter(int x, int z, boolean multicore, ChunkContext context) {
-        synchronized (this) {
-            if (!getEngine().getDimension().isUseMantle()) {
-                return;
-            }
+        if (!getEngine().getDimension().isUseMantle()) {
+            return;
+        }
 
-            int s = getRealRadius();
-            BurstExecutor burst = burst().burst(multicore);
-            MantleWriter writer = getMantle().write(this, x, z, s * 2);
-            for (int i = -s; i <= s; i++) {
-                for (int j = -s; j <= s; j++) {
-                    int xx = i + x;
-                    int zz = j + z;
-                    burst.queue(() -> {
-                        IrisContext.touch(getEngine().getContext());
-                        getMantle().raiseFlag(xx, zz, MantleFlag.PLANNED, () -> {
-                            MantleChunk mc = getMantle().getChunk(xx, zz);
+        try (MantleWriter writer = getMantle().write(this, x, z, getRadius() * 2)) {
+            var iterator = getComponents().iterator();
+            while (iterator.hasNext()) {
+                var pair = iterator.next();
+                int radius = pair.getB();
+                boolean last = !iterator.hasNext();
+                BurstExecutor burst = burst().burst(radius * 2 + 1);
+                burst.setMulticore(multicore);
 
-                            for (MantleComponent k : getComponents()) {
-                                generateMantleComponent(writer, xx, zz, k, mc, context);
-                            }
+                for (int i = -radius; i <= radius; i++) {
+                    for (int j = -radius; j <= radius; j++) {
+                        int xx = x + i;
+                        int zz = z + j;
+                        MantleChunk mc = getMantle().getChunk(xx, zz);
+
+                        burst.queue(() -> {
+                            IrisContext.touch(getEngine().getContext());
+                            pair.getA().forEach(k -> generateMantleComponent(writer, xx, zz, k, mc, context));
+                            if (last) mc.flag(MantleFlag.PLANNED, true);
                         });
-                    });
+                    }
                 }
-            }
 
-            burst.complete();
+                burst.complete();
+            }
         }
     }
 
@@ -286,23 +289,25 @@ public interface EngineMantle extends IObjectPlacer {
     }
 
     default void cleanupChunk(int x, int z) {
-        if (!getMantle().hasFlag(x, z, MantleFlag.CLEANED) && isCovered(x, z)) {
-            getMantle().raiseFlag(x, z, MantleFlag.CLEANED, () -> {
-                getMantle().deleteChunkSlice(x, z, BlockData.class);
-                getMantle().deleteChunkSlice(x, z, String.class);
-                getMantle().deleteChunkSlice(x, z, MatterCavern.class);
-                getMantle().deleteChunkSlice(x, z, MatterFluidBody.class);
+        if (!isCovered(x, z)) return;
+        MantleChunk chunk = getMantle().getChunk(x, z).use();
+        try {
+            chunk.raiseFlag(MantleFlag.CLEANED, () -> {
+                chunk.deleteSlices(BlockData.class);
+                chunk.deleteSlices(String.class);
+                chunk.deleteSlices(MatterCavern.class);
+                chunk.deleteSlices(MatterFluidBody.class);
             });
+        } finally {
+            chunk.release();
         }
     }
 
-    default long getToUnload(){
-        return getMantle().getToUnload().size();
+    default long getUnloadRegionCount() {
+        return getMantle().getUnloadRegionCount();
     }
-    default long getNotQueuedLoadedRegions(){
-        return getMantle().getLoadedRegions().size() - getMantle().getToUnload().size();
-    }
-    default double getTectonicDuration(){
-        return getMantle().getAdjustedIdleDuration().get();
+
+    default double getAdjustedIdleDuration() {
+        return getMantle().getAdjustedIdleDuration();
     }
 }

core/src/main/java/com/volmit/iris/engine/mantle/IrisMantleComponent.java

@@ -29,4 +29,5 @@ import lombok.ToString;
 public abstract class IrisMantleComponent implements MantleComponent {
     private final EngineMantle engineMantle;
     private final MantleFlag flag;
+    private final int priority;
 }

core/src/main/java/com/volmit/iris/engine/mantle/MantleComponent.java

@@ -26,11 +26,12 @@ import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.parallel.BurstExecutor;
+import org.jetbrains.annotations.NotNull;
 
-public interface MantleComponent {
-    default int getRadius() {
-        return getEngineMantle().getRealRadius();
-    }
+public interface MantleComponent extends Comparable<MantleComponent> {
+    int getPriority();
+
+    int getRadius();
 
     default IrisData getData() {
         return getEngineMantle().getData();
@@ -62,4 +63,9 @@ public interface MantleComponent {
 
     @ChunkCoordinates
     void generateLayer(MantleWriter writer, int x, int z, ChunkContext context);
+
+    @Override
+    default int compareTo(@NotNull MantleComponent o) {
+        return Integer.compare(getPriority(), o.getPriority());
+    }
 }

core/src/main/java/com/volmit/iris/engine/mantle/MantleWriter.java

@@ -29,13 +29,13 @@ import com.volmit.iris.engine.object.IrisPosition;
 import com.volmit.iris.engine.object.TileData;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.function.Function3;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.mantle.MantleChunk;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.matter.Matter;
 import lombok.Data;
-import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.util.Vector;
 
@@ -44,7 +44,7 @@ import java.util.List;
 import java.util.Set;
 
 @Data
-public class MantleWriter implements IObjectPlacer {
+public class MantleWriter implements IObjectPlacer, AutoCloseable {
     private final EngineMantle engineMantle;
     private final Mantle mantle;
     private final KMap<Long, MantleChunk> cachedChunks;
@@ -60,9 +60,10 @@ public class MantleWriter implements IObjectPlacer {
         this.x = x;
         this.z = z;
 
-        for (int i = -radius; i <= radius; i++) {
-            for (int j = -radius; j <= radius; j++) {
-                cachedChunks.put(Cache.key(i + x, j + z), mantle.getChunk(i + x, j + z));
+        int r = radius / 4;
+        for (int i = -r; i <= r; i++) {
+            for (int j = -r; j <= r; j++) {
+                cachedChunks.put(Cache.key(i + x, j + z), mantle.getChunk(i + x, j + z).use());
             }
         }
     }
@@ -143,7 +144,7 @@ public class MantleWriter implements IObjectPlacer {
 
         if (cx >= this.x - radius && cx <= this.x + radius
                 && cz >= this.z - radius && cz <= this.z + radius) {
-            MantleChunk chunk = cachedChunks.get(Cache.key(cx, cz));
+            MantleChunk chunk = cachedChunks.computeIfAbsent(Cache.key(cx, cz), k -> mantle.getChunk(cx, cz).use());
 
             if (chunk == null) {
                 Iris.error("Mantle Writer Accessed " + cx + "," + cz + " and came up null (and yet within bounds!)");
@@ -152,6 +153,8 @@ public class MantleWriter implements IObjectPlacer {
 
             Matter matter = chunk.getOrCreate(y >> 4);
             matter.slice(matter.getClass(t)).set(x & 15, y & 15, z & 15, t);
+        } else {
+            Iris.error("Mantle Writer Accessed chunk out of bounds" + cx + "," + cz);
         }
     }
 
@@ -167,7 +170,10 @@ public class MantleWriter implements IObjectPlacer {
 
     @Override
     public void set(int x, int y, int z, BlockData d) {
-        setData(x, y, z, d);
+        if (d instanceof IrisCustomData data) {
+            setData(x, y, z, data.getBase());
+            setData(x, y, z, data.getCustom());
+        } else setData(x, y, z, d);
     }
 
     @Override
@@ -633,4 +639,13 @@ public class MantleWriter implements IObjectPlacer {
         return cx >= this.x - radius && cx <= this.x + radius
                 && cz >= this.z - radius && cz <= this.z + radius;
     }
+
+    @Override
+    public void close() {
+        var iterator = cachedChunks.values().iterator();
+        while (iterator.hasNext()) {
+            iterator.next().release();
+            iterator.remove();
+        }
+    }
 }

core/src/main/java/com/volmit/iris/engine/mantle/components/MantleCarvingComponent.java

@@ -29,10 +29,14 @@ import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.RNG;
+import lombok.Getter;
 
+@Getter
 public class MantleCarvingComponent extends IrisMantleComponent {
+    private final int radius = computeRadius();
+
     public MantleCarvingComponent(EngineMantle engineMantle) {
-        super(engineMantle, MantleFlag.CARVED);
+        super(engineMantle, MantleFlag.CARVED, 0);
     }
 
     @Override
@@ -54,6 +58,23 @@ public class MantleCarvingComponent extends IrisMantleComponent {
 
     @ChunkCoordinates
     private void carve(IrisCarving carving, MantleWriter writer, RNG rng, int cx, int cz) {
-        carving.doCarving(writer, rng, getEngineMantle().getEngine(), cx << 4, -1, cz << 4);
+        carving.doCarving(writer, rng, getEngineMantle().getEngine(), cx << 4, -1, cz << 4, 0);
+    }
+
+    private int computeRadius() {
+        var dimension = getDimension();
+        int max = 0;
+
+        max = Math.max(max, dimension.getCarving().getMaxRange(getData(), 0));
+
+        for (var i : dimension.getAllRegions(this::getData)) {
+            max = Math.max(max, i.getCarving().getMaxRange(getData(), 0));
+        }
+
+        for (var i : dimension.getAllBiomes(this::getData)) {
+            max = Math.max(max, i.getCarving().getMaxRange(getData(), 0));
+        }
+
+        return max;
     }
 }

core/src/main/java/com/volmit/iris/engine/mantle/components/MantleFluidBodyComponent.java

@@ -29,10 +29,14 @@ import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.RNG;
+import lombok.Getter;
 
+@Getter
 public class MantleFluidBodyComponent extends IrisMantleComponent {
+    private final int radius = computeRadius();
+
     public MantleFluidBodyComponent(EngineMantle engineMantle) {
-        super(engineMantle, MantleFlag.FLUID_BODIES);
+        super(engineMantle, MantleFlag.FLUID_BODIES, 0);
     }
 
     @Override
@@ -56,4 +60,20 @@ public class MantleFluidBodyComponent extends IrisMantleComponent {
     private void generate(IrisFluidBodies bodies, MantleWriter writer, RNG rng, int cx, int cz) {
         bodies.generate(writer, rng, getEngineMantle().getEngine(), cx << 4, -1, cz << 4);
     }
+
+    private int computeRadius() {
+        int max = 0;
+
+        max = Math.max(max, getDimension().getFluidBodies().getMaxRange(getData()));
+
+        for (IrisRegion i : getDimension().getAllRegions(this::getData)) {
+            max = Math.max(max, i.getFluidBodies().getMaxRange(getData()));
+        }
+
+        for (IrisBiome i : getDimension().getAllBiomes(this::getData)) {
+            max = Math.max(max, i.getFluidBodies().getMaxRange(getData()));
+        }
+
+        return max;
+    }
 }

core/src/main/java/com/volmit/iris/engine/mantle/components/MantleJigsawComponent.java

@@ -34,15 +34,18 @@ import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.matter.slices.container.JigsawStructuresContainer;
 import com.volmit.iris.util.noise.CNG;
+import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
 public class MantleJigsawComponent extends IrisMantleComponent {
+    @Getter
+    private final int radius = computeRadius();
     private final CNG cng;
 
     public MantleJigsawComponent(EngineMantle engineMantle) {
-        super(engineMantle, MantleFlag.JIGSAW);
+        super(engineMantle, MantleFlag.JIGSAW, 1);
         cng = NoiseStyle.STATIC.create(new RNG(jigsaw()));
     }
 
@@ -66,7 +69,7 @@ public class MantleJigsawComponent extends IrisMantleComponent {
                 for (Position2 pos : poss) {
                     if (x == pos.getX() >> 4 && z == pos.getZ() >> 4) {
                         IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(getDimension().getStronghold());
-                        place(writer, pos.toIris(), structure, new RNG(seed));
+                        place(writer, pos.toIris(), structure, new RNG(seed), true);
                         return;
                     }
                 }
@@ -87,12 +90,14 @@ public class MantleJigsawComponent extends IrisMantleComponent {
     private boolean placeStructures(MantleWriter writer, long seed, int x, int z, KList<IrisJigsawStructurePlacement> structures,
             KSet<Position2> cachedRegions, KMap<String, KSet<Position2>> cache, KMap<Position2, Double> distanceCache) {
         IrisJigsawStructurePlacement i = pick(structures, seed, x, z);
-        if (i == null || checkMinDistances(i.collectMinDistances(), x, z, cachedRegions, cache, distanceCache))
-            return false;
+        try {
+            if (i == null || checkMinDistances(i.collectMinDistances(), x, z, cachedRegions, cache, distanceCache))
+                return false;
+        } catch (Throwable ignored) {}
         RNG rng = new RNG(seed);
         IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
         IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
-        return place(writer, position, structure, rng);
+        return place(writer, position, structure, rng, false);
     }
 
     @ChunkCoordinates
@@ -156,16 +161,41 @@ public class MantleJigsawComponent extends IrisMantleComponent {
     @ChunkCoordinates
     private IrisJigsawStructurePlacement pick(List<IrisJigsawStructurePlacement> structures, long seed, int x, int z) {
         return IRare.pick(structures.stream()
-                .filter(p -> p.shouldPlace(getDimension().getJigsawStructureDivisor(), jigsaw(), x, z))
+                .filter(p -> p.shouldPlace(getData(), getDimension().getJigsawStructureDivisor(), jigsaw(), x, z))
                 .toList(), new RNG(seed).nextDouble());
     }
 
     @BlockCoordinates
-    private boolean place(MantleWriter writer, IrisPosition position, IrisJigsawStructure structure, RNG rng) {
-        return new PlannedStructure(structure, position, rng).place(writer, getMantle(), writer.getEngine());
+    private boolean place(MantleWriter writer, IrisPosition position, IrisJigsawStructure structure, RNG rng, boolean forcePlace) {
+        return new PlannedStructure(structure, position, rng, forcePlace).place(writer, getMantle(), writer.getEngine());
     }
 
     private long jigsaw() {
         return getEngineMantle().getEngine().getSeedManager().getJigsaw();
     }
+
+    private int computeRadius() {
+        var dimension = getDimension();
+
+        KSet<String> structures = new KSet<>();
+        for (var placement : dimension.getJigsawStructures()) {
+            structures.add(placement.getStructure());
+        }
+        for (var region : dimension.getAllRegions(this::getData)) {
+            for (var placement : region.getJigsawStructures()) {
+                structures.add(placement.getStructure());
+            }
+        }
+        for (var biome : dimension.getAllBiomes(this::getData)) {
+            for (var placement : biome.getJigsawStructures()) {
+                structures.add(placement.getStructure());
+            }
+        }
+
+        int max = 0;
+        for (var structure : structures) {
+            max = Math.max(max, getData().getJigsawStructureLoader().load(structure).getMaxDimension());
+        }
+        return max;
+    }
 }