implement priority to static placement component

# Conflicts:
#	core/src/main/java/com/volmit/iris/engine/IrisEngineMantle.java

.github/ISSUE_TEMPLATE/bug.yml

@@ -39,6 +39,10 @@ body:
         - 1.17
         - 1.17.1
         - 1.18
+        - 1.19
+        - 1.20
+        - 1.21
+        - 1.22
     validations:
       required: true
   - type: input

.gitignore

@@ -1,5 +1,6 @@
 
 build/
+libs/
 
 .gradle/
 
@@ -9,4 +10,4 @@ build/
 
 collection/
 
-src/main/java/com/volmit/iris/util/uniques/
+/core/src/main/java/com/volmit/iris/util/uniques/

README.md

@@ -11,6 +11,8 @@ development.
 
 Consider supporting our development by buying Iris on spigot! We work hard to make Iris the best it can be for everyone.
 
+## Preface: if you need help compiling and you are a developer / intend to help out in the community or with development we would love to help you regardless in the discord! however do not come to the discord asking for free copies, or a tutorial on how to compile.
+
 ### Command Line Builds
 
 1. Install [Java JDK 17](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html)
@@ -28,14 +30,11 @@ Consider supporting our development by buying Iris on spigot! We work hard to ma
         3. Add `export JAVA_HOME=$(/usr/libexec/java_home)` as a new line
         4. Use `CTRL + X`, then Press `Y`, Then `ENTER`
         5. Quit & Reopen Terminal and verify with `echo $JAVA_HOME`. It should print a directory
-3. If this is your first time building Iris for MC 1.18+ run `gradlew setup` inside the root Iris project folder.
-   Otherwise, skip this step. Grab a coffee, this may take up to 5 minutes depending on your cpu & internet connection.
-4. Once the project has setup, run `gradlew iris`
-5. The Iris jar will be placed in `Iris/build/Iris-XXX-XXX.jar` Enjoy! Consider supporting us by buying it on spigot!
+3. Once the project has setup, run `gradlew iris`
+4. The Iris jar will be placed in `Iris/build/Iris-XXX-XXX.jar` Enjoy! Consider supporting us by buying it on spigot!
 
 ### IDE Builds (for development)
 
-* Run `gradlew setup` any time you get dependency issues with craftbukkit
 * Configure ITJ Gradle to use JDK 17 (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.
@@ -67,7 +66,6 @@ IrisAccess access=IrisToolbelt.createWorld() // If you like builders...
   .name("myWorld") // The world name
   .dimension("terrifyinghands")
   .seed(69133742) // The world seed
-  .headless(true)  // Headless make gen go fast
   .pregen(PregenTask // Define a pregen job to run
   .builder()
     .center(new Position2(0,0)) // REGION coords (1 region = 32x32 chunks)

build.gradle

@@ -1,323 +1,255 @@
-/*
- * 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 "6.3.0"
-    id "com.github.johnrengelman.shadow" version "7.1.2"
-    id "de.undercouch.download" version "5.0.1"
-}
-
-version '2.2.1-1.19' // Needs to be version specific
-def nmsVersion = "1.19"
-def apiVersion = '1.19'
-def spigotJarVersion = '1.19-R0.1-SNAPSHOT'
-def name = getRootProject().getName() // Defined in settings.gradle
-def main = 'com.volmit.iris.Iris'
-
-// 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', 'D://Dan/MinecraftDevelopment/server/plugins')
-registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/server/plugins')
-registerCustomOutputTask('Coco', 'D://Documents/MC/plugins')
-registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
-registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19/plugins')
-// ========================== UNIX ==============================
-registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
-registerCustomOutputTaskUnix('PsychoLT', '/Users/brianfopiano/Desktop/REMOTES/RemoteMinecraft/plugins')
-// ==============================================================
-
-/**
- * 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': name.toString(),
-                'version': version.toString(),
-                'main': main.toString(),
-                'apiversion': apiVersion.toString()
-        )
-    }
-}
-
-/**
- * Unified repo
- */
-repositories {
-    mavenLocal {
-        content {
-            includeGroup("org.bukkit")
-            includeGroup("org.spigotmc")
-        }
-    }
-    maven { url "https://dl.cloudsmith.io/public/arcane/archive/maven/" }
-    maven { url "https://maven.enginehub.org/repo/" }
-    mavenCentral()
-    mavenLocal()
-    maven { url "https://jitpack.io"}
-}
-
-/**
- * We need parameter meta for the decree command system
- */
-compileJava {
-    options.compilerArgs << '-parameters'
-}
-
-/**
- * Configure Iris for shading
- */
-shadowJar {
-    //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'
-    dependencies {
-        include(dependency('io.papermc:paperlib'))
-        include(dependency('com.dfsek:Paralithic'))
-        include(dependency('net.kyori:'))
-    }
-}
-
-configurations.all {
-    resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
-    resolutionStrategy.cacheDynamicVersionsFor 60, 'minutes'
-}
-
-/**
- * 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.projectlombok:lombok:1.18.24'
-    annotationProcessor 'org.projectlombok:lombok:1.18.24'
-    implementation 'org.spigotmc:spigot-api:1.19-R0.1-SNAPSHOT'
-    implementation 'me.clip:placeholderapi:2.11.1'
-    implementation 'io.th0rgal:oraxen:1.94.0'
-    implementation 'org.bukkit:craftbukkit:1.19-R0.1-SNAPSHOT:remapped-mojang'
-    implementation 'com.github.LoneDev6:api-itemsadder:3.1.0b'
-
-    // Shaded
-    implementation 'com.dfsek:Paralithic:0.4.0'
-    implementation 'io.papermc:paperlib:1.0.5'
-    implementation "net.kyori:adventure-text-minimessage:4.11.0"
-    implementation 'net.kyori:adventure-platform-bukkit:4.1.0'
-    implementation 'net.kyori:adventure-api:4.11.0'
-
-    // Dynamically Loaded
-    implementation 'io.timeandspace:smoothie-map:2.0.2'
-    implementation 'it.unimi.dsi:fastutil:8.5.8'
-    implementation 'com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2'
-    implementation 'org.zeroturnaround:zt-zip:1.14'
-    implementation 'com.google.code.gson:gson:2.9.0'
-    implementation 'org.ow2.asm:asm:9.2'
-    implementation 'com.google.guava:guava:31.1-jre'
-    implementation 'bsf:bsf:2.4.0'
-    implementation 'rhino:js:1.7R2'
-    implementation 'com.github.ben-manes.caffeine:caffeine:3.0.6'
-    implementation 'org.apache.commons:commons-lang3:3.12.0'
-}
-
-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);
-}
-
-def buildToolsJar = new File(buildDir, "buildtools/BuildTools.jar");
-def specialSourceJar = new File(buildDir, "specialsource/SpecialSource.jar");
-def buildToolsFolder = new File(buildDir, "buildtools");
-def specialSourceFolder = new File(buildDir, "specialsource");
-def buildToolsHint = new File(buildDir, "buildtools/craftbukkit-" + nmsVersion + ".jar");
-def outputShadeJar = new File(buildDir, "libs/Iris-" + version + "-all.jar");
-def ssiJar = new File(buildDir, "specialsource/Iris-" + version + "-all.jar");
-def ssobfJar = new File(buildDir, "specialsource/Iris-" + version + "-rmo.jar");
-def ssJar = new File(buildDir, "specialsource/Iris-" + version + "-rma.jar");
-def homePath = System.properties['user.home']
-def m2 = new File(homePath + "/.m2/repository")
-def m2s = m2.getAbsolutePath();
-
-// ======================== Building Mapped Jars =============================
-task downloadBuildtools(type: Download) {
-    group "remapping"
-    src 'https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar'
-    dest buildToolsJar
-    onlyIf {
-        !buildToolsJar.exists()
-    }
-}
-
-task downloadSpecialSource(type: Download) {
-    group "remapping"
-    src 'https://repo.maven.apache.org/maven2/net/md-5/SpecialSource/1.10.0/SpecialSource-1.10.0-shaded.jar'
-    dest specialSourceJar
-    onlyIf {
-        !specialSourceJar.exists()
-    }
-}
-
-task executeBuildTools(dependsOn: downloadBuildtools, type: JavaExec)
-{
-    group "remapping"
-    classpath = files(buildToolsJar)
-    workingDir = buildToolsFolder
-    args = [
-            "--rev",
-            nmsVersion,
-            "--compile",
-            "craftbukkit",
-            "--remap"
-    ]
-    onlyIf {
-        !buildToolsHint.exists()
-    }
-}
-
-task copyBuildToSpecialSource(type: Copy)
-{
-    group "remapping"
-    from outputShadeJar
-    into specialSourceFolder
-    dependsOn(downloadSpecialSource, shadowJar)
-}
-
-task specialSourceRemapObfuscate(type: JavaExec)
-{
-    group "remapping"
-    dependsOn(copyBuildToSpecialSource, downloadSpecialSource, shadowJar)
-    workingDir = specialSourceFolder
-    classpath = files(specialSourceJar,
-            new File(m2s + "/org/spigotmc/spigot/" + spigotJarVersion + "/spigot-" + spigotJarVersion + "-remapped-mojang.jar"))
-    mainClass = "net.md_5.specialsource.SpecialSource"
-    args = [
-            "--live",
-            "-i",
-            ssiJar.getName(),
-            "-o",
-            ssobfJar.getName(),
-            "-m",
-            m2s + "/org/spigotmc/minecraft-server/" + spigotJarVersion + "/minecraft-server-" + spigotJarVersion + "-maps-mojang.txt",
-            "--reverse",
-    ]
-}
-
-task specialSourceRemap(type: JavaExec)
-{
-    group "remapping"
-    dependsOn(specialSourceRemapObfuscate)
-    workingDir = specialSourceFolder
-    classpath = files(specialSourceJar,
-            new File(m2s + "/org/spigotmc/spigot/" + spigotJarVersion + "/spigot-" + spigotJarVersion + "-remapped-obf.jar"))
-    mainClass = "net.md_5.specialsource.SpecialSource"
-    args = [
-            "--live",
-            "-i",
-            ssobfJar.getName(),
-            "-o",
-            ssJar.getName(),
-            "-m",
-            m2s + "/org/spigotmc/minecraft-server/" + spigotJarVersion + "/minecraft-server-" + spigotJarVersion + "-maps-spigot.csrg"
-    ]
-}
-
-tasks.compileJava.dependsOn(executeBuildTools)
-
-compileJava {
-    options.encoding = "UTF-8"
-}
-
-task setup()
-{
-    group("iris")
-    dependsOn(clean, executeBuildTools)
-}
-
-task iris(type: Copy)
-{
-    group "iris"
-    from ssJar
-    into buildDir
-    rename { String fileName ->
-        fileName.replace('Iris-' + version + '-rma.jar', "Iris-" + version + ".jar")
-    }
-    dependsOn(specialSourceRemap)
-}
-
-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")
-        }
-    }
-}
+/*
+ * 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.5.2-1.19.2-1.21.3'
+
+// 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')
+// ==============================================================
+
+def NMS_BINDINGS = Map.of(
+        "v1_21_R2", "1.21.3-R0.1-SNAPSHOT",
+        "v1_21_R1", "1.21.1-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()
+NMS_BINDINGS.each { nms ->
+    project(":nms:${nms.key}") {
+        apply plugin: 'java'
+        apply plugin: 'com.volmit.nmstools'
+
+        nmsTools {
+            it.jvm = JVM_VERSION.getOrDefault(nms.key, 21)
+            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'
+    relocate 'org.bstats', 'com.volmit.util.metrics'
+    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.nexomc.com/snapshots/" }
+        maven { url "https://libraries.minecraft.net" }
+    }
+
+    dependencies {
+        // Provided or Classpath
+        compileOnly 'org.projectlombok:lombok:1.18.36'
+        annotationProcessor 'org.projectlombok:lombok:1.18.36'
+
+        // 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.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'
+    }
+
+    /**
+     * We need parameter meta for the decree command system
+     */
+    compileJava {
+        options.compilerArgs << '-parameters'
+        options.encoding = "UTF-8"
+    }
+
+    javadoc {
+        options.encoding = "UTF-8"
+        options.addStringOption('Xdoclint:none', '-quiet')
+    }
+
+    task sourcesJar(type: Jar, dependsOn: classes) {
+        archiveClassifier.set('sources')
+        from sourceSets.main.allSource
+    }
+
+    task javadocJar(type: Jar, dependsOn: javadoc) {
+        archiveClassifier.set('javadoc')
+        from javadoc.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()
+    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)
+}
+
+//    with classifier: 'javadoc' and 'sources'
+task irisDev(type: Copy) {
+    group "iris"
+    from("core/build/libs/core-javadoc.jar", "core/build/libs/core-sources.jar")
+    rename { String fileName ->
+        fileName.replace("core", "Iris-${version}")
+    }
+    into layout.buildDirectory.asFile.get()
+    dependsOn(iris)
+    dependsOn("core:sourcesJar")
+    dependsOn("core:javadocJar")
+}
+
+
+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)

core/build.gradle

@@ -0,0 +1,95 @@
+/*
+ * 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 'com.nexomc:nexo:0.6.0-dev.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')
+}
+
+java {
+    disableAutoTargetJvm()
+}
+
+/**
+ * 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/src/main/java/com/volmit/iris/core/IrisSettings.java

@@ -24,7 +24,10 @@ 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.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;
@@ -41,15 +44,67 @@ public class IrisSettings {
     private IrisSettingsConcurrency concurrency = new IrisSettingsConcurrency();
     private IrisSettingsStudio studio = new IrisSettingsStudio();
     private IrisSettingsPerformance performance = new IrisSettingsPerformance();
+    private IrisSettingsUpdater updater = new IrisSettingsUpdater();
 
     public static int getThreadCount(int c) {
-        return switch(c) {
+        return switch (c) {
             case -1, -2, -4 -> Runtime.getRuntime().availableProcessors() / -c;
             case 0, 1, 2 -> 1;
             default -> Math.max(c, 2);
         };
     }
 
+    public static IrisSettings get() {
+        if (settings != null) {
+            return settings;
+        }
+
+        settings = new IrisSettings();
+
+        File s = Iris.instance.getDataFile("settings.json");
+
+        if (!s.exists()) {
+            try {
+                IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+            } catch (JSONException | IOException e) {
+                e.printStackTrace();
+                Iris.reportError(e);
+            }
+        } else {
+            try {
+                String ss = IO.readAll(s);
+                settings = new Gson().fromJson(ss, IrisSettings.class);
+                try {
+                    IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            } catch (Throwable ee) {
+                // Iris.reportError(ee); causes a self-reference & stackoverflow
+                Iris.error("Configuration Error in settings.json! " + ee.getClass().getSimpleName() + ": " + ee.getMessage());
+            }
+        }
+
+        return settings;
+    }
+
+    public static void invalidate() {
+        synchronized (settings) {
+            settings = null;
+        }
+    }
+
+    public void forceSave() {
+        File s = Iris.instance.getDataFile("settings.json");
+
+        try {
+            IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+        } catch (JSONException | IOException e) {
+            e.printStackTrace();
+            Iris.reportError(e);
+        }
+    }
+
     @Data
     public static class IrisSettingsAutoconfiguration {
         public boolean configureSpigotTimeoutTime = true;
@@ -84,7 +139,7 @@ public class IrisSettings {
 
     @Data
     public static class IrisSettingsPerformance {
-        public boolean trimMantleInStudio = false;
+        public boolean trimMantleInStudio = false; 
         public int mantleKeepAlive = 30;
         public int cacheSize = 4_096;
         public int resourceLoaderCacheSize = 1_024;
@@ -92,8 +147,33 @@ public class IrisSettings {
         public int scriptLoaderCacheSize = 512;
     }
 
+    @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
     public static class IrisSettingsGeneral {
+        public boolean DoomsdayAnnihilationSelfDestructMode = false;
         public boolean commandSounds = true;
         public boolean debug = false;
         public boolean disableNMS = false;
@@ -105,6 +185,8 @@ public class IrisSettings {
         public int spinh = -20;
         public int spins = 7;
         public int spinb = 8;
+        public String cartographerMessage = "Iris does not allow cartographers in its world due to crashes.";
+
 
         @SuppressWarnings("BooleanMethodIsAlwaysInverted")
         public boolean canUseCustomColors(VolmitSender volmitSender) {
@@ -116,6 +198,7 @@ public class IrisSettings {
     public static class IrisSettingsGUI {
         public boolean useServerLaunchedGuis = true;
         public boolean maximumPregenGuiFPS = false;
+        public boolean colorMode = true;
     }
 
     @Data
@@ -132,55 +215,4 @@ public class IrisSettings {
         public boolean disableTimeAndWeather = true;
         public boolean autoStartDefaultStudio = false;
     }
-
-    public static IrisSettings get() {
-        if(settings != null) {
-            return settings;
-        }
-
-        settings = new IrisSettings();
-
-        File s = Iris.instance.getDataFile("settings.json");
-
-        if(!s.exists()) {
-            try {
-                IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-            } catch(JSONException | IOException e) {
-                e.printStackTrace();
-                Iris.reportError(e);
-            }
-        } else {
-            try {
-                String ss = IO.readAll(s);
-                settings = new Gson().fromJson(ss, IrisSettings.class);
-                try {
-                    IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-                } catch(IOException e) {
-                    e.printStackTrace();
-                }
-            } catch(Throwable ee) {
-                // Iris.reportError(ee); causes a self-reference & stackoverflow
-                Iris.error("Configuration Error in settings.json! " + ee.getClass().getSimpleName() + ": " + ee.getMessage());
-            }
-        }
-
-        return settings;
-    }
-
-    public static void invalidate() {
-        synchronized(settings) {
-            settings = null;
-        }
-    }
-
-    public void forceSave() {
-        File s = Iris.instance.getDataFile("settings.json");
-
-        try {
-            IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-        } catch(JSONException | IOException e) {
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-    }
 }

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

@@ -21,13 +21,15 @@ package com.volmit.iris.core;
 import com.volmit.iris.Iris;
 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.datapack.IDataFixer;
 import com.volmit.iris.engine.object.IrisBiome;
 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.KSet;
 import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
 import org.bukkit.Bukkit;
@@ -38,16 +40,17 @@ import org.bukkit.entity.Player;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 public class ServerConfigurator {
     public static void configure() {
         IrisSettings.IrisSettingsAutoconfiguration s = IrisSettings.get().getAutoConfiguration();
-        if(s.isConfigureSpigotTimeoutTime()) {
+        if (s.isConfigureSpigotTimeoutTime()) {
             J.attempt(ServerConfigurator::increaseKeepAliveSpigot);
         }
 
-        if(s.isConfigurePaperWatchdogDelay()) {
+        if (s.isConfigurePaperWatchdogDelay()) {
             J.attempt(ServerConfigurator::increasePaperWatchdog);
         }
 
@@ -55,88 +58,91 @@ public class ServerConfigurator {
     }
 
     private static void increaseKeepAliveSpigot() throws IOException, InvalidConfigurationException {
-        File spigotConfig = new File("config/spigot.yml");
+        File spigotConfig = new File("spigot.yml");
         FileConfiguration f = new YamlConfiguration();
         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(5) + " (5 minutes)");
+        if (tt < TimeUnit.MINUTES.toSeconds(5)) {
+            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + TimeUnit.MINUTES.toSeconds(20) + " (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.save(spigotConfig);
         }
     }
-
     private static void increasePaperWatchdog() throws IOException, InvalidConfigurationException {
         File spigotConfig = new File("config/paper-global.yml");
         FileConfiguration f = new YamlConfiguration();
         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(3) + " (3 minutes)");
+        if (tt < TimeUnit.MINUTES.toMillis(3)) {
+            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + TimeUnit.MINUTES.toMillis(15) + " (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.save(spigotConfig);
         }
     }
 
-    private static File getDatapacksFolder() {
-        if(!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
-            return new File(IrisSettings.get().getGeneral().forceMainWorld + "/datapacks");
+    private static List<File> getDatapacksFolder() {
+        if (!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
+            return new KList<File>().qadd(new File(Bukkit.getWorldContainer(), IrisSettings.get().getGeneral().forceMainWorld + "/datapacks"));
         }
-
-        File props = new File("server.properties");
-
-        if(props.exists()) {
-            try {
-                KList<String> m = new KList<>(IO.readAll(props).split("\\Q\n\\E"));
-
-                for(String i : m) {
-                    if(i.trim().startsWith("level-name=")) {
-                        return new File(i.trim().split("\\Q=\\E")[1] + "/datapacks");
-                    }
-                }
-            } catch(IOException e) {
-                Iris.reportError(e);
-                e.printStackTrace();
-            }
-        }
-
-        return null;
+        KList<File> worlds = new KList<>();
+        Bukkit.getServer().getWorlds().forEach(w -> worlds.add(new File(w.getWorldFolder(), "datapacks")));
+        return worlds;
     }
 
     public static void installDataPacks(boolean fullInstall) {
-        Iris.info("Checking Data Packs...");
-        boolean reboot = false;
-        File packs = new File("plugins/Iris/packs");
-        File dpacks = getDatapacksFolder();
+        installDataPacks(DataVersion.getDefault(), fullInstall);
+    }
 
-        if(dpacks == null) {
-            Iris.error("Cannot find the datapacks folder! Please try generating a default world first maybe? Is this a new server?");
-            return;
+    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();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
 
-        if(packs.exists()) {
-            for(File i : packs.listFiles()) {
-                if(i.isDirectory()) {
+        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")) {
+                    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) {
+                                if (dim == null) {
                                     continue;
                                 }
 
                                 Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
-                                if(dim.installDataPack(() -> data, dpacks)) {
-                                    reboot = true;
+                                for (File dpack : getDatapacksFolder()) {
+                                    dim.installDataPack(fixer, () -> data, dpack, ultimateMaxHeight, ultimateMinHeight);
                                 }
                             }
                         }
@@ -147,39 +153,32 @@ public class ServerConfigurator {
 
         Iris.info("Data Packs Setup!");
 
-        if(fullInstall) {
+        if (fullInstall)
             verifyDataPacksPost(IrisSettings.get().getAutoConfiguration().isAutoRestartOnCustomBiomeInstall());
-        }
     }
 
     private static void verifyDataPacksPost(boolean allowRestarting) {
         File packs = new File("plugins/Iris/packs");
-        File dpacks = getDatapacksFolder();
-
-        if(dpacks == null) {
-            Iris.error("Cannot find the datapacks folder! Please try generating a default world first maybe? Is this a new server?");
-            return;
-        }
 
         boolean bad = false;
-        if(packs.exists()) {
-            for(File i : packs.listFiles()) {
-                if(i.isDirectory()) {
+        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")) {
+                    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) {
+                                if (dim == null) {
                                     Iris.error("Failed to load " + j.getPath() + " ");
                                     continue;
                                 }
 
-                                if(!verifyDataPackInstalled(dim)) {
+                                if (!verifyDataPackInstalled(dim)) {
                                     bad = true;
                                 }
                             }
@@ -189,10 +188,10 @@ public class ServerConfigurator {
             }
         }
 
-        if(bad) {
-            if(allowRestarting) {
+        if (bad) {
+            if (allowRestarting) {
                 restart();
-            } else if(INMS.get().supportsDataPacks()) {
+            } 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.");
@@ -200,8 +199,8 @@ public class ServerConfigurator {
                 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")) {
+                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.");
@@ -231,16 +230,16 @@ public class ServerConfigurator {
         KSet<String> keys = new KSet<>();
         boolean warn = false;
 
-        for(IrisBiome i : dimension.getAllBiomes(() -> idm)) {
-            if(i.isCustom()) {
-                for(IrisBiomeCustom j : i.getCustomDerivitives()) {
+        for (IrisBiome i : dimension.getAllBiomes(() -> idm)) {
+            if (i.isCustom()) {
+                for (IrisBiomeCustom j : i.getCustomDerivitives()) {
                     keys.add(dimension.getLoadKey() + ":" + j.getId());
                 }
             }
         }
 
-        if(!INMS.get().supportsDataPacks()) {
-            if(!keys.isEmpty()) {
+        if (!INMS.get().supportsDataPacks()) {
+            if (!keys.isEmpty()) {
                 Iris.warn("===================================================================================");
                 Iris.warn("Pack " + dimension.getLoadKey() + " has " + keys.size() + " custom biome(s). ");
                 Iris.warn("Your server version does not yet support datapacks for iris.");
@@ -251,16 +250,16 @@ public class ServerConfigurator {
             return true;
         }
 
-        for(String i : keys) {
+        for (String i : keys) {
             Object o = INMS.get().getCustomBiomeBaseFor(i);
 
-            if(o == null) {
+            if (o == null) {
                 Iris.warn("The Biome " + i + " is not registered on the server.");
                 warn = true;
             }
         }
 
-        if(warn) {
+        if (warn) {
             Iris.error("The Pack " + dimension.getLoadKey() + " is INCAPABLE of generating custom biomes");
             Iris.error("If not done automatically, restart your server before generating with this pack!");
         }

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

@@ -0,0 +1,134 @@
+/*
+ * 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

@@ -0,0 +1,315 @@
+/*
+ * 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.ServerConfigurator;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.nms.datapack.DataVersion;
+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.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.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 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 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.concurrent.atomic.AtomicInteger;
+import java.util.zip.GZIPInputStream;
+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 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;
+
+        long lowestUnloadDuration = 0;
+        long highestUnloadDuration = 0;
+
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                if (IrisToolbelt.access(world).getEngine() != null) {
+                    IrisWorlds.add(world);
+                }
+            } 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++;
+                }
+            }
+        }
+        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")
+    public void benchmarkMantle(
+            @Param(description = "The world to bench", aliases = {"world"})
+            World world
+    ) throws IOException, ClassNotFoundException {
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        int maxHeight = engine.getTarget().getHeight();
+        File folder = new File(Bukkit.getWorldContainer(), world.getName());
+        int c = 0;
+        //MCAUtil.read()
+
+        File tectonicplates = new File(folder, "mantle");
+        for (File i : Objects.requireNonNull(tectonicplates.listFiles())) {
+            TectonicPlate.read(maxHeight, i);
+            c++;
+            Iris.info("Loaded count: " + c );
+
+        }
+
+    }
+
+    @Decree(description = "Test")
+    public void packBenchmark(
+            @Param(description = "The pack to bench", aliases = {"pack"}, defaultValue = "overworld")
+            IrisDimension dimension,
+            @Param(description = "Radius in regions", defaultValue = "5")
+            int radius,
+            @Param(description = "Open GUI while benchmarking", defaultValue = "false")
+            boolean gui
+    ) {
+        new IrisPackBenchmarking(dimension, radius, gui);
+    }
+
+    @Decree(description = "Upgrade to another Minecraft version")
+    public void upgrade(
+            @Param(description = "The version to upgrade to", defaultValue = "latest") DataVersion version) {
+        sender().sendMessage(C.GREEN + "Upgrading to " + version.getVersion() + "...");
+        ServerConfigurator.installDataPacks(version.get(), false);
+        sender().sendMessage(C.GREEN + "Done upgrading! You can now update your server version to " + version.getVersion());
+    }
+
+    @Decree(description = "test")
+    public void mca (
+            @Param(description = "String") String world) {
+        try {
+            File[] McaFiles = new File(world, "region").listFiles((dir, name) -> name.endsWith(".mca"));
+            for (File mca : McaFiles) {
+                MCAFile MCARegion = MCAUtil.read(mca);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    @Decree(description = "UnloadChunks for good reasons.")
+    public void unloadchunks() {
+        List<World> IrisWorlds = new ArrayList<>();
+        int chunksUnloaded = 0;
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                if (IrisToolbelt.access(world).getEngine() != null) {
+                    IrisWorlds.add(world);
+                }
+            } catch (Exception e) {
+                // no
+            }
+        }
+
+        for (World world : IrisWorlds) {
+            for (Chunk chunk : world.getLoadedChunks()) {
+                if (chunk.isLoaded()) {
+                    chunk.unload();
+                    chunksUnloaded++;
+                }
+            }
+        }
+        Iris.info(C.IRIS + "Chunks Unloaded: " + chunksUnloaded);
+
+    }
+
+    @Decree
+    public void objects(@Param(defaultValue = "overworld") IrisDimension dimension) {
+        var loader = dimension.getLoader().getObjectLoader();
+        var sender = sender();
+        var keys = loader.getPossibleKeys();
+        var burst = MultiBurst.burst.burst(keys.length);
+        AtomicInteger failed = new AtomicInteger();
+        for (String key : keys) {
+            burst.queue(() -> {
+                if (loader.load(key) == null)
+                    failed.incrementAndGet();
+            });
+        }
+        burst.complete();
+        sender.sendMessage(C.RED + "Failed to load " + failed.get() + " of " + keys.length + " objects");
+    }
+
+    @Decree(description = "Test", aliases = {"ip"})
+    public void network() {
+        try {
+            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
+            for (NetworkInterface ni : Collections.list(networkInterfaces)) {
+                Iris.info("Display Name: %s", ni.getDisplayName());
+                Enumeration<InetAddress> inetAddresses = ni.getInetAddresses();
+                for (InetAddress ia : Collections.list(inetAddresses)) {
+                    Iris.info("IP: %s", ia.getHostAddress());
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Test the compression algorithms")
+    public void compression(
+            @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) {
+        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;
+        }
+
+        File file = new File(path);
+        if (!file.exists()) return;
+
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        if(engine != null) {
+            int height = engine.getTarget().getHeight();
+            ExecutorService service = Executors.newFixedThreadPool(1);
+            VolmitSender sender = sender();
+            service.submit(() -> {
+                try {
+                    CountingDataInputStream raw = CountingDataInputStream.wrap(new FileInputStream(file));
+                    TectonicPlate plate = new TectonicPlate(height, raw);
+                    raw.close();
+
+                    double d1 = 0;
+                    double d2 = 0;
+                    long size = 0;
+                    File folder = new File("tmp");
+                    folder.mkdirs();
+                    for (int i = 0; i < amount; i++) {
+                        File tmp = new File(folder, RandomStringUtils.randomAlphanumeric(10) + "." + algorithm + ".bin");
+                        DataOutputStream dos = createOutput(tmp, algorithm);
+                        long start = System.currentTimeMillis();
+                        plate.write(dos);
+                        dos.close();
+                        d1 += System.currentTimeMillis() - start;
+                        if (size == 0)
+                            size = tmp.length();
+                        start = System.currentTimeMillis();
+                        CountingDataInputStream din = createInput(tmp, algorithm);
+                        new TectonicPlate(height, din);
+                        din.close();
+                        d2 += System.currentTimeMillis() - start;
+                        tmp.delete();
+                    }
+                    IO.delete(folder);
+                    sender.sendMessage(algorithm + " is " + Form.fileSize(size) + " big after compression");
+                    sender.sendMessage(algorithm + " Took " + d2/amount + "ms to read");
+                    sender.sendMessage(algorithm + " Took " + d1/amount + "ms to write");
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                }
+            });
+            service.shutdown();
+		} else {
+            Iris.info(C.RED + "Engine is null!");
+        }
+    }
+
+    private CountingDataInputStream createInput(File file, String algorithm) throws Throwable {
+        FileInputStream in = new FileInputStream(file);
+
+        return CountingDataInputStream.wrap(switch (algorithm) {
+            case "gzip" -> new GZIPInputStream(in);
+            case "lz4f" -> new LZ4FrameInputStream(in);
+            case "lz4b" -> new LZ4BlockInputStream(in);
+            default -> throw new IllegalStateException("Unexpected value: " + algorithm);
+        });
+    }
+
+    private DataOutputStream createOutput(File file, String algorithm) throws Throwable {
+        FileOutputStream out = new FileOutputStream(file);
+
+        return new DataOutputStream(switch (algorithm) {
+            case "gzip" -> new GZIPOutputStream(out);
+            case "lz4f" -> new LZ4FrameOutputStream(out);
+            case "lz4b" -> new LZ4BlockOutputStream(out);
+            default -> throw new IllegalStateException("Unexpected value: " + algorithm);
+        });
+    }
+}
+
+

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

@@ -20,35 +20,29 @@ package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.service.StudioSVC;
-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.IrisJigsawPiece;
-import com.volmit.iris.engine.object.IrisJigsawPool;
-import com.volmit.iris.engine.object.IrisJigsawStructure;
-import com.volmit.iris.engine.object.IrisRegion;
+import com.volmit.iris.engine.object.*;
 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 java.awt.Desktop;
+import java.awt.*;
 
 
 @Decree(name = "edit", origin = DecreeOrigin.PLAYER, studio = true, description = "Edit something")
 public class CommandEdit implements DecreeExecutor {
 
     private boolean noStudio() {
-        if(!sender().isPlayer()) {
+        if (!sender().isPlayer()) {
             sender().sendMessage(C.RED + "Players only!");
             return true;
         }
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No studio world is open!");
             return true;
         }
-        if(!engine().isStudio()) {
+        if (!engine().isStudio()) {
             sender().sendMessage(C.RED + "You must be in a studio world!");
             return true;
         }
@@ -58,17 +52,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the biome you specified", aliases = {"b"}, origin = DecreeOrigin.PLAYER)
     public void biome(@Param(contextual = false, description = "The biome to edit") IrisBiome biome) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(biome == null || biome.getLoadFile() == null) {
+            if (biome == null || biome.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(biome.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + biome.getTypeName() + " " + biome.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -76,17 +70,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the region you specified", aliases = {"r"}, origin = DecreeOrigin.PLAYER)
     public void region(@Param(contextual = false, description = "The region to edit") IrisRegion region) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(region == null || region.getLoadFile() == null) {
+            if (region == null || region.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(region.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + region.getTypeName() + " " + region.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -94,17 +88,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the dimension you specified", aliases = {"d"}, origin = DecreeOrigin.PLAYER)
     public void dimension(@Param(contextual = false, description = "The dimension to edit") IrisDimension dimension) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(dimension == null || dimension.getLoadFile() == null) {
+            if (dimension == null || dimension.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(dimension.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + dimension.getTypeName() + " " + dimension.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -112,17 +106,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the cave file you specified", aliases = {"c"}, origin = DecreeOrigin.PLAYER)
     public void cave(@Param(contextual = false, description = "The cave to edit") IrisCave cave) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(cave == null || cave.getLoadFile() == null) {
+            if (cave == null || cave.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(cave.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + cave.getTypeName() + " " + cave.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -130,17 +124,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the structure file you specified", aliases = {"jigsawstructure", "structure"}, origin = DecreeOrigin.PLAYER)
     public void jigsaw(@Param(contextual = false, description = "The jigsaw structure to edit") IrisJigsawStructure jigsaw) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(jigsaw == null || jigsaw.getLoadFile() == null) {
+            if (jigsaw == null || jigsaw.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(jigsaw.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + jigsaw.getTypeName() + " " + jigsaw.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -148,17 +142,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the pool file you specified", aliases = {"jigsawpool", "pool"}, origin = DecreeOrigin.PLAYER)
     public void jigsawPool(@Param(contextual = false, description = "The jigsaw pool to edit") IrisJigsawPool pool) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(pool == null || pool.getLoadFile() == null) {
+            if (pool == null || pool.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(pool.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + pool.getTypeName() + " " + pool.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -166,17 +160,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the jigsaw piece file you specified", aliases = {"jigsawpiece", "piece"}, origin = DecreeOrigin.PLAYER)
     public void jigsawPiece(@Param(contextual = false, description = "The jigsaw piece to edit") IrisJigsawPiece piece) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(piece == null || piece.getLoadFile() == null) {
+            if (piece == null || piece.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(piece.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + piece.getTypeName() + " " + piece.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }

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

@@ -33,61 +33,85 @@ import com.volmit.iris.util.format.C;
 public class CommandFind implements DecreeExecutor {
     @Decree(description = "Find a biome")
     public void biome(
-        @Param(description = "The biome to look for")
-            IrisBiome biome
+            @Param(description = "The biome to look for")
+            IrisBiome biome,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
     ) {
         Engine e = engine();
 
-        if(e == null) {
+        if (e == null) {
             sender().sendMessage(C.GOLD + "Not in an Iris World!");
             return;
         }
 
-        e.gotoBiome(biome, player());
+        e.gotoBiome(biome, player(), teleport);
     }
 
     @Decree(description = "Find a region")
     public void region(
-        @Param(description = "The region to look for")
-            IrisRegion region
+            @Param(description = "The region to look for")
+            IrisRegion region,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
     ) {
         Engine e = engine();
 
-        if(e == null) {
+        if (e == null) {
             sender().sendMessage(C.GOLD + "Not in an Iris World!");
             return;
         }
 
-        e.gotoRegion(region, player());
+        e.gotoRegion(region, player(), teleport);
     }
 
     @Decree(description = "Find a structure")
     public void structure(
-        @Param(description = "The structure to look for")
-            IrisJigsawStructure structure
+            @Param(description = "The structure to look for")
+            IrisJigsawStructure structure,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
     ) {
         Engine e = engine();
 
-        if(e == null) {
+        if (e == null) {
             sender().sendMessage(C.GOLD + "Not in an Iris World!");
             return;
         }
 
-        e.gotoJigsaw(structure, player());
+        e.gotoJigsaw(structure, player(), teleport);
+    }
+
+    @Decree(description = "Find a point of interest.")
+    public void poi(
+            @Param(description = "The type of PoI to look for.")
+            String type,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
+    ) {
+        Engine e = engine();
+        if (e == null) {
+            sender().sendMessage(C.GOLD + "Not in an Iris World!");
+            return;
+        }
+
+        e.gotoPOI(type, player(), teleport);
     }
 
     @Decree(description = "Find an object")
     public void object(
-        @Param(description = "The object to look for", customHandler = ObjectHandler.class)
-            String object
+            @Param(description = "The object to look for", customHandler = ObjectHandler.class)
+            String object,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
     ) {
         Engine e = engine();
 
-        if(e == null) {
+        if (e == null) {
             sender().sendMessage(C.GOLD + "Not in an Iris World!");
             return;
         }
 
-        e.gotoObject(object, player());
+        e.gotoObject(object, player(), teleport);
     }
 }

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

@@ -0,0 +1,654 @@
+/*
+ * 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.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.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;
+import com.volmit.iris.core.safeguard.UtilsSFG;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.engine.platform.BukkitChunkGenerator;
+import com.volmit.iris.engine.platform.DummyChunkGenerator;
+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.decree.specialhandlers.NullablePlayerHandler;
+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;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+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;
+
+@Decree(name = "iris", aliases = {"ir", "irs"}, description = "Basic Command")
+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;
+    String worldNameToCheck = "YourWorldName";
+    VolmitSender sender = Iris.getSender();
+
+    @Decree(description = "Create a new world", aliases = {"+", "c"})
+    public void create(
+            @Param(aliases = "world-name", description = "The name of the world to create")
+            String name,
+            @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
+    ) {
+        if(sender() instanceof Player) {
+            if (incompatibilities.get("Multiverse-Core")) {
+                sender().sendMessage(C.RED + "Your server has an incompatibility that may corrupt all worlds on the server if not handled properly.");
+                sender().sendMessage(C.RED + "it is strongly advised for you to take action. see log for full detail");
+                sender().sendMessage(C.RED + "----------------------------------------------------------------");
+                sender().sendMessage(C.RED + "Command ran: /iris create");
+                sender().sendMessage(C.RED + UtilsSFG.MSGIncompatibleWarnings());
+                sender().sendMessage(C.RED + "----------------------------------------------------------------");
+            }
+            if (unstablemode && !incompatibilities.get("Multiverse-Core")) {
+                sender().sendMessage(C.RED + "Your server is experiencing an incompatibility with the Iris plugin.");
+                sender().sendMessage(C.RED + "Please rectify this problem to avoid further complications.");
+                sender().sendMessage(C.RED + "----------------------------------------------------------------");
+                sender().sendMessage(C.RED + "Command ran: /iris create");
+                sender().sendMessage(C.RED + UtilsSFG.MSGIncompatibleWarnings());
+                sender().sendMessage(C.RED + "----------------------------------------------------------------");
+            }
+        }
+            if (name.equals("iris")) {
+                sender().sendMessage(C.RED + "You cannot use the world name \"iris\" for creating worlds as Iris uses this directory for studio worlds.");
+                sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
+                return;
+            }
+            if (name.equals("Benchmark")) {
+                sender().sendMessage(C.RED + "You cannot use the world name \"Benchmark\" for creating worlds as Iris uses this directory for Benchmarking Packs.");
+                sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
+                return;
+            }
+
+        if (new File(Bukkit.getWorldContainer(), name).exists()) {
+            sender().sendMessage(C.RED + "That folder already exists!");
+            return;
+        }
+
+        try {
+            worldCreation = true;
+            IrisToolbelt.createWorld()
+                    .dimension(type.getLoadKey())
+                    .name(name)
+                    .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.");
+            Iris.error("Exception raised during world creation: " + e.getMessage());
+            Iris.reportError(e);
+            worldCreation = false;
+            return;
+        }
+        worldCreation = false;
+        sender().sendMessage(C.GREEN + "Successfully created your world!");
+    }
+
+    @Decree(description = "Teleport to another world", aliases = {"tp"}, sync = true)
+    public void teleport(
+            @Param(description = "World to teleport to")
+            World world,
+            @Param(description = "Player to teleport", defaultValue = "---", customHandler = NullablePlayerHandler.class)
+            Player player
+    ) {
+        if (player == null && sender().isPlayer())
+            player = sender().player();
+
+        final Player target = player;
+        if (target == null) {
+            sender().sendMessage(C.RED + "The specified player does not exist.");
+            return;
+        }
+
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                target.teleport(world.getSpawnLocation());
+                new VolmitSender(target).sendMessage(C.GREEN + "You have been teleported to " + world.getName() + ".");
+            }
+        }.runTask(Iris.instance);
+    }
+
+    @Decree(description = "Print version information")
+    public void version() {
+        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)
+    public void packbenchmark(
+            @Param(description = "Dimension to benchmark")
+            IrisDimension type
+    ) throws InterruptedException {
+
+         BenchDimension = type.getLoadKey();
+
+        IrisPackBenchmarking.runBenchmark();
+    } */
+
+    @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
+    public void height() {
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "" + sender().player().getWorld().getMinHeight() + " to " + sender().player().getWorld().getMaxHeight());
+            sender().sendMessage(C.GREEN + "Total Height: " + (sender().player().getWorld().getMaxHeight() - sender().player().getWorld().getMinHeight()));
+        } else {
+            World mainWorld = getServer().getWorlds().get(0);
+            Iris.info(C.GREEN + "" + mainWorld.getMinHeight() + " to " + mainWorld.getMaxHeight());
+            Iris.info(C.GREEN + "Total Height: " + (mainWorld.getMaxHeight() - mainWorld.getMinHeight()));
+        }
+    }
+
+    @Decree(description = "QOL command to open a overworld studio world.", sync = true)
+    public void so() {
+        sender().sendMessage(C.GREEN + "Opening studio for the \"Overworld\" pack (seed: 1337)");
+        Iris.service(StudioSVC.class).open(sender(), 1337, "overworld");
+    }
+
+    @Decree(description = "Check access of all worlds.", aliases = {"accesslist"})
+    public void worlds() {
+        KList<World> IrisWorlds = new KList<>();
+        KList<World> BukkitWorlds = new KList<>();
+
+        for (World w : Bukkit.getServer().getWorlds()) {
+            try {
+                Engine engine = IrisToolbelt.access(w).getEngine();
+                if (engine != null) {
+                    IrisWorlds.add(w);
+                }
+            } catch (Exception e) {
+                BukkitWorlds.add(w);
+            }
+        }
+
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                sender().sendMessage(C.IRIS + "- " +IrisWorld.getName());
+            }
+            sender().sendMessage(C.GOLD + "Bukkit Worlds: ");
+            for (World BukkitWorld : BukkitWorlds.copy()) {
+                sender().sendMessage(C.GRAY + "- " +BukkitWorld.getName());
+            }
+        } else {
+            Iris.info(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                Iris.info(C.IRIS + "- " +IrisWorld.getName());
+            }
+            Iris.info(C.GOLD + "Bukkit Worlds: ");
+            for (World BukkitWorld : BukkitWorlds.copy()) {
+                Iris.info(C.GRAY + "- " +BukkitWorld.getName());
+            }
+            
+        }
+    }
+
+    @Decree(description = "Remove an Iris world", aliases = {"del", "rm", "delete"}, sync = true)
+    public void remove(
+            @Param(description = "The world to remove")
+            World world,
+            @Param(description = "Whether to also remove the folder (if set to false, just does not load the world)", defaultValue = "true")
+            boolean delete
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
+        try {
+            if (IrisToolbelt.removeWorld(world)) {
+                sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
+            } else {
+                sender().sendMessage(C.YELLOW + "Looks like the world was already removed from bukkit.yml");
+            }
+        } catch (IOException e) {
+            sender().sendMessage(C.RED + "Failed to save bukkit.yml because of " + e.getMessage());
+            e.printStackTrace();
+        }
+        IrisToolbelt.evacuate(world, "Deleting world");
+        deletingWorld = true;
+        Bukkit.unloadWorld(world, false);
+        int retries = 12;
+        if (delete) {
+            if (deleteDirectory(world.getWorldFolder())) {
+                sender().sendMessage(C.GREEN + "Successfully removed world folder");
+            } else {
+                while(true){
+                    if (deleteDirectory(world.getWorldFolder())){
+                        sender().sendMessage(C.GREEN + "Successfully removed world folder");
+                        break;
+                    }
+                    retries--;
+                    if (retries == 0){
+                        sender().sendMessage(C.RED + "Failed to remove world folder");
+                        break;
+                    }
+                    J.sleep(3000);
+                }
+            }
+        }
+        deletingWorld = false;
+    }
+
+    public static boolean deleteDirectory(File dir) {
+        if (dir.isDirectory()) {
+            File[] children = dir.listFiles();
+            for (int i = 0; i < children.length; i++) {
+                boolean success = deleteDirectory(children[i]);
+                if (!success) {
+                    return false;
+                }
+            }
+        }
+        return dir.delete();
+    }
+
+    @Decree(description = "Updates all chunk in the specified world")
+    public void updater(
+            @Param(description = "World to update chunks at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        ChunkUpdater updater = new ChunkUpdater(world);
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "Updating " + world.getName() + " Total chunks: " + Form.f(updater.getChunks()));
+        } else {
+            Iris.info(C.GREEN + "Updating " + world.getName() + " Total chunks: " + Form.f(updater.getChunks()));
+        }
+        updater.start();
+    }
+
+    @Decree(description = "Set aura spins")
+    public void aura(
+            @Param(description = "The h color value", defaultValue = "-20")
+            int h,
+            @Param(description = "The s color value", defaultValue = "7")
+            int s,
+            @Param(description = "The b color value", defaultValue = "8")
+            int b
+    ) {
+        IrisSettings.get().getGeneral().setSpinh(h);
+        IrisSettings.get().getGeneral().setSpins(s);
+        IrisSettings.get().getGeneral().setSpinb(b);
+        IrisSettings.get().forceSave();
+        sender().sendMessage("<rainbow>Aura Spins updated to " + h + " " + s + " " + b);
+    }
+
+    @Decree(description = "Bitwise calculations")
+    public void bitwise(
+            @Param(description = "The first value to run calculations on")
+            int value1,
+            @Param(description = "The operator: | & ^ ≺≺ ≻≻ ％")
+            String operator,
+            @Param(description = "The second value to run calculations on")
+            int value2
+    ) {
+        Integer v = null;
+        switch (operator) {
+            case "|" -> v = value1 | value2;
+            case "&" -> v = value1 & value2;
+            case "^" -> v = value1 ^ value2;
+            case "%" -> v = value1 % value2;
+            case ">>" -> v = value1 >> value2;
+            case "<<" -> v = value1 << value2;
+        }
+        if (v == null) {
+            sender().sendMessage(C.RED + "The operator you entered: (" + operator + ") is invalid!");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "" + value1 + " " + C.GREEN + operator.replaceAll("<", "≺").replaceAll(">", "≻").replaceAll("%", "％") + " " + C.GREEN + value2 + C.GREEN + " returns " + C.GREEN + v);
+    }
+
+    @Decree(description = "Toggle debug")
+    public void debug(
+            @Param(name = "on", description = "Whether or not debug should be on", defaultValue = "other")
+            Boolean on
+    ) {
+        boolean to = on == null ? !IrisSettings.get().getGeneral().isDebug() : on;
+        IrisSettings.get().getGeneral().setDebug(to);
+        IrisSettings.get().forceSave();
+        sender().sendMessage(C.GREEN + "Set debug to: " + to);
+    }
+
+    @Decree(description = "Download a project.", aliases = "dl")
+    public void download(
+            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
+            String pack,
+            @Param(name = "branch", description = "The branch to download from", defaultValue = "main")
+            String branch,
+            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            boolean trim,
+            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
+            boolean overwrite
+    ) {
+        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";
+            Iris.service(StudioSVC.class).downloadRelease(sender(), url, trim, overwrite);
+        } else {
+            Iris.service(StudioSVC.class).downloadSearch(sender(), "IrisDimensions/" + pack + "/" + branch, trim, overwrite);
+        }
+    }
+
+    @Decree(description = "Get metrics for your world", aliases = "measure", origin = DecreeOrigin.PLAYER)
+    public void metrics() {
+        if (!IrisToolbelt.isIrisWorld(world())) {
+            sender().sendMessage(C.RED + "You must be in an Iris world");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Sending metrics...");
+        engine().printMetrics(sender());
+    }
+
+    @Decree(description = "Reload configuration file (this is also done automatically)")
+    public void reload() {
+        IrisSettings.invalidate();
+        IrisSettings.get();
+        sender().sendMessage(C.GREEN + "Hotloaded settings");
+    }
+
+    @Decree(description = "Update the pack of a world (UNSAFE!)", name = "^world", aliases = "update-world")
+    public void updateWorld(
+            @Param(description = "The world to update", contextual = true)
+            World world,
+            @Param(description = "The pack to install into the world", contextual = true, aliases = "dimension")
+            IrisDimension pack,
+            @Param(description = "Make sure to make a backup & read the warnings first!", defaultValue = "false", aliases = "c")
+            boolean confirm,
+            @Param(description = "Should Iris download the pack again for you", defaultValue = "false", name = "fresh-download", aliases = {"fresh", "new"})
+            boolean freshDownload
+    ) {
+        if (!confirm) {
+            sender().sendMessage(new String[]{
+                    C.RED + "You should always make a backup before using this",
+                    C.YELLOW + "Issues caused by this can be, but are not limited to:",
+                    C.YELLOW + " - Broken chunks (cut-offs) between old and new chunks (before & after the update)",
+                    C.YELLOW + " - Regenerated chunks that do not fit in with the old chunks",
+                    C.YELLOW + " - Structures not spawning again when regenerating",
+                    C.YELLOW + " - Caves not lining up",
+                    C.YELLOW + " - Terrain layers not lining up",
+                    C.RED + "Now that you are aware of the risks, and have made a back-up:",
+                    C.RED + "/iris ^world " + world.getName() + " " + pack.getLoadKey() + " confirm=true"
+            });
+            return;
+        }
+
+        File folder = world.getWorldFolder();
+        folder.mkdirs();
+
+        if (freshDownload) {
+            Iris.service(StudioSVC.class).downloadSearch(sender(), pack.getLoadKey(), false, true);
+        }
+
+        Iris.service(StudioSVC.class).installIntoWorld(sender(), pack.getLoadKey(), folder);
+    }
+
+    @Decree(description = "Unload an Iris World", origin = DecreeOrigin.PLAYER, sync = true)
+    public void unloadWorld(
+            @Param(description = "The world to unload")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Unloading world: " + world.getName());
+        try {
+            IrisToolbelt.evacuate(world);
+            Bukkit.unloadWorld(world, false);
+            sender().sendMessage(C.GREEN + "World unloaded successfully.");
+        } catch (Exception e) {
+            sender().sendMessage(C.RED + "Failed to unload the world: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Load an Iris World", origin = DecreeOrigin.PLAYER, sync = true, aliases = {"import"})
+    public void loadWorld(
+            @Param(description = "The name of the world to load")
+            String world
+    ) {
+        World worldloaded = Bukkit.getWorld(world);
+        worldNameToCheck = world;
+        boolean worldExists = doesWorldExist(worldNameToCheck);
+        WorldEngine = world;
+
+        if (!worldExists) {
+            sender().sendMessage(C.YELLOW + world + " Doesnt exist on the server.");
+            return;
+        }
+
+        File BUKKIT_YML = new File("bukkit.yml");
+        String pathtodim = world + File.separator +"iris"+File.separator +"pack"+File.separator +"dimensions"+File.separator;
+        File directory = new File(Bukkit.getWorldContainer(), pathtodim);
+
+        String dimension = null;
+        if (directory.exists() && directory.isDirectory()) {
+            File[] files = directory.listFiles();
+            if (files != null) {
+                for (File file : files) {
+                    if (file.isFile()) {
+                        String fileName = file.getName();
+                        if (fileName.endsWith(".json")) {
+                            dimension = fileName.substring(0, fileName.length() - 5);
+                            sender().sendMessage(C.BLUE + "Generator: " + dimension);
+                        }
+                    }
+                }
+            }
+        } else {
+            sender().sendMessage(C.GOLD + world + " is not an iris world.");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Loading world: " + world);
+
+        YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
+        String gen = "Iris:" + dimension;
+        ConfigurationSection section = yml.contains("worlds") ? yml.getConfigurationSection("worlds") : yml.createSection("worlds");
+        if (!section.contains(world)) {
+            section.createSection(world).set("generator", gen);
+            try {
+                yml.save(BUKKIT_YML);
+                Iris.info("Registered \"" + world + "\" in bukkit.yml");
+            } catch (IOException e) {
+                Iris.error("Failed to update bukkit.yml!");
+                e.printStackTrace();
+                return;
+            }
+        }
+        checkForBukkitWorlds(world);
+        sender().sendMessage(C.GREEN + world + " loaded successfully.");
+    }
+    @Decree(description = "Evacuate an iris world", origin = DecreeOrigin.PLAYER, sync = true)
+    public void evacuate(
+            @Param(description = "Evacuate the world")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Evacuating world" + world.getName());
+        IrisToolbelt.evacuate(world);
+    }
+
+    boolean doesWorldExist(String worldName) {
+        File worldContainer = Bukkit.getWorldContainer();
+        File worldDirectory = new File(worldContainer, worldName);
+        return worldDirectory.exists() && worldDirectory.isDirectory();
+    }
+    private void checkForBukkitWorlds(String world) {
+        FileConfiguration fc = new YamlConfiguration();
+        try {
+            fc.load(new File("bukkit.yml"));
+            ConfigurationSection section = fc.getConfigurationSection("worlds");
+            if (section == null) {
+                return;
+            }
+
+            List<String> worldsToLoad = Collections.singletonList(world);
+
+             for (String s : section.getKeys(false)) {
+                if (!worldsToLoad.contains(s)) {
+                    continue;
+                }
+                ConfigurationSection entry = section.getConfigurationSection(s);
+                if (!entry.contains("generator", true)) {
+                    continue;
+                }
+                String generator = entry.getString("generator");
+                if (generator.startsWith("Iris:")) {
+                    generator = generator.split("\\Q:\\E")[1];
+                } else if (generator.equalsIgnoreCase("Iris")) {
+                    generator = IrisSettings.get().getGenerator().getDefaultWorldType();
+                } else {
+                    continue;
+                }
+                Iris.info("2 World: %s | Generator: %s", s, generator);
+                if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
+                    continue;
+                }
+                Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
+                new WorldCreator(s)
+                        .generator(getDefaultWorldGenerator(s, generator))
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                        .createWorld();
+                Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
+        if (worldName.equals("test")) {
+            try {
+                throw new RuntimeException();
+            } catch (Throwable e) {
+                Iris.info(e.getStackTrace()[1].getClassName());
+                if (e.getStackTrace()[1].getClassName().contains("com.onarandombox.MultiverseCore")) {
+                    Iris.debug("MVC Test detected, Quick! Send them the dummy!");
+                    return new DummyChunkGenerator();
+                }
+            }
+        }
+        IrisDimension dim;
+        if (id == null || id.isEmpty()) {
+            dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
+        } else {
+            dim = IrisData.loadAnyDimension(id);
+        }
+        Iris.debug("Generator ID: " + id + " requested by bukkit/plugin");
+
+        if (dim == null) {
+            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
+
+            service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, true);
+            dim = IrisData.loadAnyDimension(id);
+
+            if (dim == null) {
+                throw new RuntimeException("Can't find dimension " + id + "!");
+            } else {
+                Iris.info("Resolved missing dimension, proceeding with generation.");
+            }
+        }
+        Iris.debug("Assuming IrisDimension: " + dim.getName());
+        IrisWorld w = IrisWorld.builder()
+                .name(worldName)
+                .seed(1337)
+                .environment(dim.getEnvironment())
+                .worldFolder(new File(Bukkit.getWorldContainer(), worldName))
+                .minHeight(dim.getMinHeight())
+                .maxHeight(dim.getMaxHeight())
+                .build();
+        Iris.debug("Generator Config: " + w.toString());
+        File ff = new File(w.worldFolder(), "iris/pack");
+        if (!ff.exists() || ff.listFiles().length == 0) {
+            ff.mkdirs();
+            service(StudioSVC.class).installIntoWorld(sender, dim.getLoadKey(), ff.getParentFile());
+        }
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey(), false);
+    }
+}

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

@@ -21,6 +21,7 @@ package com.volmit.iris.core.commands;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.edit.JigsawEditor;
 import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.engine.framework.placer.WorldObjectPlacer;
 import com.volmit.iris.engine.jigsaw.PlannedStructure;
 import com.volmit.iris.engine.object.IrisJigsawPiece;
 import com.volmit.iris.engine.object.IrisJigsawStructure;
@@ -34,6 +35,7 @@ import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 
 import java.io.File;
@@ -42,7 +44,7 @@ import java.io.File;
 public class CommandJigsaw implements DecreeExecutor {
     @Decree(description = "Edit a jigsaw piece")
     public void edit(
-        @Param(description = "The jigsaw piece to edit")
+            @Param(description = "The jigsaw piece to edit")
             IrisJigsawPiece piece
     ) {
         File dest = piece.getLoadFile();
@@ -51,27 +53,34 @@ public class CommandJigsaw implements DecreeExecutor {
 
     @Decree(description = "Place a jigsaw structure")
     public void place(
-        @Param(description = "The jigsaw structure to place")
+            @Param(description = "The jigsaw structure to place")
             IrisJigsawStructure structure
     ) {
         PrecisionStopwatch p = PrecisionStopwatch.start();
-        PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation()), new RNG());
-        sender().sendMessage(C.GREEN + "Generated " + ps.getPieces().size() + " pieces in " + Form.duration(p.getMilliseconds(), 2));
-        ps.place(world());
+        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(), 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!"));
+        } catch (IllegalArgumentException e) {
+            sender().sendMessage(C.RED + "Failed to place the structure: " + e.getMessage());
+        }
     }
 
     @Decree(description = "Create a jigsaw piece")
     public void create(
-        @Param(description = "The name of the jigsaw piece")
+            @Param(description = "The name of the jigsaw piece")
             String piece,
-        @Param(description = "The project to add the jigsaw piece to")
+            @Param(description = "The project to add the jigsaw piece to")
             String project,
-        @Param(description = "The object to use for this piece", customHandler = ObjectHandler.class)
+            @Param(description = "The object to use for this piece", customHandler = ObjectHandler.class)
             String object
     ) {
         IrisObject o = IrisData.loadAnyObject(object);
 
-        if(object == null) {
+        if (object == null) {
             sender().sendMessage(C.RED + "Failed to find existing object");
             return;
         }
@@ -88,7 +97,7 @@ public class CommandJigsaw implements DecreeExecutor {
     public void exit() {
         JigsawEditor editor = JigsawEditor.editors.get(player());
 
-        if(editor == null) {
+        if (editor == null) {
             sender().sendMessage(C.GOLD + "You don't have any pieces open to exit!");
             return;
         }
@@ -101,7 +110,7 @@ public class CommandJigsaw implements DecreeExecutor {
     public void save() {
         JigsawEditor editor = JigsawEditor.editors.get(player());
 
-        if(editor == null) {
+        if (editor == null) {
             sender().sendMessage(C.GOLD + "You don't have any pieces open to save!");
             return;
         }

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

@@ -0,0 +1,121 @@
+/*
+ * 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.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;
+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 = "lazypregen", aliases = "lazy", description = "Pregenerate your Iris worlds!")
+public class CommandLazyPregen implements DecreeExecutor {
+    public String worldName;
+    @Decree(description = "Pregenerate 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,
+            @Param(aliases = "maxcpm", description = "Limit the chunks per minute the pregen will generate", defaultValue = "999999999")
+            int cpm,
+            @Param(aliases = "silent", description = "Silent generation", defaultValue = "false")
+            boolean silent
+            ) {
+
+        worldName = world.getName();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File lazyFile = new File(worldDirectory, "lazygen.json");
+        if (lazyFile.exists()) {
+            sender().sendMessage(C.BLUE + "Lazy pregen is already in progress");
+            Iris.info(C.YELLOW + "Lazy pregen is already in progress");
+            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.");
+            }
+
+            LazyPregenerator.LazyPregenJob pregenJob = LazyPregenerator.LazyPregenJob.builder()
+                    .world(worldName)
+                    .healingPosition(0)
+                    .healing(false)
+                    .chunksPerMinute(cpm)
+                    .radiusBlocks(radius)
+                    .position(0)
+                    .silent(silent)
+                    .build();
+
+            File lazyGenFile = new File(worldDirectory, "lazygen.json");
+            LazyPregenerator pregenerator = new LazyPregenerator(pregenJob, lazyGenFile);
+            pregenerator.start();
+
+            String msg = C.GREEN + "LazyPregen 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 pregeneration task", aliases = "x")
+    public void stop(
+            @Param(aliases = "world", description = "The world to pause")
+            World world
+    ) throws IOException {
+        if (LazyPregenerator.getInstance() != null) {
+            LazyPregenerator.getInstance().shutdownInstance(world);
+            sender().sendMessage(C.LIGHT_PURPLE + "Closed lazygen instance for " + world.getName());
+        } 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 (LazyPregenerator.getInstance() != null) {
+            LazyPregenerator.getInstance().setPausedLazy(world);
+            sender().sendMessage(C.GREEN + "Paused/unpaused Lazy Pregen, now: " + (LazyPregenerator.getInstance().isPausedLazy(world) ? "Paused" : "Running") + ".");
+        } else {
+            sender().sendMessage(C.YELLOW + "No active Lazy Pregen tasks to pause/unpause.");
+
+        }
+    }
+}

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

@@ -24,14 +24,9 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.service.ObjectSVC;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.service.WandSVC;
+import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IObjectPlacer;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisObjectPlacement;
-import com.volmit.iris.engine.object.IrisObjectPlacementScaleInterpolator;
-import com.volmit.iris.engine.object.IrisObjectRotation;
-import com.volmit.iris.engine.object.TileData;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.data.Cuboid;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
@@ -41,6 +36,7 @@ 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;
@@ -53,21 +49,13 @@ import org.bukkit.util.Vector;
 import java.io.File;
 import java.io.IOException;
 import java.text.NumberFormat;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.stream.Collectors;
+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(Material.GRASS, Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
-        Material.POPPY, Material.DANDELION);
+    private static final Set<Material> skipBlocks = Set.of(E.getOrDefault(Material.class, "GRASS", "SHORT_GRASS"), Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
+            Material.POPPY, Material.DANDELION);
 
     public static IObjectPlacer createPlacer(World world, Map<Block, BlockData> futureBlockChanges) {
 
@@ -87,7 +75,7 @@ public class CommandObject implements DecreeExecutor {
                 Block block = world.getBlockAt(x, y, z);
 
                 //Prevent blocks being set in or bellow bedrock
-                if(y <= world.getMinHeight() || block.getType() == Material.BEDROCK) return;
+                if (y <= world.getMinHeight() || block.getType() == Material.BEDROCK) return;
 
                 futureBlockChanges.put(block, block.getBlockData());
 
@@ -130,10 +118,8 @@ public class CommandObject implements DecreeExecutor {
             }
 
             @Override
-            public void setTile(int xx, int yy, int zz, TileData<? extends TileState> tile) {
-                BlockState state = world.getBlockAt(xx, yy, zz).getState();
-                tile.toBukkitTry(state);
-                state.update();
+            public void setTile(int xx, int yy, int zz, TileData tile) {
+                tile.toBukkitTry(world.getBlockAt(xx, yy, zz));
             }
 
             @Override
@@ -145,7 +131,7 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Check the composition of an object")
     public void analyze(
-        @Param(description = "The object to analyze", customHandler = ObjectHandler.class)
+            @Param(description = "The object to analyze", customHandler = ObjectHandler.class)
             String object
     ) {
         IrisObject o = IrisData.loadAnyObject(object);
@@ -156,19 +142,19 @@ public class CommandObject implements DecreeExecutor {
         Map<Material, Set<BlockData>> unsorted = new HashMap<>();
         Map<BlockData, Integer> amounts = new HashMap<>();
         Map<Material, Integer> materials = new HashMap<>();
-        while(queue.hasNext()) {
+        while (queue.hasNext()) {
             BlockData block = queue.next();
 
             //unsorted.put(block.getMaterial(), block);
 
-            if(!amounts.containsKey(block)) {
+            if (!amounts.containsKey(block)) {
                 amounts.put(block, 1);
 
 
             } else
                 amounts.put(block, amounts.get(block) + 1);
 
-            if(!materials.containsKey(block.getMaterial())) {
+            if (!materials.containsKey(block.getMaterial())) {
                 materials.put(block.getMaterial(), 1);
                 unsorted.put(block.getMaterial(), new HashSet<>());
                 unsorted.get(block.getMaterial()).add(block);
@@ -180,13 +166,13 @@ public class CommandObject implements DecreeExecutor {
         }
 
         List<Material> sortedMatsList = amounts.keySet().stream().map(BlockData::getMaterial)
-            .sorted().collect(Collectors.toList());
+                .sorted().toList();
         Set<Material> sortedMats = new TreeSet<>(Comparator.comparingInt(materials::get).reversed());
         sortedMats.addAll(sortedMatsList);
         sender().sendMessage("== Blocks in object ==");
 
         int n = 0;
-        for(Material mat : sortedMats) {
+        for (Material mat : sortedMats) {
             int amount = materials.get(mat);
             List<BlockData> set = new ArrayList<>(unsorted.get(mat));
             set.sort(Comparator.comparingInt(amounts::get).reversed());
@@ -194,23 +180,47 @@ public class CommandObject implements DecreeExecutor {
             int dataAmount = amounts.get(data);
 
             String string = " - " + mat.toString() + "*" + amount;
-            if(data.getAsString(true).contains("[")) {
+            if (data.getAsString(true).contains("[")) {
                 string = string + " --> [" + data.getAsString(true).split("\\[")[1]
-                    .replaceAll("true", ChatColor.GREEN + "true" + ChatColor.GRAY)
-                    .replaceAll("false", ChatColor.RED + "false" + ChatColor.GRAY) + "*" + dataAmount;
+                        .replaceAll("true", ChatColor.GREEN + "true" + ChatColor.GRAY)
+                        .replaceAll("false", ChatColor.RED + "false" + ChatColor.GRAY) + "*" + dataAmount;
             }
 
             sender().sendMessage(string);
 
             n++;
 
-            if(n >= 10) {
+            if (n >= 10) {
                 sender().sendMessage("  + " + (sortedMats.size() - n) + " other block types");
                 return;
             }
         }
     }
 
+    @Decree(description = "Shrink an object to its minimum size")
+    public void shrink(@Param(description = "The object to shrink", customHandler = ObjectHandler.class) String object) {
+        IrisObject o = IrisData.loadAnyObject(object);
+        sender().sendMessage("Current Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
+        o.shrinkwrap();
+        sender().sendMessage("New Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
+        try {
+            o.write(o.getLoadFile());
+        } catch (IOException e) {
+            sender().sendMessage("Failed to save object " + o.getLoadFile() + ": " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Convert .schem files in the 'convert' folder to .iob files.")
+    public void convert () {
+        try {
+            IrisConverter.convertSchematics(sender());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
     @Decree(description = "Get a powder that reveals objects", studio = true, aliases = "d")
     public void dust() {
         player().getInventory().addItem(WandSVC.createDust());
@@ -219,16 +229,19 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Contract a selection based on your looking direction", aliases = "-")
     public void contract(
-        @Param(description = "The amount to inset by", defaultValue = "1")
+            @Param(description = "The amount to inset by", defaultValue = "1")
             int amount
     ) {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage("Hold your wand.");
             return;
         }
 
 
         Location[] b = WandSVC.getCuboid(player());
+        if (b == null) {
+            return;
+        }
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Cuboid cursor = new Cuboid(a1, a2);
@@ -244,18 +257,21 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Set point 1 to look", aliases = "p1")
     public void position1(
-        @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
+            @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
             boolean here
     ) {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage("Ready your Wand.");
             return;
         }
 
-        if(WandSVC.isHoldingWand(player())) {
+        if (WandSVC.isHoldingWand(player())) {
             Location[] g = WandSVC.getCuboid(player());
 
-            if(!here) {
+            if (g == null) {
+                return;
+            }
+            if (!here) {
                 // TODO: WARNING HEIGHT
                 g[1] = player().getTargetBlock(null, 256).getLocation().clone();
             } else {
@@ -267,18 +283,22 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Set point 2 to look", aliases = "p2")
     public void position2(
-        @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
+            @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
             boolean here
     ) {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage("Ready your Wand.");
             return;
         }
 
-        if(WandSVC.isHoldingIrisWand(player())) {
+        if (WandSVC.isHoldingIrisWand(player())) {
             Location[] g = WandSVC.getCuboid(player());
 
-            if(!here) {
+            if (g == null) {
+                return;
+            }
+
+            if (!here) {
                 // TODO: WARNING HEIGHT
                 g[0] = player().getTargetBlock(null, 256).getLocation().clone();
             } else {
@@ -290,13 +310,13 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Paste an object", sync = true)
     public void paste(
-        @Param(description = "The object to paste", customHandler = ObjectHandler.class)
+            @Param(description = "The object to paste", customHandler = ObjectHandler.class)
             String object,
-        @Param(description = "Whether or not to edit the object (need to hold wand)", defaultValue = "false")
+            @Param(description = "Whether or not to edit the object (need to hold wand)", defaultValue = "false")
             boolean edit,
-        @Param(description = "The amount of degrees to rotate by", defaultValue = "0")
+            @Param(description = "The amount of degrees to rotate by", defaultValue = "0")
             int rotate,
-        @Param(description = "The factor by which to scale the object placement", defaultValue = "1")
+            @Param(description = "The factor by which to scale the object placement", defaultValue = "1")
             double scale
 //            ,
 //            @Param(description = "The scale interpolator to use", defaultValue = "none")
@@ -304,7 +324,7 @@ public class CommandObject implements DecreeExecutor {
     ) {
         IrisObject o = IrisData.loadAnyObject(object);
         double maxScale = Double.max(10 - o.getBlocks().size() / 10000d, 1);
-        if(scale > maxScale) {
+        if (scale > maxScale) {
             sender().sendMessage(C.YELLOW + "Indicated scale exceeds maximum. Downscaled to maximum: " + maxScale);
             scale = maxScale;
         }
@@ -319,8 +339,7 @@ public class CommandObject implements DecreeExecutor {
 
         Map<Block, BlockData> futureChanges = new HashMap<>();
 
-        if(scale != 1)
-        {
+        if (scale != 1) {
             o = o.scaled(scale, IrisObjectPlacementScaleInterpolator.TRICUBIC);
         }
 
@@ -328,16 +347,16 @@ public class CommandObject implements DecreeExecutor {
 
         Iris.service(ObjectSVC.class).addChanges(futureChanges);
 
-        if(edit) {
+        if (edit) {
             ItemStack newWand = WandSVC.createWand(block.clone().subtract(o.getCenter()).add(o.getW() - 1,
-                o.getH() + o.getCenter().clone().getY() - 1, o.getD() - 1), block.clone().subtract(o.getCenter().clone().setY(0)));
-            if(WandSVC.isWand(wand)) {
+                    o.getH() + o.getCenter().clone().getY() - 1, o.getD() - 1), block.clone().subtract(o.getCenter().clone().setY(0)));
+            if (WandSVC.isWand(wand)) {
                 wand = newWand;
                 player().getInventory().setItemInMainHand(wand);
                 sender().sendMessage("Updated wand for " + "objects/" + o.getLoadKey() + ".iob ");
             } else {
                 int slot = WandSVC.findWand(player().getInventory());
-                if(slot == -1) {
+                if (slot == -1) {
                     player().getInventory().addItem(newWand);
                     sender().sendMessage("Given new wand for " + "objects/" + o.getLoadKey() + ".iob ");
                 } else {
@@ -346,35 +365,37 @@ public class CommandObject implements DecreeExecutor {
                 }
             }
         } else {
-            sender().sendMessage("Placed " + object);
+            sender().sendMessage(C.IRIS + "Placed " + object);
         }
     }
 
     @Decree(description = "Save an object")
     public void save(
-        @Param(description = "The dimension to store the object in", contextual = true)
+            @Param(description = "The dimension to store the object in", contextual = true)
             IrisDimension dimension,
-        @Param(description = "The file to store it in, can use / for subfolders")
+            @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
+            @Param(description = "Overwrite existing object files", defaultValue = "false", aliases = "force")
+            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) {
+        if (o == null) {
             sender().sendMessage(C.YELLOW + "You need to hold your wand!");
             return;
         }
 
         File file = Iris.service(StudioSVC.class).getWorkspaceFile(dimension.getLoadKey(), "objects", name + ".iob");
 
-        if(file.exists() && !overwrite) {
+        if (file.exists() && !overwrite) {
             sender().sendMessage(C.RED + "File already exists. Set overwrite=true to overwrite it.");
             return;
         }
         try {
-            o.write(file);
-        } catch(IOException e) {
+            o.write(file, sender());
+        } catch (IOException e) {
             sender().sendMessage(C.RED + "Failed to save object because of an IOException: " + e.getMessage());
             Iris.reportError(e);
         }
@@ -385,10 +406,10 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Shift a selection in your looking direction", aliases = "-")
     public void shift(
-        @Param(description = "The amount to shift by", defaultValue = "1")
+            @Param(description = "The amount to shift by", defaultValue = "1")
             int amount
     ) {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage("Hold your wand.");
             return;
         }
@@ -397,6 +418,9 @@ public class CommandObject implements DecreeExecutor {
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
+        if (d == null) {
+            return; // HOW DID THIS HAPPEN
+        }
         a1.add(d.toVector().multiply(amount));
         a2.add(d.toVector().multiply(amount));
         Cuboid cursor = new Cuboid(a1, a2);
@@ -409,26 +433,25 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Undo a number of pastes", aliases = "-")
     public void undo(
-        @Param(description = "The amount of pastes to undo", defaultValue = "1")
+            @Param(description = "The amount of pastes to undo", defaultValue = "1")
             int amount
     ) {
         ObjectSVC service = Iris.service(ObjectSVC.class);
         int actualReverts = Math.min(service.getUndos().size(), amount);
         service.revertChanges(actualReverts);
-        sender().sendMessage("Reverted " + actualReverts + " pastes!");
+        sender().sendMessage(C.BLUE + "Reverted " + actualReverts + C.BLUE +" pastes!");
     }
 
     @Decree(description = "Gets an object wand and grabs the current WorldEdit selection.", aliases = "we", origin = DecreeOrigin.PLAYER, studio = true)
     public void we() {
-        if(!Bukkit.getPluginManager().isPluginEnabled("WorldEdit")) {
+        if (!Bukkit.getPluginManager().isPluginEnabled("WorldEdit")) {
             sender().sendMessage(C.RED + "You can't get a WorldEdit selection without WorldEdit, you know.");
             return;
         }
 
         Cuboid locs = WorldEditLink.getSelection(sender().player());
 
-        if(locs == null)
-        {
+        if (locs == null) {
             sender().sendMessage(C.RED + "You don't have a WorldEdit selection in this world.");
             return;
         }
@@ -446,7 +469,7 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(name = "x&y", description = "Autoselect up, down & out", sync = true)
     public void xay() {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage(C.YELLOW + "Hold your wand!");
             return;
         }
@@ -459,7 +482,7 @@ public class CommandObject implements DecreeExecutor {
         Cuboid cursor = new Cuboid(a1, a2);
         Cuboid cursorx = new Cuboid(a1, a2);
 
-        while(!cursor.containsOnly(Material.AIR)) {
+        while (!cursor.containsOnly(Material.AIR)) {
             a1.add(new org.bukkit.util.Vector(0, 1, 0));
             a2.add(new org.bukkit.util.Vector(0, 1, 0));
             cursor = new Cuboid(a1, a2);
@@ -468,7 +491,7 @@ public class CommandObject implements DecreeExecutor {
         a1.add(new org.bukkit.util.Vector(0, -1, 0));
         a2.add(new org.bukkit.util.Vector(0, -1, 0));
 
-        while(!cursorx.containsOnly(Material.AIR)) {
+        while (!cursorx.containsOnly(Material.AIR)) {
             a1x.add(new org.bukkit.util.Vector(0, -1, 0));
             a2x.add(new org.bukkit.util.Vector(0, -1, 0));
             cursorx = new Cuboid(a1x, a2x);
@@ -493,7 +516,7 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(name = "x+y", description = "Autoselect up & out", sync = true)
     public void xpy() {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage(C.YELLOW + "Hold your wand!");
             return;
         }
@@ -505,7 +528,7 @@ public class CommandObject implements DecreeExecutor {
         Location a2 = b[1].clone();
         Cuboid cursor = new Cuboid(a1, a2);
 
-        while(!cursor.containsOnly(Material.AIR)) {
+        while (!cursor.containsOnly(Material.AIR)) {
             a1.add(new Vector(0, 1, 0));
             a2.add(new Vector(0, 1, 0));
             cursor = new Cuboid(a1, a2);

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

@@ -19,7 +19,9 @@
 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;
@@ -27,37 +29,41 @@ 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")
     public void start(
-        @Param(description = "The radius of the pregen in blocks", aliases = "size")
+            @Param(description = "The radius of the pregen in blocks", aliases = "size")
             int radius,
-        @Param(description = "The world to pregen", contextual = true)
+            @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")
+            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
             Vector center
-    ) {
+            ) {
         try {
-            if(sender().isPlayer() && access() == null) {
+            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.");
             }
             radius = Math.max(radius, 1024);
             int w = (radius >> 9 + 1) * 2;
             IrisToolbelt.pregenerate(PregenTask
-                .builder()
-                .center(new Position2(center))
-                .width(w)
-                .height(w)
-                .build(), world);
+                    .builder()
+                    .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
+                    .gui(true)
+                    .width(w)
+                    .height(w)
+                    .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);
             Iris.info(msg);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             sender().sendMessage(C.RED + "Epic fail. See console.");
             Iris.reportError(e);
             e.printStackTrace();
@@ -66,8 +72,8 @@ public class CommandPregen implements DecreeExecutor {
 
     @Decree(description = "Stop the active pregeneration task", aliases = "x")
     public void stop() {
-        if(PregeneratorJob.shutdownInstance()) {
-            sender().sendMessage(C.GREEN + "Stopped pregeneration task");
+        if (PregeneratorJob.shutdownInstance()) {
+            Iris.info( C.BLUE + "Finishing up mca region...");
         } else {
             sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
         }
@@ -75,7 +81,7 @@ public class CommandPregen implements DecreeExecutor {
 
     @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
     public void pause() {
-        if(PregeneratorJob.pauseResume()) {
+        if (PregeneratorJob.pauseResume()) {
             sender().sendMessage(C.GREEN + "Paused/unpaused pregeneration task, now: " + (PregeneratorJob.isPaused() ? "Paused" : "Running") + ".");
         } else {
             sender().sendMessage(C.YELLOW + "No active pregeneration tasks to pause/unpause.");

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

@@ -28,23 +28,12 @@ import com.volmit.iris.core.service.ConversionSVC;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.InventorySlotType;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBiomePaletteLayer;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisEntity;
-import com.volmit.iris.engine.object.IrisGenerator;
-import com.volmit.iris.engine.object.IrisInterpolator;
-import com.volmit.iris.engine.object.IrisLootTable;
-import com.volmit.iris.engine.object.IrisNoiseGenerator;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisObjectPlacement;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.engine.object.IrisScript;
-import com.volmit.iris.engine.object.NoiseStyle;
+import com.volmit.iris.engine.object.*;
+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.collection.KSet;
+import com.volmit.iris.util.decree.DecreeContext;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -58,31 +47,24 @@ import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONArray;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.math.Spiraler;
 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.J;
 import com.volmit.iris.util.scheduling.O;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import com.volmit.iris.util.scheduling.jobs.Job;
-import com.volmit.iris.util.scheduling.jobs.JobCollection;
 import com.volmit.iris.util.scheduling.jobs.QueueJob;
-import com.volmit.iris.util.scheduling.jobs.SingleJob;
 import io.papermc.lib.PaperLib;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.FluidCollisionMode;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.World;
+import org.bukkit.*;
 import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.util.BlockVector;
 import org.bukkit.util.Vector;
 
-import java.awt.*;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -91,32 +73,33 @@ import java.nio.file.Files;
 import java.nio.file.attribute.FileTime;
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
+import java.util.Arrays;
 import java.util.Date;
 import java.util.Objects;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
-import java.util.function.Consumer;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
 
 @Decree(name = "studio", aliases = {"std", "s"}, description = "Studio Commands", studio = true)
 public class CommandStudio implements DecreeExecutor {
+    private CommandFind find;
+    private CommandEdit edit;
+    //private CommandDeepSearch deepSearch;
+
     public static String hrf(Duration duration) {
         return duration.toString().substring(2).replaceAll("(\\d[HMS])(?!$)", "$1 ").toLowerCase();
     }
 
-    private CommandFind find;
-    private CommandEdit edit;
-
-
     @Decree(description = "Download a project.", aliases = "dl")
     public void download(
-        @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
+            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
             String pack,
-        @Param(name = "branch", description = "The branch to download from", defaultValue = "master")
+            @Param(name = "branch", description = "The branch to download from", defaultValue = "master")
             String branch,
-        @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
             boolean trim,
-        @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
+            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
             boolean overwrite
     ) {
         new CommandIris().download(pack, branch, trim, overwrite);
@@ -124,9 +107,9 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Open a new studio world", aliases = "o", sync = true)
     public void open(
-        @Param(defaultValue = "default", description = "The dimension to open a studio for", aliases = "dim")
+            @Param(defaultValue = "default", description = "The dimension to open a studio for", aliases = "dim")
             IrisDimension dimension,
-        @Param(defaultValue = "1337", description = "The seed to generate the studio with", aliases = "s")
+            @Param(defaultValue = "1337", description = "The seed to generate the studio with", aliases = "s")
             long seed) {
         sender().sendMessage(C.GREEN + "Opening studio for the \"" + dimension.getName() + "\" pack (seed: " + seed + ")");
         Iris.service(StudioSVC.class).open(sender(), seed, dimension.getLoadKey());
@@ -134,7 +117,7 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Open VSCode for a dimension", aliases = {"vsc", "edit"})
     public void vscode(
-        @Param(defaultValue = "default", description = "The dimension to open VSCode for", aliases = "dim")
+            @Param(defaultValue = "default", description = "The dimension to open VSCode for", aliases = "dim")
             IrisDimension dimension
     ) {
         sender().sendMessage(C.GREEN + "Opening VSCode for the \"" + dimension.getName() + "\" pack");
@@ -143,7 +126,7 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Close an open studio project", aliases = {"x", "c"}, sync = true)
     public void close() {
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No open studio projects.");
             return;
         }
@@ -154,158 +137,105 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Create a new studio project", aliases = "+", sync = true)
     public void create(
-        @Param(description = "The name of this new Iris Project.")
+            @Param(description = "The name of this new Iris Project.")
             String name,
-        @Param(description = "Copy the contents of an existing project in your packs folder and use it as a template in this new project.", contextual = true)
+            @Param(description = "Copy the contents of an existing project in your packs folder and use it as a template in this new project.", contextual = true)
             IrisDimension template) {
-        if(template != null) {
+        if (template != null) {
             Iris.service(StudioSVC.class).create(sender(), name, template.getLoadKey());
         } else {
             Iris.service(StudioSVC.class).create(sender(), name);
         }
     }
 
-    @Decree(description = "Clean an Iris Project, optionally beautifying JSON & fixing block ids with missing keys. Also rebuilds the vscode schemas. ")
-    public void clean(
-        @Param(description = "The project to update", contextual = true)
-            IrisDimension project,
-
-        @Param(defaultValue = "true", description = "Filters all valid JSON files with a beautifier (indentation: 4)")
-            boolean beautify,
-
-        @Param(name = "fix-ids", defaultValue = "true", description = "Fixes any block ids used such as \"dirt\" will be converted to \"minecraft:dirt\"")
-            boolean fixIds,
-
-        @Param(name = "rewrite-objects", defaultValue = "false", description = "Imports all objects and re-writes them cleaning up positions & block data in the process.")
-            boolean rewriteObjects
-    ) {
-        KList<Job> jobs = new KList<>();
-        KList<File> files = new KList<File>();
-        files(Iris.instance.getDataFolder("packs", project.getLoadKey()), files);
-        MultiBurst burst = MultiBurst.burst;
-
-        jobs.add(new SingleJob("Updating Workspace", () -> {
-            if(!new IrisProject(Iris.service(StudioSVC.class).getWorkspaceFolder(project.getLoadKey())).updateWorkspace()) {
-                sender().sendMessage(C.GOLD + "Invalid project: " + project.getLoadKey() + ". Try deleting the code-workspace file and try again.");
-            }
-            J.sleep(250);
-        }));
-
-        sender().sendMessage("Files: " + files.size());
-
-        if(fixIds) {
-            QueueJob<File> r = new QueueJob<>() {
-                @Override
-                public void execute(File f) {
-                    try {
-                        JSONObject p = new JSONObject(IO.readAll(f));
-                        fixBlocks(p);
-                        J.sleep(1);
-                        IO.writeAll(f, p.toString(4));
-
-                    } catch(IOException e) {
-                        e.printStackTrace();
-                    }
-                }
-
-                @Override
-                public String getName() {
-                    return "Fixing IDs";
-                }
-            };
-
-            r.queue(files);
-            jobs.add(r);
-        }
-
-        if(beautify) {
-            QueueJob<File> r = new QueueJob<>() {
-                @Override
-                public void execute(File f) {
-                    try {
-                        JSONObject p = new JSONObject(IO.readAll(f));
-                        IO.writeAll(f, p.toString(4));
-                        J.sleep(1);
-                    } catch(IOException e) {
-                        e.printStackTrace();
-                    }
-                }
-
-                @Override
-                public String getName() {
-                    return "Beautify";
-                }
-            };
-
-            r.queue(files);
-            jobs.add(r);
-        }
-
-        if(rewriteObjects) {
-            QueueJob<Runnable> q = new QueueJob<>() {
-                @Override
-                public void execute(Runnable runnable) {
-                    runnable.run();
-                    J.sleep(50);
-                }
-
-                @Override
-                public String getName() {
-                    return "Rewriting Objects";
-                }
-            };
-
-            IrisData data = IrisData.get(Iris.service(StudioSVC.class).getWorkspaceFolder(project.getLoadKey()));
-            for(String f : data.getObjectLoader().getPossibleKeys()) {
-                Future<?> gg = burst.complete(() -> {
-                    File ff = data.getObjectLoader().findFile(f);
-                    IrisObject oo = new IrisObject(0, 0, 0);
-                    try {
-                        oo.read(ff);
-                    } catch(Throwable e) {
-                        Iris.error("FAILER TO READ: " + f);
-                        return;
-                    }
-
-                    try {
-                        oo.write(ff);
-                    } catch(IOException e) {
-                        Iris.error("FAILURE TO WRITE: " + oo.getLoadFile());
-                    }
-                });
-
-                q.queue(() -> {
-                    try {
-                        gg.get();
-                    } catch(InterruptedException | ExecutionException e) {
-                        e.printStackTrace();
-                    }
-                });
-            }
-
-            jobs.add(q);
-        }
-
-        new JobCollection("Cleaning", jobs).execute(sender());
-    }
-
     @Decree(description = "Get the version of a pack")
     public void version(
-        @Param(defaultValue = "default", description = "The dimension get the version of", aliases = "dim", contextual = true)
+            @Param(defaultValue = "default", description = "The dimension get the version of", aliases = "dim", contextual = true)
             IrisDimension dimension
     ) {
         sender().sendMessage(C.GREEN + "The \"" + dimension.getName() + "\" pack has version: " + dimension.getVersion());
     }
 
+    @Decree(name = "regen", description = "Regenerate nearby chunks.", aliases = "rg", sync = true, origin = DecreeOrigin.PLAYER)
+    public void regen(
+            @Param(name = "radius", description = "The radius of nearby cunks", defaultValue = "5")
+            int radius
+    ) {
+        if (IrisToolbelt.isIrisWorld(player().getWorld())) {
+            VolmitSender sender = sender();
+            J.a(() -> {
+                DecreeContext.touch(sender);
+                PlatformChunkGenerator plat = IrisToolbelt.access(player().getWorld());
+                Engine engine = plat.getEngine();
+                try {
+                    Chunk cx = player().getLocation().getChunk();
+                    KList<Runnable> js = new KList<>();
+                    BurstExecutor b = MultiBurst.burst.burst();
+                    b.setMulticore(false);
+                    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());
+                        }
+                    }
+
+                    for (int i = -radius; i <= radius; i++) {
+                        for (int j = -radius; j <= radius; j++) {
+                            int finalJ = j;
+                            int finalI = i;
+                            b.queue(() -> plat.injectChunkReplacement(player().getWorld(), finalI + cx.getX(), finalJ + cx.getZ(), (f) -> {
+                                synchronized (js) {
+                                    js.add(f);
+                                }
+                            }));
+                        }
+                    }
+
+                    b.complete();
+                    sender().sendMessage(C.GREEN + "Regenerating " + Form.f(js.size()) + " Sections");
+                    QueueJob<Runnable> r = new QueueJob<>() {
+                        final KList<Future<?>> futures = new KList<>();
+
+                        @Override
+                        public void execute(Runnable runnable) {
+                            futures.add(J.sfut(runnable));
+
+                            if (futures.size() > 64) {
+                                while (futures.isNotEmpty()) {
+                                    try {
+                                        futures.remove(0).get();
+                                    } catch (InterruptedException | ExecutionException e) {
+                                        e.printStackTrace();
+                                    }
+                                }
+                            }
+                        }
+
+                        @Override
+                        public String getName() {
+                            return "Regenerating";
+                        }
+                    };
+                    r.queue(js);
+                    r.execute(sender());
+                } catch (Throwable e) {
+                    sender().sendMessage("Unable to parse view-distance");
+                }
+            });
+        } else {
+            sender().sendMessage(C.RED + "You must be in an Iris World to use regen!");
+        }
+    }
+
     @Decree(description = "Convert objects in the \"convert\" folder")
     public void convert() {
         Iris.service(ConversionSVC.class).check(sender());
+        //IrisConverter.convertSchematics(sender());
     }
 
-
     @Decree(description = "Execute a script", aliases = "run", origin = DecreeOrigin.PLAYER)
     public void execute(
-        @Param(description = "The script to run")
+            @Param(description = "The script to run")
             IrisScript script
     ) {
         engine().getExecution().execute(script.getLoadKey());
@@ -313,14 +243,14 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Open the noise explorer (External GUI)", aliases = {"nmap", "n"})
     public void noise() {
-        if(noGUI()) return;
+        if (noGUI()) return;
         sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
         NoiseExplorerGUI.launch();
     }
 
     @Decree(description = "Charges all spawners in the area", aliases = "zzt", origin = DecreeOrigin.PLAYER)
     public void charge() {
-        if(!IrisToolbelt.isIrisWorld(world())) {
+        if (!IrisToolbelt.isIrisWorld(world())) {
             sender().sendMessage(C.RED + "You must be in an Iris world to charge spawners!");
             return;
         }
@@ -330,17 +260,17 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Preview noise gens (External GUI)", aliases = {"generator", "gen"})
     public void explore(
-        @Param(description = "The generator to explore", contextual = true)
+            @Param(description = "The generator to explore", contextual = true)
             IrisGenerator generator,
-        @Param(description = "The seed to generate with", defaultValue = "12345")
+            @Param(description = "The seed to generate with", defaultValue = "12345")
             long seed
     ) {
-        if(noGUI()) return;
+        if (noGUI()) return;
         sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
 
         Supplier<Function2<Double, Double, Double>> l = () -> {
 
-            if(generator == null) {
+            if (generator == null) {
                 return (x, z) -> 0D;
             }
 
@@ -351,7 +281,7 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Hotload a studio", aliases = {"reload", "h"})
     public void hotload() {
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No studio world open!");
             return;
         }
@@ -361,19 +291,19 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Show loot if a chest were right here", origin = DecreeOrigin.PLAYER, sync = true)
     public void loot(
-        @Param(description = "Fast insertion of items in virtual inventory (may cause performance drop)", defaultValue = "false")
+            @Param(description = "Fast insertion of items in virtual inventory (may cause performance drop)", defaultValue = "false")
             boolean fast,
-        @Param(description = "Whether or not to append to the inventory currently open (if false, clears opened inventory)", defaultValue = "true")
+            @Param(description = "Whether or not to append to the inventory currently open (if false, clears opened inventory)", defaultValue = "true")
             boolean add
     ) {
-        if(noStudio()) return;
+        if (noStudio()) return;
 
         KList<IrisLootTable> tables = engine().getLootTables(RNG.r, player().getLocation().getBlock());
         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);
-        } catch(Throwable e) {
+            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());
             return;
@@ -385,31 +315,98 @@ public class CommandStudio implements DecreeExecutor {
 
         ta.set(Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, () ->
         {
-            if(!player().getOpenInventory().getType().equals(InventoryType.CHEST)) {
+            if (!player().getOpenInventory().getType().equals(InventoryType.CHEST)) {
                 Bukkit.getScheduler().cancelTask(ta.get());
                 sender().sendMessage(C.GREEN + "Opened inventory!");
                 return;
             }
 
-            if(!add) {
+            if (!add) {
                 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!");
         player().openInventory(inv);
     }
 
+
+    @Decree(description = "Get all structures in a radius of chunks", aliases = "dist", origin = DecreeOrigin.PLAYER)
+    public void distances(@Param(description = "The radius in chunks") int radius) {
+        var engine = engine();
+        if (engine == null) {
+            sender().sendMessage(C.RED + "Only works in an Iris world!");
+            return;
+        }
+        var sender = sender();
+        int d = radius * 2;
+        KMap<String, KList<Position2>> data = new KMap<>();
+        var multiBurst = new MultiBurst("Distance Sampler", Thread.MIN_PRIORITY);
+        var executor = multiBurst.burst(radius * radius);
+
+        sender.sendMessage(C.GRAY + "Generating data...");
+        var loc = player().getLocation();
+        int totalTasks = d * d;
+        AtomicInteger completedTasks = new AtomicInteger(0);
+        int c = J.ar(() -> {
+            sender.sendProgress((double) completedTasks.get() / totalTasks, "Finding structures");
+        }, 0);
+
+        new Spiraler(d, d, (x, z) -> executor.queue(() -> {
+            var struct = engine.getStructureAt(x, z);
+            if (struct != null) {
+                data.computeIfAbsent(struct.getLoadKey(), (k) -> new KList<>()).add(new Position2(x, z));
+            }
+            completedTasks.incrementAndGet();
+        })).setOffset(loc.getBlockX(), loc.getBlockZ()).drain();
+
+        executor.complete();
+        multiBurst.close();
+        J.car(c);
+
+        for (var key : data.keySet()) {
+            var list = data.get(key);
+            KList<Long> distances = new KList<>(list.size() - 1);
+            for (int i = 0; i < list.size(); i++) {
+                var pos = list.get(i);
+                double dist = Integer.MAX_VALUE;
+                for (var p : list) {
+                    if (p.equals(pos)) continue;
+                    dist = Math.min(dist, Math.sqrt(Math.pow(pos.getX() - p.getX(), 2) + Math.pow(pos.getZ() - p.getZ(), 2)));
+                }
+                if (dist == Integer.MAX_VALUE) continue;
+                distances.add(Math.round(dist * 16));
+            }
+            long[] array = new long[distances.size()];
+            for (int i = 0; i < distances.size(); i++) {
+                array[i] = distances.get(i);
+            }
+            Arrays.sort(array);
+            long min = array.length > 0 ? array[0] : 0;
+            long max = array.length > 0 ? array[array.length - 1] : 0;
+            long sum = Arrays.stream(array).sum();
+            long avg = array.length > 0 ? Math.round(sum / (double) array.length) : 0;
+            String msg = "%s: %s => min: %s/max: %s -> avg: %s".formatted(key, list.size(), min, max, avg);
+            sender.sendMessage(msg);
+        }
+        if (data.isEmpty()) {
+            sender.sendMessage(C.RED + "No data found!");
+        } else {
+            sender.sendMessage(C.GREEN + "Done!");
+        }
+    }
+
+
     @Decree(description = "Render a world map (External GUI)", aliases = "render")
     public void map(
-        @Param(name = "world", description = "The world to open the generator for", contextual = true)
+            @Param(name = "world", description = "The world to open the generator for", contextual = true)
             World world
     ) {
-        if(noGUI()) return;
+        if (noGUI()) return;
 
-        if(!IrisToolbelt.isIrisWorld(world)) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
             sender().sendMessage(C.RED + "You need to be in or specify an Iris-generated world!");
             return;
         }
@@ -420,11 +417,11 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Package a dimension into a compressed format", aliases = "package")
     public void pkg(
-        @Param(name = "dimension", description = "The dimension pack to compress", contextual = true, defaultValue = "default")
+            @Param(name = "dimension", description = "The dimension pack to compress", contextual = true, defaultValue = "default")
             IrisDimension dimension,
-        @Param(name = "obfuscate", description = "Whether or not to obfuscate the pack", defaultValue = "false")
+            @Param(name = "obfuscate", description = "Whether or not to obfuscate the pack", defaultValue = "false")
             boolean obfuscate,
-        @Param(name = "minify", description = "Whether or not to minify the pack", defaultValue = "true")
+            @Param(name = "minify", description = "Whether or not to minify the pack", defaultValue = "true")
             boolean minify
     ) {
         Iris.service(StudioSVC.class).compilePackage(sender(), dimension.getLoadKey(), obfuscate, minify);
@@ -432,9 +429,10 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Profiles the performance of a dimension", origin = DecreeOrigin.PLAYER)
     public void profile(
-        @Param(description = "The dimension to profile", contextual = true, defaultValue = "default")
+            @Param(description = "The dimension to profile", contextual = true, defaultValue = "default")
             IrisDimension dimension
     ) {
+        // Todo: Make this more accurate
         File pack = dimension.getLoadFile().getParentFile().getParentFile();
         File report = Iris.instance.getDataFile("profile.txt");
         IrisProject project = new IrisProject(pack);
@@ -450,17 +448,17 @@ public class CommandStudio implements DecreeExecutor {
 
         sender().sendMessage("Calculating Performance Metrics for Noise generators");
 
-        for(NoiseStyle i : NoiseStyle.values()) {
+        for (NoiseStyle i : NoiseStyle.values()) {
             CNG c = i.create(new RNG(i.hashCode()));
 
-            for(int j = 0; j < 3000; j++) {
+            for (int j = 0; j < 3000; j++) {
                 c.noise(j, j + 1000, j * j);
                 c.noise(j, -j);
             }
 
             PrecisionStopwatch px = PrecisionStopwatch.start();
 
-            for(int j = 0; j < 100000; j++) {
+            for (int j = 0; j < 100000; j++) {
                 c.noise(j, j + 1000, j * j);
                 c.noise(j, -j);
             }
@@ -470,7 +468,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Noise Style Performance Impacts: ");
 
-        for(NoiseStyle i : styleTimings.sortKNumber()) {
+        for (NoiseStyle i : styleTimings.sortKNumber()) {
             fileText.add(i.name() + ": " + styleTimings.get(i));
         }
 
@@ -478,20 +476,20 @@ public class CommandStudio implements DecreeExecutor {
 
         sender().sendMessage("Calculating Interpolator Timings...");
 
-        for(InterpolationMethod i : InterpolationMethod.values()) {
+        for (InterpolationMethod i : InterpolationMethod.values()) {
             IrisInterpolator in = new IrisInterpolator();
             in.setFunction(i);
             in.setHorizontalScale(8);
 
             NoiseProvider np = (x, z) -> Math.random();
 
-            for(int j = 0; j < 3000; j++) {
+            for (int j = 0; j < 3000; j++) {
                 in.interpolate(j, -j, np);
             }
 
             PrecisionStopwatch px = PrecisionStopwatch.start();
 
-            for(int j = 0; j < 100000; j++) {
+            for (int j = 0; j < 100000; j++) {
                 in.interpolate(j + 10000, -j - 100000, np);
             }
 
@@ -500,7 +498,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Noise Interpolator Performance Impacts: ");
 
-        for(InterpolationMethod i : interpolatorTimings.sortKNumber()) {
+        for (InterpolationMethod i : interpolatorTimings.sortKNumber()) {
             fileText.add(i.name() + ": " + interpolatorTimings.get(i));
         }
 
@@ -510,13 +508,13 @@ public class CommandStudio implements DecreeExecutor {
 
         KMap<String, KList<String>> btx = new KMap<>();
 
-        for(String i : data.getGeneratorLoader().getPossibleKeys()) {
+        for (String i : data.getGeneratorLoader().getPossibleKeys()) {
             KList<String> vv = new KList<>();
             IrisGenerator g = data.getGeneratorLoader().load(i);
             KList<IrisNoiseGenerator> composites = g.getAllComposites();
             double score = 0;
             int m = 0;
-            for(IrisNoiseGenerator j : composites) {
+            for (IrisNoiseGenerator j : composites) {
                 m++;
                 score += styleTimings.get(j.getStyle().getStyle());
                 vv.add("Composite Noise Style " + m + " " + j.getStyle().getStyle().name() + ": " + styleTimings.get(j.getStyle().getStyle()));
@@ -530,7 +528,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Project Generator Performance Impacts: ");
 
-        for(String i : generatorTimings.sortKNumber()) {
+        for (String i : generatorTimings.sortKNumber()) {
             fileText.add(i + ": " + generatorTimings.get(i));
 
             btx.get(i).forEach((ii) -> fileText.add("  " + ii));
@@ -540,13 +538,13 @@ public class CommandStudio implements DecreeExecutor {
 
         KMap<String, KList<String>> bt = new KMap<>();
 
-        for(String i : data.getBiomeLoader().getPossibleKeys()) {
+        for (String i : data.getBiomeLoader().getPossibleKeys()) {
             KList<String> vv = new KList<>();
             IrisBiome b = data.getBiomeLoader().load(i);
             double score = 0;
 
             int m = 0;
-            for(IrisBiomePaletteLayer j : b.getLayers()) {
+            for (IrisBiomePaletteLayer j : b.getLayers()) {
                 m++;
                 score += styleTimings.get(j.getStyle().getStyle());
                 vv.add("Palette Layer " + m + ": " + styleTimings.get(j.getStyle().getStyle()));
@@ -562,7 +560,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Project Biome Performance Impacts: ");
 
-        for(String i : biomeTimings.sortKNumber()) {
+        for (String i : biomeTimings.sortKNumber()) {
             fileText.add(i + ": " + biomeTimings.get(i));
 
             bt.get(i).forEach((ff) -> fileText.add("  " + ff));
@@ -570,7 +568,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("");
 
-        for(String i : data.getRegionLoader().getPossibleKeys()) {
+        for (String i : data.getRegionLoader().getPossibleKeys()) {
             IrisRegion b = data.getRegionLoader().load(i);
             double score = 0;
 
@@ -581,25 +579,25 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Project Region Performance Impacts: ");
 
-        for(String i : regionTimings.sortKNumber()) {
+        for (String i : regionTimings.sortKNumber()) {
             fileText.add(i + ": " + regionTimings.get(i));
         }
 
         fileText.add("");
 
         double m = 0;
-        for(double i : biomeTimings.v()) {
+        for (double i : biomeTimings.v()) {
             m += i;
         }
         m /= biomeTimings.size();
         double mm = 0;
-        for(double i : generatorTimings.v()) {
+        for (double i : generatorTimings.v()) {
             mm += i;
         }
         mm /= generatorTimings.size();
         m += mm;
         double mmm = 0;
-        for(double i : regionTimings.v()) {
+        for (double i : regionTimings.v()) {
             mmm += i;
         }
         mmm /= regionTimings.size();
@@ -610,7 +608,7 @@ public class CommandStudio implements DecreeExecutor {
 
         try {
             IO.writeAll(report, fileText.toString("\n"));
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -618,30 +616,27 @@ public class CommandStudio implements DecreeExecutor {
         sender().sendMessage(C.GREEN + "Done! " + report.getPath());
     }
 
-    @Decree(description = "Summon an Iris Entity", origin = DecreeOrigin.PLAYER)
-    public void summon(
-        @Param(description = "The Iris Entity to spawn")
+    @Decree(description = "Spawn an Iris entity", aliases = "summon", origin = DecreeOrigin.PLAYER)
+    public void spawn(
+            @Param(description = "The entity to spawn")
             IrisEntity entity,
-        @Param(description = "The location at which to spawn the entity", defaultValue = "self")
+            @Param(description = "The location to spawn the entity at", contextual = true)
             Vector location
     ) {
-        if(!sender().isPlayer()) {
-            sender().sendMessage(C.RED + "Players only (this is a config error. Ask support to add DecreeOrigin.PLAYER to the command you tried to run)");
-            return;
+        if (!IrisToolbelt.isIrisWorld(player().getWorld())) {
+            sender().sendMessage(C.RED + "You have to be in an Iris world to spawn entities properly. Trying to spawn the best we can do.");
         }
-
-        sender().sendMessage(C.GREEN + "Spawning entity");
         entity.spawn(engine(), new Location(world(), location.getX(), location.getY(), location.getZ()));
     }
 
     @Decree(description = "Teleport to the active studio world", aliases = "stp", origin = DecreeOrigin.PLAYER, sync = true)
     public void tpstudio() {
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No studio world is open!");
             return;
         }
 
-        if(IrisToolbelt.isIrisWorld(world()) && engine().isStudio()) {
+        if (IrisToolbelt.isIrisWorld(world()) && engine().isStudio()) {
             sender().sendMessage(C.RED + "You are already in a studio world!");
             return;
         }
@@ -653,11 +648,11 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Update your dimension projects VSCode workspace")
     public void update(
-        @Param(description = "The dimension to update the workspace of", contextual = true, defaultValue = "default")
+            @Param(description = "The dimension to update the workspace of", contextual = true, defaultValue = "default")
             IrisDimension dimension
     ) {
         sender().sendMessage(C.GOLD + "Updating Code Workspace for " + dimension.getName() + "...");
-        if(new IrisProject(dimension.getLoader().getDataFolder()).updateWorkspace()) {
+        if (new IrisProject(dimension.getLoader().getDataFolder()).updateWorkspace()) {
             sender().sendMessage(C.GREEN + "Updated Code Workspace for " + dimension.getName());
         } else {
             sender().sendMessage(C.RED + "Invalid project: " + dimension.getName() + ". Try deleting the code-workspace file and try again.");
@@ -666,14 +661,14 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(aliases = "find-objects", description = "Get information about nearby structures")
     public void objects() {
-        if(!IrisToolbelt.isIrisWorld(player().getWorld())) {
+        if (!IrisToolbelt.isIrisWorld(player().getWorld())) {
             sender().sendMessage(C.RED + "You must be in an Iris world");
             return;
         }
 
         World world = player().getWorld();
 
-        if(!IrisToolbelt.isIrisWorld(world)) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
             sender().sendMessage("You must be in an iris world.");
             return;
         }
@@ -687,7 +682,7 @@ public class CommandStudio implements DecreeExecutor {
             int cx = l.getChunk().getX();
             int cz = l.getChunk().getZ();
             new Spiraler(3, 3, (x, z) -> chunks.addIfMissing(world.getChunkAt(x + cx, z + cz))).drain();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
         }
 
@@ -705,7 +700,7 @@ public class CommandStudio implements DecreeExecutor {
             pw.println("Report Captured At: " + new Date());
             pw.println("Chunks: (" + chunks.size() + "): ");
 
-            for(Chunk i : chunks) {
+            for (Chunk i : chunks) {
                 pw.println("- [" + i.getX() + ", " + i.getZ() + "]");
             }
 
@@ -714,19 +709,19 @@ public class CommandStudio implements DecreeExecutor {
             String age = "No idea...";
 
             try {
-                for(File i : Objects.requireNonNull(new File(world.getWorldFolder(), "region").listFiles())) {
-                    if(i.isFile()) {
+                for (File i : Objects.requireNonNull(new File(world.getWorldFolder(), "region").listFiles())) {
+                    if (i.isFile()) {
                         size += i.length();
                     }
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
 
             try {
                 FileTime creationTime = (FileTime) Files.getAttribute(world.getWorldFolder().toPath(), "creationTime");
                 age = hrf(Duration.of(M.ms() - creationTime.toMillis(), ChronoUnit.MILLIS));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
             }
 
@@ -734,10 +729,10 @@ public class CommandStudio implements DecreeExecutor {
             KList<String> caveBiomes = new KList<>();
             KMap<String, KMap<String, KList<String>>> objects = new KMap<>();
 
-            for(Chunk i : chunks) {
-                for(int j = 0; j < 16; j += 3) {
+            for (Chunk i : chunks) {
+                for (int j = 0; j < 16; j += 3) {
 
-                    for(int k = 0; k < 16; k += 3) {
+                    for (int k = 0; k < 16; k += 3) {
 
                         assert engine() != null;
                         IrisBiome bb = engine().getSurfaceBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
@@ -764,20 +759,20 @@ public class CommandStudio implements DecreeExecutor {
             pw.println("== Biome Info ==");
             pw.println("Found " + biomes.size() + " Biome(s): ");
 
-            for(String i : biomes) {
+            for (String i : biomes) {
                 pw.println("- " + i);
             }
             pw.println();
 
             pw.println("== Object Info ==");
 
-            for(String i : objects.k()) {
+            for (String i : objects.k()) {
                 pw.println("- " + i);
 
-                for(String j : objects.get(i).k()) {
+                for (String j : objects.get(i).k()) {
                     pw.println("  @ " + j);
 
-                    for(String k : objects.get(i).get(j)) {
+                    for (String k : objects.get(i).get(j)) {
                         pw.println("    * " + k);
                     }
                 }
@@ -787,7 +782,7 @@ public class CommandStudio implements DecreeExecutor {
             pw.close();
 
             sender().sendMessage("Reported to: " + ff.getPath());
-        } catch(FileNotFoundException e) {
+        } catch (FileNotFoundException e) {
             e.printStackTrace();
             Iris.reportError(e);
         }
@@ -797,15 +792,15 @@ public class CommandStudio implements DecreeExecutor {
         String n1 = bb.getName() + " [" + Form.capitalize(bb.getInferredType().name().toLowerCase()) + "] " + " (" + bb.getLoadFile().getName() + ")";
         int m = 0;
         KSet<String> stop = new KSet<>();
-        for(IrisObjectPlacement f : bb.getObjects()) {
+        for (IrisObjectPlacement f : bb.getObjects()) {
             m++;
             String n2 = "Placement #" + m + " (" + f.getPlace().size() + " possible objects)";
 
-            for(String i : f.getPlace()) {
+            for (String i : f.getPlace()) {
                 String nn3 = i + ": [ERROR] Failed to find object!";
 
                 try {
-                    if(stop.contains(i)) {
+                    if (stop.contains(i)) {
                         continue;
                     }
 
@@ -813,13 +808,13 @@ public class CommandStudio implements DecreeExecutor {
                     BlockVector sz = IrisObject.sampleSize(ff);
                     nn3 = i + ": size=[" + sz.getBlockX() + "," + sz.getBlockY() + "," + sz.getBlockZ() + "] location=[" + ff.getPath() + "]";
                     stop.add(i);
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     Iris.reportError(e);
                 }
 
                 String n3 = nn3;
                 objects.computeIfAbsent(n1, (k1) -> new KMap<>())
-                    .computeIfAbsent(n2, (k) -> new KList<>()).addIfMissing(n3);
+                        .computeIfAbsent(n2, (k) -> new KList<>()).addIfMissing(n3);
             }
         }
     }
@@ -828,7 +823,7 @@ public class CommandStudio implements DecreeExecutor {
      * @return true if server GUIs are not enabled
      */
     private boolean noGUI() {
-        if(!IrisSettings.get().getGui().isUseServerLaunchedGuis()) {
+        if (!IrisSettings.get().getGui().isUseServerLaunchedGuis()) {
             sender().sendMessage(C.RED + "You must have server launched GUIs enabled in the settings!");
             return true;
         }
@@ -839,15 +834,15 @@ public class CommandStudio implements DecreeExecutor {
      * @return true if no studio is open or the player is not in one
      */
     private boolean noStudio() {
-        if(!sender().isPlayer()) {
+        if (!sender().isPlayer()) {
             sender().sendMessage(C.RED + "Players only!");
             return true;
         }
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No studio world is open!");
             return true;
         }
-        if(!engine().isStudio()) {
+        if (!engine().isStudio()) {
             sender().sendMessage(C.RED + "You must be in a studio world!");
             return true;
         }
@@ -856,14 +851,14 @@ public class CommandStudio implements DecreeExecutor {
 
 
     public void files(File clean, KList<File> files) {
-        if(clean.isDirectory()) {
-            for(File i : clean.listFiles()) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
                 files(i, files);
             }
-        } else if(clean.getName().endsWith(".json")) {
+        } else if (clean.getName().endsWith(".json")) {
             try {
                 files.add(clean);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
                 Iris.error("Failed to beautify " + clean.getAbsolutePath() + " You may have errors in your json!");
             }
@@ -871,28 +866,28 @@ public class CommandStudio implements DecreeExecutor {
     }
 
     private void fixBlocks(JSONObject obj) {
-        for(String i : obj.keySet()) {
+        for (String i : obj.keySet()) {
             Object o = obj.get(i);
 
-            if(i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
+            if (i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
                 obj.put(i, "minecraft:" + o);
             }
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o);
             }
         }
     }
 
     private void fixBlocks(JSONArray obj) {
-        for(int i = 0; i < obj.length(); i++) {
+        for (int i = 0; i < obj.length(); i++) {
             Object o = obj.get(i);
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o);
             }
         }

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

@@ -0,0 +1,82 @@
+/*
+ * 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/CommandTurboPregen.java

@@ -0,0 +1,131 @@
+/*
+ * 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.LazyPregenerator;
+import com.volmit.iris.core.pregenerator.TurboPregenerator;
+import com.volmit.iris.core.pregenerator.TurboPregenerator;
+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 org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.IOException;
+
+@Decree(name = "turbopregen", aliases = "turbo", description = "Pregenerate your Iris worlds!")
+public class CommandTurboPregen implements DecreeExecutor {
+    public String worldName;
+    @Decree(description = "Pregenerate 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, "turbogen.json");
+        if (TurboFile.exists()) {
+            if (TurboPregenerator.getInstance() != null) {
+                sender().sendMessage(C.BLUE + "Turbo pregen is already in progress");
+                Iris.info(C.YELLOW + "Turbo pregen is already in progress");
+                return;
+            } else {
+                try {
+                    TurboFile.delete();
+                } catch (Exception e){
+                   Iris.error("Failed to delete the old instance file of Turbo Pregen!");
+                   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.");
+            }
+
+            TurboPregenerator.TurboPregenJob pregenJob = TurboPregenerator.TurboPregenJob.builder()
+                    .world(worldName)
+                    .radiusBlocks(radius)
+                    .position(0)
+                    .build();
+
+            File TurboGenFile = new File(worldDirectory, "turbogen.json");
+            TurboPregenerator pregenerator = new TurboPregenerator(pregenJob, TurboGenFile);
+            pregenerator.start();
+
+            String msg = C.GREEN + "TurboPregen 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 pregeneration task", aliases = "x")
+    public void stop(@Param(aliases = "world", description = "The world to pause") World world) throws IOException {
+        TurboPregenerator turboPregenInstance = TurboPregenerator.getInstance();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File turboFile = new File(worldDirectory, "turbogen.json");
+
+        if (turboPregenInstance != null) {
+            turboPregenInstance.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, "turbogen.json");
+            if (TurboFile.exists()){
+                TurboPregenerator.loadTurboGenerator(world.getName());
+                sender().sendMessage(C.YELLOW + "Started Turbo Pregen back up!");
+            } else {
+                sender().sendMessage(C.YELLOW + "No active Turbo Pregen tasks to pause/unpause.");
+            }
+
+        }
+    }
+}

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

@@ -0,0 +1,96 @@
+/*
+ * 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 org.bukkit.World;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.ChunkUpdater;
+import com.volmit.iris.core.tools.IrisToolbelt;
+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;
+
+@Decree(name = "updater", origin = DecreeOrigin.BOTH, description = "Iris World Updater")
+public class CommandUpdater implements DecreeExecutor {
+    private ChunkUpdater chunkUpdater;
+
+    @Decree(description = "Updates all chunk in the specified world")
+    public void start(
+            @Param(description = "World to update chunks at", contextual = true)
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            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()));
+        } else {
+            Iris.info(C.GREEN + "Updating " + world.getName() + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
+        }
+        chunkUpdater.start();
+    }
+
+    @Decree(description = "Pause the updater")
+    public void pause( ) {
+        if (chunkUpdater == null) {
+            sender().sendMessage(C.GOLD + "You cant pause something that doesnt exist?");
+            return;
+        }
+        boolean status = chunkUpdater.pause();
+        if (sender().isPlayer()) {
+            if (status) {
+                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
+            } else {
+                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
+            }
+        } else {
+            if (status) {
+                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
+            } else {
+                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
+            }
+        }
+    }
+
+    @Decree(description = "Stops the updater")
+    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 + chunkUpdater.getName());
+        } else {
+            Iris.info("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
+        }
+        chunkUpdater.stop();
+    }
+}
+
+

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

@@ -22,7 +22,9 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.edit.BlockSignal;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisRegion;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
@@ -37,6 +39,7 @@ import org.bukkit.Material;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
 
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 
 @Decree(name = "what", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris What?")
@@ -45,16 +48,16 @@ public class CommandWhat implements DecreeExecutor {
     public void hand() {
         try {
             BlockData bd = player().getInventory().getItemInMainHand().getType().createBlockData();
-            if(!bd.getMaterial().equals(Material.AIR)) {
+            if (!bd.getMaterial().equals(Material.AIR)) {
                 sender().sendMessage("Material: " + C.GREEN + bd.getMaterial().name());
                 sender().sendMessage("Full: " + C.WHITE + bd.getAsString(true));
             } else {
                 sender().sendMessage("Please hold a block/item");
             }
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Material bd = player().getInventory().getItemInMainHand().getType();
-            if(!bd.equals(Material.AIR)) {
+            if (!bd.equals(Material.AIR)) {
                 sender().sendMessage("Material: " + C.GREEN + bd.name());
             } else {
                 sender().sendMessage("Please hold a block/item");
@@ -65,63 +68,76 @@ public class CommandWhat implements DecreeExecutor {
     @Decree(description = "What biome am i in?", origin = DecreeOrigin.PLAYER)
     public void biome() {
         try {
-            IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ());
+            IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY() - player().getWorld().getMinHeight(), player().getLocation().getBlockZ());
             sender().sendMessage("IBiome: " + b.getLoadKey() + " (" + b.getDerivative().name() + ")");
 
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage("Non-Iris Biome: " + player().getLocation().getBlock().getBiome().name());
 
-            if(player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
+            if (player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
                 try {
                     sender().sendMessage("Data Pack Biome: " + INMS.get().getTrueBiomeBaseKey(player().getLocation()) + " (ID: " + INMS.get().getTrueBiomeBaseId(INMS.get().getTrueBiomeBase(player().getLocation())) + ")");
-                } catch(Throwable ee) {
+                } catch (Throwable ee) {
                     Iris.reportError(ee);
                 }
             }
         }
     }
 
+    @Decree(description = "What region am i in?", origin = DecreeOrigin.PLAYER)
+    public void region() {
+        try {
+            Chunk chunk = world().getChunkAt(player().getLocation().getBlockZ() / 16, player().getLocation().getBlockZ() /  16);
+            IrisRegion r = engine().getRegion(chunk);
+            sender().sendMessage("IRegion: " + r.getLoadKey() + " (" + r.getName() + ")");
+
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.IRIS + "Iris worlds only.");
+        }
+    }
+
     @Decree(description = "What block am i looking at?", origin = DecreeOrigin.PLAYER)
     public void block() {
         BlockData bd;
         try {
             bd = player().getTargetBlockExact(128, FluidCollisionMode.NEVER).getBlockData();
-        } catch(NullPointerException e) {
+        } catch (NullPointerException e) {
             Iris.reportError(e);
             sender().sendMessage("Please look at any block, not at the sky");
             bd = null;
         }
 
-        if(bd != null) {
+        if (bd != null) {
             sender().sendMessage("Material: " + C.GREEN + bd.getMaterial().name());
             sender().sendMessage("Full: " + C.WHITE + bd.getAsString(true));
 
-            if(B.isStorage(bd)) {
+            if (B.isStorage(bd)) {
                 sender().sendMessage(C.YELLOW + "* Storage Block (Loot Capable)");
             }
 
-            if(B.isLit(bd)) {
+            if (B.isLit(bd)) {
                 sender().sendMessage(C.YELLOW + "* Lit Block (Light Capable)");
             }
 
-            if(B.isFoliage(bd)) {
+            if (B.isFoliage(bd)) {
                 sender().sendMessage(C.YELLOW + "* Foliage Block");
             }
 
-            if(B.isDecorant(bd)) {
+            if (B.isDecorant(bd)) {
                 sender().sendMessage(C.YELLOW + "* Decorant Block");
             }
 
-            if(B.isFluid(bd)) {
+            if (B.isFluid(bd)) {
                 sender().sendMessage(C.YELLOW + "* Fluid Block");
             }
 
-            if(B.isFoliagePlantable(bd)) {
+            if (B.isFoliagePlantable(bd)) {
                 sender().sendMessage(C.YELLOW + "* Plantable Foliage Block");
             }
 
-            if(B.isSolid(bd)) {
+            if (B.isSolid(bd)) {
                 sender().sendMessage(C.YELLOW + "* Solid Block");
             }
         }
@@ -131,23 +147,23 @@ public class CommandWhat implements DecreeExecutor {
     public void markers(@Param(description = "Marker name such as cave_floor or cave_ceiling") String marker) {
         Chunk c = player().getLocation().getChunk();
 
-        if(IrisToolbelt.isIrisWorld(c.getWorld())) {
+        if (IrisToolbelt.isIrisWorld(c.getWorld())) {
             int m = 1;
             AtomicInteger v = new AtomicInteger(0);
 
-            for(int xxx = c.getX() - 4; xxx <= c.getX() + 4; xxx++) {
-                for(int zzz = c.getZ() - 4; zzz <= c.getZ() + 4; zzz++) {
+            for (int xxx = c.getX() - 4; xxx <= c.getX() + 4; xxx++) {
+                for (int zzz = c.getZ() - 4; zzz <= c.getZ() + 4; zzz++) {
                     IrisToolbelt.access(c.getWorld()).getEngine().getMantle().findMarkers(xxx, zzz, new MatterMarker(marker))
-                        .convert((i) -> i.toLocation(c.getWorld())).forEach((i) -> {
-                            J.s(() -> BlockSignal.of(i.getBlock(), 100));
-                            v.incrementAndGet();
-                        });
+                            .convert((i) -> i.toLocation(c.getWorld())).forEach((i) -> {
+                                J.s(() -> BlockSignal.of(i.getBlock(), 100));
+                                v.incrementAndGet();
+                            });
                 }
             }
 
             sender().sendMessage("Found " + v.get() + " Nearby Markers (" + marker + ")");
         } else {
-            sender().sendMessage("Iris worlds only.");
+            sender().sendMessage(C.IRIS + "Iris worlds only.");
         }
     }
 }

core/src/main/java/com/volmit/iris/core/edit/BlockSignal.java

@@ -51,7 +51,7 @@ public class BlockSignal {
             active.decrementAndGet();
             BlockData type = block.getBlockData();
             MultiBurst.burst.lazy(() -> {
-                for(Player i : block.getWorld().getPlayers()) {
+                for (Player i : block.getWorld().getPlayers()) {
                     i.sendBlockChange(block.getLocation(), block.getBlockData());
                 }
             });
@@ -82,7 +82,7 @@ public class BlockSignal {
         new SR(20) {
             @Override
             public void run() {
-                if(e.isDead()) {
+                if (e.isDead()) {
                     cancel();
                     return;
                 }
@@ -98,7 +98,7 @@ public class BlockSignal {
             BlockData type = block.getBlockData();
 
             MultiBurst.burst.lazy(() -> {
-                for(Player i : block.getWorld().getPlayers()) {
+                for (Player i : block.getWorld().getPlayers()) {
                     i.sendBlockChange(block.getLocation(), block.getBlockData());
                 }
             });

core/src/main/java/com/volmit/iris/core/edit/DustRevealer.java

@@ -50,11 +50,11 @@ public class DustRevealer {
 
         J.s(() -> {
             new BlockSignal(world.getBlockAt(block.getX(), block.getY(), block.getZ()), 10);
-            if(M.r(0.25)) {
+            if (M.r(0.25)) {
                 world.playSound(block.toBlock(world).getLocation(), Sound.BLOCK_AMETHYST_BLOCK_CHIME, 1f, RNG.r.f(0.2f, 2f));
             }
             J.a(() -> {
-                while(BlockSignal.active.get() > 128) {
+                while (BlockSignal.active.get() > 128) {
                     J.sleep(5);
                 }
 
@@ -85,7 +85,7 @@ public class DustRevealer {
                     is(new BlockPosition(block.getX() + 1, block.getY() + 1, block.getZ() + 1));
                     is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ() - 1));
                     is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ() + 1));
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     Iris.reportError(e);
                     e.printStackTrace();
                 }
@@ -97,9 +97,9 @@ public class DustRevealer {
         World world = block.getWorld();
         Engine access = IrisToolbelt.access(world).getEngine();
 
-        if(access != null) {
+        if (access != null) {
             String a = access.getObjectPlacementKey(block.getX(), block.getY() - block.getWorld().getMinHeight(), block.getZ());
-            if(a != null) {
+            if (a != null) {
                 world.playSound(block.getLocation(), Sound.ITEM_LODESTONE_COMPASS_LOCK, 1f, 0.1f);
 
                 sender.sendMessage("Found object " + a);
@@ -112,7 +112,7 @@ public class DustRevealer {
 
     private boolean is(BlockPosition a) {
         int betterY = a.getY() - world.getMinHeight();
-        if(isValidTry(a) && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()) != null && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()).equals(key)) {
+        if (isValidTry(a) && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()) != null && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()).equals(key)) {
             hits.add(a);
             new DustRevealer(engine, world, a, key, hits);
             return true;

core/src/main/java/com/volmit/iris/core/edit/JigsawEditor.java

@@ -19,14 +19,9 @@
 package com.volmit.iris.core.edit;
 
 import com.google.gson.Gson;
-import com.google.gson.JsonObject;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.service.WandSVC;
-import com.volmit.iris.engine.object.IrisDirection;
-import com.volmit.iris.engine.object.IrisJigsawPiece;
-import com.volmit.iris.engine.object.IrisJigsawPieceConnector;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisPosition;
+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.data.Cuboid;
@@ -66,13 +61,12 @@ public class JigsawEditor implements Listener {
     private Location target;
 
     public JigsawEditor(Player player, IrisJigsawPiece piece, IrisObject object, File saveLocation) {
-        if(editors.containsKey(player)) {
+        if (editors.containsKey(player)) {
             editors.get(player).close();
         }
 
         editors.put(player, this);
-        if(object == null)
-        {
+        if (object == null) {
             throw new RuntimeException("Object is null! " + piece.getObject());
         }
         this.object = object;
@@ -90,20 +84,20 @@ public class JigsawEditor implements Listener {
 
     @EventHandler
     public void on(PlayerMoveEvent e) {
-        if(e.getPlayer().equals(player)) {
+        if (e.getPlayer().equals(player)) {
             try {
                 target = player.getTargetBlockExact(7).getLocation();
-            } catch(Throwable ex) {
+            } catch (Throwable ex) {
                 Iris.reportError(ex);
                 target = player.getLocation();
                 return;
             }
 
-            if(cuboid.contains(target)) {
-                for(IrisPosition i : falling.k()) {
+            if (cuboid.contains(target)) {
+                for (IrisPosition i : falling.k()) {
                     Location at = toLocation(i);
 
-                    if(at.equals(target)) {
+                    if (at.equals(target)) {
                         falling.remove(i).run();
                     }
                 }
@@ -113,43 +107,43 @@ public class JigsawEditor implements Listener {
 
     public Location toLocation(IrisPosition i) {
         return origin.clone()
-            .add(new Vector(i.getX(), i.getY(), i.getZ()))
-            .add(object.getCenter())
-            .getBlock()
-            .getLocation();
+                .add(new Vector(i.getX(), i.getY(), i.getZ()))
+                .add(object.getCenter())
+                .getBlock()
+                .getLocation();
     }
 
     public IrisPosition toPosition(Location l) {
         return new IrisPosition(l.clone().getBlock().getLocation()
-            .subtract(origin.clone())
-            .subtract(object.getCenter())
-            .add(1, 1, 1)
-            .toVector());
+                .subtract(origin.clone())
+                .subtract(object.getCenter())
+                .add(1, 1, 1)
+                .toVector());
     }
 
     @EventHandler
     public void on(PlayerInteractEvent e) {
-        if(e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
-            if(e.getClickedBlock() != null && cuboid.contains(e.getClickedBlock().getLocation()) && e.getPlayer().equals(player)) {
+        if (e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
+            if (e.getClickedBlock() != null && cuboid.contains(e.getClickedBlock().getLocation()) && e.getPlayer().equals(player)) {
                 IrisPosition pos = toPosition(e.getClickedBlock().getLocation());
                 IrisJigsawPieceConnector connector = null;
-                for(IrisJigsawPieceConnector i : piece.getConnectors()) {
-                    if(i.getPosition().equals(pos)) {
+                for (IrisJigsawPieceConnector i : piece.getConnectors()) {
+                    if (i.getPosition().equals(pos)) {
                         connector = i;
                         break;
                     }
                 }
 
-                if(!player.isSneaking() && connector == null) {
+                if (!player.isSneaking() && connector == null) {
                     connector = new IrisJigsawPieceConnector();
                     connector.setDirection(IrisDirection.getDirection(e.getBlockFace()));
                     connector.setPosition(pos);
                     piece.getConnectors().add(connector);
                     player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_ADD_ITEM, 1f, 1f);
-                } else if(player.isSneaking() && connector != null) {
+                } else if (player.isSneaking() && connector != null) {
                     piece.getConnectors().remove(connector);
                     player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_REMOVE_ITEM, 1f, 1f);
-                } else if(connector != null && !player.isSneaking()) {
+                } else if (connector != null && !player.isSneaking()) {
                     connector.setDirection(IrisDirection.getDirection(e.getBlockFace()));
                     player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 1f);
                 }
@@ -157,10 +151,8 @@ public class JigsawEditor implements Listener {
         }
     }
 
-    private void removeKey(JSONObject o, String... path)
-    {
-        if(path.length == 1)
-        {
+    private void removeKey(JSONObject o, String... path) {
+        if (path.length == 1) {
             o.remove(path[0]);
             return;
         }
@@ -170,13 +162,11 @@ public class JigsawEditor implements Listener {
         removeKey(o.getJSONObject(path[0]), s.toArray(new String[0]));
     }
 
-    private List<JSONObject> getObjectsInArray(JSONObject a, String key)
-    {
+    private List<JSONObject> getObjectsInArray(JSONObject a) { // This gets all the objects in an array that are connectors
         KList<JSONObject> o = new KList<>();
 
-        for(int i = 0; i < a.getJSONArray(key).length(); i++)
-        {
-            o.add(a.getJSONArray(key).getJSONObject(i));
+        for (int i = 0; i < a.getJSONArray("connectors").length(); i++) {
+            o.add(a.getJSONArray("connectors").getJSONObject(i));
         }
 
         return o;
@@ -192,16 +182,15 @@ public class JigsawEditor implements Listener {
 
             // remove root key
             removeKey(j, "placementOptions"); // should work
-           j.remove("placementOptions"); // otherwise
+            j.remove("placementOptions"); // otherwise
 
-           // Remove key in all objects in array
-           for(JSONObject i : getObjectsInArray(j, "connectors"))
-           {
-               removeKey(i, "rotateConnector");
-           }
+            // Remove key in all objects in array
+            for (JSONObject i : getObjectsInArray(j)) {
+                removeKey(i, "rotateConnector");
+            }
 
             IO.writeAll(targetSaveLocation, j.toString(4));
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -215,20 +204,20 @@ public class JigsawEditor implements Listener {
                 object.unplaceCenterY(origin);
                 falling.v().forEach(Runnable::run);
             }).get();
-        } catch(InterruptedException | ExecutionException e) {
+        } catch (InterruptedException | ExecutionException e) {
             e.printStackTrace();
         }
         editors.remove(player);
     }
 
     public void onTick() {
-        if(cl.flip()) {
+        if (cl.flip()) {
             Iris.service(WandSVC.class).draw(cuboid, player);
 
             f:
-            for(IrisPosition i : falling.k()) {
-                for(IrisJigsawPieceConnector j : piece.getConnectors()) {
-                    if(j.getPosition().equals(i)) {
+            for (IrisPosition i : falling.k()) {
+                for (IrisJigsawPieceConnector j : piece.getConnectors()) {
+                    if (j.getPosition().equals(i)) {
                         continue f;
                     }
                 }
@@ -236,23 +225,23 @@ public class JigsawEditor implements Listener {
                 falling.remove(i).run();
             }
 
-            for(IrisJigsawPieceConnector i : piece.getConnectors()) {
+            for (IrisJigsawPieceConnector i : piece.getConnectors()) {
                 IrisPosition pos = i.getPosition();
                 Location at = toLocation(pos);
 
                 Vector dir = i.getDirection().toVector().clone();
 
 
-                for(int ix = 0; ix < RNG.r.i(1, 3); ix++) {
+                for (int ix = 0; ix < RNG.r.i(1, 3); ix++) {
                     at.getWorld().spawnParticle(Particle.SOUL_FIRE_FLAME, at.clone().getBlock().getLocation().add(0.25, 0.25, 0.25).add(RNG.r.d(0.5), RNG.r.d(0.5), RNG.r.d(0.5)), 0, dir.getX(), dir.getY(), dir.getZ(), 0.092 + RNG.r.d(-0.03, 0.08));
                 }
 
-                if(at.getBlock().getLocation().equals(target)) {
+                if (at.getBlock().getLocation().equals(target)) {
                     continue;
                 }
 
-                if(!falling.containsKey(pos)) {
-                    if(at.getBlock().getType().isAir()) {
+                if (!falling.containsKey(pos)) {
+                    if (at.getBlock().getType().isAir()) {
                         at.getBlock().setType(Material.STONE);
                     }
 

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

@@ -19,6 +19,7 @@
 package com.volmit.iris.core.gui;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.events.IrisEngineHotloadEvent;
 import com.volmit.iris.engine.object.NoiseStyle;
 import com.volmit.iris.util.collection.KList;
@@ -35,24 +36,9 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 
 import javax.imageio.ImageIO;
-import javax.swing.JComboBox;
-import javax.swing.JComponent;
-import javax.swing.JFrame;
-import javax.swing.JLayeredPane;
-import javax.swing.JPanel;
-import javax.swing.JViewport;
-import java.awt.Color;
-import java.awt.Dimension;
-import java.awt.EventQueue;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.Rectangle;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseMotionListener;
-import java.awt.event.MouseWheelEvent;
-import java.awt.event.MouseWheelListener;
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
@@ -76,7 +62,7 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
     @SuppressWarnings("CanBeFinal")
     RollingSequence r = new RollingSequence(20);
     @SuppressWarnings("CanBeFinal")
-    boolean colorMode = true;
+    boolean colorMode = IrisSettings.get().getGui().colorMode;
     double scale = 1;
     CNG cng = NoiseStyle.STATIC.create(new RNG(RNG.r.nextLong()));
     @SuppressWarnings("CanBeFinal")
@@ -133,10 +119,10 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         frame.add(pane);
         File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
 
-        if(file != null) {
+        if (file != null) {
             try {
                 frame.setIconImage(ImageIO.read(file));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
             }
         }
@@ -148,7 +134,7 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         JFrame frame = new JFrame("Noise Explorer");
         NoiseExplorerGUI nv = new NoiseExplorerGUI();
         frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
-        KList<String> li = new KList<>(NoiseStyle.values()).toStringList();
+        KList<String> li = new KList<>(NoiseStyle.values()).toStringList().sort();
         combo = new JComboBox<>(li.toArray(new String[0]));
         combo.setSelectedItem("STATIC");
         combo.setFocusable(false);
@@ -167,10 +153,10 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         frame.add(pane);
         File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
 
-        if(file != null) {
+        if (file != null) {
             try {
                 frame.setIconImage(ImageIO.read(file));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
             }
         }
@@ -194,14 +180,14 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
 
     @EventHandler
     public void on(IrisEngineHotloadEvent e) {
-        if(generator != null)
+        if (generator != null)
             generator = loader.get();
     }
 
     public void mouseWheelMoved(MouseWheelEvent e) {
 
         int notches = e.getWheelRotation();
-        if(e.isControlDown()) {
+        if (e.isControlDown()) {
             t = t + ((0.0025 * t) * notches);
             return;
         }
@@ -212,51 +198,51 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
 
     @Override
     public void paint(Graphics g) {
-        if(scale < ascale) {
+        if (scale < ascale) {
             ascale -= Math.abs(scale - ascale) * 0.16;
         }
 
-        if(scale > ascale) {
+        if (scale > ascale) {
             ascale += Math.abs(ascale - scale) * 0.16;
         }
 
-        if(t < tz) {
+        if (t < tz) {
             tz -= Math.abs(t - tz) * 0.29;
         }
 
-        if(t > tz) {
+        if (t > tz) {
             tz += Math.abs(tz - t) * 0.29;
         }
 
-        if(ox < oxp) {
+        if (ox < oxp) {
             oxp -= Math.abs(ox - oxp) * 0.16;
         }
 
-        if(ox > oxp) {
+        if (ox > oxp) {
             oxp += Math.abs(oxp - ox) * 0.16;
         }
 
-        if(oz < ozp) {
+        if (oz < ozp) {
             ozp -= Math.abs(oz - ozp) * 0.16;
         }
 
-        if(oz > ozp) {
+        if (oz > ozp) {
             ozp += Math.abs(ozp - oz) * 0.16;
         }
 
-        if(mx < mxx) {
+        if (mx < mxx) {
             mxx -= Math.abs(mx - mxx) * 0.16;
         }
 
-        if(mx > mxx) {
+        if (mx > mxx) {
             mxx += Math.abs(mxx - mx) * 0.16;
         }
 
-        if(mz < mzz) {
+        if (mz < mzz) {
             mzz -= Math.abs(mz - mzz) * 0.16;
         }
 
-        if(mz > mzz) {
+        if (mz > mzz) {
             mzz += Math.abs(mzz - mz) * 0.16;
         }
 
@@ -265,35 +251,35 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         accuracy = down ? accuracy * 4 : accuracy;
         int v = 1000;
 
-        if(g instanceof Graphics2D gg) {
+        if (g instanceof Graphics2D gg) {
 
-            if(getParent().getWidth() != w || getParent().getHeight() != h) {
+            if (getParent().getWidth() != w || getParent().getHeight() != h) {
                 w = getParent().getWidth();
                 h = getParent().getHeight();
                 img = null;
             }
 
-            if(img == null) {
+            if (img == null) {
                 img = new BufferedImage(w / accuracy, h / accuracy, BufferedImage.TYPE_INT_RGB);
             }
 
             BurstExecutor e = gx.burst(w);
 
-            for(int x = 0; x < w / accuracy; x++) {
+            for (int x = 0; x < w / accuracy; x++) {
                 int xx = x;
 
                 int finalAccuracy = accuracy;
                 e.queue(() -> {
-                    for(int z = 0; z < h / finalAccuracy; z++) {
+                    for (int z = 0; z < h / finalAccuracy; z++) {
                         double n = generator != null ? generator.apply(((xx * finalAccuracy) * ascale) + oxp, ((z * finalAccuracy) * ascale) + ozp) : cng.noise(((xx * finalAccuracy) * ascale) + oxp, ((z * finalAccuracy) * ascale) + ozp);
                         n = n > 1 ? 1 : n < 0 ? 0 : n;
 
                         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), 1f - (float) (n * n * n * n * n * n), 1f - (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 xxx) {
-
+                        } catch (Throwable ignored) {
                         }
                     }
                 });
@@ -308,15 +294,15 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         t += 1D;
         r.put(p.getMilliseconds());
 
-        if(!isVisible()) {
+        if (!isVisible()) {
             return;
         }
 
-        if(!getParent().isVisible()) {
+        if (!getParent().isVisible()) {
             return;
         }
 
-        if(!getParent().getParent().isVisible()) {
+        if (!getParent().getParent().isVisible()) {
             return;
         }
 

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

@@ -24,6 +24,7 @@ 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;
@@ -35,12 +36,8 @@ import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 
-import javax.swing.JFrame;
-import javax.swing.JPanel;
-import java.awt.Color;
-import java.awt.Font;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
+import javax.swing.*;
+import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.awt.image.BufferedImage;
@@ -48,6 +45,8 @@ import java.util.concurrent.TimeUnit;
 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");
@@ -66,24 +65,23 @@ public class PregeneratorJob implements PregenListener {
     private final IrisPregenerator pregenerator;
     private final Position2 min;
     private final Position2 max;
+    private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
+    private final Engine engine;
     private JFrame frame;
     private PregenRenderer renderer;
     private int rgc = 0;
-    private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
     private String[] info;
-    private final Engine engine;
 
     public PregeneratorJob(PregenTask task, PregeneratorMethod method, Engine engine) {
         this.engine = engine;
         instance = this;
         monitor = new MemoryMonitor(50);
         saving = false;
-        info = new String[] {"Initializing..."};
+        info = new String[]{"Initializing..."};
         this.task = task;
         this.pregenerator = new IrisPregenerator(task, method, this);
         max = new Position2(0, 0);
         min = new Position2(0, 0);
-        KList<Runnable> draw = new KList<>();
         task.iterateRegions((xx, zz) -> {
             min.setX(Math.min(xx << 5, min.getX()));
             min.setZ(Math.min(zz << 5, min.getZ()));
@@ -91,19 +89,20 @@ public class PregeneratorJob implements PregenListener {
             max.setZ(Math.max((zz << 5) + 31, max.getZ()));
         });
 
-        if(IrisSettings.get().getGui().isUseServerLaunchedGuis()) {
+        if (IrisSettings.get().getGui().isUseServerLaunchedGuis() && task.isGui()) {
             open();
         }
 
-        J.a(this.pregenerator::start, 20);
-    }
-
-    public Mantle getMantle() {
-        return pregenerator.getMantle();
+        var t = new Thread(() -> {
+            J.sleep(1000);
+            this.pregenerator.start();
+        }, "Iris Pregenerator");
+        t.setPriority(Thread.MIN_PRIORITY);
+        t.start();
     }
 
     public static boolean shutdownInstance() {
-        if(instance == null) {
+        if (instance == null) {
             return false;
         }
 
@@ -116,11 +115,11 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public static boolean pauseResume() {
-        if(instance == null) {
+        if (instance == null) {
             return false;
         }
 
-        if(isPaused()) {
+        if (isPaused()) {
             instance.pregenerator.resume();
         } else {
             instance.pregenerator.pause();
@@ -129,7 +128,7 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public static boolean isPaused() {
-        if(instance == null) {
+        if (instance == null) {
             return true;
         }
 
@@ -140,7 +139,7 @@ public class PregeneratorJob implements PregenListener {
         String v = (c.startsWith("#") ? c : "#" + c).trim();
         try {
             return Color.decode(v);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.error("Error Parsing 'color', (" + c + ")");
         }
@@ -148,6 +147,10 @@ public class PregeneratorJob implements PregenListener {
         return Color.RED;
     }
 
+    public Mantle getMantle() {
+        return pregenerator.getMantle();
+    }
+
     public PregeneratorJob onProgress(Consumer<Double> c) {
         onProgress.add(c);
         return this;
@@ -159,21 +162,19 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public void drawRegion(int x, int z, Color color) {
-        J.a(() -> {
-            PregenTask.iterateRegion(x, z, (xx, zz) -> {
-                draw(xx, zz, color);
-                J.sleep(3);
-            });
-        });
+        J.a(() -> PregenTask.iterateRegion(x, z, (xx, zz) -> {
+            draw(xx, zz, color);
+            J.sleep(3);
+        }));
     }
 
     public void draw(int x, int z, Color color) {
         try {
-            if(renderer != null && frame != null && frame.isVisible()) {
+            if (renderer != null && frame != null && frame.isVisible()) {
                 renderer.func.accept(new Position2(x, z), color);
             }
-        } catch(Throwable ignored) {
-
+        } catch (Throwable ignored) {
+            Iris.error("Failed to draw pregen");
         }
     }
 
@@ -191,8 +192,8 @@ public class PregeneratorJob implements PregenListener {
                 monitor.close();
                 J.sleep(3000);
                 frame.setVisible(false);
-            } catch(Throwable e) {
-
+            } catch (Throwable ignored) {
+                Iris.error("Error closing pregen gui");
             }
         });
     }
@@ -206,8 +207,7 @@ public class PregeneratorJob implements PregenListener {
                 renderer.l = new ReentrantLock();
                 renderer.frame = frame;
                 renderer.job = this;
-                renderer.func = (c, b) ->
-                {
+                renderer.func = (c, b) -> {
                     renderer.l.lock();
                     renderer.order.add(() -> renderer.draw(c, b, renderer.bg));
                     renderer.l.unlock();
@@ -215,40 +215,36 @@ public class PregeneratorJob implements PregenListener {
                 frame.add(renderer);
                 frame.setSize(1000, 1000);
                 frame.setVisible(true);
-            } catch(Throwable e) {
-
+            } catch (Throwable ignored) {
+                Iris.error("Error opening pregen gui");
             }
         });
     }
 
     @Override
     public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
-        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",
-            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",
+        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",
+                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",
 
         };
 
-        for(Consumer<Double> i : onProgress) {
+        for (Consumer<Double> i : onProgress) {
             i.accept(percent);
         }
     }
 
     @Override
     public void onChunkGenerating(int x, int z) {
-        if(engine != null) {
-            return;
-        }
-
         draw(x, z, COLOR_GENERATING);
     }
 
     @Override
     public void onChunkGenerated(int x, int z) {
-        if(engine != null) {
+        if (engine != null) {
             draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
             return;
         }
@@ -263,7 +259,7 @@ public class PregeneratorJob implements PregenListener {
     }
 
     private void shouldGc() {
-        if(cl.flip() && rgc > 16) {
+        if (cl.flip() && rgc > 16) {
             System.gc();
         }
     }
@@ -322,7 +318,7 @@ public class PregeneratorJob implements PregenListener {
 
     @Override
     public void onChunkExistsInRegionGen(int x, int z) {
-        if(engine != null) {
+        if (engine != null) {
             draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
             return;
         }
@@ -371,10 +367,10 @@ public class PregeneratorJob implements PregenListener {
             bg = (Graphics2D) image.getGraphics();
             l.lock();
 
-            while(order.isNotEmpty()) {
+            while (order.isNotEmpty()) {
                 try {
                     order.pop().run();
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     Iris.reportError(e);
 
                 }
@@ -388,12 +384,12 @@ public class PregeneratorJob implements PregenListener {
             int h = g.getFontMetrics().getHeight() + 5;
             int hh = 20;
 
-            if(job.paused()) {
+            if (job.paused()) {
                 g.drawString("PAUSED", 20, hh += h);
 
                 g.drawString("Press P to Resume", 20, hh += h);
             } else {
-                for(String i : prog) {
+                for (String i : prog) {
                     g.drawString(i, 20, hh += h);
                 }
 
@@ -429,7 +425,7 @@ public class PregeneratorJob implements PregenListener {
 
         @Override
         public void keyReleased(KeyEvent e) {
-            if(e.getKeyCode() == KeyEvent.VK_P) {
+            if (e.getKeyCode() == KeyEvent.VK_P) {
                 PregeneratorJob.pauseResume();
             }
         }

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

@@ -44,16 +44,10 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
 import javax.imageio.ImageIO;
-import javax.swing.JFrame;
-import javax.swing.JPanel;
+import javax.swing.*;
 import javax.swing.event.MouseInputListener;
 import java.awt.*;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseMotionListener;
-import java.awt.event.MouseWheelEvent;
-import java.awt.event.MouseWheelListener;
+import java.awt.event.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
@@ -143,7 +137,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         J.a(() -> {
             J.sleep(10000);
 
-            if(!helpIgnored && help) {
+            if (!helpIgnored && help) {
                 help = false;
             }
         });
@@ -167,11 +161,11 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         frame.setVisible(true);
         File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
 
-        if(file != null) {
+        if (file != null) {
             try {
                 nv.texture = ImageIO.read(file);
                 frame.setIconImage(ImageIO.read(file));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
 
             }
@@ -180,16 +174,16 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     public static void launch(Engine g, int i) {
         J.a(() ->
-            createAndShowGUI(g, i, g.getWorld()));
+                createAndShowGUI(g, i, g.getWorld()));
     }
 
     public boolean updateEngine() {
-        if(engine.isClosed()) {
-            if(world.hasRealWorld()) {
+        if (engine.isClosed()) {
+            if (world.hasRealWorld()) {
                 try {
                     engine = IrisToolbelt.access(world.realWorld()).getEngine();
                     return !engine.isClosed();
-                } catch(Throwable e) {
+                } catch (Throwable e) {
 
                 }
             }
@@ -217,13 +211,19 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     public int getColor(double wx, double wz) {
         BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
 
-        switch(currentType) {
-            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD -> colorFunction = (x, z) -> engine.getComplex().getTrueBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case BIOME_LAND -> colorFunction = (x, z) -> engine.getComplex().getLandBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case BIOME_SEA -> colorFunction = (x, z) -> engine.getComplex().getSeaBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case REGION -> colorFunction = (x, z) -> engine.getComplex().getRegionStream().get(x, z).getColor(engine.getComplex(), currentType).getRGB();
-            case CAVE_LAND -> colorFunction = (x, z) -> engine.getComplex().getCaveBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case HEIGHT -> colorFunction = (x, z) -> Color.getHSBColor(engine.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
+        switch (currentType) {
+            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
+                    colorFunction = (x, z) -> engine.getComplex().getTrueBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case BIOME_LAND ->
+                    colorFunction = (x, z) -> engine.getComplex().getLandBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case BIOME_SEA ->
+                    colorFunction = (x, z) -> engine.getComplex().getSeaBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case REGION ->
+                    colorFunction = (x, z) -> engine.getComplex().getRegionStream().get(x, z).getColor(engine.getComplex(), currentType).getRGB();
+            case CAVE_LAND ->
+                    colorFunction = (x, z) -> engine.getComplex().getCaveBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case HEIGHT ->
+                    colorFunction = (x, z) -> Color.getHSBColor(engine.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
         }
 
         return colorFunction.apply(wx, wz);
@@ -240,51 +240,51 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     @Override
     public void keyPressed(KeyEvent e) {
-        if(e.getKeyCode() == KeyEvent.VK_SHIFT) {
+        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
             shift = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_CONTROL) {
+        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
             control = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
+        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
             debug = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_SLASH) {
+        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
             help = true;
             helpIgnored = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_ALT) {
+        if (e.getKeyCode() == KeyEvent.VK_ALT) {
             alt = true;
         }
     }
 
     @Override
     public void keyReleased(KeyEvent e) {
-        if(e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
+        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
             debug = false;
         }
-        if(e.getKeyCode() == KeyEvent.VK_SHIFT) {
+        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
             shift = false;
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_CONTROL) {
+        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
             control = false;
         }
-        if(e.getKeyCode() == KeyEvent.VK_SLASH) {
+        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
             help = false;
             helpIgnored = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_ALT) {
+        if (e.getKeyCode() == KeyEvent.VK_ALT) {
             alt = false;
         }
 
         // Pushes
-        if(e.getKeyCode() == KeyEvent.VK_F) {
+        if (e.getKeyCode() == KeyEvent.VK_F) {
             follow = !follow;
 
-            if(player != null && follow) {
+            if (player != null && follow) {
                 notify("Following " + player.getName() + ". Press F to disable");
-            } else if(follow) {
+            } else if (follow) {
                 notify("Can't follow, no one is in the world");
                 follow = false;
             } else {
@@ -294,38 +294,38 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             return;
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_R) {
+        if (e.getKeyCode() == KeyEvent.VK_R) {
             dump();
             notify("Refreshing Chunks");
             return;
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_P) {
+        if (e.getKeyCode() == KeyEvent.VK_P) {
             lowtile = !lowtile;
             dump();
             notify("Rendering " + (lowtile ? "Low" : "High") + " Quality Tiles");
             return;
         }
-        if(e.getKeyCode() == KeyEvent.VK_E) {
+        if (e.getKeyCode() == KeyEvent.VK_E) {
             eco = !eco;
             dump();
             notify("Using " + (eco ? "60" : "Uncapped") + " FPS Limit");
             return;
         }
-        if(e.getKeyCode() == KeyEvent.VK_EQUALS) {
+        if (e.getKeyCode() == KeyEvent.VK_EQUALS) {
             mscale = mscale + ((0.044 * mscale) * -3);
             mscale = Math.max(mscale, 0.00001);
             dump();
             return;
         }
-        if(e.getKeyCode() == KeyEvent.VK_MINUS) {
+        if (e.getKeyCode() == KeyEvent.VK_MINUS) {
             mscale = mscale + ((0.044 * mscale) * 3);
             mscale = Math.max(mscale, 0.00001);
             dump();
             return;
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_BACK_SLASH) {
+        if (e.getKeyCode() == KeyEvent.VK_BACK_SLASH) {
             mscale = 1D;
             dump();
             notify("Zoom Reset");
@@ -334,9 +334,9 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
         int currentMode = currentType.ordinal();
 
-        for(RenderType i : RenderType.values()) {
-            if(e.getKeyChar() == String.valueOf(i.ordinal() + 1).charAt(0)) {
-                if(i.ordinal() != currentMode) {
+        for (RenderType i : RenderType.values()) {
+            if (e.getKeyChar() == String.valueOf(i.ordinal() + 1).charAt(0)) {
+                if (i.ordinal() != currentMode) {
                     currentType = i;
                     dump();
                     notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
@@ -345,7 +345,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             }
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_M) {
+        if (e.getKeyCode() == KeyEvent.VK_M) {
             currentType = RenderType.values()[(currentMode + 1) % RenderType.values().length];
             notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
             dump();
@@ -361,15 +361,15 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         BlockPosition key = new BlockPosition((int) mscale, Math.floorDiv(x, div), Math.floorDiv(z, div));
         fg.add(key);
 
-        if(positions.containsKey(key)) {
+        if (positions.containsKey(key)) {
             return positions.get(key);
         }
 
-        if(fastpositions.containsKey(key)) {
-            if(!working.contains(key) && working.size() < 9) {
+        if (fastpositions.containsKey(key)) {
+            if (!working.contains(key) && working.size() < 9) {
                 m.set(m.get() - 1);
 
-                if(m.get() >= 0 && velocity < 50) {
+                if (m.get() >= 0 && velocity < 50) {
                     working.add(key);
                     double mk = mscale;
                     double mkd = scale;
@@ -380,7 +380,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
                         rs.put(ps.getMilliseconds());
                         working.remove(key);
 
-                        if(mk == mscale && mkd == scale) {
+                        if (mk == mscale && mkd == scale) {
                             positions.put(key, b);
                         }
                     });
@@ -390,7 +390,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             return fastpositions.get(key);
         }
 
-        if(workingfast.contains(key) || workingfast.size() > Runtime.getRuntime().availableProcessors()) {
+        if (workingfast.contains(key) || workingfast.size() > Runtime.getRuntime().availableProcessors()) {
             return null;
         }
 
@@ -404,7 +404,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             rs.put(ps.getMilliseconds());
             workingfast.remove(key);
 
-            if(mk == mscale && mkd == scale) {
+            if (mk == mscale && mkd == scale) {
                 fastpositions.put(key, b);
             }
         });
@@ -431,15 +431,11 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     @Override
     public void paint(Graphics gx) {
 
-        if(engine.isClosed()) {
+        if (engine.isClosed()) {
             EventQueue.invokeLater(() -> {
-                try
-                {
+                try {
                     setVisible(false);
-                }
-
-                catch(Throwable e)
-                {
+                } catch (Throwable e) {
 
                 }
             });
@@ -447,49 +443,49 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             return;
         }
 
-        if(updateEngine()) {
+        if (updateEngine()) {
             dump();
         }
 
-        if(ox < oxp) {
+        if (ox < oxp) {
             velocity = Math.abs(ox - oxp) * 0.36;
             oxp -= velocity;
         }
 
-        if(ox > oxp) {
+        if (ox > oxp) {
             velocity = Math.abs(oxp - ox) * 0.36;
             oxp += velocity;
         }
 
-        if(oz < ozp) {
+        if (oz < ozp) {
             velocity = Math.abs(oz - ozp) * 0.36;
             ozp -= velocity;
         }
 
-        if(oz > ozp) {
+        if (oz > ozp) {
             velocity = Math.abs(ozp - oz) * 0.36;
             ozp += velocity;
         }
 
-        if(lx < hx) {
+        if (lx < hx) {
             hx -= Math.abs(lx - hx) * 0.36;
         }
 
-        if(lx > hx) {
+        if (lx > hx) {
             hx += Math.abs(hx - lx) * 0.36;
         }
 
-        if(lz < hz) {
+        if (lz < hz) {
             hz -= Math.abs(lz - hz) * 0.36;
         }
 
-        if(lz > hz) {
+        if (lz > hz) {
             hz += Math.abs(hz - lz) * 0.36;
         }
 
-        if(centities.flip()) {
+        if (centities.flip()) {
             J.s(() -> {
-                synchronized(lastEntities) {
+                synchronized (lastEntities) {
                     lastEntities.clear();
                     lastEntities.addAll(world.getEntitiesByClass(LivingEntity.class));
                 }
@@ -503,7 +499,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         double vscale = scale;
         scale = w / 12D;
 
-        if(scale != vscale) {
+        if (scale != vscale) {
             positions.clear();
         }
 
@@ -515,15 +511,15 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         int posZ = (int) ozp;
         m.set(3);
 
-        for(int r = 0; r < Math.max(w, h); r += iscale) {
-            for(int i = -iscale; i < w + iscale; i += iscale) {
-                for(int j = -iscale; j < h + iscale; j += iscale) {
+        for (int r = 0; r < Math.max(w, h); r += iscale) {
+            for (int i = -iscale; i < w + iscale; i += iscale) {
+                for (int j = -iscale; j < h + iscale; j += iscale) {
                     int a = i - (w / 2);
                     int b = j - (h / 2);
-                    if(a * a + b * b <= r * r) {
+                    if (a * a + b * b <= r * r) {
                         BufferedImage t = getTile(gg, iscale, Math.floorDiv((posX / iscale) + i, iscale) * iscale, Math.floorDiv((posZ / iscale) + j, iscale) * iscale, m);
 
-                        if(t != null) {
+                        if (t != null) {
                             g.drawImage(t, i - ((posX / iscale) % (iscale)), j - ((posZ / iscale) % (iscale)), iscale, iscale, (img, infoflags, x, y, width, height) -> true);
                         }
                     }
@@ -533,8 +529,8 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
         p.end();
 
-        for(BlockPosition i : positions.k()) {
-            if(!gg.contains(i)) {
+        for (BlockPosition i : positions.k()) {
+            if (!gg.contains(i)) {
                 positions.remove(i);
             }
         }
@@ -542,15 +538,15 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         hanleFollow();
         renderOverlays(g);
 
-        if(!isVisible()) {
+        if (!isVisible()) {
             return;
         }
 
-        if(!getParent().isVisible()) {
+        if (!getParent().isVisible()) {
             return;
         }
 
-        if(!getParent().getParent().isVisible()) {
+        if (!getParent().getParent().isVisible()) {
             return;
         }
 
@@ -562,7 +558,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     }
 
     private void hanleFollow() {
-        if(follow && player != null) {
+        if (follow && player != null) {
             animateTo(player.getLocation().getX(), player.getLocation().getZ());
         }
     }
@@ -570,16 +566,16 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void renderOverlays(Graphics2D g) {
         renderPlayer(g);
 
-        if(help) {
+        if (help) {
             renderOverlayHelp(g);
-        } else if(debug) {
+        } else if (debug) {
             renderOverlayDebug(g);
         }
 
         renderOverlayLegend(g);
 
         renderHoverOverlay(g, shift);
-        if(!notifications.isEmpty()) {
+        if (!notifications.isEmpty()) {
             renderNotification(g);
         }
     }
@@ -597,8 +593,8 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void renderNotification(Graphics2D g) {
         drawCardCB(g, notifications.k());
 
-        for(String i : notifications.k()) {
-            if(M.ms() > notifications.get(i)) {
+        for (String i : notifications.k()) {
+            if (M.ms() > notifications.get(i)) {
                 notifications.remove(i);
             }
         }
@@ -607,32 +603,32 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void renderPlayer(Graphics2D g) {
         Player b = null;
 
-        for(Player i : world.getPlayers()) {
+        for (Player i : world.getPlayers()) {
             b = i;
             renderPosition(g, i.getLocation().getX(), i.getLocation().getZ());
         }
 
-        synchronized(lastEntities) {
+        synchronized (lastEntities) {
             double dist = Double.MAX_VALUE;
             LivingEntity h = null;
 
-            for(LivingEntity i : lastEntities) {
-                if(i instanceof Player) {
+            for (LivingEntity i : lastEntities) {
+                if (i instanceof Player) {
                     continue;
                 }
 
                 renderMobPosition(g, i, i.getLocation().getX(), i.getLocation().getZ());
-                if(shift) {
+                if (shift) {
                     double d = i.getLocation().distanceSquared(new Location(i.getWorld(), getWorldX(hx), i.getLocation().getY(), getWorldZ(hz)));
 
-                    if(d < dist) {
+                    if (d < dist) {
                         dist = d;
                         h = i;
                     }
                 }
             }
 
-            if(h != null && shift) {
+            if (h != null && shift) {
                 g.setColor(Color.red);
                 g.fillRoundRect((int) getScreenX(h.getLocation().getX()) - 10, (int) getScreenZ(h.getLocation().getZ()) - 10, 20, 20, 20, 20);
                 KList<String> k = new KList<>();
@@ -657,7 +653,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     }
 
     private void renderPosition(Graphics2D g, double x, double z) {
-        if(texture != null) {
+        if (texture != null) {
             g.drawImage(texture, (int) getScreenX(x), (int) getScreenZ(z), 66, 66, (img, infoflags, xx, xy, width, height) -> true);
         } else {
             g.setColor(Color.darkGray);
@@ -679,7 +675,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         l.add("Biome: " + biome.getName());
         l.add("Region: " + region.getName() + "(" + region.getLoadKey() + ")");
         l.add("Block " + (int) getWorldX(hx) + ", " + (int) getWorldZ(hz));
-        if(detailed) {
+        if (detailed) {
             l.add("Chunk " + ((int) getWorldX(hx) >> 4) + ", " + ((int) getWorldZ(hz) >> 4));
             l.add("Region " + (((int) getWorldX(hx) >> 4) >> 5) + ", " + (((int) getWorldZ(hz) >> 4) >> 5));
             l.add("Key: " + biome.getLoadKey());
@@ -708,7 +704,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         l.add("E to toggle Eco FPS Mode");
 
         int ff = 0;
-        for(RenderType i : RenderType.values()) {
+        for (RenderType i : RenderType.values()) {
             ff++;
             l.add(ff + " to view " + Form.capitalizeWords(i.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
         }
@@ -738,8 +734,9 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void open() {
         IrisComplex complex = engine.getComplex();
         File r = null;
-        switch(currentType) {
-            case BIOME, LAYER_LOAD, DECORATOR_LOAD, OBJECT_LOAD, HEIGHT -> r = complex.getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+        switch (currentType) {
+            case BIOME, LAYER_LOAD, DECORATOR_LOAD, OBJECT_LOAD, HEIGHT ->
+                    r = complex.getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
             case BIOME_LAND -> r = complex.getLandBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
             case BIOME_SEA -> r = complex.getSeaBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
             case REGION -> r = complex.getRegionStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
@@ -751,7 +748,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     private void teleport() {
         J.s(() -> {
-            if(player != null) {
+            if (player != null) {
                 int xx = (int) getWorldX(hx);
                 int zz = (int) getWorldZ(hz);
                 int h = engine.getComplex().getRoundedHeighteightStream().get(xx, zz);
@@ -776,7 +773,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         int h = 0;
         int w = 0;
 
-        for(String i : text) {
+        for (String i : text) {
             h += g.getFontMetrics().getHeight();
             w = Math.max(w, g.getFontMetrics().stringWidth(i));
         }
@@ -796,14 +793,14 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
         g.setColor(Color.black);
         int m = 0;
-        for(String i : text) {
+        for (String i : text) {
             g.drawString(i, x + 14 - cw, y + 14 - ch + (++m * g.getFontMetrics().getHeight()));
         }
     }
 
     public void mouseWheelMoved(MouseWheelEvent e) {
         int notches = e.getWheelRotation();
-        if(e.isControlDown()) {
+        if (e.isControlDown()) {
             return;
         }
 
@@ -816,9 +813,9 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     @Override
     public void mouseClicked(MouseEvent e) {
-        if(control) {
+        if (control) {
             teleport();
-        } else if(alt) {
+        } else if (alt) {
             open();
         }
     }

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

@@ -0,0 +1,85 @@
+/*
+ * 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.gui.components;
+
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisBiomeGeneratorLink;
+import com.volmit.iris.util.interpolation.IrisInterpolation;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.function.BiFunction;
+
+public class IrisRenderer {
+    private final Engine renderer;
+
+    public IrisRenderer(Engine renderer) {
+        this.renderer = renderer;
+    }
+
+    public BufferedImage render(double sx, double sz, double size, int resolution, RenderType currentType) {
+        BufferedImage image = new BufferedImage(resolution, resolution, BufferedImage.TYPE_INT_RGB);
+        BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
+
+        switch (currentType) {
+            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
+                    colorFunction = (x, z) -> renderer.getComplex().getTrueBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case BIOME_LAND ->
+                    colorFunction = (x, z) -> renderer.getComplex().getLandBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case BIOME_SEA ->
+                    colorFunction = (x, z) -> renderer.getComplex().getSeaBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case REGION ->
+                    colorFunction = (x, z) -> renderer.getComplex().getRegionStream().get(x, z).getColor(renderer.getComplex(), currentType).getRGB();
+            case CAVE_LAND ->
+                    colorFunction = (x, z) -> renderer.getComplex().getCaveBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case HEIGHT ->
+                    colorFunction = (x, z) -> Color.getHSBColor(renderer.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
+            case CONTINENT -> colorFunction = (x, z) -> {
+                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) {
+                    // Max is below water level, so it is most likely an ocean biome
+                    c = Color.BLUE;
+                } else if (g.getMin(renderer) < 0) {
+                    // Min is below water level, but max is not, so it is most likely a shore biome
+                    c = Color.YELLOW;
+                } else {
+                    // Both min and max are above water level, so it is most likely a land biome
+                    c = Color.GREEN;
+                }
+                return c.getRGB();
+            };
+        }
+
+        double x, z;
+        int i, j;
+        for (i = 0; i < resolution; i++) {
+            x = IrisInterpolation.lerp(sx, sx + size, (double) i / (double) (resolution));
+
+            for (j = 0; j < resolution; j++) {
+                z = IrisInterpolation.lerp(sz, sz + size, (double) j / (double) (resolution));
+                image.setRGB(i, j, colorFunction.apply(x, z));
+            }
+        }
+
+        return image;
+    }
+}

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

@@ -19,5 +19,5 @@
 package com.volmit.iris.core.gui.components;
 
 public enum RenderType {
-    BIOME, BIOME_LAND, BIOME_SEA, REGION, CAVE_LAND, HEIGHT, OBJECT_LOAD, DECORATOR_LOAD, LAYER_LOAD
+    BIOME, BIOME_LAND, BIOME_SEA, REGION, CAVE_LAND, HEIGHT, OBJECT_LOAD, DECORATOR_LOAD, CONTINENT, LAYER_LOAD
 }

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

@@ -18,7 +18,7 @@
 
 package com.volmit.iris.core.gui.components;
 
-import java.awt.Color;
+import java.awt.*;
 
 @FunctionalInterface
 public interface Renderer {

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

@@ -0,0 +1,102 @@
+//package com.volmit.iris.core.link;
+//
+//import com.jojodmo.customitems.api.CustomItemsAPI;
+//import com.jojodmo.customitems.item.custom.CustomItem;
+//import com.jojodmo.customitems.item.custom.block.CustomMushroomBlock;
+//import com.jojodmo.customitems.version.SafeMaterial;
+//import com.volmit.iris.util.collection.KList;
+//import com.volmit.iris.util.reflect.WrappedField;
+//import com.volmit.iris.util.reflect.WrappedReturningMethod;
+//import org.bukkit.block.BlockFace;
+//import org.bukkit.block.data.BlockData;
+//import org.bukkit.block.data.MultipleFacing;
+//import org.bukkit.inventory.ItemStack;
+//
+//import java.util.Map;
+//import java.util.MissingResourceException;
+//
+//public class CustomItemsDataProvider extends ExternalDataProvider {
+//
+//    private static final String FIELD_FACES = "faces";
+//    private static final String METHOD_GET_MATERIAL = "getMaterial";
+//
+//    private WrappedField<CustomMushroomBlock, Map<Integer, boolean[]>> mushroomFaces;
+//    private WrappedReturningMethod<CustomMushroomBlock, SafeMaterial> mushroomMaterial;
+//
+//    public CustomItemsDataProvider() {
+//        super("CustomItems");
+//    }
+//
+//    @Override
+//    public void init() {
+//        this.mushroomFaces = new WrappedField<>(CustomMushroomBlock.class, FIELD_FACES);
+//        this.mushroomMaterial = new WrappedReturningMethod<>(CustomMushroomBlock.class, METHOD_GET_MATERIAL);
+//    }
+//
+//    @Override
+//    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+//        CustomItem item = CustomItem.get(blockId.key());
+//        if(item == null) {
+//            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+//        } else if(item.getBlockTexture().isSpawner()) {
+//            throw new MissingResourceException("Iris does not yet support SpawnerBlocks from CustomItems.", blockId.namespace(), blockId.key());
+//        } else if(item.getBlockTexture() != null && item.getBlockTexture().isValid()) {
+//            throw new MissingResourceException("Tried to fetch BlockData for a CustomItem that is not placeable!", blockId.namespace(), blockId.key());
+//        }
+//        return getMushroomData(item);
+//    }
+//
+//    @Override
+//    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+//        ItemStack stack = CustomItemsAPI.getCustomItem(itemId.key());
+//        if(stack == null) {
+//            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+//        }
+//        return stack;
+//    }
+//
+//    @Override
+//    public Identifier[] getBlockTypes() {
+//        KList<Identifier> names = new KList<>();
+//        for (String name : CustomItemsAPI.listBlockCustomItemIDs()) {
+//            try {
+//                Identifier key = new Identifier("cui", name);
+//                if (getItemStack(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 : CustomItemsAPI.listCustomItemIDs()) {
+//            try {
+//                Identifier key = new Identifier("cui", name);
+//                if (getItemStack(key) != null)
+//                    names.add(key);
+//            } catch (MissingResourceException ignored) { }
+//        }
+//
+//        return names.toArray(new Identifier[0]);
+//    }
+//
+//    @Override
+//    public boolean isValidProvider(Identifier key, boolean isItem) {
+//        return key.namespace().equalsIgnoreCase("cui");
+//    }
+//
+//    private BlockData getMushroomData(CustomItem item) {
+//        MultipleFacing data = (MultipleFacing)mushroomMaterial.invoke(item.getBlockTexture().getMushroomId()).parseMaterial().createBlockData();
+//        boolean[] values = mushroomFaces.get().get(item.getBlockTexture().getMushroomId());
+//        data.setFace(BlockFace.DOWN, values[0]);
+//        data.setFace(BlockFace.EAST, values[1]);
+//        data.setFace(BlockFace.NORTH, values[2]);
+//        data.setFace(BlockFace.SOUTH, values[3]);
+//        data.setFace(BlockFace.UP, values[4]);
+//        data.setFace(BlockFace.WEST, values[5]);
+//        return data;
+//    }
+//}

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

@@ -0,0 +1,77 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.reflect.WrappedField;
+import com.willfp.ecoitems.items.EcoItem;
+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;
+
+public class EcoItemsDataProvider extends ExternalDataProvider {
+    private WrappedField<EcoItem, ItemStack> itemStack;
+    private WrappedField<EcoItem, NamespacedKey> id;
+
+    public EcoItemsDataProvider() {
+        super("EcoItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up EcoItems Link...");
+        itemStack = new WrappedField<>(EcoItem.class, "_itemStack");
+        if (this.itemStack.hasFailed()) {
+            Iris.error("Failed to set up EcoItems Link: Unable to fetch ItemStack field!");
+        }
+        id = new WrappedField<>(EcoItem.class, "id");
+        if (this.id.hasFailed()) {
+            Iris.error("Failed to set up EcoItems Link: Unable to fetch id field!");
+        }
+    }
+
+    @NotNull
+    @Override
+    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(@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<>();
+        for (EcoItem item : EcoItems.INSTANCE.values()) {
+            try {
+                Identifier key = Identifier.fromNamespacedKey(id.get(item));
+                if (getItemStack(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    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

@@ -0,0 +1,64 @@
+package com.volmit.iris.core.link;
+
+import com.ssomar.score.api.executableitems.ExecutableItemsAPI;
+import com.volmit.iris.Iris;
+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;
+
+public class ExecutableItemsDataProvider extends ExternalDataProvider {
+    public ExecutableItemsDataProvider() {
+        super("ExecutableItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up ExecutableItems Link...");
+    }
+
+    @NotNull
+    @Override
+    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(@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<>();
+        for (String name : ExecutableItemsAPI.getExecutableItemsManager().getExecutableItemIdsList()) {
+            try {
+                Identifier key = new Identifier("executable_items", name);
+                if (getItemStack(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    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

@@ -0,0 +1,93 @@
+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.IrisBlockData;
+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 {
+
+    @NonNull
+    private final String pluginId;
+
+    @Nullable
+    public Plugin getPlugin() {
+        return Bukkit.getPluginManager().getPlugin(pluginId);
+    }
+
+    public boolean isReady() {
+        return getPlugin() != null && getPlugin().isEnabled();
+    }
+
+    public abstract void init();
+
+    /**
+     * @see ExternalDataProvider#getBlockData(Identifier, KMap)
+     */
+    @NotNull
+    public BlockData getBlockData(@NotNull Identifier blockId) throws MissingResourceException {
+        return getBlockData(blockId, new KMap<>());
+    }
+
+    /**
+     * 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 IrisBlockData} 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;
+
+    /**
+     * @see ExternalDataProvider#getItemStack(Identifier)
+     */
+    @NotNull
+    public ItemStack getItemStack(@NotNull Identifier itemId) throws MissingResourceException {
+        return getItemStack(itemId, new KMap<>());
+    }
+
+    /**
+     * 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;
+
+    /**
+     * 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 IrisBlockData}
+     *
+     * @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 @NotNull Identifier[] getBlockTypes();
+
+    public abstract @NotNull Identifier[] getItemTypes();
+
+    public abstract boolean isValidProvider(@NotNull Identifier id, boolean isItem);
+}

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

@@ -0,0 +1,144 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+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.reflect.WrappedField;
+import com.volmit.iris.util.reflect.WrappedReturningMethod;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+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;
+import java.util.function.Supplier;
+
+public class HMCLeavesDataProvider extends ExternalDataProvider {
+	private Object apiInstance;
+	private WrappedReturningMethod<Object, Material> worldBlockType;
+	private WrappedReturningMethod<Object, Boolean> setCustomBlock;
+	private Map<String, Object> blockDataMap = Map.of();
+	private Map<String, Supplier<ItemStack>> itemDataField = Map.of();
+
+	public HMCLeavesDataProvider() {
+		super("HMCLeaves");
+	}
+
+	@Override
+	public String getPluginId() {
+		return "HMCLeaves";
+	}
+
+	@Override
+	public void init() {
+		try {
+			worldBlockType = new WrappedReturningMethod<>((Class<Object>) Class.forName("io.github.fisher2911.hmcleaves.data.BlockData"), "worldBlockType");
+			apiInstance = getApiInstance(Class.forName("io.github.fisher2911.hmcleaves.api.HMCLeavesAPI"));
+			setCustomBlock = new WrappedReturningMethod<>((Class<Object>) apiInstance.getClass(), "setCustomBlock", Location.class, String.class, boolean.class);
+			Object config = getLeavesConfig(apiInstance.getClass());
+			blockDataMap = getMap(config, "blockDataMap");
+			itemDataField = getMap(config, "itemSupplierMap");
+		} catch (Throwable e) {
+			Iris.error("Failed to initialize HMCLeavesDataProvider: " + e.getMessage());
+		}
+	}
+
+	@NotNull
+	@Override
+	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());
+		Material material = worldBlockType.invoke(o, new Object[0]);
+		if (material == null)
+			throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+		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));
+	}
+
+	@NotNull
+	@Override
+	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(@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});
+		if (result == null || !result)
+			Iris.warn("Failed to set custom block! " + blockId.key() + " " + block.getX() + " " + block.getY() + " " + block.getZ());
+		else if (IrisSettings.get().getGenerator().preventLeafDecay) {
+			BlockData blockData = block.getBlockData();
+			if (blockData instanceof Leaves leaves)
+				leaves.setPersistent(true);
+		}
+	}
+
+	@NotNull
+	@Override
+	public Identifier[] getBlockTypes() {
+		KList<Identifier> names = new KList<>();
+		for (String name : blockDataMap.keySet()) {
+			try {
+				Identifier key = new Identifier("hmcleaves", name);
+				if (getBlockData(key) != null)
+					names.add(key);
+			} catch (MissingResourceException ignored) {
+			}
+		}
+
+		return names.toArray(new Identifier[0]);
+	}
+
+	@NotNull
+	@Override
+	public Identifier[] getItemTypes() {
+		KList<Identifier> names = new KList<>();
+		for (String name : itemDataField.keySet()) {
+			try {
+				Identifier key = new Identifier("hmcleaves", name);
+				if (getItemStack(key) != null)
+					names.add(key);
+			} catch (MissingResourceException ignored) {
+			}
+		}
+
+		return names.toArray(new Identifier[0]);
+	}
+
+	@Override
+	public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
+		return (isItem ? itemDataField.keySet() : blockDataMap.keySet()).contains(id.key());
+	}
+
+	private <C, T> Map<String, T> getMap(C config, String name) {
+		WrappedField<C, Map<String, T>> field = new WrappedField<>((Class<C>) config.getClass(), name);
+		return field.get(config);
+	}
+
+	private <A> A getApiInstance(Class<A> apiClass) {
+		WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
+		return instance.invoke();
+	}
+
+	private <A, C> C getLeavesConfig(Class<A> apiClass) {
+		WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
+		WrappedField<A, C> config = new WrappedField<>(apiClass, "config");
+		return config.get(instance.invoke());
+	}
+}

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

@@ -0,0 +1,37 @@
+package com.volmit.iris.core.link;
+
+import org.bukkit.NamespacedKey;
+
+public record Identifier(String namespace, String key) {
+
+    private static final String DEFAULT_NAMESPACE = "minecraft";
+
+    public static Identifier fromNamespacedKey(NamespacedKey key) {
+        return new Identifier(key.getNamespace(), key.getKey());
+    }
+
+    public static Identifier fromString(String id) {
+        String[] strings = id.split(":", 2);
+        if (strings.length == 1) {
+            return new Identifier(DEFAULT_NAMESPACE, strings[0]);
+        } else {
+            return new Identifier(strings[0], strings[1]);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return namespace + ":" + key;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Identifier i) {
+            return i.namespace().equals(this.namespace) && i.key().equals(this.key);
+        } else if (obj instanceof NamespacedKey i) {
+            return i.getNamespace().equals(this.namespace) && i.getKey().equals(this.key);
+        } else {
+            return false;
+        }
+    }
+}

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

@@ -20,31 +20,33 @@ package com.volmit.iris.core.link;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 import org.bukkit.Location;
 import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
 
 // See/update https://app.gitbook.com/@volmitsoftware/s/iris/compatability/papi/
 public class IrisPapiExpansion extends PlaceholderExpansion {
     @Override
-    public String getIdentifier() {
+    public @NotNull String getIdentifier() {
         return "iris";
     }
 
     @Override
-    public String getAuthor() {
+    public @NotNull String getAuthor() {
         return "Volmit Software";
     }
 
     @Override
-    public String getVersion() {
+    public @NotNull String getVersion() {
         return Iris.instance.getDescription().getVersion();
     }
 
     @Override
     public boolean persist() {
-        return false;
+        return true;
     }
 
     @Override
@@ -52,59 +54,63 @@ public class IrisPapiExpansion extends PlaceholderExpansion {
         Location l = null;
         PlatformChunkGenerator a = null;
 
-        if(player.isOnline()) {
-            l = player.getPlayer().getLocation();
+        if (player.isOnline() && player.getPlayer() != null) {
+            l = player.getPlayer().getLocation().add(0, 2, 0);
             a = IrisToolbelt.access(l.getWorld());
         }
 
-        if(p.equalsIgnoreCase("biome_name")) {
-            if(a != null) {
-                return a.getEngine().getBiome(l).getName();
+        if (p.equalsIgnoreCase("biome_name")) {
+            if (a != null) {
+                return getBiome(a, l).getName();
             }
-        } else if(p.equalsIgnoreCase("biome_id")) {
-            if(a != null) {
-                return a.getEngine().getBiome(l).getLoadKey();
+        } else if (p.equalsIgnoreCase("biome_id")) {
+            if (a != null) {
+                return getBiome(a, l).getLoadKey();
             }
-        } else if(p.equalsIgnoreCase("biome_file")) {
-            if(a != null) {
-                return a.getEngine().getBiome(l).getLoadFile().getPath();
+        } else if (p.equalsIgnoreCase("biome_file")) {
+            if (a != null) {
+                return getBiome(a, l).getLoadFile().getPath();
             }
-        } else if(p.equalsIgnoreCase("region_name")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("region_name")) {
+            if (a != null) {
                 return a.getEngine().getRegion(l).getName();
             }
-        } else if(p.equalsIgnoreCase("region_id")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("region_id")) {
+            if (a != null) {
                 return a.getEngine().getRegion(l).getLoadKey();
             }
-        } else if(p.equalsIgnoreCase("region_file")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("region_file")) {
+            if (a != null) {
                 return a.getEngine().getRegion(l).getLoadFile().getPath();
             }
-        } else if(p.equalsIgnoreCase("terrain_slope")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("terrain_slope")) {
+            if (a != null) {
                 return (a.getEngine())
-                    .getComplex().getSlopeStream()
-                    .get(l.getX(), l.getZ()) + "";
+                        .getComplex().getSlopeStream()
+                        .get(l.getX(), l.getZ()) + "";
             }
-        } else if(p.equalsIgnoreCase("terrain_height")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("terrain_height")) {
+            if (a != null) {
                 return Math.round(a.getEngine().getHeight(l.getBlockX(), l.getBlockZ())) + "";
             }
-        } else if(p.equalsIgnoreCase("world_mode")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("world_mode")) {
+            if (a != null) {
                 return a.isStudio() ? "Studio" : "Production";
             }
-        } else if(p.equalsIgnoreCase("world_seed")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("world_seed")) {
+            if (a != null) {
                 return a.getEngine().getSeedManager().getSeed() + "";
             }
-        } else if(p.equalsIgnoreCase("world_speed")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("world_speed")) {
+            if (a != null) {
                 return a.getEngine().getGeneratedPerSecond() + "/s";
             }
         }
 
         return null;
     }
+
+    private IrisBiome getBiome(PlatformChunkGenerator a, Location l) {
+        return a.getEngine().getBiome(l.getBlockX(), l.getBlockY() - l.getWorld().getMinHeight(), l.getBlockZ());
+    }
 }

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

@@ -0,0 +1,76 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+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;
+
+public class ItemAdderDataProvider extends ExternalDataProvider {
+
+    private KList<String> itemNamespaces, blockNamespaces;
+
+    public ItemAdderDataProvider() {
+        super("ItemsAdder");
+    }
+
+    @Override
+    public void init() {
+        this.itemNamespaces = new KList<>();
+        this.blockNamespaces = new KList<>();
+
+        for (Identifier i : getItemTypes()) {
+            itemNamespaces.addIfMissing(i.namespace());
+        }
+        for (Identifier i : getBlockTypes()) {
+            blockNamespaces.addIfMissing(i.namespace());
+            Iris.info("Found ItemAdder Block: " + i);
+        }
+    }
+
+    @NotNull
+    @Override
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        return CustomBlock.getBaseBlockData(blockId.toString());
+    }
+
+    @NotNull
+    @Override
+    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());
+        }
+        return stack.getItemStack();
+    }
+
+    @NotNull
+    @Override
+    public Identifier[] getBlockTypes() {
+        KList<Identifier> keys = new KList<>();
+        for (String s : CustomBlock.getNamespacedIdsInRegistry()) {
+            keys.add(Identifier.fromString(s));
+        }
+        return keys.toArray(new Identifier[0]);
+    }
+
+    @NotNull
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> keys = new KList<>();
+        for (String s : CustomStack.getNamespacedIdsInRegistry()) {
+            keys.add(Identifier.fromString(s));
+        }
+        return keys.toArray(new Identifier[0]);
+    }
+
+    @Override
+    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

@@ -0,0 +1,139 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.scheduling.J;
+import net.Indyuce.mmoitems.MMOItems;
+import net.Indyuce.mmoitems.api.ItemTier;
+import net.Indyuce.mmoitems.api.Type;
+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;
+import java.util.concurrent.ExecutionException;
+
+public class MMOItemsDataProvider extends ExternalDataProvider {
+
+    public MMOItemsDataProvider() {
+        super("MMOItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up MMOItems Link...");
+    }
+
+    @NotNull
+    @Override
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        int id = -1;
+        try {
+            id = Integer.parseInt(blockId.key());
+        } catch (NumberFormatException ignored) {}
+        CustomBlock block = api().getCustomBlocks().getBlock(id);
+        if (block == null) throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        return block.getState().getBlockData();
+    }
+
+    @NotNull
+    @Override
+    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());
+        CompletableFuture<ItemStack> future = new CompletableFuture<>();
+        Runnable run = () -> {
+            try {
+                var type = api().getTypes().get(parts[1]);
+                int level = -1;
+                ItemTier tier = null;
+
+                if (customNbt != null) {
+                    level = (int) customNbt.getOrDefault("level", -1);
+                    tier = api().getTiers().get(String.valueOf(customNbt.get("tier")));
+                }
+
+                ItemStack itemStack;
+                if (type == null) {
+                    future.complete(null);
+                    return;
+                }
+
+                if (level != -1 && tier != null) {
+                    itemStack = api().getItem(type, itemId.key(), level, tier);
+                } else {
+                    itemStack = api().getItem(type, itemId.key());
+                }
+                future.complete(itemStack);
+            } catch (Throwable e) {
+                future.completeExceptionally(e);
+            }
+        };
+        if (Bukkit.isPrimaryThread()) run.run();
+        else J.s(run);
+        ItemStack item = null;
+        try {
+            item = future.get();
+        } catch (InterruptedException | ExecutionException ignored) {}
+        if (item == null)
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        return item;
+    }
+
+    @NotNull
+    @Override
+    public Identifier[] getBlockTypes() {
+        KList<Identifier> names = new KList<>();
+        for (Integer id : api().getCustomBlocks().getBlockIds()) {
+            try {
+                Identifier key = new Identifier("mmoitems", String.valueOf(id));
+                if (getBlockData(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+        return names.toArray(new Identifier[0]);
+    }
+
+    @NotNull
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> names = new KList<>();
+        Runnable run = () -> {
+            for (Type type : api().getTypes().getAll()) {
+                for (String name : api().getTemplates().getTemplateNames(type)) {
+                    try {
+                        Identifier key = new Identifier("mmoitems_" + type.getId(), name);
+                        if (getItemStack(key) != null)
+                            names.add(key);
+                    } catch (MissingResourceException ignored) {
+                    }
+                }
+            }
+        };
+        if (Bukkit.isPrimaryThread()) run.run();
+        else {
+            try {
+                J.sfut(run).get();
+            } catch (InterruptedException | ExecutionException e) {
+                Iris.error("Failed getting MMOItems item types!");
+                Iris.reportError(e);
+            }
+        }
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
+        return isItem ? id.namespace().split("_", 2).length == 2 : id.namespace().equals("mmoitems");
+    }
+
+    private MMOItems api() {
+        return MMOItems.plugin;
+    }
+}

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

@@ -38,7 +38,7 @@ public class MultiverseCoreLink {
     }
 
     public boolean addWorld(String worldName, IrisDimension dim, String seed) {
-        if(!isSupported()) {
+        if (!isSupported()) {
             return false;
         }
 
@@ -47,11 +47,11 @@ public class MultiverseCoreLink {
             Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
             Method m = mvWorldManager.getClass().getDeclaredMethod("addWorld",
 
-                String.class, World.Environment.class, String.class, WorldType.class, Boolean.class, String.class, boolean.class);
+                    String.class, World.Environment.class, String.class, WorldType.class, Boolean.class, String.class, boolean.class);
             boolean b = (boolean) m.invoke(mvWorldManager, worldName, dim.getEnvironment(), seed, WorldType.NORMAL, false, "Iris", false);
             saveConfig();
             return b;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -67,7 +67,7 @@ public class MultiverseCoreLink {
             Field f = mvWorldManager.getClass().getDeclaredField("worldsFromTheConfig");
             f.setAccessible(true);
             return (Map<String, ?>) f.get(mvWorldManager);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -76,7 +76,7 @@ public class MultiverseCoreLink {
     }
 
     public void removeFromConfig(World world) {
-        if(!isSupported()) {
+        if (!isSupported()) {
             return;
         }
 
@@ -85,7 +85,7 @@ public class MultiverseCoreLink {
     }
 
     public void removeFromConfig(String world) {
-        if(!isSupported()) {
+        if (!isSupported()) {
             return;
         }
 
@@ -98,7 +98,7 @@ public class MultiverseCoreLink {
             Plugin p = getMultiverse();
             Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
             mvWorldManager.getClass().getDeclaredMethod("saveWorldsConfig").invoke(mvWorldManager);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -112,7 +112,7 @@ public class MultiverseCoreLink {
         try {
             String t = worldNameTypes.get(worldName);
             return t == null ? defaultType : t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             return defaultType;
         }
@@ -128,11 +128,11 @@ public class MultiverseCoreLink {
     }
 
     public String envName(World.Environment environment) {
-        if(environment == null) {
+        if (environment == null) {
             return "normal";
         }
 
-        return switch(environment) {
+        return switch (environment) {
             case NORMAL -> "normal";
             case NETHER -> "nether";
             case THE_END -> "end";

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.IrisBlockData;
+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 IrisBlockData(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

@@ -0,0 +1,59 @@
+/*
+ * 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 io.lumine.mythic.bukkit.MythicBukkit;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.plugin.Plugin;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+
+public class MythicMobsLink {
+
+    public MythicMobsLink() {
+
+    }
+
+    public boolean isEnabled() {
+        return getPlugin() != null;
+    }
+
+    public Plugin getPlugin() {
+        return Bukkit.getPluginManager().getPlugin("MythicMobs");
+    }
+
+    /**
+     * Spawn a mythic mob at this location
+     *
+     * @param mob      The mob
+     * @param location The location
+     * @return The mob, or null if it can't be spawned
+     */
+    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;
+    }
+}

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.IrisBlockData;
+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 IrisBlockData(data, blockState);
+        } else if (NexoFurniture.isFurniture(blockId.key())) {
+            return new IrisBlockData(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 Arrays.stream(NexoItems.itemNames())
+                .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 Arrays.stream(NexoItems.itemNames())
+                .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/WorldEditLink.java

@@ -0,0 +1,59 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.engine.data.cache.AtomicCache;
+import com.volmit.iris.util.data.Cuboid;
+import com.volmit.iris.util.data.KCache;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.InvocationTargetException;
+import java.time.Duration;
+import java.util.UUID;
+
+public class WorldEditLink {
+    private static final AtomicCache<Boolean> active = new AtomicCache<>();
+
+    public static Cuboid getSelection(Player p) {
+        if (!hasWorldEdit())
+            return null;
+
+        try {
+            Object instance = Class.forName("com.sk89q.worldedit.WorldEdit").getDeclaredMethod("getInstance").invoke(null);
+            Object sessionManager = instance.getClass().getDeclaredMethod("getSessionManager").invoke(instance);
+            Class<?> bukkitAdapter = Class.forName("com.sk89q.worldedit.bukkit.BukkitAdapter");
+            Object world = bukkitAdapter.getDeclaredMethod("adapt", World.class).invoke(null, p.getWorld());
+            Object player = bukkitAdapter.getDeclaredMethod("adapt", Player.class).invoke(null, p);
+            Object localSession = sessionManager.getClass().getDeclaredMethod("getIfPresent", Class.forName("com.sk89q.worldedit.session.SessionOwner")).invoke(sessionManager, player);
+            if (localSession == null) return null;
+
+            Object region = null;
+            try {
+                region = localSession.getClass().getDeclaredMethod("getSelection", Class.forName("com.sk89q.worldedit.world.World")).invoke(localSession, world);
+            } catch (InvocationTargetException ignored) {}
+            if (region == null) return null;
+
+            Object min = region.getClass().getDeclaredMethod("getMinimumPoint").invoke(region);
+            Object max = region.getClass().getDeclaredMethod("getMaximumPoint").invoke(region);
+            return new Cuboid(p.getWorld(),
+                    (int) min.getClass().getDeclaredMethod("x").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("y").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("z").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("x").invoke(max),
+                    (int) min.getClass().getDeclaredMethod("y").invoke(max),
+                    (int) min.getClass().getDeclaredMethod("z").invoke(max)
+            );
+        } catch (Throwable e) {
+            Iris.error("Could not get selection");
+            e.printStackTrace();
+            active.reset();
+            active.aquire(() -> false);
+        }
+        return null;
+    }
+
+    public static boolean hasWorldEdit() {
+        return active.aquire(() -> Bukkit.getPluginManager().isPluginEnabled("WorldEdit"));
+    }
+}

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

@@ -29,6 +29,7 @@ import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
 import java.io.File;
+import java.util.Set;
 
 public class ImageResourceLoader extends ResourceLoader<IrisImage> {
     public ImageResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
@@ -59,57 +60,73 @@ public class ImageResourceLoader extends ResourceLoader<IrisImage> {
             logLoad(j, img);
             tlt.addAndGet(p.getMilliseconds());
             return img;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
             return null;
         }
     }
 
+    void getPNGFiles(File directory, Set<String> m) {
+        for (File file : directory.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".png")) {
+                m.add(file.getName().replaceAll("\\Q.png\\E", ""));
+            } else if (file.isDirectory()) {
+                getPNGFiles(file, m);
+            }
+        }
+    }
+
+
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
 
         Iris.debug("Building " + resourceTypeName + " Possibility Lists");
         KSet<String> m = new KSet<>();
 
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".png")) {
-                    m.add(j.getName().replaceAll("\\Q.png\\E", ""));
-                } else if(j.isDirectory()) {
-                    for(File k : j.listFiles()) {
-                        if(k.isFile() && k.getName().endsWith(".png")) {
-                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.png\\E", ""));
-                        } else if(k.isDirectory()) {
-                            for(File l : k.listFiles()) {
-                                if(l.isFile() && l.getName().endsWith(".png")) {
-                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.png\\E", ""));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+
+        for (File i : getFolders()) {
+            getPNGFiles(i, m);
         }
 
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".png")) {
+//                    m.add(j.getName().replaceAll("\\Q.png\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".png")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.png\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".png")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.png\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+
         KList<String> v = new KList<>(m);
         possibleKeys = v.toArray(new String[0]);
         return possibleKeys;
     }
 
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".png");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -124,16 +141,16 @@ public class ImageResourceLoader extends ResourceLoader<IrisImage> {
     }
 
     private IrisImage loadRaw(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".png");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }

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

@@ -18,12 +18,7 @@
 
 package com.volmit.iris.core.loader;
 
-import com.google.gson.ExclusionStrategy;
-import com.google.gson.FieldAttributes;
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.TypeAdapter;
-import com.google.gson.TypeAdapterFactory;
+import com.google.gson.*;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonToken;
@@ -39,6 +34,9 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.context.IrisContext;
 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;
@@ -100,8 +98,8 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
     public static int cacheSize() {
         int m = 0;
-        for(IrisData i : dataLoaders.values()) {
-            for(ResourceLoader<?> j : i.getLoaders().values()) {
+        for (IrisData i : dataLoaders.values()) {
+            for (ResourceLoader<?> j : i.getLoaders().values()) {
                 m += j.getLoadCache().getSize();
             }
         }
@@ -116,6 +114,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     public static IrisObject loadAnyObject(String key) {
         return loadAny(key, (dm) -> dm.getObjectLoader().load(key, false));
     }
+
     public static IrisMatterObject loadAnyMatter(String key) {
         return loadAny(key, (dm) -> dm.getMatterLoader().load(key, false));
     }
@@ -194,17 +193,17 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
     public static <T extends IrisRegistrant> T loadAny(String key, Function<IrisData, T> v) {
         try {
-            for(File i : Objects.requireNonNull(Iris.instance.getDataFolder("packs").listFiles())) {
-                if(i.isDirectory()) {
+            for (File i : Objects.requireNonNull(Iris.instance.getDataFolder("packs").listFiles())) {
+                if (i.isDirectory()) {
                     IrisData dm = get(i);
                     T t = v.apply(dm);
 
-                    if(t != null) {
+                    if (t != null) {
                         return t;
                     }
                 }
             }
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -215,9 +214,9 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     public ResourceLoader<?> getTypedLoaderFor(File f) {
         String[] k = f.getPath().split("\\Q" + File.separator + "\\E");
 
-        for(String i : k) {
-            for(ResourceLoader<?> j : loaders.values()) {
-                if(j.getFolderName().equals(i)) {
+        for (String i : k) {
+            for (ResourceLoader<?> j : loaders.values()) {
+                if (j.getFolderName().equals(i)) {
                     return j;
                 }
             }
@@ -227,7 +226,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     }
 
     public void cleanupEngine() {
-        if(engine != null && engine.isClosed()) {
+        if (engine != null && engine.isClosed()) {
             engine = null;
             Iris.debug("Dereferenced Data<Engine> " + getId() + " " + getDataFolder());
         }
@@ -238,30 +237,30 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
             IrisContext ctx = IrisContext.get();
             Engine engine = this.engine;
 
-            if(engine == null && ctx != null && ctx.getEngine() != null) {
+            if (engine == null && ctx != null && ctx.getEngine() != null) {
                 engine = ctx.getEngine();
             }
 
-            if(engine == null && t.getPreprocessors().isNotEmpty()) {
+            if (engine == null && t.getPreprocessors().isNotEmpty()) {
                 Iris.error("Failed to preprocess object " + t.getLoadKey() + " because there is no engine context here. (See stack below)");
                 try {
                     throw new RuntimeException();
-                } catch(Throwable ex) {
+                } catch (Throwable ex) {
                     ex.printStackTrace();
                 }
             }
 
-            if(engine != null && t.getPreprocessors().isNotEmpty()) {
-                synchronized(this) {
+            if (engine != null && t.getPreprocessors().isNotEmpty()) {
+                synchronized (this) {
                     engine.getExecution().getAPI().setPreprocessorObject(t);
 
-                    for(String i : t.getPreprocessors()) {
+                    for (String i : t.getPreprocessors()) {
                         engine.getExecution().execute(i);
                         Iris.debug("Loader<" + C.GREEN + t.getTypeName() + C.LIGHT_PURPLE + "> iprocess " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in <rainbow>" + i);
                     }
                 }
             }
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.error("Failed to preprocess object!");
             e.printStackTrace();
         }
@@ -280,18 +279,18 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         try {
             IrisRegistrant rr = registrant.getConstructor().newInstance();
             ResourceLoader<T> r = null;
-            if(registrant.equals(IrisObject.class)) {
+            if (registrant.equals(IrisObject.class)) {
                 r = (ResourceLoader<T>) new ObjectResourceLoader(dataFolder, this, rr.getFolderName(),
-                    rr.getTypeName());
-            } else if(registrant.equals(IrisMatterObject.class)) {
+                        rr.getTypeName());
+            } else if (registrant.equals(IrisMatterObject.class)) {
                 r = (ResourceLoader<T>) new MatterObjectResourceLoader(dataFolder, this, rr.getFolderName(),
                         rr.getTypeName());
-            } else if(registrant.equals(IrisScript.class)) {
+            } else if (registrant.equals(IrisScript.class)) {
                 r = (ResourceLoader<T>) new ScriptResourceLoader(dataFolder, this, rr.getFolderName(),
                         rr.getTypeName());
-            } else if(registrant.equals(IrisImage.class)) {
+            } else if (registrant.equals(IrisImage.class)) {
                 r = (ResourceLoader<T>) new ImageResourceLoader(dataFolder, this, rr.getFolderName(),
-                    rr.getTypeName());
+                        rr.getTypeName());
             } else {
                 J.attempt(() -> registrant.getConstructor().newInstance().registerTypeAdapters(builder));
                 r = new ResourceLoader<>(dataFolder, this, rr.getFolderName(), rr.getTypeName(), registrant);
@@ -300,7 +299,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
             loaders.put(registrant, r);
 
             return r;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
             Iris.error("Failed to create loader! " + registrant.getCanonicalName());
         }
@@ -311,11 +310,11 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     public synchronized void hotloaded() {
         possibleSnippets = new KMap<>();
         builder = new GsonBuilder()
-            .addDeserializationExclusionStrategy(this)
-            .addSerializationExclusionStrategy(this)
-            .setLenient()
-            .registerTypeAdapterFactory(this)
-            .setPrettyPrinting();
+                .addDeserializationExclusionStrategy(this)
+                .addSerializationExclusionStrategy(this)
+                .setLenient()
+                .registerTypeAdapterFactory(this)
+                .setPrettyPrinting();
         loaders.clear();
         File packs = dataFolder;
         packs.mkdirs();
@@ -339,30 +338,39 @@ 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();
     }
 
     public void dump() {
-        for(ResourceLoader<?> i : loaders.values()) {
+        for (ResourceLoader<?> i : loaders.values()) {
             i.clearCache();
         }
     }
 
     public void clearLists() {
-        for(ResourceLoader<?> i : loaders.values()) {
+        for (ResourceLoader<?> i : loaders.values()) {
             i.clearList();
         }
     }
 
     public String toLoadKey(File f) {
-        if(f.getPath().startsWith(getDataFolder().getPath())) {
+        if (f.getPath().startsWith(getDataFolder().getPath())) {
             String[] full = f.getPath().split("\\Q" + File.separator + "\\E");
             String[] df = getDataFolder().getPath().split("\\Q" + File.separator + "\\E");
             StringBuilder g = new StringBuilder();
             boolean m = true;
-            for(int i = 0; i < full.length; i++) {
-                if(i >= df.length) {
-                    if(m) {
+            for (int i = 0; i < full.length; i++) {
+                if (i >= df.length) {
+                    if (m) {
                         m = false;
                         continue;
                     }
@@ -371,8 +379,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
                 }
             }
 
-            String ff = g.substring(1).split("\\Q.\\E")[0];
-            return ff;
+            return g.substring(1).split("\\Q.\\E")[0];
         } else {
             Iris.error("Forign file from loader " + f.getPath() + " (loader realm: " + getDataFolder().getPath() + ")");
         }
@@ -389,14 +396,14 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
     @Override
     public boolean shouldSkipClass(Class<?> c) {
-        if(c.equals(AtomicCache.class)) {
+        if (c.equals(AtomicCache.class)) {
             return true;
         } else return c.equals(ChronoLatch.class);
     }
 
     @Override
     public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
-        if(!typeToken.getRawType().isAnnotationPresent(Snippet.class)) {
+        if (!typeToken.getRawType().isAnnotationPresent(Snippet.class)) {
             return null;
         }
 
@@ -412,17 +419,17 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
             public T read(JsonReader reader) throws IOException {
                 TypeAdapter<T> adapter = gson.getDelegateAdapter(IrisData.this, typeToken);
 
-                if(reader.peek().equals(JsonToken.STRING)) {
+                if (reader.peek().equals(JsonToken.STRING)) {
                     String r = reader.nextString();
 
-                    if(r.startsWith("snippet/" + snippetType + "/")) {
+                    if (r.startsWith("snippet/" + snippetType + "/")) {
                         File f = new File(getDataFolder(), r + ".json");
 
-                        if(f.exists()) {
+                        if (f.exists()) {
                             try {
                                 JsonReader snippetReader = new JsonReader(new FileReader(f));
                                 return adapter.read(snippetReader);
-                            } catch(Throwable e) {
+                            } catch (Throwable e) {
                                 Iris.error("Couldn't read snippet " + r + " in " + reader.getPath() + " (" + e.getMessage() + ")");
                             }
                         } else {
@@ -435,11 +442,12 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
                 try {
                     return adapter.read(reader);
-                } catch(Throwable e) {
+                } 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) {
+                    } catch (Throwable ignored) {
 
                     }
                 }
@@ -454,8 +462,8 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
             File snippetFolder = new File(getDataFolder(), "snippet/" + f);
 
-            if(snippetFolder.exists() && snippetFolder.isDirectory()) {
-                for(File i : snippetFolder.listFiles()) {
+            if (snippetFolder.exists() && snippetFolder.isDirectory()) {
+                for (File i : snippetFolder.listFiles()) {
                     l.add("snippet/" + f + "/" + i.getName().split("\\Q.\\E")[0]);
                 }
             }
@@ -467,4 +475,38 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     public boolean isClosed() {
         return closed;
     }
+
+    public void savePrefetch(Engine engine) {
+        BurstExecutor b = MultiBurst.burst.burst(loaders.size());
+
+        for (ResourceLoader<?> i : loaders.values()) {
+            b.queue(() -> {
+                try {
+                    i.saveFirstAccess(engine);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+
+        b.complete();
+        Iris.info("Saved Prefetch Cache to speed up future world startups");
+    }
+
+    public void loadPrefetch(Engine engine) {
+        BurstExecutor b = MultiBurst.burst.burst(loaders.size());
+
+        for (ResourceLoader<?> i : loaders.values()) {
+            b.queue(() -> {
+                try {
+                    i.loadFirstAccess(engine);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+
+        b.complete();
+        Iris.info("Loaded Prefetch Cache to reduce generation disk use.");
+    }
 }

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

@@ -29,7 +29,7 @@ import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.plugin.VolmitSender;
 import lombok.Data;
 
-import java.awt.Desktop;
+import java.awt.*;
 import java.io.File;
 
 @Data
@@ -56,7 +56,7 @@ public abstract class IrisRegistrant {
     public File openInVSCode() {
         try {
             Desktop.getDesktop().open(getLoadFile());
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
         }
 

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

@@ -29,6 +29,8 @@ import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import java.io.File;
 
 public class MatterObjectResourceLoader extends ResourceLoader<IrisMatterObject> {
+    private String[] possibleKeys;
+
     public MatterObjectResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
         super(root, idm, folderName, resourceTypeName, IrisMatterObject.class);
         loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getObjectLoaderCacheSize());
@@ -56,39 +58,33 @@ public class MatterObjectResourceLoader extends ResourceLoader<IrisMatterObject>
             logLoad(j, t);
             tlt.addAndGet(p.getMilliseconds());
             return t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
             return null;
         }
     }
 
+    private void findMatFiles(File dir, KSet<String> m) {
+        for (File file : dir.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".mat")) {
+                m.add(file.getName().replaceAll("\\Q.mat\\E", ""));
+            } else if (file.isDirectory()) {
+                findMatFiles(file, m);
+            }
+        }
+    }
+
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
 
         Iris.debug("Building " + resourceTypeName + " Possibility Lists");
         KSet<String> m = new KSet<>();
 
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".mat")) {
-                    m.add(j.getName().replaceAll("\\Q.mat\\E", ""));
-                } else if(j.isDirectory()) {
-                    for(File k : j.listFiles()) {
-                        if(k.isFile() && k.getName().endsWith(".mat")) {
-                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.mat\\E", ""));
-                        } else if(k.isDirectory()) {
-                            for(File l : k.listFiles()) {
-                                if(l.isFile() && l.getName().endsWith(".mat")) {
-                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.mat\\E", ""));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+        for (File folder : getFolders()) {
+            findMatFiles(folder, m);
         }
 
         KList<String> v = new KList<>(m);
@@ -96,17 +92,51 @@ public class MatterObjectResourceLoader extends ResourceLoader<IrisMatterObject>
         return possibleKeys;
     }
 
+
+//    public String[] getPossibleKeys() {
+//        if (possibleKeys != null) {
+//            return possibleKeys;
+//        }
+//
+//        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+//        KSet<String> m = new KSet<>();
+//
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".mat")) {
+//                    m.add(j.getName().replaceAll("\\Q.mat\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".mat")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.mat\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".mat")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.mat\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        KList<String> v = new KList<>(m);
+//        possibleKeys = v.toArray(new String[0]);
+//        return possibleKeys;
+//    }
+
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".mat");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -121,16 +151,16 @@ public class MatterObjectResourceLoader extends ResourceLoader<IrisMatterObject>
     }
 
     private IrisMatterObject loadRaw(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".mat");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }

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

@@ -50,14 +50,14 @@ public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
         try {
             PrecisionStopwatch p = PrecisionStopwatch.start();
             IrisObject t = new IrisObject(0, 0, 0);
-            t.read(j);
             t.setLoadKey(name);
             t.setLoader(manager);
             t.setLoadFile(j);
+            t.read(j);
             logLoad(j, t);
             tlt.addAndGet(p.getMilliseconds());
             return t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
             return null;
@@ -65,49 +65,42 @@ public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
     }
 
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
-
         Iris.debug("Building " + resourceTypeName + " Possibility Lists");
         KSet<String> m = new KSet<>();
-
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".iob")) {
-                    m.add(j.getName().replaceAll("\\Q.iob\\E", ""));
-                } else if(j.isDirectory()) {
-                    for(File k : j.listFiles()) {
-                        if(k.isFile() && k.getName().endsWith(".iob")) {
-                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.iob\\E", ""));
-                        } else if(k.isDirectory()) {
-                            for(File l : k.listFiles()) {
-                                if(l.isFile() && l.getName().endsWith(".iob")) {
-                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.iob\\E", ""));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+        for (File i : getFolders()) {
+            m.addAll(getFiles(i, ".iob", true));
         }
-
-        KList<String> v = new KList<>(m);
-        possibleKeys = v.toArray(new String[0]);
+        possibleKeys = m.toArray(new String[0]);
         return possibleKeys;
     }
 
+    private KList<String> getFiles(File dir, String ext, boolean skipDirName) {
+        KList<String> paths = new KList<>();
+        String name = skipDirName ? "" : dir.getName() + "/";
+        for (File f : dir.listFiles()) {
+            if (f.isFile() && f.getName().endsWith(ext)) {
+                paths.add(name + f.getName().replaceAll("\\Q" + ext + "\\E", ""));
+            } else if (f.isDirectory()) {
+                getFiles(f, ext, false).forEach(e -> paths.add(name + e));
+            }
+        }
+        return paths;
+    }
+
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".iob");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -122,16 +115,16 @@ public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
     }
 
     private IrisObject loadRaw(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".iob");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }

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

@@ -23,37 +23,48 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.project.SchemaBuilder;
 import com.volmit.iris.core.service.PreservationSVC;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.MeteredCache;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.data.KCache;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.CustomOutputStream;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONArray;
 import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
 
-import java.io.File;
+import java.io.*;
 import java.util.Locale;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
 
 @Data
+@EqualsAndHashCode(exclude = "manager")
+@ToString(exclude = "manager")
 public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public static final AtomicDouble tlt = new AtomicDouble(0);
     private static final int CACHE_SIZE = 100000;
+    protected final AtomicReference<KList<File>> folderCache;
+    protected KSet<String> firstAccess;
     protected File root;
     protected String folderName;
     protected String resourceTypeName;
     protected KCache<String, T> loadCache;
-    protected final AtomicReference<KList<File>> folderCache;
     protected Class<? extends T> objectClass;
     protected String cname;
     protected String[] possibleKeys = null;
@@ -63,6 +74,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
 
     public ResourceLoader(File root, IrisData manager, String folderName, String resourceTypeName, Class<? extends T> objectClass) {
         this.manager = manager;
+        firstAccess = new KSet<>();
         folderCache = new AtomicReference<>();
         sec = new ChronoLatch(5000);
         loads = new AtomicInteger();
@@ -81,7 +93,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         JSONObject o = new JSONObject();
         KList<String> fm = new KList<>();
 
-        for(int g = 1; g < 8; g++) {
+        for (int g = 1; g < 8; g++) {
             fm.add("/" + folderName + Form.repeat("/*", g) + ".json");
         }
 
@@ -94,16 +106,16 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".json");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -116,11 +128,11 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public void logLoad(File path, T t) {
         loads.getAndIncrement();
 
-        if(loads.get() == 1) {
+        if (loads.get() == 1) {
             sec.flip();
         }
 
-        if(sec.flip()) {
+        if (sec.flip()) {
             J.a(() -> {
                 Iris.verbose("Loaded " + C.WHITE + loads.get() + " " + resourceTypeName + (loads.get() == 1 ? "" : "s") + C.GRAY + " (" + Form.f(getLoadCache().getSize()) + " " + resourceTypeName + (loadCache.getSize() == 1 ? "" : "s") + " Loaded)");
                 loads.set(0);
@@ -141,32 +153,32 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     private void matchFiles(File at, KList<File> files, Predicate<File> f) {
-        if(at.isDirectory()) {
-            for(File i : at.listFiles()) {
+        if (at.isDirectory()) {
+            for (File i : at.listFiles()) {
                 matchFiles(i, files, f);
             }
         } else {
-            if(f.test(at)) {
+            if (f.test(at)) {
                 files.add(at);
             }
         }
     }
 
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
 
         KSet<String> m = new KSet<>();
         KList<File> files = getFolders();
 
-        if(files == null) {
+        if (files == null) {
             possibleKeys = new String[0];
             return possibleKeys;
         }
 
-        for(File i : files) {
-            for(File j : matchAllFiles(i, (f) -> f.getName().endsWith(".json"))) {
+        for (File i : files) {
+            for (File j : matchAllFiles(i, (f) -> f.getName().endsWith(".json"))) {
                 m.add(i.toURI().relativize(j.toURI()).getPath().replaceAll("\\Q.json\\E", ""));
             }
         }
@@ -184,7 +196,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         try {
             PrecisionStopwatch p = PrecisionStopwatch.start();
             T t = getManager().getGson()
-                .fromJson(preprocess(new JSONObject(IO.readAll(j))).toString(0), objectClass);
+                    .fromJson(preprocess(new JSONObject(IO.readAll(j))).toString(0), objectClass);
             t.setLoadKey(name);
             t.setLoadFile(j);
             t.setLoader(manager);
@@ -192,7 +204,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
             logLoad(j, t);
             tlt.addAndGet(p.getMilliseconds());
             return t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             failLoad(j, e);
             return null;
@@ -210,10 +222,10 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public KList<T> loadAll(KList<String> s) {
         KList<T> m = new KList<>();
 
-        for(String i : s) {
+        for (String i : s) {
             T t = load(i);
 
-            if(t != null) {
+            if (t != null) {
                 m.add(t);
             }
         }
@@ -221,13 +233,31 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         return m;
     }
 
+    public KList<T> loadAllParallel(KList<String> s) {
+        KList<T> m = new KList<>();
+        BurstExecutor burst = MultiBurst.burst.burst(s.size());
+
+        for (String i : s) {
+            burst.queue(() -> {
+                T t = load(i);
+
+                if (t != null) {
+                    m.add(t);
+                }
+            });
+        }
+
+        burst.complete();
+        return m;
+    }
+
     public KList<T> loadAll(KList<String> s, Consumer<T> postLoad) {
         KList<T> m = new KList<>();
 
-        for(String i : s) {
+        for (String i : s) {
             T t = load(i);
 
-            if(t != null) {
+            if (t != null) {
                 m.add(t);
                 postLoad.accept(t);
             }
@@ -239,10 +269,10 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public KList<T> loadAll(String[] s) {
         KList<T> m = new KList<>();
 
-        for(String i : s) {
+        for (String i : s) {
             T t = load(i);
 
-            if(t != null) {
+            if (t != null) {
                 m.add(t);
             }
         }
@@ -255,17 +285,17 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     private T loadRaw(String name) {
-        for(File i : getFolders(name)) {
+        for (File i : getFolders(name)) {
             //noinspection ConstantConditions
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".json");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }
@@ -274,27 +304,72 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     public T load(String name, boolean warn) {
-        if(name == null) {
+        if (name == null) {
             return null;
         }
 
-        if(name.trim().isEmpty()) {
+        if (name.trim().isEmpty()) {
             return null;
         }
 
+        firstAccess.add(name);
         return loadCache.get(name);
     }
 
+    public void loadFirstAccess(Engine engine) throws IOException {
+        String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
+        File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
+
+        if (!file.exists()) {
+            return;
+        }
+
+        FileInputStream fin = new FileInputStream(file);
+        GZIPInputStream gzi = new GZIPInputStream(fin);
+        DataInputStream din = new DataInputStream(gzi);
+        int m = din.readInt();
+        KList<String> s = new KList<>();
+
+        for (int i = 0; i < m; i++) {
+            s.add(din.readUTF());
+        }
+
+        din.close();
+        file.deleteOnExit();
+        Iris.info("Loading " + s.size() + " prefetch " + getFolderName());
+        loadAllParallel(s);
+    }
+
+    public void saveFirstAccess(Engine engine) throws IOException {
+        String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
+        File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
+        file.getParentFile().mkdirs();
+        FileOutputStream fos = new FileOutputStream(file);
+        GZIPOutputStream gzo = new CustomOutputStream(fos, 9);
+        DataOutputStream dos = new DataOutputStream(gzo);
+        dos.writeInt(firstAccess.size());
+
+        for (String i : firstAccess) {
+            dos.writeUTF(i);
+        }
+
+        dos.flush();
+        dos.close();
+    }
+
     public KList<File> getFolders() {
-
-
-        synchronized(folderCache) {
-            if(folderCache.get() == null) {
+        synchronized (folderCache) {
+            if (folderCache.get() == null) {
                 KList<File> fc = new KList<>();
 
-                for(File i : root.listFiles()) {
-                    if(i.isDirectory()) {
-                        if(i.getName().equals(folderName)) {
+                File[] files = root.listFiles();
+                if (files == null) {
+                    throw new IllegalStateException("Failed to list files in " + root);
+                }
+
+                for (File i : files) {
+                    if (i.isDirectory()) {
+                        if (i.getName().equals(folderName)) {
                             fc.add(i);
                             break;
                         }
@@ -311,9 +386,9 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public KList<File> getFolders(String rc) {
         KList<File> folders = getFolders().copy();
 
-        if(rc.contains(":")) {
-            for(File i : folders.copy()) {
-                if(!rc.startsWith(i.getName() + ":")) {
+        if (rc.contains(":")) {
+            for (File i : folders.copy()) {
+                if (!rc.startsWith(i.getName() + ":")) {
                     folders.remove(i);
                 }
             }
@@ -329,16 +404,16 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     public File fileFor(T b) {
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(b.getLoadKey())) {
+        for (File i : getFolders()) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(b.getLoadKey())) {
                     return j;
                 }
             }
 
             File file = new File(i, b.getLoadKey() + ".json");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -358,8 +433,8 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public KList<String> getPossibleKeys(String arg) {
         KList<String> f = new KList<>();
 
-        for(String i : getPossibleKeys()) {
-            if(i.equalsIgnoreCase(arg) || i.toLowerCase(Locale.ROOT).startsWith(arg.toLowerCase(Locale.ROOT)) || i.toLowerCase(Locale.ROOT).contains(arg.toLowerCase(Locale.ROOT)) || arg.toLowerCase(Locale.ROOT).contains(i.toLowerCase(Locale.ROOT))) {
+        for (String i : getPossibleKeys()) {
+            if (i.equalsIgnoreCase(arg) || i.toLowerCase(Locale.ROOT).startsWith(arg.toLowerCase(Locale.ROOT)) || i.toLowerCase(Locale.ROOT).contains(arg.toLowerCase(Locale.ROOT)) || arg.toLowerCase(Locale.ROOT).contains(i.toLowerCase(Locale.ROOT))) {
                 f.add(i);
             }
         }

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

@@ -21,13 +21,13 @@ package com.volmit.iris.core.loader;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.engine.object.IrisScript;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.data.KCache;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 
 import java.io.File;
+import java.util.HashSet;
+import java.util.Set;
 
 public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
     public ScriptResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
@@ -53,57 +53,88 @@ public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
             logLoad(j, t);
             tlt.addAndGet(p.getMilliseconds());
             return t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
             return null;
         }
     }
 
+
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
 
         Iris.debug("Building " + resourceTypeName + " Possibility Lists");
-        KSet<String> m = new KSet<>();
+        Set<String> keys = new HashSet<>();
 
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".js")) {
-                    m.add(j.getName().replaceAll("\\Q.js\\E", ""));
-                } else if(j.isDirectory()) {
-                    for(File k : j.listFiles()) {
-                        if(k.isFile() && k.getName().endsWith(".js")) {
-                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.js\\E", ""));
-                        } else if(k.isDirectory()) {
-                            for(File l : k.listFiles()) {
-                                if(l.isFile() && l.getName().endsWith(".js")) {
-                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.js\\E", ""));
-                                }
-                            }
-                        }
-                    }
-                }
+        for (File i : getFolders()) {
+            if (i.isDirectory()) {
+                keys.addAll(getKeysInDirectory(i));
             }
         }
 
-        KList<String> v = new KList<>(m);
-        possibleKeys = v.toArray(new String[0]);
+        possibleKeys = keys.toArray(new String[0]);
         return possibleKeys;
     }
 
+    private Set<String> getKeysInDirectory(File directory) {
+        Set<String> keys = new HashSet<>();
+        for (File file : directory.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".js")) {
+                keys.add(file.getName().replaceAll("\\Q.js\\E", ""));
+            } else if (file.isDirectory()) {
+                keys.addAll(getKeysInDirectory(file));
+            }
+        }
+        return keys;
+    }
+
+//    public String[] getPossibleKeys() {
+//        if (possibleKeys != null) {
+//            return possibleKeys;
+//        }
+//
+//        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+//        KSet<String> m = new KSet<>();
+//
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".js")) {
+//                    m.add(j.getName().replaceAll("\\Q.js\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".js")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.js\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".js")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.js\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        KList<String> v = new KList<>(m);
+//        possibleKeys = v.toArray(new String[0]);
+//        return possibleKeys;
+//    }
+
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".js");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -114,16 +145,16 @@ public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
     }
 
     private IrisScript loadRaw(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".js");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }

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

@@ -20,15 +20,20 @@ package com.volmit.iris.core.nms;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.nms.v19_1.NMSBinding19_1;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
-import com.volmit.iris.util.collection.KMap;
 import org.bukkit.Bukkit;
 
+import java.util.Map;
+
 public class INMS {
-    //@builder
-    private static final KMap<String, Class<? extends INMSBinding>> bindings = new KMap<String, Class<? extends INMSBinding>>()
-        .qput("v1_19_R1", NMSBinding19_1.class);
+    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.21.2", "v1_21_R2",
+        "1.21.3", "v1_21_R2"
+    );
     //@done
     private static final INMSBinding binding = bind();
 
@@ -37,13 +42,18 @@ public class INMS {
     }
 
     public static String getNMSTag() {
-        if(IrisSettings.get().getGeneral().isDisableNMS()) {
+        if (IrisSettings.get().getGeneral().isDisableNMS()) {
             return "BUKKIT";
         }
 
         try {
-            return Bukkit.getServer().getClass().getCanonicalName().split("\\Q.\\E")[3];
-        } catch(Throwable e) {
+            String name = Bukkit.getServer().getClass().getCanonicalName();
+            if (name.equals("org.bukkit.craftbukkit.CraftServer")) {
+                return REVISION.getOrDefault(Bukkit.getServer().getBukkitVersion().split("-")[0], "BUKKIT");
+            } else {
+                return name.split("\\Q.\\E")[3];
+            }
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.error("Failed to determine server nms version!");
             e.printStackTrace();
@@ -56,17 +66,19 @@ public class INMS {
         String code = getNMSTag();
         Iris.info("Locating NMS Binding for " + code);
 
-        if(bindings.containsKey(code)) {
+        try {
+            Class<?> clazz = Class.forName("com.volmit.iris.core.nms."+code+".NMSBinding");
             try {
-                INMSBinding b = bindings.get(code).getConstructor().newInstance();
-                Iris.info("Craftbukkit " + code + " <-> " + b.getClass().getSimpleName() + " Successfully Bound");
-
-                return b;
-            } catch(Throwable e) {
+                Object b = clazz.getConstructor().newInstance();
+                if (b instanceof INMSBinding binding) {
+                    Iris.info("Craftbukkit " + code + " <-> " + b.getClass().getSimpleName() + " Successfully Bound");
+                    return binding;
+                }
+            } catch (Throwable e) {
                 Iris.reportError(e);
                 e.printStackTrace();
             }
-        }
+        } catch (ClassNotFoundException|NoClassDefFoundError classNotFoundException) {}
 
         Iris.info("Craftbukkit " + code + " <-> " + NMSBinding1X.class.getSimpleName() + " Successfully Bound");
         Iris.warn("Note: Some features of Iris may not work the same since you are on an unsupported version of Minecraft.");

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

@@ -18,22 +18,37 @@
 
 package com.volmit.iris.core.nms;
 
+import com.volmit.iris.core.nms.container.BiomeColor;
+import com.volmit.iris.core.nms.datapack.DataVersion;
+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.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
 import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.WorldCreator;
+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 {
+    boolean hasTile(Material material);
+
     boolean hasTile(Location l);
 
-    CompoundTag serializeTile(Location location);
+    KMap<String, Object> serializeTile(Location location);
 
-    void deserializeTile(CompoundTag s, Location newPosition);
+    void deserializeTile(KMap<String, Object> s, Location newPosition);
 
     CompoundTag serializeEntity(Entity location);
 
@@ -54,14 +69,19 @@ public interface INMSBinding {
     String getTrueBiomeBaseKey(Location location);
 
     Object getCustomBiomeBaseFor(String mckey);
+
     Object getCustomBiomeBaseHolderFor(String mckey);
 
+    int getBiomeBaseIdForKey(String key);
+
     String getKeyForBiomeBase(Object biomeBase);
 
     Object getBiomeBase(World world, Biome biome);
 
     Object getBiomeBase(Object registry, Biome biome);
 
+    KList<Biome> getBiomes();
+
     boolean isBukkit();
 
     int getBiomeId(Biome biome);
@@ -83,4 +103,26 @@ public interface INMSBinding {
     }
 
     MCAPaletteAccess createPalette();
+
+    void injectBiomesFromMantle(Chunk e, Mantle mantle);
+
+    ItemStack applyCustomNbt(ItemStack itemStack, KMap<String, Object> customNbt) throws IllegalArgumentException;
+
+    void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException;
+
+    Vector3d getBoundingbox(org.bukkit.entity.EntityType entity);
+    
+    Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason);
+
+    Color getBiomeColor(Location location, BiomeColor type);
+
+    default DataVersion getDataVersion() {
+        return DataVersion.V1192;
+    }
+
+    default int getSpawnChunkCount(World world) {
+        return 441;
+    }
+
+    KList<String> getStructureKeys();
 }

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

@@ -0,0 +1,10 @@
+package com.volmit.iris.core.nms.container;
+
+public enum BiomeColor {
+    FOG,
+    WATER,
+    WATER_FOG,
+    SKY,
+    FOLIAGE,
+    GRASS
+}

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

@@ -0,0 +1,14 @@
+package com.volmit.iris.core.nms.container;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class BlockPos {
+    private int x;
+    private int y;
+    private int z;
+}

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

@@ -0,0 +1,13 @@
+package com.volmit.iris.core.nms.container;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Pair<A, B> {
+    private A a;
+    private B b;
+}

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

@@ -0,0 +1,42 @@
+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;
+
+import java.util.function.Supplier;
+
+//https://minecraft.wiki/w/Pack_format
+@Getter
+public enum DataVersion {
+    V1192("1.19.2", 10, DataFixerV1192::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;
+    private final String version;
+    private final int packFormat;
+
+    DataVersion(String version, int packFormat, Supplier<IDataFixer> constructor) {
+        this.constructor = constructor;
+        this.packFormat = packFormat;
+        this.version = version;
+    }
+
+    public IDataFixer get() {
+        return cache.computeIfAbsent(this, k -> constructor.get());
+    }
+
+    public static IDataFixer getDefault() {
+        return INMS.get().getDataVersion().get();
+    }
+
+    public static DataVersion getLatest() {
+        return values()[values().length - 1];
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.volmit.iris.core.nms.datapack;
+
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.util.json.JSONObject;
+
+public interface IDataFixer {
+
+    JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json);
+
+    JSONObject fixDimension(JSONObject json);
+}

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

@@ -0,0 +1,18 @@
+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;
+
+public class DataFixerV1192 implements IDataFixer {
+
+    @Override
+    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+        return json;
+    }
+
+    @Override
+    public JSONObject fixDimension(JSONObject json) {
+        return json;
+    }
+}

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

@@ -0,0 +1,56 @@
+package com.volmit.iris.core.nms.datapack.v1206;
+
+import com.volmit.iris.core.nms.datapack.IDataFixer;
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.engine.object.IrisBiomeCustomSpawn;
+import com.volmit.iris.engine.object.IrisBiomeCustomSpawnType;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.json.JSONArray;
+import com.volmit.iris.util.json.JSONObject;
+
+import java.util.Locale;
+
+public class DataFixerV1206 implements IDataFixer {
+    @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();
+        if (spawns != null && spawns.isNotEmpty()) {
+            JSONObject spawners = new JSONObject();
+            KMap<IrisBiomeCustomSpawnType, JSONArray> groups = new KMap<>();
+
+            for (IrisBiomeCustomSpawn i : spawns) {
+                JSONArray g = groups.computeIfAbsent(i.getGroup(), (k) -> new JSONArray());
+                JSONObject o = new JSONObject();
+                o.put("type", i.getType().getKey());
+                o.put("weight", i.getWeight());
+                o.put("minCount", i.getMinCount());
+                o.put("maxCount", i.getMaxCount());
+                g.put(o);
+            }
+
+            for (IrisBiomeCustomSpawnType i : groups.k()) {
+                spawners.put(i.name().toLowerCase(Locale.ROOT), groups.get(i));
+            }
+
+            json.put("spawners", spawners);
+        }
+        return json;
+    }
+
+    @Override
+    public JSONObject fixDimension(JSONObject json) {
+        if (!(json.get("monster_spawn_light_level") instanceof JSONObject lightLevel))
+            return json;
+        var value = (JSONObject) lightLevel.remove("value");
+        lightLevel.put("max_inclusive", value.get("max_inclusive"));
+        lightLevel.put("min_inclusive", value.get("min_inclusive"));
+        return json;
+    }
+}

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,14 +20,26 @@ 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.BiomeColor;
+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.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
 import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
-import org.bukkit.Location;
-import org.bukkit.World;
+import org.bukkit.*;
 import org.bukkit.block.Biome;
 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.Color;
+import java.util.stream.StreamSupport;
 
 public class NMSBinding1X implements INMSBinding {
     private static final boolean supportsCustomHeight = testCustomHeight();
@@ -35,33 +47,77 @@ public class NMSBinding1X implements INMSBinding {
     @SuppressWarnings("ConstantConditions")
     private static boolean testCustomHeight() {
         try {
-            if(World.class.getDeclaredMethod("getMaxHeight") != null && World.class.getDeclaredMethod("getMinHeight") != null)
+            if (World.class.getDeclaredMethod("getMaxHeight") != null && World.class.getDeclaredMethod("getMinHeight") != null)
                 ;
             {
                 return true;
             }
-        } catch(Throwable ignored) {
+        } catch (Throwable ignored) {
 
         }
 
         return false;
     }
 
+    @Override
+    public boolean hasTile(Material material) {
+        return false;
+    }
+
     @Override
     public boolean hasTile(Location l) {
         return false;
     }
 
     @Override
-    public CompoundTag serializeTile(Location location) {
+    public KMap<String, Object> serializeTile(Location location) {
         return null;
     }
 
     @Override
-    public void deserializeTile(CompoundTag s, Location newPosition) {
+    public void deserializeTile(KMap<String, Object> s, Location newPosition) {
 
     }
 
+
+    @Override
+    public void injectBiomesFromMantle(Chunk e, Mantle mantle) {
+
+    }
+
+    @Override
+    public ItemStack applyCustomNbt(ItemStack itemStack, KMap<String, Object> customNbt) throws IllegalArgumentException {
+        return itemStack;
+    }
+
+    @Override
+    public void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException {
+
+    }
+
+    public Vector3d getBoundingbox() {
+        return null;
+    }
+
+    @Override
+    public Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        return location.getWorld().spawnEntity(location, type);
+    }
+
+    @Override
+    public Color getBiomeColor(Location location, BiomeColor type) {
+        return Color.GREEN;
+    }
+
+    @Override
+    public KList<String> getStructureKeys() {
+        var list = StreamSupport.stream(Registry.STRUCTURE.spliterator(), false)
+                .map(Structure::getKey)
+                .map(NamespacedKey::toString)
+                .toList();
+        return new KList<>(list);
+    }
+
     @Override
     public CompoundTag serializeEntity(Entity location) {
         return null;
@@ -117,6 +173,11 @@ public class NMSBinding1X implements INMSBinding {
         return null;
     }
 
+    @Override
+    public int getBiomeBaseIdForKey(String key) {
+        return 0;
+    }
+
     @Override
     public String getKeyForBiomeBase(Object biomeBase) {
         return null;
@@ -131,6 +192,11 @@ public class NMSBinding1X implements INMSBinding {
         return null;
     }
 
+    @Override
+    public KList<Biome> getBiomes() {
+        return new KList<>(Biome.values()).qdel(Biome.CUSTOM);
+    }
+
     @Override
     public boolean isBukkit() {
         return true;
@@ -165,6 +231,11 @@ public class NMSBinding1X implements INMSBinding {
 
     }
 
+    @Override
+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+      return null;
+    }
+
     @Override
     public MCAPaletteAccess createPalette() {
         Iris.error("Cannot use the global data palette! Iris is incapable of using MCA generation on this version of minecraft!");

core/src/main/java/com/volmit/iris/core/pack/IrisPack.java

@@ -54,8 +54,7 @@ public class IrisPack {
      * Create an iris pack backed by a data folder
      * the data folder is assumed to be in the Iris/packs/NAME folder
      *
-     * @param name
-     *     the name
+     * @param name the name
      */
     public IrisPack(String name) {
         this(packsPack(name));
@@ -64,17 +63,16 @@ public class IrisPack {
     /**
      * Create an iris pack backed by a data folder
      *
-     * @param folder
-     *     the folder of the pack. Must be a directory
+     * @param folder the folder of the pack. Must be a directory
      */
     public IrisPack(File folder) {
         this.folder = folder;
 
-        if(!folder.exists()) {
+        if (!folder.exists()) {
             throw new RuntimeException("Cannot open Pack " + folder.getPath() + " (directory doesnt exist)");
         }
 
-        if(!folder.isDirectory()) {
+        if (!folder.isDirectory()) {
             throw new RuntimeException("Cannot open Pack " + folder.getPath() + " (not a directory)");
         }
 
@@ -84,23 +82,20 @@ public class IrisPack {
     /**
      * Create a new pack from the input url
      *
-     * @param sender
-     *     the sender
-     * @param url
-     *     the url, or name, or really anything see IrisPackRepository.from(String)
+     * @param sender the sender
+     * @param url    the url, or name, or really anything see IrisPackRepository.from(String)
      * @return the iris pack
-     * @throws IrisException
-     *     fails
+     * @throws IrisException fails
      */
     public static Future<IrisPack> from(VolmitSender sender, String url) throws IrisException {
         IrisPackRepository repo = IrisPackRepository.from(url);
-        if(repo == null) {
+        if (repo == null) {
             throw new IrisException("Null Repo");
         }
 
         try {
             return from(sender, repo);
-        } catch(MalformedURLException e) {
+        } catch (MalformedURLException e) {
             throw new IrisException("Malformed URL " + e.getMessage());
         }
     }
@@ -108,13 +103,10 @@ public class IrisPack {
     /**
      * Create a pack from a repo
      *
-     * @param sender
-     *     the sender
-     * @param repo
-     *     the repo
+     * @param sender the sender
+     * @param repo   the repo
      * @return the pack
-     * @throws MalformedURLException
-     *     shit happens
+     * @throws MalformedURLException shit happens
      */
     public static Future<IrisPack> from(VolmitSender sender, IrisPackRepository repo) throws MalformedURLException {
         CompletableFuture<IrisPack> pack = new CompletableFuture<>();
@@ -127,16 +119,14 @@ public class IrisPack {
     /**
      * Create a blank pack with a given name
      *
-     * @param name
-     *     the name of the pack
+     * @param name the name of the pack
      * @return the pack
-     * @throws IrisException
-     *     if the pack already exists or another error
+     * @throws IrisException if the pack already exists or another error
      */
     public static IrisPack blank(String name) throws IrisException {
         File f = packsPack(name);
 
-        if(f.exists()) {
+        if (f.exists()) {
             throw new IrisException("Already exists");
         }
 
@@ -144,10 +134,10 @@ public class IrisPack {
         fd.getParentFile().mkdirs();
         try {
             IO.writeAll(fd, "{\n" +
-                "    \"name\": \"" + Form.capitalize(name) + "\",\n" +
-                "    \"version\": 1\n" +
-                "}\n");
-        } catch(IOException e) {
+                    "    \"name\": \"" + Form.capitalize(name) + "\",\n" +
+                    "    \"version\": 1\n" +
+                    "}\n");
+        } catch (IOException e) {
             throw new IrisException(e.getMessage(), e);
         }
 
@@ -159,8 +149,7 @@ public class IrisPack {
     /**
      * Get a packs pack folder for a name. Such that overworld would resolve as Iris/packs/overworld
      *
-     * @param name
-     *     the name
+     * @param name the name
      * @return the file path
      */
     public static File packsPack(String name) {
@@ -170,11 +159,11 @@ public class IrisPack {
     private static KList<File> collectFiles(File f, String fileExtension) {
         KList<File> l = new KList<>();
 
-        if(f.isDirectory()) {
-            for(File i : f.listFiles()) {
+        if (f.isDirectory()) {
+            for (File i : f.listFiles()) {
                 l.addAll(collectFiles(i, fileExtension));
             }
-        } else if(f.getName().endsWith("." + fileExtension)) {
+        } else if (f.getName().endsWith("." + fileExtension)) {
             l.add(f);
         }
 
@@ -225,13 +214,13 @@ public class IrisPack {
             p.end();
             Iris.debug("Building Workspace: " + ws.getPath() + " took " + Form.duration(p.getMilliseconds(), 2));
             return true;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Pack invalid: " + ws.getAbsolutePath() + " Re-creating. You may loose some vs-code workspace settings! But not your actual project!");
             ws.delete();
             try {
                 IO.writeAll(ws, generateWorkspaceConfig());
-            } catch(IOException e1) {
+            } catch (IOException e1) {
                 Iris.reportError(e1);
                 e1.printStackTrace();
             }
@@ -243,8 +232,7 @@ public class IrisPack {
     /**
      * Install this pack into a world
      *
-     * @param world
-     *     the world to install into (world/iris/pack)
+     * @param world the world to install into (world/iris/pack)
      * @return the installed pack
      */
     public IrisPack install(World world) throws IrisException {
@@ -254,8 +242,7 @@ public class IrisPack {
     /**
      * Install this pack into a world
      *
-     * @param world
-     *     the world to install into (world/iris/pack)
+     * @param world the world to install into (world/iris/pack)
      * @return the installed pack
      */
     public IrisPack install(IrisWorld world) throws IrisException {
@@ -265,12 +252,11 @@ public class IrisPack {
     /**
      * Install this pack into a world
      *
-     * @param folder
-     *     the folder to install this pack into
+     * @param folder the folder to install this pack into
      * @return the installed pack
      */
     public IrisPack install(File folder) throws IrisException {
-        if(folder.exists()) {
+        if (folder.exists()) {
             throw new IrisException("Cannot install new pack because the folder " + folder.getName() + " already exists!");
         }
 
@@ -278,7 +264,7 @@ public class IrisPack {
 
         try {
             FileUtils.copyDirectory(getFolder(), folder);
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
         }
 
@@ -289,20 +275,19 @@ public class IrisPack {
      * Create a new pack using this pack as a template. The new pack will be renamed & have a renamed dimension
      * to match it.
      *
-     * @param newName
-     *     the new pack name
+     * @param newName the new pack name
      * @return the new IrisPack
      */
     public IrisPack install(String newName) throws IrisException {
         File newPack = packsPack(newName);
 
-        if(newPack.exists()) {
+        if (newPack.exists()) {
             throw new IrisException("Cannot install new pack because the folder " + newName + " already exists!");
         }
 
         try {
             FileUtils.copyDirectory(getFolder(), newPack);
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
         }
 
@@ -314,7 +299,7 @@ public class IrisPack {
         try {
             FileUtils.moveFile(from, to);
             new File(newPack, getWorkspaceFile().getName()).delete();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             throw new IrisException(e);
         }
 
@@ -345,8 +330,7 @@ public class IrisPack {
     /**
      * Find all files in this pack with the given extension
      *
-     * @param fileExtension
-     *     the extension
+     * @param fileExtension the extension
      * @return the list of files
      */
     public KList<File> collectFiles(String fileExtension) {
@@ -386,8 +370,8 @@ public class IrisPack {
         JSONArray schemas = new JSONArray();
         IrisData dm = IrisData.get(getFolder());
 
-        for(ResourceLoader<?> r : dm.getLoaders().v()) {
-            if(r.supportsSchemas()) {
+        for (ResourceLoader<?> r : dm.getLoaders().v()) {
+            if (r.supportsSchemas()) {
                 schemas.put(r.buildSchema());
             }
         }

core/src/main/java/com/volmit/iris/core/pack/IrisPackRepository.java

@@ -55,34 +55,34 @@ public class IrisPackRepository {
      */
     public static IrisPackRepository from(String g) {
         // https://github.com/IrisDimensions/overworld
-        if(g.startsWith("https://github.com/")) {
+        if (g.startsWith("https://github.com/")) {
             String sub = g.split("\\Qgithub.com/\\E")[1];
             IrisPackRepository r = IrisPackRepository.builder()
-                .user(sub.split("\\Q/\\E")[0])
-                .repo(sub.split("\\Q/\\E")[1]).build();
+                    .user(sub.split("\\Q/\\E")[0])
+                    .repo(sub.split("\\Q/\\E")[1]).build();
 
-            if(g.contains("/tree/")) {
+            if (g.contains("/tree/")) {
                 r.setBranch(g.split("/tree/")[1]);
             }
 
             return r;
-        } else if(g.contains("/")) {
+        } else if (g.contains("/")) {
             String[] f = g.split("\\Q/\\E");
 
-            if(f.length == 1) {
+            if (f.length == 1) {
                 return from(g);
-            } else if(f.length == 2) {
+            } else if (f.length == 2) {
                 return IrisPackRepository.builder()
-                    .user(f[0])
-                    .repo(f[1])
-                    .build();
-            } else if(f.length >= 3) {
+                        .user(f[0])
+                        .repo(f[1])
+                        .build();
+            } else if (f.length >= 3) {
                 IrisPackRepository r = IrisPackRepository.builder()
-                    .user(f[0])
-                    .repo(f[1])
-                    .build();
+                        .user(f[0])
+                        .repo(f[1])
+                        .build();
 
-                if(f[2].startsWith("#")) {
+                if (f[2].startsWith("#")) {
                     r.setTag(f[2].substring(1));
                 } else {
                     r.setBranch(f[2]);
@@ -92,17 +92,17 @@ public class IrisPackRepository {
             }
         } else {
             return IrisPackRepository.builder()
-                .user("IrisDimensions")
-                .repo(g)
-                .branch(g.equals("overworld") ? "stable" : "master")
-                .build();
+                    .user("IrisDimensions")
+                    .repo(g)
+                    .branch(g.equals("overworld") ? "stable" : "master")
+                    .build();
         }
 
         return null;
     }
 
     public String toURL() {
-        if(!tag.trim().isEmpty()) {
+        if (!tag.trim().isEmpty()) {
             return "https://codeload.github.com/" + user + "/" + repo + "/zip/refs/tags/" + tag;
         }
 
@@ -112,19 +112,19 @@ public class IrisPackRepository {
     public void install(VolmitSender sender, Runnable whenComplete) throws MalformedURLException {
         File pack = Iris.instance.getDataFolderNoCreate(StudioSVC.WORKSPACE_NAME, getRepo());
 
-        if(!pack.exists()) {
+        if (!pack.exists()) {
             File dl = new File(Iris.getTemp(), "dltk-" + UUID.randomUUID() + ".zip");
             File work = new File(Iris.getTemp(), "extk-" + UUID.randomUUID());
             new JobCollection(Form.capitalize(getRepo()),
-                new DownloadJob(toURL(), pack),
-                new SingleJob("Extracting", () -> ZipUtil.unpack(dl, work)),
-                new SingleJob("Installing", () -> {
-                    try {
-                        FileUtils.copyDirectory(work.listFiles()[0], pack);
-                    } catch(IOException e) {
-                        e.printStackTrace();
-                    }
-                })).execute(sender, whenComplete);
+                    new DownloadJob(toURL(), pack),
+                    new SingleJob("Extracting", () -> ZipUtil.unpack(dl, work)),
+                    new SingleJob("Installing", () -> {
+                        try {
+                            FileUtils.copyDirectory(work.listFiles()[0], pack);
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    })).execute(sender, whenComplete);
         } else {
             sender.sendMessage("Pack already exists!");
         }

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

@@ -0,0 +1,358 @@
+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.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.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;
+
+import java.io.File;
+
+import java.util.ArrayList;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class ChunkUpdater {
+    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.world = world;
+        this.dimensions = calculateWorldDimensions(new File(world.getWorldFolder(), "region"));
+        this.task = dimensions.task();
+        this.totalMaxChunks.set(dimensions.count * 1024);
+        this.latch = new CountDownLatch(totalMaxChunks.get());
+    }
+
+    public String getName() {
+        return world.getName();
+    }
+
+    public int getChunks() {
+        return totalMaxChunks.get();
+    }
+
+    public void start() {
+        unloadAndSaveAllChunks();
+        update();
+    }
+
+    public boolean pause() {
+        unloadAndSaveAllChunks();
+        if (paused.get()) {
+            paused.set(false);
+            return false;
+        } else {
+            paused.set(true);
+            return true;
+        }
+    }
+
+    public void stop() {
+        unloadAndSaveAllChunks();
+        cancelled.set(true);
+    }
+
+    private void update() {
+        Iris.info("Updating..");
+        try {
+            startTime.set(System.currentTimeMillis());
+            scheduler.scheduleAtFixedRate(() -> {
+                try {
+                    if (!paused.get()) {
+                        long eta = computeETA();
+                        int processed = chunksProcessed.get();
+                        double last = processed - chunksProcessedLast.getAndSet(processed);
+                        double cps = last / ((M.ms() - lastCpsTime.getAndSet(M.ms())) / 1000d);
+                        chunksPerSecond.put(cps);
+                        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) {
+                    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);
+
+            var t = new Thread(() -> {
+                run();
+                close();
+            }, "Iris Chunk Updater - " + world.getName());
+            t.setPriority(Thread.MAX_PRIORITY);
+            t.start();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void close() {
+        try {
+            loadBalancer.close();
+            semaphore.acquire(256);
+
+            executor.shutdown();
+            executor.awaitTermination(5, TimeUnit.SECONDS);
+            chunkExecutor.shutdown();
+            chunkExecutor.awaitTermination(5, TimeUnit.SECONDS);
+            scheduler.shutdownNow();
+            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()));
+            Iris.info("Stopped updater.");
+        } else {
+            Iris.info("Processed: " + Form.f(chunksProcessed.get()) + " Chunks");
+            Iris.info("Finished Updating: " + Form.f(chunksUpdated.get()) + " Chunks");
+        }
+    }
+
+    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()) {
+                return;
+            }
+
+            PregenTask.iterateRegion(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();
+        }
+    }
+
+    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)) {
+                    return false;
+                }
+            }
+        }
+
+        AtomicBoolean generated = new AtomicBoolean(true);
+        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;
+                executor.submit(() -> {
+                    try {
+                        Chunk c;
+                        try {
+                            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();
+                    }
+                });
+            }
+        }
+
+        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(() -> {
+                if (world == null) {
+                    Iris.warn("World was null somehow...");
+                    return;
+                }
+
+                unloadChunks();
+                world.save();
+            }).get();
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private long computeETA() {
+        return (long) (totalMaxChunks.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)
+                ((totalMaxChunks.get() - chunksProcessed.get()) * ((double) (M.ms() - startTime.get()) / (double) chunksProcessed.get())) :
+                // If no, use quick function (which is less accurate over time but responds better to the initial delay)
+                ((totalMaxChunks.get() - chunksProcessed.get()) / chunksPerSecond.getAverage()) * 1000
+        );
+    }
+
+    private Dimensions calculateWorldDimensions(File regionDir) {
+        File[] files = regionDir.listFiles((dir, name) -> name.endsWith(".mca"));
+
+        int minX = Integer.MAX_VALUE;
+        int maxX = Integer.MIN_VALUE;
+        int minZ = Integer.MAX_VALUE;
+        int maxZ = Integer.MIN_VALUE;
+
+        for (File file : files) {
+            String[] parts = file.getName().split("\\.");
+            int x = Integer.parseInt(parts[1]);
+            int z = Integer.parseInt(parts[2]);
+
+            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;
+        int width = maxZ - minZ + 1;
+
+        return new Dimensions(new Position2(minX, minZ), new Position2(maxX, maxZ), height * width, PregenTask.builder()
+                .width((int) Math.ceil(width / 2d))
+                .height((int) Math.ceil(height / 2d))
+                .center(new Position2(oX, oZ))
+                .build());
+    }
+
+    private record Dimensions(Position2 min, Position2 max, int count, PregenTask task) { }
+}

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

@@ -0,0 +1,274 @@
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.util.collection.KList;
+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.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.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import lombok.Data;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class DeepSearchPregenerator extends Thread implements Listener {
+    @Getter
+    private static DeepSearchPregenerator instance;
+    private final DeepSearchJob job;
+    private final File destination;
+    private final int maxPosition;
+    private World world;
+    private final ChronoLatch latch;
+    private static AtomicInteger foundChunks;
+    private final AtomicInteger foundLast;
+    private final AtomicInteger foundTotalChunks;
+    private final AtomicLong startTime;
+    private final RollingSequence chunksPerSecond;
+    private final RollingSequence chunksPerMinute;
+    private final AtomicInteger chunkCachePos;
+    private final AtomicInteger chunkCacheSize;
+    private int pos;
+    private final AtomicInteger foundCacheLast;
+    private final AtomicInteger foundCache;
+    private LinkedHashMap<Integer, Position2> chunkCache;
+    private KList<Position2> chunkQueue;
+    private final ReentrantLock cacheLock;
+
+    private static final Map<String, DeepSearchJob> jobs = new HashMap<>();
+
+    public DeepSearchPregenerator(DeepSearchJob job, File destination) {
+        this.job = job;
+        this.chunkCacheSize = new AtomicInteger(); // todo
+        this.chunkCachePos = new AtomicInteger(1000);
+        this.foundCacheLast = new AtomicInteger();
+        this.foundCache = new AtomicInteger();
+        this.cacheLock = new ReentrantLock();
+        this.destination = destination;
+        this.chunkCache = new LinkedHashMap<>();
+        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+        }).count();
+        this.world = Bukkit.getWorld(job.getWorld().getUID());
+        this.chunkQueue = new KList<>();
+        this.latch = new ChronoLatch(3000);
+        this.startTime = new AtomicLong(M.ms());
+        this.chunksPerSecond = new RollingSequence(10);
+        this.chunksPerMinute = new RollingSequence(10);
+        foundChunks = new AtomicInteger(0);
+        this.foundLast = new AtomicInteger(0);
+        this.foundTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
+
+        this.pos = 0;
+        jobs.put(job.getWorld().getName(), job);
+        DeepSearchPregenerator.instance = this;
+    }
+
+    @EventHandler
+    public void on(WorldUnloadEvent e) {
+        if (e.getWorld().equals(world)) {
+            interrupt();
+        }
+    }
+
+    public void run() {
+        while (!interrupted()) {
+            tick();
+        }
+        try {
+            saveNow();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tick() {
+        DeepSearchJob job = jobs.get(world.getName());
+       // chunkCache(); //todo finish this
+        if (latch.flip() && !job.paused) {
+            if (cacheLock.isLocked()) {
+                Iris.info("DeepFinder: Caching: " + chunkCachePos.get() + " Of " + chunkCacheSize.get());
+            } else {
+                long eta = computeETA();
+                save();
+                int secondGenerated = foundChunks.get() - foundLast.get();
+                foundLast.set(foundChunks.get());
+                secondGenerated = secondGenerated / 3;
+                chunksPerSecond.put(secondGenerated);
+                chunksPerMinute.put(secondGenerated * 60);
+                Iris.info("DeepFinder: " + C.IRIS + world.getName() + C.RESET + " Searching: " + Form.f(foundChunks.get()) + " of " + Form.f(foundTotalChunks.get()) + " " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
+            }
+
+        }
+        if (foundChunks.get() >= foundTotalChunks.get()) {
+            Iris.info("Completed DeepSearch!");
+            interrupt();
+        }
+    }
+
+    private long computeETA() {
+        return (long) ((foundTotalChunks.get() - foundChunks.get()) / chunksPerSecond.getAverage()) * 1000;
+        // todo broken
+    }
+
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+    private void queueSystem(Position2 chunk) {
+        if (chunkQueue.isEmpty()) {
+            for (int limit = 512; limit != 0; limit--) {
+                pos = job.getPosition() + 1;
+                chunkQueue.add(getChunk(pos));
+            }
+        } else {
+            //MCAUtil.read();
+
+        }
+
+
+    }
+
+    private void findInChunk(World world, int x, int z) throws IOException {
+        int xx = x * 16;
+        int zz = z * 16;
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        for (int i = 0; i < 16; i++) {
+            for (int j = 0; j < 16; j++) {
+                int height = engine.getHeight(xx + i, zz + j);
+                if (height > 300) {
+                    File found = new File("plugins" + "iris" + "found.txt");
+                    FileWriter writer = new FileWriter(found);
+                    if (!found.exists()) {
+                        found.createNewFile();
+                    }
+                    IrisBiome biome = engine.getBiome(xx, engine.getHeight(), zz);
+                    Iris.info("Found at! " + xx + ", " + zz + "Biome ID: " + biome.getName() + ", ");
+                    writer.write("Biome at: X: " + xx + " Z: " + zz + "Biome ID: " + biome.getName() +  ", ");
+                    return;
+               }
+            }
+        }
+    }
+
+    public Position2 getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+
+        return new Position2(xx.get(), zz.get());
+    }
+
+    public void save() {
+        J.a(() -> {
+            try {
+                saveNow();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    public static void setPausedDeep(World world) {
+        DeepSearchJob job = jobs.get(world.getName());
+        if (isPausedDeep(world)){
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if ( job.paused) {
+            Iris.info(C.BLUE + "DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedDeep(World world) {
+        DeepSearchJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
+    public void shutdownInstance(World world) throws IOException {
+        Iris.info("DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
+        DeepSearchJob job = jobs.get(world.getName());
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File deepFile = new File(worldDirectory, "DeepSearch.json");
+
+        if (job == null) {
+            Iris.error("No DeepSearch job found for world: " + world.getName());
+            return;
+        }
+
+        try {
+            if (!job.isPaused()) {
+                job.setPaused(true);
+            }
+            save();
+            jobs.remove(world.getName());
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    while (deepFile.exists()){
+                        deepFile.delete();
+                        J.sleep(1000);
+                    }
+                    Iris.info("DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
+                }
+            }.runTaskLater(Iris.instance, 20L);
+        } catch (Exception e) {
+            Iris.error("Failed to shutdown DeepSearch for " + world.getName());
+            e.printStackTrace();
+        } finally {
+            saveNow();
+            interrupt();
+        }
+    }
+
+
+    public void saveNow() throws IOException {
+        IO.writeAll(this.destination, new Gson().toJson(job));
+    }
+
+    @Data
+    @lombok.Builder
+    public static class DeepSearchJob {
+        private World world;
+        @lombok.Builder.Default
+        private int radiusBlocks = 5000;
+        @lombok.Builder.Default
+        private int position = 0;
+        @lombok.Builder.Default
+        boolean paused = false;
+    }
+}
+

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

@@ -19,7 +19,11 @@
 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;
+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.math.M;
@@ -34,6 +38,7 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 
+
 public class IrisPregenerator {
     private final PregenTask task;
     private final PregeneratorMethod generator;
@@ -44,10 +49,11 @@ public class IrisPregenerator {
     private final RollingSequence chunksPerSecond;
     private final RollingSequence chunksPerMinute;
     private final RollingSequence regionsPerMinute;
-    private final AtomicInteger generated;
+    private final KList<Integer> chunksPerSecondHistory;
+    private static AtomicInteger generated;
     private final AtomicInteger generatedLast;
     private final AtomicInteger generatedLastMinute;
-    private final AtomicInteger totalChunks;
+    private static AtomicInteger totalChunks;
     private final AtomicLong startTime;
     private final ChronoLatch minuteLatch;
     private final AtomicReference<String> currentGeneratorMethod;
@@ -55,6 +61,7 @@ public class IrisPregenerator {
     private final KSet<Position2> retry;
     private final KSet<Position2> net;
     private final ChronoLatch cl;
+    private final ChronoLatch saveLatch = new ChronoLatch(30000);
 
     public IrisPregenerator(PregenTask task, PregeneratorMethod generator, PregenListener listener) {
         this.listener = listenify(listener);
@@ -71,6 +78,7 @@ public class IrisPregenerator {
         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);
@@ -84,8 +92,9 @@ public class IrisPregenerator {
                 int secondGenerated = generated.get() - generatedLast.get();
                 generatedLast.set(generated.get());
                 chunksPerSecond.put(secondGenerated);
+                chunksPerSecondHistory.add(secondGenerated);
 
-                if(minuteLatch.flip()) {
+                if (minuteLatch.flip()) {
                     int minuteGenerated = generated.get() - generatedLastMinute.get();
                     generatedLastMinute.set(generated.get());
                     chunksPerMinute.put(minuteGenerated);
@@ -93,26 +102,35 @@ public class IrisPregenerator {
                 }
 
                 listener.onTick(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());
+                        regionsPerMinute.getAverage(),
+                        (double) generated.get() / (double) totalChunks.get(),
+                        generated.get(), totalChunks.get(),
+                        totalChunks.get() - generated.get(),
+                        eta, M.ms() - startTime.get(), currentGeneratorMethod.get());
 
-                if(cl.flip()) {
-                    Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (" + Form.pc((double) generated.get() / (double) totalChunks.get(), 0) + ") " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
+                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);
+                    }
                 }
-
                 return 1000;
             }
         };
     }
 
     private long computeETA() {
-        return (long) ((totalChunks.get() - generated.get()) *
-            ((double) (M.ms() - startTime.get()) / (double) generated.get()));
+        return (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())) :
+                // 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
+        );
     }
 
+
     public void close() {
         shutdown.set(true);
     }
@@ -124,6 +142,11 @@ public class IrisPregenerator {
         task.iterateRegions((x, z) -> visitRegion(x, z, true));
         task.iterateRegions((x, z) -> visitRegion(x, z, false));
         shutdown();
+        if (!IrisPackBenchmarking.benchmarkInProgress) {
+            Iris.info(C.IRIS + "Pregen stopped.");
+        } else {
+            IrisPackBenchmarking.instance.finishedBenchmark(chunksPerSecondHistory);
+        }
     }
 
     private void checkRegions() {
@@ -140,47 +163,61 @@ public class IrisPregenerator {
         generator.close();
         ticker.interrupt();
         listener.onClose();
+        Mantle mantle = getMantle();
+        if (mantle != null) {
+            mantle.trim(0, 0);
+        }
     }
 
     private void visitRegion(int x, int z, boolean regions) {
-        while(paused.get() && !shutdown.get()) {
+        while (paused.get() && !shutdown.get()) {
             J.sleep(50);
         }
 
-        if(shutdown.get()) {
+        if (shutdown.get()) {
             listener.onRegionSkipped(x, z);
             return;
         }
 
         Position2 pos = new Position2(x, z);
 
-        if(generatedRegions.contains(pos)) {
+        if (generatedRegions.contains(pos)) {
             return;
         }
 
         currentGeneratorMethod.set(generator.getMethod(x, z));
         boolean hit = false;
-        if(generator.supportsRegions(x, z, listener) && regions) {
+        if (generator.supportsRegions(x, z, listener) && regions) {
             hit = true;
             listener.onRegionGenerating(x, z);
             generator.generateRegion(x, z, listener);
-        } else if(!regions) {
+        } else if (!regions) {
             hit = true;
             listener.onRegionGenerating(x, z);
-            PregenTask.iterateRegion(x, z, (xx, zz) -> generator.generateChunk(xx, zz, listener));
+            PregenTask.iterateRegion(x, z, (xx, zz) -> {
+                while (paused.get() && !shutdown.get()) {
+                    J.sleep(50);
+                }
+
+                generator.generateChunk(xx, zz, listener);
+            });
         }
 
-        if(hit) {
+        if (hit) {
             listener.onRegionGenerated(x, z);
-            listener.onSaving();
-            generator.save();
+
+            if (saveLatch.flip()) {
+                listener.onSaving();
+                generator.save();
+            }
+
             generatedRegions.add(pos);
             checkRegions();
         }
     }
 
     private void checkRegion(int x, int z) {
-        if(generatedRegions.contains(new Position2(x, z))) {
+        if (generatedRegions.contains(new Position2(x, z))) {
             return;
         }
 

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

@@ -0,0 +1,285 @@
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+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.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.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import io.papermc.lib.PaperLib;
+import lombok.Data;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LazyPregenerator extends Thread implements Listener {
+    @Getter
+    private static LazyPregenerator instance;
+    private final LazyPregenJob job;
+    private final File destination;
+    private final int maxPosition;
+    private World world;
+    private final long rate;
+    private final ChronoLatch latch;
+    private static AtomicInteger lazyGeneratedChunks;
+    private final AtomicInteger generatedLast;
+    private final AtomicInteger lazyTotalChunks;
+    private final AtomicLong startTime;
+    private final RollingSequence chunksPerSecond;
+    private final RollingSequence chunksPerMinute;
+
+    private static final Map<String, LazyPregenJob> jobs = new HashMap<>();
+
+    public LazyPregenerator(LazyPregenJob job, File destination) {
+        this.job = job;
+        this.destination = destination;
+        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+        }).count();
+        this.world = Bukkit.getWorld(job.getWorld());
+        this.rate = Math.round((1D / (job.getChunksPerMinute() / 60D)) * 1000D);
+        this.latch = new ChronoLatch(15000);
+        this.startTime = new AtomicLong(M.ms());
+        this.chunksPerSecond = new RollingSequence(10);
+        this.chunksPerMinute = new RollingSequence(10);
+        lazyGeneratedChunks = new AtomicInteger(0);
+        this.generatedLast = new AtomicInteger(0);
+        this.lazyTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
+        jobs.put(job.getWorld(), job);
+        LazyPregenerator.instance = this;
+    }
+
+    public LazyPregenerator(File file) throws IOException {
+        this(new Gson().fromJson(IO.readAll(file), LazyPregenJob.class), file);
+    }
+
+    public static void loadLazyGenerators() {
+        for (World i : Bukkit.getWorlds()) {
+            File lazygen = new File(i.getWorldFolder(), "lazygen.json");
+            if (lazygen.exists()) {
+                try {
+                    LazyPregenerator p = new LazyPregenerator(lazygen);
+                    p.start();
+                    Iris.info("Started Lazy Pregenerator: " + p.job);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @EventHandler
+    public void on(WorldUnloadEvent e) {
+        if (e.getWorld().equals(world)) {
+            interrupt();
+        }
+    }
+
+    public void run() {
+        while (!interrupted()) {
+            J.sleep(rate);
+            tick();
+        }
+
+        try {
+            saveNow();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tick() {
+        LazyPregenJob job = jobs.get(world.getName());
+        if (latch.flip() && !job.paused) {
+            long eta = computeETA();
+            save();
+            int secondGenerated = lazyGeneratedChunks.get() - generatedLast.get();
+            generatedLast.set(lazyGeneratedChunks.get());
+            secondGenerated = secondGenerated / 15;
+            chunksPerSecond.put(secondGenerated);
+            chunksPerMinute.put(secondGenerated * 60);
+            if (!job.isSilent()) {
+                Iris.info("LazyGen: " + C.IRIS + world.getName() + C.RESET + " RTT: " + Form.f(lazyGeneratedChunks.get()) + " of " + Form.f(lazyTotalChunks.get()) + " " + Form.f((int) chunksPerMinute.getAverage()) + "/m ETA: " + Form.duration((double) eta, 2));
+            }
+        }
+
+        if (lazyGeneratedChunks.get() >= lazyTotalChunks.get()) {
+            if (job.isHealing()) {
+                int pos = (job.getHealingPosition() + 1) % maxPosition;
+                job.setHealingPosition(pos);
+                tickRegenerate(getChunk(pos));
+            } else {
+                Iris.info("Completed Lazy Gen!");
+                interrupt();
+            }
+        } else {
+            int pos = job.getPosition() + 1;
+            job.setPosition(pos);
+            if (!job.paused) {
+                tickGenerate(getChunk(pos));
+            }
+        }
+    }
+
+    private long computeETA() {
+        return (long) ((lazyTotalChunks.get() - lazyGeneratedChunks.get()) / chunksPerMinute.getAverage()) * 1000;
+        // todo broken
+    }
+
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+    private void tickGenerate(Position2 chunk) {
+        executorService.submit(() -> {
+            CountDownLatch latch = new CountDownLatch(1);
+            if (PaperLib.isPaper()) {
+                PaperLib.getChunkAtAsync(world, chunk.getX(), chunk.getZ(), true)
+                        .thenAccept((i) -> {
+                            Iris.verbose("Generated Async " + chunk);
+                            latch.countDown();
+                        });
+            } else {
+                J.s(() -> {
+                    world.getChunkAt(chunk.getX(), chunk.getZ());
+                    Iris.verbose("Generated " + chunk);
+                    latch.countDown();
+                });
+            }
+            try {
+                latch.await();
+            } catch (InterruptedException ignored) {}
+            lazyGeneratedChunks.addAndGet(1);
+        });
+    }
+
+    private void tickRegenerate(Position2 chunk) {
+        J.s(() -> world.regenerateChunk(chunk.getX(), chunk.getZ()));
+        Iris.verbose("Regenerated " + chunk);
+    }
+
+    public Position2 getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+
+        return new Position2(xx.get(), zz.get());
+    }
+
+    public void save() {
+        J.a(() -> {
+            try {
+                saveNow();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    public static void setPausedLazy(World world) {
+        LazyPregenJob job = jobs.get(world.getName());
+        if (isPausedLazy(world)){
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if ( job.paused) {
+            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedLazy(World world) {
+        LazyPregenJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
+    public void shutdownInstance(World world) throws IOException {
+        Iris.info("LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
+        LazyPregenJob job = jobs.get(world.getName());
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File lazyFile = new File(worldDirectory, "lazygen.json");
+
+        if (job == null) {
+            Iris.error("No Lazygen job found for world: " + world.getName());
+            return;
+        }
+
+        try {
+            if (!job.isPaused()) {
+                job.setPaused(true);
+            }
+            save();
+            jobs.remove(world.getName());
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    while (lazyFile.exists()){
+                        lazyFile.delete();
+                        J.sleep(1000);
+                    }
+                    Iris.info("LazyGen: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
+                }
+            }.runTaskLater(Iris.instance, 20L);
+        } catch (Exception e) {
+            Iris.error("Failed to shutdown Lazygen for " + world.getName());
+            e.printStackTrace();
+        } finally {
+            saveNow();
+            interrupt();
+        }
+    }
+
+
+    public void saveNow() throws IOException {
+        IO.writeAll(this.destination, new Gson().toJson(job));
+    }
+
+    @Data
+    @lombok.Builder
+    public static class LazyPregenJob {
+        private String world;
+        @lombok.Builder.Default
+        private int healingPosition = 0;
+        @lombok.Builder.Default
+        private boolean healing = false;
+        @lombok.Builder.Default
+        private int chunksPerMinute = 32;
+        @lombok.Builder.Default
+        private int radiusBlocks = 5000;
+        @lombok.Builder.Default
+        private int position = 0;
+        @lombok.Builder.Default
+        boolean silent = false;
+        @lombok.Builder.Default
+        boolean paused = false;
+    }
+}
+

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

@@ -35,6 +35,8 @@ public class PregenTask {
     private static final KList<Position2> ORDER_CENTER = computeChunkOrder();
     private static final KMap<Position2, KList<Position2>> ORDERS = new KMap<>();
 
+    @Builder.Default
+    private boolean gui = false;
     @Builder.Default
     private Position2 center = new Position2(0, 0);
     @Builder.Default
@@ -43,13 +45,13 @@ public class PregenTask {
     private int height = 1;
 
     public static void iterateRegion(int xr, int zr, Spiraled s, Position2 pull) {
-        for(Position2 i : ORDERS.computeIfAbsent(pull, PregenTask::computeOrder)) {
+        for (Position2 i : ORDERS.computeIfAbsent(pull, PregenTask::computeOrder)) {
             s.on(i.getX() + (xr << 5), i.getZ() + (zr << 5));
         }
     }
 
     public static void iterateRegion(int xr, int zr, Spiraled s) {
-        iterateRegion(xr, zr, s, new Position2(0, 0));
+        iterateRegion(xr, zr, s, new Position2(-(xr << 5), -(zr << 5)));
     }
 
     private static KList<Position2> computeOrder(Position2 pull) {
@@ -57,7 +59,7 @@ public class PregenTask {
         new Spiraler(33, 33, (x, z) -> {
             int xx = (x + 15);
             int zz = (z + 15);
-            if(xx < 0 || xx > 31 || zz < 0 || zz > 31) {
+            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
                 return;
             }
 
@@ -74,7 +76,7 @@ public class PregenTask {
         new Spiraler(33, 33, (x, z) -> {
             int xx = x + 15;
             int zz = z + 15;
-            if(xx < 0 || xx > 31 || zz < 0 || zz > 31) {
+            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
                 return;
             }
 
@@ -86,11 +88,11 @@ public class PregenTask {
 
     public void iterateRegions(Spiraled s) {
         new Spiraler(getWidth() * 2, getHeight() * 2, s)
-            .setOffset(center.getX(), center.getZ()).drain();
+                .setOffset(center.getX(), center.getZ()).drain();
     }
 
     public void iterateAllChunks(Spiraled s) {
         new Spiraler(getWidth() * 2, getHeight() * 2, (x, z) -> iterateRegion(x, z, s))
-            .setOffset(center.getX(), center.getZ()).drain();
+                .setOffset(center.getX(), center.getZ()).drain();
     }
 }

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

@@ -43,10 +43,8 @@ public interface PregeneratorMethod {
     /**
      * Return true if regions can be generated
      *
-     * @param x
-     *     the x region
-     * @param z
-     *     the z region
+     * @param x the x region
+     * @param z the z region
      * @return true if they can be
      */
     boolean supportsRegions(int x, int z, PregenListener listener);
@@ -54,10 +52,8 @@ public interface PregeneratorMethod {
     /**
      * Return the name of the method being used
      *
-     * @param x
-     *     the x region
-     * @param z
-     *     the z region
+     * @param x the x region
+     * @param z the z region
      * @return the name
      */
     String getMethod(int x, int z);
@@ -66,22 +62,17 @@ public interface PregeneratorMethod {
      * Called to generate a region. Execute sync, if multicore internally, wait
      * for the task to complete
      *
-     * @param x
-     *     the x
-     * @param z
-     *     the z
-     * @param listener
-     *     signal chunks generating & generated. Parallel capable.
+     * @param x        the x
+     * @param z        the z
+     * @param listener signal chunks generating & generated. Parallel capable.
      */
     void generateRegion(int x, int z, PregenListener listener);
 
     /**
      * Called to generate a chunk. You can go async so long as save will wait on the threads to finish
      *
-     * @param x
-     *     the x
-     * @param z
-     *     the z
+     * @param x the x
+     * @param z the z
      */
     void generateChunk(int x, int z, PregenListener listener);
 

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

@@ -0,0 +1,341 @@
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.util.collection.KList;
+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.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.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.HyperLock;
+import com.volmit.iris.util.parallel.MultiBurst;
+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.Data;
+import lombok.Getter;
+import org.apache.logging.log4j.core.util.ExecutorServices;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.checkerframework.checker.units.qual.N;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.IntStream;
+
+public class TurboPregenerator extends Thread implements Listener {
+    @Getter
+    private static TurboPregenerator instance;
+    private final TurboPregenJob job;
+    private final File destination;
+    private final int maxPosition;
+    private World world;
+    private final ChronoLatch latch;
+    private static AtomicInteger turboGeneratedChunks;
+    private final AtomicInteger generatedLast;
+    private final AtomicLong cachedLast;
+    private final RollingSequence cachePerSecond;
+    private final AtomicInteger turboTotalChunks;
+    private final AtomicLong startTime;
+    private final RollingSequence chunksPerSecond;
+    private final RollingSequence chunksPerMinute;
+    private KList<Position2> queue;
+    private ConcurrentHashMap<Integer, Position2> cache;
+    private AtomicInteger maxWaiting;
+    private ReentrantLock cachinglock;
+    private AtomicBoolean caching;
+    private final HyperLock hyperLock;
+    private MultiBurst burst;
+    private static final Map<String, TurboPregenJob> jobs = new HashMap<>();
+
+    public TurboPregenerator(TurboPregenJob job, File destination) {
+        this.job = job;
+        queue = new KList<>(512);
+        this.maxWaiting = new AtomicInteger(128);
+        this.destination = destination;
+        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+        }).count();
+        this.world = Bukkit.getWorld(job.getWorld());
+        this.latch = new ChronoLatch(3000);
+        this.burst = MultiBurst.burst;
+        this.hyperLock = new HyperLock();
+        this.startTime = new AtomicLong(M.ms());
+        this.cachePerSecond = new RollingSequence(10);
+        this.chunksPerSecond = new RollingSequence(10);
+        this.chunksPerMinute = new RollingSequence(10);
+        turboGeneratedChunks = new AtomicInteger(0);
+        this.generatedLast = new AtomicInteger(0);
+        this.cachedLast = new AtomicLong(0);
+        this.caching = new AtomicBoolean(false);
+        this.turboTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
+        cache = new ConcurrentHashMap<>(turboTotalChunks.get());
+        this.cachinglock = new ReentrantLock();
+        jobs.put(job.getWorld(), job);
+        TurboPregenerator.instance = this;
+    }
+
+    public TurboPregenerator(File file) throws IOException {
+        this(new Gson().fromJson(IO.readAll(file), TurboPregenerator.TurboPregenJob.class), file);
+    }
+
+    public static void loadTurboGenerator(String i) {
+        World x = Bukkit.getWorld(i);
+        File turbogen = new File(x.getWorldFolder(), "turbogen.json");
+        if (turbogen.exists()) {
+            try {
+                TurboPregenerator p = new TurboPregenerator(turbogen);
+                p.start();
+                Iris.info("Started Turbo Pregenerator: " + p.job);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
+    @EventHandler
+    public void on(WorldUnloadEvent e) {
+        if (e.getWorld().equals(world)) {
+            interrupt();
+        }
+    }
+
+    public void run() {
+        while (!interrupted()) {
+            tick();
+        }
+
+        try {
+            saveNow();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tick() {
+        TurboPregenJob job = jobs.get(world.getName());
+        if (!cachinglock.isLocked() && cache.isEmpty() && !caching.get()) {
+            ExecutorService cache = Executors.newFixedThreadPool(1);
+            cache.submit(this::cache);
+        }
+
+        if (latch.flip() && caching.get()) {
+            long secondCached = cache.mappingCount() - cachedLast.get();
+            cachedLast.set(cache.mappingCount());
+            secondCached = secondCached / 3;
+            cachePerSecond.put(secondCached);
+            Iris.info("TurboGen: " + C.IRIS + world.getName() + C.RESET + C.BLUE + " Caching: " + Form.f(cache.mappingCount()) + " of " + Form.f(turboTotalChunks.get()) + " " + Form.f((int) cachePerSecond.getAverage()) + "/s");
+        }
+
+        if (latch.flip() && !job.paused && !cachinglock.isLocked()) {
+            long eta = computeETA();
+            save();
+            int secondGenerated = turboGeneratedChunks.get() - generatedLast.get();
+            generatedLast.set(turboGeneratedChunks.get());
+            secondGenerated = secondGenerated / 3;
+            chunksPerSecond.put(secondGenerated);
+            chunksPerMinute.put(secondGenerated * 60);
+            Iris.info("TurboGen: " + C.IRIS + world.getName() + C.RESET + " RTT: " + Form.f(turboGeneratedChunks.get()) + " of " + Form.f(turboTotalChunks.get()) + " " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
+
+        }
+        if (turboGeneratedChunks.get() >= turboTotalChunks.get()) {
+            Iris.info("Completed Turbo Gen!");
+            interrupt();
+        } else {
+            if (!cachinglock.isLocked()) {
+                int pos = job.getPosition() + 1;
+                job.setPosition(pos);
+                if (!job.paused) {
+                    if (queue.size() < maxWaiting.get()) {
+                        Position2 chunk = cache.get(pos);
+                        queue.add(chunk);
+                    }
+                    waitForChunksPartial();
+                }
+            }
+        }
+    }
+
+    private void cache() {
+        if (!cachinglock.isLocked()) {
+            cachinglock.lock();
+            caching.set(true);
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            BurstExecutor b = MultiBurst.burst.burst(turboTotalChunks.get());
+            b.setMulticore(true);
+            int[] list = IntStream.rangeClosed(0, turboTotalChunks.get()).toArray();
+            AtomicInteger order = new AtomicInteger(turboTotalChunks.get());
+
+            int threads = Runtime.getRuntime().availableProcessors();
+            if (threads > 1) threads--;
+            ExecutorService process = Executors.newFixedThreadPool(threads);
+
+            for (int id : list) {
+                b.queue(() -> {
+                    cache.put(id, getChunk(id));
+                    order.addAndGet(-1);
+                });
+            }
+            b.complete();
+
+            if (order.get() < 0) {
+                cachinglock.unlock();
+                caching.set(false);
+                Iris.info("Completed Caching in: " + Form.duration(p.getMilliseconds(), 2));
+            }
+        } else {
+            Iris.error("TurboCache is locked!");
+        }
+    }
+
+    private void waitForChunksPartial() {
+        while (!queue.isEmpty() && maxWaiting.get() > queue.size()) {
+            try {
+                for (Position2 c : new KList<>(queue)) {
+                    tickGenerate(c);
+                    queue.remove(c);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private long computeETA() {
+        return (long) ((turboTotalChunks.get() - turboGeneratedChunks.get()) / chunksPerMinute.getAverage()) * 1000;
+        // todo broken
+    }
+
+    private final ExecutorService executorService = Executors.newFixedThreadPool(10);
+    private void tickGenerate(Position2 chunk) {
+        executorService.submit(() -> {
+            CountDownLatch latch = new CountDownLatch(1);
+            PaperLib.getChunkAtAsync(world, chunk.getX(), chunk.getZ(), true)
+                    .thenAccept((i) -> {
+                        latch.countDown();
+                    });
+            try {
+                latch.await();
+            } catch (InterruptedException ignored) {
+            }
+            turboGeneratedChunks.addAndGet(1);
+        });
+    }
+
+    public Position2 getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+
+        return new Position2(xx.get(), zz.get());
+    }
+
+    public void save() {
+        J.a(() -> {
+            try {
+                saveNow();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    public static void setPausedTurbo(World world) {
+        TurboPregenJob job = jobs.get(world.getName());
+        if (isPausedTurbo(world)) {
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if (job.paused) {
+            Iris.info(C.BLUE + "TurboGen: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "TurboGen: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedTurbo(World world) {
+        TurboPregenJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
+    public void shutdownInstance(World world) throws IOException {
+        Iris.info("turboGen: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
+        TurboPregenJob job = jobs.get(world.getName());
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File turboFile = new File(worldDirectory, "turbogen.json");
+
+        if (job == null) {
+            Iris.error("No turbogen job found for world: " + world.getName());
+            return;
+        }
+
+        try {
+            if (!job.isPaused()) {
+                job.setPaused(true);
+            }
+            save();
+            jobs.remove(world.getName());
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    while (turboFile.exists()) {
+                        turboFile.delete();
+                        J.sleep(1000);
+                    }
+                    Iris.info("turboGen: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
+                }
+            }.runTaskLater(Iris.instance, 20L);
+        } catch (Exception e) {
+            Iris.error("Failed to shutdown turbogen for " + world.getName());
+            e.printStackTrace();
+        } finally {
+            saveNow();
+            interrupt();
+        }
+    }
+
+
+    public void saveNow() throws IOException {
+        IO.writeAll(this.destination, new Gson().toJson(job));
+    }
+
+    @Data
+    @lombok.Builder
+    public static class TurboPregenJob {
+        private String world;
+        @lombok.Builder.Default
+        private int radiusBlocks = 5000;
+        @lombok.Builder.Default
+        private int position = 0;
+        @lombok.Builder.Default
+        boolean paused = false;
+    }
+}
+

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

@@ -19,73 +19,73 @@
 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;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.scheduling.J;
 import io.papermc.lib.PaperLib;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 
-import java.util.concurrent.Future;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.Semaphore;
 
 public class AsyncPregenMethod implements PregeneratorMethod {
     private final World world;
     private final MultiBurst burst;
-    private final KList<Future<?>> future;
+    private final Semaphore semaphore;
+    private final Map<Chunk, Long> lastUse;
 
     public AsyncPregenMethod(World world, int threads) {
-        if(!PaperLib.isPaper()) {
+        if (!PaperLib.isPaper()) {
             throw new UnsupportedOperationException("Cannot use PaperAsync on non paper!");
         }
 
         this.world = world;
-        burst = MultiBurst.burst;
-        future = new KList<>(1024);
+        burst = new MultiBurst("Iris Async Pregen", Thread.MIN_PRIORITY);
+        semaphore = new Semaphore(256);
+        this.lastUse = new KMap<>();
     }
 
     private void unloadAndSaveAllChunks() {
         try {
             J.sfut(() -> {
-                if(world == null) {
+                if (world == null) {
                     Iris.warn("World was null somehow...");
                     return;
                 }
 
-                for(Chunk i : world.getLoadedChunks()) {
-                    i.unload(true);
+                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
+                    Long lastUseTime = lastUse.get(i);
+                    if (!i.isLoaded() || (lastUseTime != null && M.ms() - lastUseTime >= 10000)) {
+                        i.unload();
+                        lastUse.remove(i);
+                    }
                 }
                 world.save();
             }).get();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
         }
     }
 
     private void completeChunk(int x, int z, PregenListener listener) {
         try {
-            PaperLib.getChunkAtAsync(world, x, z, true).get();
-            listener.onChunkGenerated(x, z);
-            listener.onChunkCleaned(x, z);
-        } catch(Throwable e) {
+            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();
-            J.sleep(5);
-            future.add(burst.complete(() -> completeChunk(x, z, listener)));
-        }
-    }
-
-    private void waitForChunks() {
-        for(Future<?> i : future.copy()) {
-            try {
-                i.get();
-                future.remove(i);
-            } catch(Throwable e) {
-                e.printStackTrace();
-            }
+        } finally {
+            semaphore.release();
         }
     }
 
@@ -101,13 +101,13 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     @Override
     public void close() {
-        waitForChunks();
+        semaphore.acquireUninterruptibly(256);
         unloadAndSaveAllChunks();
+        burst.close();
     }
 
     @Override
     public void save() {
-        waitForChunks();
         unloadAndSaveAllChunks();
     }
 
@@ -123,17 +123,18 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     @Override
     public void generateChunk(int x, int z, PregenListener listener) {
-        if(future.size() > IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())) { // TODO: FIX
-            waitForChunks();
-        }
-
         listener.onChunkGenerating(x, z);
-        future.add(burst.complete(() -> completeChunk(x, z, listener)));
+        try {
+            semaphore.acquire();
+        } catch (InterruptedException e) {
+            return;
+        }
+        burst.complete(() -> completeChunk(x, z, listener));
     }
 
     @Override
     public Mantle getMantle() {
-        if(IrisToolbelt.isIrisWorld(world)) {
+        if (IrisToolbelt.isIrisWorld(world)) {
             return IrisToolbelt.access(world).getEngine().getMantle().getMantle();
         }
 

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

@@ -18,17 +18,11 @@
 
 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.mantle.Mantle;
-import com.volmit.iris.util.math.Position2;
 import org.bukkit.World;
 
-import java.io.File;
-
 public class HybridPregenMethod implements PregeneratorMethod {
     private final PregeneratorMethod inWorld;
     private final World world;
@@ -60,7 +54,7 @@ public class HybridPregenMethod implements PregeneratorMethod {
 
     @Override
     public boolean supportsRegions(int x, int z, PregenListener listener) {
-       return inWorld.supportsRegions(x, z, listener);
+        return inWorld.supportsRegions(x, z, listener);
     }
 
     @Override

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

@@ -18,32 +18,40 @@
 
 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;
 import com.volmit.iris.util.scheduling.J;
+import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 
+import java.util.ArrayList;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
 public class MedievalPregenMethod implements PregeneratorMethod {
     private final World world;
     private final KList<CompletableFuture<?>> futures;
+    private final Map<Chunk, Long> lastUse;
 
     public MedievalPregenMethod(World world) {
         this.world = world;
         futures = new KList<>();
+        this.lastUse = new KMap<>();
     }
 
     private void waitForChunks() {
-        for(CompletableFuture<?> i : futures) {
+        for (CompletableFuture<?> i : futures) {
             try {
                 i.get();
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 e.printStackTrace();
             }
         }
@@ -52,15 +60,23 @@ public class MedievalPregenMethod implements PregeneratorMethod {
     }
 
     private void unloadAndSaveAllChunks() {
-        waitForChunks();
         try {
             J.sfut(() -> {
-                for(Chunk i : world.getLoadedChunks()) {
-                    i.unload(true);
+                if (world == null) {
+                    Iris.warn("World was null somehow...");
+                    return;
+                }
+
+                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
+                    Long lastUseTime = lastUse.get(i);
+                    if (lastUseTime != null && M.ms() - lastUseTime >= 10) {
+                        i.unload();
+                        lastUse.remove(i);
+                    }
                 }
                 world.save();
             }).get();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
         }
     }
@@ -97,13 +113,15 @@ public class MedievalPregenMethod implements PregeneratorMethod {
 
     @Override
     public void generateChunk(int x, int z, PregenListener listener) {
-        if(futures.size() > IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())) {
+        if (futures.size() > IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())) {
             waitForChunks();
         }
 
         listener.onChunkGenerating(x, z);
         futures.add(J.sfut(() -> {
             world.getChunkAt(x, z);
+            Chunk c = Bukkit.getWorld(world.getUID()).getChunkAt(x, z);
+            lastUse.put(c, M.ms());
             listener.onChunkGenerated(x, z);
             listener.onChunkCleaned(x, z);
         }));
@@ -111,7 +129,7 @@ public class MedievalPregenMethod implements PregeneratorMethod {
 
     @Override
     public Mantle getMantle() {
-        if(IrisToolbelt.isIrisWorld(world)) {
+        if (IrisToolbelt.isIrisWorld(world)) {
             return IrisToolbelt.access(world).getEngine().getMantle().getMantle();
         }
 

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

@@ -25,16 +25,7 @@ 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.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBlockData;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisEntity;
-import com.volmit.iris.engine.object.IrisGenerator;
-import com.volmit.iris.engine.object.IrisLootTable;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisObjectPlacement;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.engine.object.IrisSpawner;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.engine.object.annotations.Snippet;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
 import com.volmit.iris.util.collection.KList;
@@ -60,8 +51,7 @@ import org.bukkit.GameMode;
 import org.bukkit.World;
 import org.zeroturnaround.zip.ZipUtil;
 
-import java.awt.Desktop;
-import java.awt.GraphicsEnvironment;
+import java.awt.*;
 import java.io.File;
 import java.io.IOException;
 import java.util.Objects;
@@ -82,14 +72,14 @@ public class IrisProject {
 
     public static int clean(VolmitSender s, File clean) {
         int c = 0;
-        if(clean.isDirectory()) {
-            for(File i : clean.listFiles()) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
                 c += clean(s, i);
             }
-        } else if(clean.getName().endsWith(".json")) {
+        } else if (clean.getName().endsWith(".json")) {
             try {
                 clean(clean);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
                 Iris.error("Failed to beautify " + clean.getAbsolutePath() + " You may have errors in your json!");
             }
@@ -108,29 +98,29 @@ public class IrisProject {
     }
 
     public static void fixBlocks(JSONObject obj, File f) {
-        for(String i : obj.keySet()) {
+        for (String i : obj.keySet()) {
             Object o = obj.get(i);
 
-            if(i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
+            if (i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
                 obj.put(i, "minecraft:" + o);
                 Iris.debug("Updated Block Key: " + o + " to " + obj.getString(i) + " in " + f.getPath());
             }
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o, f);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o, f);
             }
         }
     }
 
     public static void fixBlocks(JSONArray obj, File f) {
-        for(int i = 0; i < obj.length(); i++) {
+        for (int i = 0; i < obj.length(); i++) {
             Object o = obj.get(i);
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o, f);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o, f);
             }
         }
@@ -143,11 +133,11 @@ public class IrisProject {
     public KList<File> collectFiles(File f, String fileExtension) {
         KList<File> l = new KList<>();
 
-        if(f.isDirectory()) {
-            for(File i : f.listFiles()) {
+        if (f.isDirectory()) {
+            for (File i : f.listFiles()) {
                 l.addAll(collectFiles(i, fileExtension));
             }
-        } else if(f.getName().endsWith("." + fileExtension)) {
+        } else if (f.getName().endsWith("." + fileExtension)) {
             l.add(f);
         }
 
@@ -170,28 +160,28 @@ public class IrisProject {
         J.attemptAsync(() ->
         {
             try {
-                if(d.getLoader() == null) {
+                if (d.getLoader() == null) {
                     sender.sendMessage("Could not get dimension loader");
                     return;
                 }
                 File f = d.getLoader().getDataFolder();
 
-                if(!doOpenVSCode(f)) {
+                if (!doOpenVSCode(f)) {
                     File ff = new File(d.getLoader().getDataFolder(), d.getLoadKey() + ".code-workspace");
                     Iris.warn("Project missing code-workspace: " + ff.getAbsolutePath() + " Re-creating code workspace.");
 
                     try {
                         IO.writeAll(ff, createCodeWorkspaceConfig());
-                    } catch(IOException e1) {
+                    } catch (IOException e1) {
                         Iris.reportError(e1);
                         e1.printStackTrace();
                     }
                     updateWorkspace();
-                    if(!doOpenVSCode(f)) {
+                    if (!doOpenVSCode(f)) {
                         Iris.warn("Tried creating code workspace but failed a second time. Your project is likely corrupt.");
                     }
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
                 e.printStackTrace();
             }
@@ -200,16 +190,16 @@ public class IrisProject {
 
     private boolean doOpenVSCode(File f) throws IOException {
         boolean foundWork = false;
-        for(File i : Objects.requireNonNull(f.listFiles())) {
-            if(i.getName().endsWith(".code-workspace")) {
+        for (File i : Objects.requireNonNull(f.listFiles())) {
+            if (i.getName().endsWith(".code-workspace")) {
                 foundWork = true;
                 J.a(() ->
                 {
                     updateWorkspace();
                 });
 
-                if(IrisSettings.get().getStudio().isOpenVSCode()) {
-                    if(!GraphicsEnvironment.isHeadless()) {
+                if (IrisSettings.get().getStudio().isOpenVSCode()) {
+                    if (!GraphicsEnvironment.isHeadless()) {
                         Iris.msg("Opening VSCode. You may see the output from VSCode.");
                         Iris.msg("VSCode output always starts with: '(node:#####) electron'");
                         Desktop.getDesktop().open(i);
@@ -223,21 +213,21 @@ public class IrisProject {
     }
 
     public void open(VolmitSender sender, long seed, Consumer<World> onDone) throws IrisException {
-        if(isOpen()) {
+        if (isOpen()) {
             close();
         }
 
         boolean hasError = false;
 
-        if(hasError) {
+        if (hasError) {
             return;
         }
 
         IrisDimension d = IrisData.loadAnyDimension(getName());
-        if(d == null) {
+        if (d == null) {
             sender.sendMessage("Can't find dimension: " + getName());
             return;
-        } else if(sender.isPlayer()) {
+        } else if (sender.isPlayer()) {
             sender.player().setGameMode(GameMode.SPECTATOR);
         }
 
@@ -247,14 +237,14 @@ public class IrisProject {
         J.a(() -> {
             try {
                 activeProvider = (PlatformChunkGenerator) IrisToolbelt.createWorld()
-                    .seed(seed)
-                    .sender(sender)
-                    .studio(true)
-                    .name("iris/" + UUID.randomUUID())
-                    .dimension(d.getLoadKey())
-                    .create().getGenerator();
+                        .seed(seed)
+                        .sender(sender)
+                        .studio(true)
+                        .name("iris/" + UUID.randomUUID())
+                        .dimension(d.getLoadKey())
+                        .create().getGenerator();
                 onDone.accept(activeProvider.getTarget().getWorld().realWorld());
-            } catch(IrisException e) {
+            } catch (IrisException e) {
                 e.printStackTrace();
             }
         });
@@ -286,13 +276,13 @@ public class IrisProject {
             IO.writeAll(ws, j.toString(4));
             p.end();
             return true;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Project invalid: " + ws.getAbsolutePath() + " Re-creating. You may loose some vs-code workspace settings! But not your actual project!");
             ws.delete();
             try {
                 IO.writeAll(ws, createCodeWorkspaceConfig());
-            } catch(IOException e1) {
+            } catch (IOException e1) {
                 Iris.reportError(e1);
                 e1.printStackTrace();
             }
@@ -334,19 +324,19 @@ public class IrisProject {
         JSONArray schemas = new JSONArray();
         IrisData dm = IrisData.get(getPath());
 
-        for(ResourceLoader<?> r : dm.getLoaders().v()) {
-            if(r.supportsSchemas()) {
+        for (ResourceLoader<?> r : dm.getLoaders().v()) {
+            if (r.supportsSchemas()) {
                 schemas.put(r.buildSchema());
             }
         }
 
-        for(Class<?> i : Iris.getClasses("com.volmit.iris.engine.object.", Snippet.class)) {
+        for (Class<?> i : Iris.getClasses("com.volmit.iris.engine.object.", Snippet.class)) {
             try {
                 String snipType = i.getDeclaredAnnotation(Snippet.class).value();
                 JSONObject o = new JSONObject();
                 KList<String> fm = new KList<>();
 
-                for(int g = 1; g < 8; g++) {
+                for (int g = 1; g < 8; g++) {
                     fm.add("/snippet/" + snipType + Form.repeat("/*", g) + ".json");
                 }
 
@@ -357,11 +347,11 @@ public class IrisProject {
                 J.attemptAsync(() -> {
                     try {
                         IO.writeAll(a, new SchemaBuilder(i, dm).construct().toString(4));
-                    } catch(Throwable e) {
+                    } catch (Throwable e) {
                         e.printStackTrace();
                     }
                 });
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 e.printStackTrace();
             }
         }
@@ -387,7 +377,7 @@ public class IrisProject {
         KSet<IrisLootTable> loot = new KSet<>();
         KSet<IrisBlockData> blocks = new KSet<>();
 
-        for(String i : dm.getDimensionLoader().getPossibleKeys()) {
+        for (String i : dm.getDimensionLoader().getPossibleKeys()) {
             blocks.add(dm.getBlockLoader().load(i));
         }
 
@@ -407,13 +397,13 @@ public class IrisProject {
         StringBuilder c = new StringBuilder();
         sender.sendMessage("Serializing Objects");
 
-        for(IrisBiome i : biomes) {
-            for(IrisObjectPlacement j : i.getObjects()) {
+        for (IrisBiome i : biomes) {
+            for (IrisObjectPlacement j : i.getObjects()) {
                 b.append(j.hashCode());
                 KList<String> newNames = new KList<>();
 
-                for(String k : j.getPlace()) {
-                    if(renameObjects.containsKey(k)) {
+                for (String k : j.getPlace()) {
+                    if (renameObjects.containsKey(k)) {
                         newNames.add(renameObjects.get(k));
                         continue;
                     }
@@ -441,12 +431,12 @@ public class IrisProject {
                 gb.append(IO.hash(f));
                 ggg.set(ggg.get() + 1);
 
-                if(cl.flip()) {
+                if (cl.flip()) {
                     int g = ggg.get();
                     ggg.set(0);
                     sender.sendMessage("Wrote another " + g + " Objects");
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
         })));
@@ -462,7 +452,7 @@ public class IrisProject {
             IO.writeAll(new File(folder, "dimensions/" + dimension.getLoadKey() + ".json"), a);
             b.append(IO.hash(a));
 
-            for(IrisGenerator i : generators) {
+            for (IrisGenerator i : generators) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "generators/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
@@ -471,31 +461,31 @@ public class IrisProject {
             c.append(IO.hash(b.toString()));
             b = new StringBuilder();
 
-            for(IrisRegion i : regions) {
+            for (IrisRegion i : regions) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "regions/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
             }
 
-            for(IrisBlockData i : blocks) {
+            for (IrisBlockData i : blocks) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "blocks/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
             }
 
-            for(IrisBiome i : biomes) {
+            for (IrisBiome i : biomes) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "biomes/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
             }
 
-            for(IrisEntity i : entities) {
+            for (IrisEntity i : entities) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "entities/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
             }
 
-            for(IrisLootTable i : loot) {
+            for (IrisLootTable i : loot) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "loot/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
@@ -515,7 +505,7 @@ public class IrisProject {
 
             sender.sendMessage("Package Compiled!");
             return p;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -538,18 +528,18 @@ public class IrisProject {
                     IrisObject o = new IrisObject(0, 0, 0);
                     o.read(f);
 
-                    if(o.getBlocks().isEmpty()) {
+                    if (o.getBlocks().isEmpty()) {
                         sender.sendMessageRaw("<hover:show_text:'Error:\n" +
-                            "<yellow>" + f.getPath() +
-                            "'><red>- IOB " + f.getName() + " has 0 blocks!");
+                                "<yellow>" + f.getPath() +
+                                "'><red>- IOB " + f.getName() + " has 0 blocks!");
                     }
 
-                    if(o.getW() == 0 || o.getH() == 0 || o.getD() == 0) {
+                    if (o.getW() == 0 || o.getH() == 0 || o.getD() == 0) {
                         sender.sendMessageRaw("<hover:show_text:'Error:\n" +
-                            "<yellow>" + f.getPath() + "\n<red>The width height or depth has a zero in it (bad format)" +
-                            "'><red>- IOB " + f.getName() + " is not 3D!");
+                                "<yellow>" + f.getPath() + "\n<red>The width height or depth has a zero in it (bad format)" +
+                                "'><red>- IOB " + f.getName() + " is not 3D!");
                     }
-                } catch(IOException e) {
+                } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
@@ -569,11 +559,11 @@ public class IrisProject {
                     scanForErrors(data, f, p, sender);
                     IO.writeAll(f, p.toString(4));
 
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     sender.sendMessageRaw("<hover:show_text:'Error:\n" +
-                        "<yellow>" + f.getPath() +
-                        "\n<red>" + e.getMessage() +
-                        "'><red>- JSON Error " + f.getName());
+                            "<yellow>" + f.getPath() +
+                            "\n<red>" + e.getMessage() +
+                            "'><red>- JSON Error " + f.getName());
                 }
             }
 
@@ -590,7 +580,7 @@ public class IrisProject {
         String key = data.toLoadKey(f);
         ResourceLoader<?> loader = data.getTypedLoaderFor(f);
 
-        if(loader == null) {
+        if (loader == null) {
             sender.sendMessageBasic("Can't find loader for " + f.getPath());
             return;
         }
@@ -603,62 +593,62 @@ public class IrisProject {
     public void compare(Class<?> c, JSONObject j, VolmitSender sender, KList<String> path) {
         try {
             Object o = c.getClass().getConstructor().newInstance();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
 
         }
     }
 
     public void files(File clean, KList<File> files) {
-        if(clean.isDirectory()) {
-            for(File i : clean.listFiles()) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
                 files(i, files);
             }
-        } else if(clean.getName().endsWith(".json")) {
+        } else if (clean.getName().endsWith(".json")) {
             try {
                 files.add(clean);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
         }
     }
 
     public void filesObjects(File clean, KList<File> files) {
-        if(clean.isDirectory()) {
-            for(File i : clean.listFiles()) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
                 filesObjects(i, files);
             }
-        } else if(clean.getName().endsWith(".iob")) {
+        } else if (clean.getName().endsWith(".iob")) {
             try {
                 files.add(clean);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
         }
     }
 
     private void fixBlocks(JSONObject obj) {
-        for(String i : obj.keySet()) {
+        for (String i : obj.keySet()) {
             Object o = obj.get(i);
 
-            if(i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
+            if (i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
                 obj.put(i, "minecraft:" + o);
             }
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o);
             }
         }
     }
 
     private void fixBlocks(JSONArray obj) {
-        for(int i = 0; i < obj.length(); i++) {
+        for (int i = 0; i < obj.length(); i++) {
             Object o = obj.get(i);
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o);
             }
         }

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

@@ -22,38 +22,30 @@ 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.object.annotations.ArrayType;
-import com.volmit.iris.engine.object.annotations.Desc;
-import com.volmit.iris.engine.object.annotations.MaxNumber;
-import com.volmit.iris.engine.object.annotations.MinNumber;
-import com.volmit.iris.engine.object.annotations.RegistryListBlockType;
-import com.volmit.iris.engine.object.annotations.RegistryListFont;
-import com.volmit.iris.engine.object.annotations.RegistryListItemType;
-import com.volmit.iris.engine.object.annotations.RegistryListResource;
-import com.volmit.iris.engine.object.annotations.RegistryListSpecialEntity;
-import com.volmit.iris.engine.object.annotations.Required;
-import com.volmit.iris.engine.object.annotations.Snippet;
+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.GraphicsEnvironment;
+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 {
     private static final String SYMBOL_LIMIT__N = "*";
     private static final String SYMBOL_TYPE__N = "";
     private static final JSONArray POTION_TYPES = getPotionTypes();
-    private static final JSONArray ENCHANT_TYPES = getEnchantmentTypes();
-    private static final JSONArray ITEM_TYPES = new JSONArray(B.getItemTypes());
+    private static final JSONArray ENCHANT_TYPES = getEnchantTypes();
     private static final JSONArray FONT_TYPES = new JSONArray(GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames());
     private final KMap<String, JSONObject> definitions;
     private final Class<?> root;
@@ -67,24 +59,22 @@ public class SchemaBuilder {
         this.root = root;
     }
 
-    private static JSONArray getEnchantmentTypes() {
+    private static JSONArray getPotionTypes() {
         JSONArray a = new JSONArray();
 
-        for(Field gg : Enchantment.class.getDeclaredFields()) {
-            a.put(gg.getName());
+        for (PotionEffectType gg : PotionEffectType.values()) {
+            a.put(gg.getName().toUpperCase().replaceAll("\\Q \\E", "_"));
         }
 
         return a;
     }
 
-    private static JSONArray getPotionTypes() {
-        JSONArray a = new JSONArray();
-
-        for(PotionEffectType gg : PotionEffectType.values()) {
-            a.put(gg.getName().toUpperCase().replaceAll("\\Q \\E", "_"));
+    private static JSONArray getEnchantTypes() {
+        JSONArray array = new JSONArray();
+        for (Enchantment e : Enchantment.values()) {
+            array.put(e.getKey().getKey());
         }
-
-        return a;
+        return array;
     }
 
     public JSONObject construct() {
@@ -94,21 +84,21 @@ public class SchemaBuilder {
 
         JSONObject props = buildProperties(root);
 
-        for(String i : props.keySet()) {
-            if(!schema.has(i)) {
+        for (String i : props.keySet()) {
+            if (!schema.has(i)) {
                 schema.put(i, props.get(i));
             }
         }
 
         JSONObject defs = new JSONObject();
 
-        for(Map.Entry<String, JSONObject> entry : definitions.entrySet()) {
+        for (Map.Entry<String, JSONObject> entry : definitions.entrySet()) {
             defs.put(entry.getKey(), entry.getValue());
         }
 
         schema.put("definitions", defs);
 
-        for(String i : warnings) {
+        for (String i : warnings) {
             Iris.warn(root.getSimpleName() + ": " + i);
         }
 
@@ -122,17 +112,17 @@ public class SchemaBuilder {
         o.put("type", getType(c));
         JSONArray required = new JSONArray();
 
-        if(c.isAssignableFrom(IrisRegistrant.class) || IrisRegistrant.class.isAssignableFrom(c)) {
-            for(Field k : IrisRegistrant.class.getDeclaredFields()) {
+        if (c.isAssignableFrom(IrisRegistrant.class) || IrisRegistrant.class.isAssignableFrom(c)) {
+            for (Field k : IrisRegistrant.class.getDeclaredFields()) {
                 k.setAccessible(true);
 
-                if(Modifier.isStatic(k.getModifiers()) || Modifier.isFinal(k.getModifiers()) || Modifier.isTransient(k.getModifiers())) {
+                if (Modifier.isStatic(k.getModifiers()) || Modifier.isFinal(k.getModifiers()) || Modifier.isTransient(k.getModifiers())) {
                     continue;
                 }
 
                 JSONObject property = buildProperty(k, c);
 
-                if(property.getBoolean("!required")) {
+                if (property.getBoolean("!required")) {
                     required.put(k.getName());
                 }
 
@@ -141,10 +131,10 @@ public class SchemaBuilder {
             }
         }
 
-        for(Field k : c.getDeclaredFields()) {
+        for (Field k : c.getDeclaredFields()) {
             k.setAccessible(true);
 
-            if(Modifier.isStatic(k.getModifiers()) || Modifier.isFinal(k.getModifiers()) || Modifier.isTransient(k.getModifiers())) {
+            if (Modifier.isStatic(k.getModifiers()) || Modifier.isFinal(k.getModifiers()) || Modifier.isTransient(k.getModifiers())) {
                 continue;
             }
 
@@ -154,14 +144,14 @@ public class SchemaBuilder {
             properties.put(k.getName(), property);
         }
 
-        if(required.length() > 0) {
+        if (required.length() > 0) {
             o.put("required", required);
         }
 
         o.put("properties", properties);
 
 
-        if(c.isAnnotationPresent(Snippet.class)) {
+        if (c.isAnnotationPresent(Snippet.class)) {
             JSONObject anyOf = new JSONObject();
             JSONArray arr = new JSONArray();
             JSONObject str = new JSONObject();
@@ -184,16 +174,16 @@ public class SchemaBuilder {
         prop.put("type", type);
         String fancyType = "Unknown Type";
 
-        switch(type) {
+        switch (type) {
             case "boolean" -> fancyType = "Boolean";
             case "integer" -> {
                 fancyType = "Integer";
-                if(k.isAnnotationPresent(MinNumber.class)) {
+                if (k.isAnnotationPresent(MinNumber.class)) {
                     int min = (int) k.getDeclaredAnnotation(MinNumber.class).value();
                     prop.put("minimum", min);
                     description.add(SYMBOL_LIMIT__N + " Minimum allowed is " + min);
                 }
-                if(k.isAnnotationPresent(MaxNumber.class)) {
+                if (k.isAnnotationPresent(MaxNumber.class)) {
                     int max = (int) k.getDeclaredAnnotation(MaxNumber.class).value();
                     prop.put("maximum", max);
                     description.add(SYMBOL_LIMIT__N + " Maximum allowed is " + max);
@@ -201,12 +191,12 @@ public class SchemaBuilder {
             }
             case "number" -> {
                 fancyType = "Number";
-                if(k.isAnnotationPresent(MinNumber.class)) {
+                if (k.isAnnotationPresent(MinNumber.class)) {
                     double min = k.getDeclaredAnnotation(MinNumber.class).value();
                     prop.put("minimum", min);
                     description.add(SYMBOL_LIMIT__N + " Minimum allowed is " + min);
                 }
-                if(k.isAnnotationPresent(MaxNumber.class)) {
+                if (k.isAnnotationPresent(MaxNumber.class)) {
                     double max = k.getDeclaredAnnotation(MaxNumber.class).value();
                     prop.put("maximum", max);
                     description.add(SYMBOL_LIMIT__N + " Maximum allowed is " + max);
@@ -214,26 +204,26 @@ public class SchemaBuilder {
             }
             case "string" -> {
                 fancyType = "Text";
-                if(k.isAnnotationPresent(MinNumber.class)) {
+                if (k.isAnnotationPresent(MinNumber.class)) {
                     int min = (int) k.getDeclaredAnnotation(MinNumber.class).value();
                     prop.put("minLength", min);
                     description.add(SYMBOL_LIMIT__N + " Minimum Length allowed is " + min);
                 }
-                if(k.isAnnotationPresent(MaxNumber.class)) {
+                if (k.isAnnotationPresent(MaxNumber.class)) {
                     int max = (int) k.getDeclaredAnnotation(MaxNumber.class).value();
                     prop.put("maxLength", max);
                     description.add(SYMBOL_LIMIT__N + " Maximum Length allowed is " + max);
                 }
 
 
-                if(k.isAnnotationPresent(RegistryListResource.class)) {
+                if (k.isAnnotationPresent(RegistryListResource.class)) {
                     RegistryListResource rr = k.getDeclaredAnnotation(RegistryListResource.class);
                     ResourceLoader<?> loader = data.getLoaders().get(rr.value());
 
-                    if(loader != null) {
+                    if (loader != null) {
                         String key = "erz" + loader.getFolderName();
 
-                        if(!definitions.containsKey(key)) {
+                        if (!definitions.containsKey(key)) {
                             JSONObject j = new JSONObject();
                             j.put("enum", new JSONArray(loader.getPossibleKeys()));
                             definitions.put(key, j);
@@ -245,18 +235,18 @@ public class SchemaBuilder {
                     } else {
                         Iris.error("Cannot find Registry Loader for type " + rr.value() + " used in " + k.getDeclaringClass().getCanonicalName() + " in field " + k.getName());
                     }
-                } else if(k.isAnnotationPresent(RegistryListBlockType.class)) {
+                } else if (k.isAnnotationPresent(RegistryListBlockType.class)) {
                     String key = "enum-block-type";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         JSONArray ja = new JSONArray();
 
-                        for(String i : data.getBlockLoader().getPossibleKeys()) {
+                        for (String i : data.getBlockLoader().getPossibleKeys()) {
                             ja.put(i);
                         }
 
-                        for(String i : B.getBlockTypes()) {
+                        for (String i : B.getBlockTypes()) {
                             ja.put(i);
                         }
 
@@ -268,12 +258,12 @@ public class SchemaBuilder {
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Block Type (use ctrl+space for auto complete!)");
 
-                } else if(k.isAnnotationPresent(RegistryListItemType.class)) {
+                } else if (k.isAnnotationPresent(RegistryListItemType.class)) {
                     String key = "enum-item-type";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
-                        j.put("enum", ITEM_TYPES);
+                        j.put("enum", B.getItemTypes());
                         definitions.put(key, j);
                     }
 
@@ -281,10 +271,10 @@ public class SchemaBuilder {
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Item Type (use ctrl+space for auto complete!)");
 
-                } else if(k.isAnnotationPresent(RegistryListSpecialEntity.class)) {
+                } else if (k.isAnnotationPresent(RegistryListSpecialEntity.class)) {
                     String key = "enum-reg-specialentity";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         KList<String> list = new KList<>();
                         list.addAll(Iris.linkMythicMobs.getMythicMobTypes().stream().map(s -> "MythicMobs:" + s).collect(Collectors.toList()));
@@ -296,10 +286,10 @@ public class SchemaBuilder {
                     fancyType = "Mythic Mob Type";
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Mythic Mob Type (use ctrl+space for auto complete!) Define mythic mobs with the mythic mobs plugin configuration files.");
-                } else if(k.isAnnotationPresent(RegistryListFont.class)) {
+                } else if (k.isAnnotationPresent(RegistryListFont.class)) {
                     String key = "enum-font";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         j.put("enum", FONT_TYPES);
                         definitions.put(key, j);
@@ -309,10 +299,10 @@ public class SchemaBuilder {
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Font Family (use ctrl+space for auto complete!)");
 
-                } else if(k.getType().equals(Enchantment.class)) {
+                } else if (k.isAnnotationPresent(RegistryListEnchantment.class)) {
                     String key = "enum-enchantment";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         j.put("enum", ENCHANT_TYPES);
                         definitions.put(key, j);
@@ -321,10 +311,28 @@ public class SchemaBuilder {
                     fancyType = "Enchantment Type";
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Enchantment Type (use ctrl+space for auto complete!)");
-                } else if(k.getType().equals(PotionEffectType.class)) {
+                } else if (k.isAnnotationPresent(RegistryListFunction.class)) {
+                    var functionClass = k.getDeclaredAnnotation(RegistryListFunction.class).value();
+                    try {
+                        var instance = functionClass.getDeclaredConstructor().newInstance();
+                        String key = instance.key();
+                        fancyType = instance.fancyName();
+
+                        if (!definitions.containsKey(key)) {
+                            JSONObject j = new JSONObject();
+                            j.put("enum", instance.apply(data));
+                            definitions.put(key, j);
+                        }
+
+                        prop.put("$ref", "#/definitions/" + key);
+                        description.add(SYMBOL_TYPE__N + "  Must be a valid " + fancyType + " (use ctrl+space for auto complete!)");
+                    } catch (Throwable e) {
+                        Iris.error("Could not execute apply method in " + functionClass.getName());
+                    }
+                } else if (k.getType().equals(PotionEffectType.class)) {
                     String key = "enum-potion-effect-type";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         j.put("enum", POTION_TYPES);
                         definitions.put(key, j);
@@ -334,45 +342,16 @@ public class SchemaBuilder {
                     prop.put("$ref", "#/definitions/" + key);
                     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!)");
-
+                } else if (k.getType().isEnum()) {
+                    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" -> {
                 fancyType = k.getType().getSimpleName().replaceAll("\\QIris\\E", "") + " (Object)";
                 String key = "obj-" + k.getType().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
-                if(!definitions.containsKey(key)) {
+                if (!definitions.containsKey(key)) {
                     definitions.put(key, new JSONObject());
                     definitions.put(key, buildProperties(k.getType()));
                 }
@@ -381,10 +360,10 @@ public class SchemaBuilder {
             case "array" -> {
                 fancyType = "List of Something...?";
                 ArrayType t = k.getDeclaredAnnotation(ArrayType.class);
-                if(t != null) {
-                    if(t.min() > 0) {
+                if (t != null) {
+                    if (t.min() > 0) {
                         prop.put("minItems", t.min());
-                        if(t.min() == 1) {
+                        if (t.min() == 1) {
                             description.add(SYMBOL_LIMIT__N + " At least one entry must be defined, or just remove this list.");
                         } else {
                             description.add(SYMBOL_LIMIT__N + " Requires at least " + t.min() + " entries.");
@@ -393,13 +372,13 @@ public class SchemaBuilder {
 
                     String arrayType = getType(t.type());
 
-                    switch(arrayType) {
+                    switch (arrayType) {
                         case "integer" -> fancyType = "List of Integers";
                         case "number" -> fancyType = "List of Numbers";
                         case "object" -> {
                             fancyType = "List of " + t.type().getSimpleName().replaceAll("\\QIris\\E", "") + "s (Objects)";
                             String key = "obj-" + t.type().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
-                            if(!definitions.containsKey(key)) {
+                            if (!definitions.containsKey(key)) {
                                 definitions.put(key, new JSONObject());
                                 definitions.put(key, buildProperties(t.type()));
                             }
@@ -410,15 +389,15 @@ public class SchemaBuilder {
                         case "string" -> {
                             fancyType = "List of Text";
 
-                            if(k.isAnnotationPresent(RegistryListResource.class)) {
+                            if (k.isAnnotationPresent(RegistryListResource.class)) {
                                 RegistryListResource rr = k.getDeclaredAnnotation(RegistryListResource.class);
                                 ResourceLoader<?> loader = data.getLoaders().get(rr.value());
 
-                                if(loader != null) {
+                                if (loader != null) {
                                     fancyType = "List<" + loader.getResourceTypeName() + ">";
                                     String key = "erz" + loader.getFolderName();
 
-                                    if(!definitions.containsKey(key)) {
+                                    if (!definitions.containsKey(key)) {
                                         JSONObject j = new JSONObject();
                                         j.put("enum", new JSONArray(loader.getPossibleKeys()));
                                         definitions.put(key, j);
@@ -431,19 +410,19 @@ public class SchemaBuilder {
                                 } else {
                                     Iris.error("Cannot find Registry Loader for type (list schema) " + rr.value() + " used in " + k.getDeclaringClass().getCanonicalName() + " in field " + k.getName());
                                 }
-                            } else if(k.isAnnotationPresent(RegistryListBlockType.class)) {
+                            } else if (k.isAnnotationPresent(RegistryListBlockType.class)) {
                                 fancyType = "List of Block Types";
                                 String key = "enum-block-type";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     JSONArray ja = new JSONArray();
 
-                                    for(String i : data.getBlockLoader().getPossibleKeys()) {
+                                    for (String i : data.getBlockLoader().getPossibleKeys()) {
                                         ja.put(i);
                                     }
 
-                                    for(String i : B.getBlockTypes()) {
+                                    for (String i : B.getBlockTypes()) {
                                         ja.put(i);
                                     }
 
@@ -455,13 +434,13 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Block Type (use ctrl+space for auto complete!)");
-                            } else if(k.isAnnotationPresent(RegistryListItemType.class)) {
+                            } else if (k.isAnnotationPresent(RegistryListItemType.class)) {
                                 fancyType = "List of Item Types";
                                 String key = "enum-item-type";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
-                                    j.put("enum", ITEM_TYPES);
+                                    j.put("enum", B.getItemTypes());
                                     definitions.put(key, j);
                                 }
 
@@ -469,11 +448,11 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Item Type (use ctrl+space for auto complete!)");
-                            } else if(k.isAnnotationPresent(RegistryListFont.class)) {
+                            } else if (k.isAnnotationPresent(RegistryListFont.class)) {
                                 String key = "enum-font";
                                 fancyType = "List of Font Families";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     j.put("enum", FONT_TYPES);
                                     definitions.put(key, j);
@@ -483,11 +462,11 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Font Family (use ctrl+space for auto complete!)");
-                            } else if(t.type().equals(Enchantment.class)) {
+                            } else if (k.isAnnotationPresent(RegistryListEnchantment.class)) {
                                 fancyType = "List of Enchantment Types";
                                 String key = "enum-enchantment";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     j.put("enum", ENCHANT_TYPES);
                                     definitions.put(key, j);
@@ -497,11 +476,11 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Enchantment Type (use ctrl+space for auto complete!)");
-                            } else if(t.type().equals(PotionEffectType.class)) {
+                            } else if (t.type().equals(PotionEffectType.class)) {
                                 fancyType = "List of Potion Effect Types";
                                 String key = "enum-potion-effect-type";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     j.put("enum", POTION_TYPES);
                                     definitions.put(key, j);
@@ -511,40 +490,10 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 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!)");
+                            } else if (t.type().isEnum()) {
+                                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);
                             }
                         }
                     }
@@ -552,7 +501,8 @@ public class SchemaBuilder {
                     warnings.add("Undefined array type for field " + k.getName() + " (" + k.getType().getSimpleName() + ") in class " + cl.getSimpleName());
                 }
             }
-            default -> warnings.add("Unexpected Schema Type: " + type + " for field " + k.getName() + " (" + k.getType().getSimpleName() + ") in class " + cl.getSimpleName());
+            default ->
+                    warnings.add("Unexpected Schema Type: " + type + " for field " + k.getName() + " (" + k.getType().getSimpleName() + ") in class " + cl.getSimpleName());
         }
 
         KList<String> d = new KList<>();
@@ -562,7 +512,7 @@ public class SchemaBuilder {
         d.add(fancyType);
         d.add(getDescription(k.getType()));
 
-        if(k.getType().isAnnotationPresent(Snippet.class)) {
+        if (k.getType().isAnnotationPresent(Snippet.class)) {
             String sm = k.getType().getDeclaredAnnotation(Snippet.class).value();
             d.add("    ");
             d.add("You can instead specify \"snippet/" + sm + "/some-name.json\" to use a snippet file instead of specifying it here.");
@@ -572,11 +522,11 @@ public class SchemaBuilder {
             k.setAccessible(true);
             Object value = k.get(cl.newInstance());
 
-            if(value != null) {
-                if(value instanceof List) {
+            if (value != null) {
+                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 {
@@ -584,7 +534,7 @@ public class SchemaBuilder {
                     d.add("* Default Value is " + value);
                 }
             }
-        } catch(Throwable ignored) {
+        } catch (Throwable ignored) {
 
         }
 
@@ -592,7 +542,7 @@ public class SchemaBuilder {
         prop.put("type", type);
         prop.put("description", d.toString("\n"));
 
-        if(k.getType().isAnnotationPresent(Snippet.class)) {
+        if (k.getType().isAnnotationPresent(Snippet.class)) {
             JSONObject anyOf = new JSONObject();
             JSONArray arr = new JSONArray();
             JSONObject str = new JSONObject();
@@ -600,7 +550,7 @@ public class SchemaBuilder {
             String key = "enum-snippet-" + k.getType().getDeclaredAnnotation(Snippet.class).value();
             str.put("$ref", "#/definitions/" + key);
 
-            if(!definitions.containsKey(key)) {
+            if (!definitions.containsKey(key)) {
                 JSONObject j = new JSONObject();
                 JSONArray snl = new JSONArray();
                 data.getPossibleSnippets(k.getType().getDeclaredAnnotation(Snippet.class).value()).forEach(snl::put);
@@ -622,32 +572,76 @@ 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)) {
+        if (c.equals(int.class) || c.equals(Integer.class) || c.equals(long.class) || c.equals(Long.class)) {
             return "integer";
         }
 
-        if(c.equals(float.class) || c.equals(double.class) || c.equals(Float.class) || c.equals(Double.class)) {
+        if (c.equals(float.class) || c.equals(double.class) || c.equals(Float.class) || c.equals(Double.class)) {
             return "number";
         }
 
-        if(c.equals(boolean.class) || c.equals(Boolean.class)) {
+        if (c.equals(boolean.class) || c.equals(Boolean.class)) {
             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";
         }
 
-        if(c.equals(KList.class)) {
+        if (c.equals(KList.class)) {
             return "array";
         }
 
-        if(c.equals(KMap.class)) {
+        if (c.equals(KMap.class)) {
             return "object";
         }
 
-        if(!c.isAnnotationPresent(Desc.class) && c.getCanonicalName().startsWith("com.volmit.iris.")) {
+        if (!c.isAnnotationPresent(Desc.class) && c.getCanonicalName().startsWith("com.volmit.iris.")) {
             warnings.addIfMissing("Unsupported Type: " + c.getCanonicalName() + " Did you forget @Desc?");
         }
 
@@ -656,12 +650,12 @@ public class SchemaBuilder {
 
     private String getFieldDescription(Field r) {
 
-        if(r.isAnnotationPresent(Desc.class)) {
+        if (r.isAnnotationPresent(Desc.class)) {
             return r.getDeclaredAnnotation(Desc.class).value();
         }
 
         // suppress warnings on bukkit classes
-        if(r.getDeclaringClass().getName().startsWith("org.bukkit.")) {
+        if (r.getDeclaringClass().getName().startsWith("org.bukkit.")) {
             return "Bukkit package classes and enums have no descriptions";
         }
 
@@ -670,11 +664,11 @@ public class SchemaBuilder {
     }
 
     private String getDescription(Class<?> r) {
-        if(r.isAnnotationPresent(Desc.class)) {
+        if (r.isAnnotationPresent(Desc.class)) {
             return r.getDeclaredAnnotation(Desc.class).value();
         }
 
-        if(!r.isPrimitive() && !r.equals(KList.class) && !r.equals(KMap.class) && r.getCanonicalName().startsWith("com.volmit.")) {
+        if (!r.isPrimitive() && !r.equals(KList.class) && !r.equals(KMap.class) && r.getCanonicalName().startsWith("com.volmit.")) {
             warnings.addIfMissing("Missing @Desc on " + r.getSimpleName() + " in " + (r.getDeclaringClass() != null ? r.getDeclaringClass().getCanonicalName() : " NOSRC"));
         }
         return "";

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

@@ -0,0 +1,15 @@
+package com.volmit.iris.core.safeguard;
+
+import com.volmit.iris.Iris;
+
+public class IrisSafeguard {
+    public static boolean unstablemode = false;
+    public static boolean warningmode = false;
+    public static boolean stablemode = false;
+
+    public static void IrisSafeguardSystem() {
+        Iris.info("Enabled Iris SafeGuard");
+        ServerBootSFG.BootCheck();
+    }
+}
+

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

@@ -0,0 +1,80 @@
+package com.volmit.iris.core.safeguard;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.util.format.C;
+
+public class ModesSFG {
+    public static void selectMode() {
+        if (IrisSafeguard.unstablemode) {
+            Iris.safeguard(C.DARK_RED + "Iris is running in Unstable Mode");
+            unstable();
+        }
+        if (IrisSafeguard.warningmode) {
+            Iris.safeguard(C.GOLD + "Iris is running in Warning Mode");
+            warning();
+        }
+        if (IrisSafeguard.stablemode) {
+            stable();
+        }
+    }
+
+    public static void stable() {
+        Iris.safeguard(C.BLUE + "Iris is running Stable");
+    }
+
+    public static void unstable() {
+
+        UtilsSFG.printIncompatibleWarnings();
+
+        if (IrisSafeguard.unstablemode) {
+            Iris.info("");
+            Iris.info(C.DARK_GRAY + "--==<" + C.RED + " IMPORTANT " + C.DARK_GRAY + ">==--");
+            Iris.info(C.RED + "Iris is running in unstable mode which may cause the following issues:");
+            Iris.info(C.DARK_RED + "Server Issues");
+            Iris.info(C.RED + "- Server won't boot");
+            Iris.info(C.RED + "- Data Loss");
+            Iris.info(C.RED + "- Unexpected behavior.");
+            Iris.info(C.RED + "- And More...");
+            Iris.info(C.DARK_RED + "World Issues");
+            Iris.info(C.RED + "- Worlds can't load due to corruption.");
+            Iris.info(C.RED + "- Worlds may slowly corrupt until they can't load.");
+            Iris.info(C.RED + "- World data loss.");
+            Iris.info(C.RED + "- And More...");
+            Iris.info(C.DARK_RED + "ATTENTION: " + C.RED + "While running Iris in unstable mode, you won't be eligible for support.");
+            Iris.info(C.DARK_RED + "CAUSE: " + C.RED + UtilsSFG.MSGIncompatibleWarnings());
+
+            if (IrisSettings.get().getGeneral().DoomsdayAnnihilationSelfDestructMode) {
+                Iris.info(C.DARK_RED + "Boot Unstable is set to true, continuing with the startup process.");
+            } else {
+                Iris.info(C.DARK_RED + "Go to plugins/iris/settings.json and set DoomsdayAnnihilationSelfDestructMode to true if you wish to proceed.");
+                while (true) {
+                    try {
+                        Thread.sleep(Long.MAX_VALUE);
+                    } catch (InterruptedException e) {
+                        // no
+                    }
+                }
+            }
+            Iris.info("");
+        }
+    }
+
+    public static void warning() {
+
+        UtilsSFG.printIncompatibleWarnings();
+
+        if (IrisSafeguard.warningmode) {
+            Iris.info("");
+            Iris.info(C.DARK_GRAY + "--==<" + C.GOLD + " IMPORTANT " + C.DARK_GRAY + ">==--");
+            Iris.info(C.GOLD + "Iris is running in warning mode which may cause the following issues:");
+            Iris.info(C.YELLOW + "- Data Loss");
+            Iris.info(C.YELLOW + "- Errors");
+            Iris.info(C.YELLOW + "- Broken worlds");
+            Iris.info(C.YELLOW + "- Unexpected behavior.");
+            Iris.info(C.YELLOW + "- And perhaps further complications.");
+            Iris.info(C.GOLD + "CAUSE: " + C.YELLOW + UtilsSFG.MSGIncompatibleWarnings());
+            Iris.info("");
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.volmit.iris.core.safeguard;
+
+public class PerformanceSFG {
+    public static void calculatePerformance() {
+
+
+    }
+}

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

@@ -0,0 +1,168 @@
+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 org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginManager;
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import java.io.File;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.StringJoiner;
+
+import static com.volmit.iris.Iris.getJavaVersion;
+import static com.volmit.iris.core.safeguard.IrisSafeguard.*;
+
+public class ServerBootSFG {
+    public static final Map<String, Boolean> incompatibilities = new HashMap<>();
+    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;
+    protected static boolean safeguardPassed;
+    public static boolean passedserversoftware = true;
+    protected static int count;
+    protected static byte severityLow;
+    protected static byte severityMedium;
+    protected static byte severityHigh;
+    public static String allIncompatibilities;
+
+    public static void BootCheck() {
+        Iris.info("Checking for possible conflicts..");
+        PluginManager pluginManager = Bukkit.getPluginManager();
+        Plugin[] plugins = pluginManager.getPlugins();
+
+        incompatibilities.clear();
+        incompatibilities.put("Multiverse-Core", false);
+        incompatibilities.put("dynmap", false);
+        incompatibilities.put("TerraformGenerator", false);
+        incompatibilities.put("Stratos", false);
+
+        String pluginName;
+        for (Plugin plugin : plugins) {
+            pluginName = plugin.getName();
+            Boolean flag = incompatibilities.get(pluginName);
+            if (flag != null && !flag) {
+                severityHigh++;
+                incompatibilities.put(pluginName, true);
+            }
+        }
+
+        StringJoiner joiner = new StringJoiner(", ");
+        for (Map.Entry<String, Boolean> entry : incompatibilities.entrySet()) {
+            if (entry.getValue()) {
+                joiner.add(entry.getKey());
+            }
+        }
+        // Legacy ServerInfo
+        String distro = Bukkit.getName().toLowerCase();
+        if (
+                !distro.contains("purpur") &&
+                        !distro.contains("paper") &&
+                        !distro.contains("spigot") &&
+                        !distro.contains("pufferfish") &&
+                        !distro.contains("bukkit")) {
+
+
+            passedserversoftware = false;
+            joiner.add("Server Software");
+            severityMedium++;
+        }
+
+
+        if (INMS.get() instanceof NMSBinding1X) {
+            unsuportedversion = true;
+            joiner.add("Unsupported Minecraft Version");
+            severityHigh++;
+        }
+
+        if (!List.of(21).contains(getJavaVersion())) {
+            isCorrectJDK = false;
+            joiner.add("Unsupported Java version");
+            severityMedium++;
+        }
+
+        if (!isJDK()) {
+            isJRE = true;
+            joiner.add("Unsupported JDK");
+            severityMedium++;
+        }
+
+//        if (!hasPrivileges()){
+//            hasPrivileges = false;
+//            joiner.add("Insufficient Privileges");
+//            severityMedium++;
+//        } Some servers dont like this
+
+        if (!enoughDiskSpace()){
+            hasEnoughDiskSpace = false;
+            joiner.add("Insufficient Disk Space");
+            severityMedium++;
+        }
+
+        allIncompatibilities = joiner.toString();
+
+        safeguardPassed = (severityHigh == 0 && severityMedium == 0 && severityLow == 0);
+        count = severityHigh + severityMedium + severityLow;
+        if (safeguardPassed) {
+            stablemode = true;
+            Iris.safeguard("Stable mode has been activated.");
+        }
+        if (!safeguardPassed) {
+            if (severityMedium >= 1 && severityHigh == 0) {
+                warningmode = true;
+                Iris.safeguard("Warning mode has been activated.");
+            }
+            if (severityHigh >= 1) {
+                unstablemode = true;
+                Iris.safeguard("Unstable mode has been activated.");
+            }
+        }
+    }
+
+
+    public static boolean isJDK() {
+        try {
+            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+            // If the compiler is null, it means this is a JRE environment, not a JDK.
+            return compiler != null;
+        } catch (Exception ignored) {}
+        return false;
+    }
+    public static boolean hasPrivileges() {
+        Path pv = Paths.get(Bukkit.getWorldContainer() + "iristest.json");
+        try (FileChannel fc = FileChannel.open(pv, StandardOpenOption.CREATE, StandardOpenOption.DELETE_ON_CLOSE, StandardOpenOption.READ, StandardOpenOption.WRITE)) {
+            if (Files.isReadable(pv) && Files.isWritable(pv)) {
+                return true;
+            }
+        } catch (Exception e) {
+            return false;
+        }
+        return false;
+    }
+
+    public static boolean enoughDiskSpace() {
+        File freeSpace = new File(Bukkit.getWorldContainer() + ".");
+        double gigabytes = freeSpace.getFreeSpace() / (1024.0 * 1024.0 * 1024.0);
+        if (gigabytes > 3){
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private static boolean checkJavac(String path) {
+        return !path.isEmpty() && (new File(path, "javac").exists() || new File(path, "javac.exe").exists());
+    }
+
+}

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

@@ -0,0 +1,68 @@
+package com.volmit.iris.core.safeguard;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.format.C;
+
+public class UtilsSFG {
+    public static void splash() {
+        ModesSFG.selectMode();
+    }
+
+    public static void printIncompatibleWarnings() {
+        // String SupportedIrisVersion = getDescription().getVersion(); //todo Automatic version
+
+        if (ServerBootSFG.safeguardPassed) {
+            Iris.safeguard(C.BLUE + "0 Conflicts found");
+        } else {
+            if (IrisSafeguard.unstablemode) {
+                Iris.safeguard(C.DARK_RED + "" + ServerBootSFG.count + " Conflicts found");
+            }
+            if (IrisSafeguard.warningmode) {
+                Iris.safeguard(C.YELLOW + "" + ServerBootSFG.count + " Conflicts found");
+            }
+
+            if (ServerBootSFG.incompatibilities.get("Multiverse-Core")) {
+                Iris.safeguard(C.RED + "Multiverse");
+                Iris.safeguard(C.RED + "- The plugin Multiverse is not compatible with the server.");
+                Iris.safeguard(C.RED + "- If you want to have a world manager, consider using PhantomWorlds or MyWorlds instead.");
+            }
+            if (ServerBootSFG.incompatibilities.get("dynmap")) {
+                Iris.safeguard(C.RED + "Dynmap");
+                Iris.safeguard(C.RED + "- The plugin Dynmap is not compatible with the server.");
+                Iris.safeguard(C.RED + "- If you want to have a map plugin like Dynmap, consider Bluemap.");
+            }
+            if (ServerBootSFG.incompatibilities.get("TerraformGenerator") || ServerBootSFG.incompatibilities.get("Stratos")) {
+                Iris.safeguard(C.YELLOW + "Terraform Generator / Stratos");
+                Iris.safeguard(C.YELLOW + "- Iris is not compatible with other worldgen plugins.");
+            }
+            if (ServerBootSFG.unsuportedversion) {
+                Iris.safeguard(C.RED + "Server Version");
+                Iris.safeguard(C.RED + "- Iris only supports 1.19.2 > 1.21.3");
+            }
+            if (!ServerBootSFG.passedserversoftware) {
+                Iris.safeguard(C.YELLOW + "Unsupported Server Software");
+                Iris.safeguard(C.YELLOW + "- Please consider using Paper or Purpur instead.");
+            }
+            if (!ServerBootSFG.hasPrivileges) {
+                Iris.safeguard(C.YELLOW + "Insufficient Privileges");
+                Iris.safeguard(C.YELLOW + "- The server has insufficient Privileges to run iris. Please contact support.");
+            }
+            if (!ServerBootSFG.hasEnoughDiskSpace) {
+                Iris.safeguard(C.YELLOW + "Insufficient Disk Space");
+                Iris.safeguard(C.YELLOW + "- The server has insufficient Free DiskSpace to run iris required 3GB+.");
+            }
+            if (!ServerBootSFG.isCorrectJDK) {
+                Iris.safeguard(C.YELLOW + "Unsupported java version");
+                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 21 Instead of JRE " + Iris.getJavaVersion());
+            }
+        }
+    }
+
+    public static String MSGIncompatibleWarnings() {
+        return ServerBootSFG.allIncompatibilities;
+    }
+}

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

@@ -19,6 +19,7 @@
 package com.volmit.iris.core.service;
 
 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;
@@ -39,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<>();
@@ -48,9 +50,9 @@ public class BoardSVC implements IrisService, BoardProvider {
     public void onEnable() {
         J.ar(this::tick, 20);
         manager = new BoardManager(Iris.instance, BoardSettings.builder()
-            .boardProvider(this)
-            .scoreDirection(ScoreDirection.DOWN)
-            .build());
+                .boardProvider(this)
+                .scoreDirection(ScoreDirection.DOWN)
+                .build());
     }
 
     @Override
@@ -70,7 +72,7 @@ public class BoardSVC implements IrisService, BoardProvider {
     }
 
     public void updatePlayer(Player p) {
-        if(IrisToolbelt.isIrisStudioWorld(p.getWorld())) {
+        if (IrisToolbelt.isIrisStudioWorld(p.getWorld())) {
             manager.remove(p);
             manager.setup(p);
         } else {
@@ -85,7 +87,7 @@ public class BoardSVC implements IrisService, BoardProvider {
     }
 
     public void tick() {
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             return;
         }
 
@@ -95,7 +97,7 @@ public class BoardSVC implements IrisService, BoardProvider {
     @Override
     public List<String> getLines(Player player) {
         PlayerBoard pb = boards.computeIfAbsent(player, PlayerBoard::new);
-        synchronized(pb.lines) {
+        synchronized (pb.lines) {
             return pb.lines;
         }
     }
@@ -103,19 +105,19 @@ 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();
         }
 
         public void update() {
-            synchronized(lines) {
+            synchronized (lines) {
                 lines.clear();
 
-                if(!IrisToolbelt.isIrisStudioWorld(player.getWorld())) {
+                if (!IrisToolbelt.isIrisStudioWorld(player.getWorld())) {
                     return;
                 }
 
@@ -124,17 +126,32 @@ public class BoardSVC implements IrisService, BoardProvider {
                 int y = player.getLocation().getBlockY() - player.getWorld().getMinHeight();
                 int z = player.getLocation().getBlockZ();
 
-                lines.add("&7&m                   ");
-                lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
-                lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
-                lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
-                lines.add("&7&m                   ");
-                lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
-                lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
-                lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z) + player.getWorld().getMinHeight()));
-                lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
-                lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
-                lines.add("&7&m                   ");
+                if(IrisSettings.get().getGeneral().debug){
+                    lines.add("&7&m                   ");
+                    lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
+                    lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
+                    lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
+                    lines.add(C.LIGHT_PURPLE + "Carving" + C.GRAY + ": " + engine.getMantle().isCarved(x,y,z));
+                    lines.add("&7&m                   ");
+                    lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
+                    lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
+                    lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z)));
+                    lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
+                    lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
+                    lines.add("&7&m                   ");
+                } else {
+                    lines.add("&7&m                   ");
+                    lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
+                    lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
+                    lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
+                    lines.add("&7&m                   ");
+                    lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
+                    lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
+                    lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z)));
+                    lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
+                    lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
+                    lines.add("&7&m                   ");
+                }
             }
         }
     }

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

@@ -38,8 +38,8 @@ import java.util.concurrent.CompletableFuture;
 
 public class CommandSVC implements IrisService, DecreeSystem {
     private final KMap<String, CompletableFuture<String>> futures = new KMap<>();
-    private CompletableFuture<String> consoleFuture = null;
     private final transient AtomicCache<VirtualDecreeCommand> commandCache = new AtomicCache<>();
+    private CompletableFuture<String> consoleFuture = null;
 
     @Override
     public void onEnable() {
@@ -56,18 +56,18 @@ public class CommandSVC implements IrisService, DecreeSystem {
     public void on(PlayerCommandPreprocessEvent e) {
         String msg = e.getMessage().startsWith("/") ? e.getMessage().substring(1) : e.getMessage();
 
-        if(msg.startsWith("irisdecree ")) {
+        if (msg.startsWith("irisdecree ")) {
             String[] args = msg.split("\\Q \\E");
             CompletableFuture<String> future = futures.get(args[1]);
 
-            if(future != null) {
+            if (future != null) {
                 future.complete(args[2]);
                 e.setCancelled(true);
                 return;
             }
         }
 
-        if((msg.startsWith("locate ") || msg.startsWith("locatebiome ")) && IrisToolbelt.isIrisWorld(e.getPlayer().getWorld())) {
+        if ((msg.startsWith("locate ") || msg.startsWith("locatebiome ")) && IrisToolbelt.isIrisWorld(e.getPlayer().getWorld())) {
             new VolmitSender(e.getPlayer()).sendMessage(C.RED + "Locating biomes & objects is disabled in Iris Worlds. Use /iris studio goto <biome>");
             e.setCancelled(true);
         }
@@ -75,8 +75,8 @@ public class CommandSVC implements IrisService, DecreeSystem {
 
     @EventHandler
     public void on(ServerCommandEvent e) {
-        if(consoleFuture != null && !consoleFuture.isCancelled() && !consoleFuture.isDone()) {
-            if(!e.getCommand().contains(" ")) {
+        if (consoleFuture != null && !consoleFuture.isCancelled() && !consoleFuture.isDone()) {
+            if (!e.getCommand().contains(" ")) {
                 String pick = e.getCommand().trim().toLowerCase(Locale.ROOT);
                 consoleFuture.complete(pick);
                 e.setCancelled(true);

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

@@ -20,12 +20,7 @@ package com.volmit.iris.core.service;
 
 import com.google.gson.Gson;
 import com.volmit.iris.Iris;
-import com.volmit.iris.engine.object.IrisDirection;
-import com.volmit.iris.engine.object.IrisJigsawPiece;
-import com.volmit.iris.engine.object.IrisJigsawPieceConnector;
-import com.volmit.iris.engine.object.IrisJigsawPool;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisPosition;
+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.format.Form;
@@ -60,10 +55,10 @@ public class ConversionSVC implements IrisService {
         converters = new KList<>();
 
         J.s(() ->
-            J.attemptAsync(() ->
-            {
+                J.attemptAsync(() ->
+                {
 
-            }), 5);
+                }), 5);
     }
 
     @Override
@@ -84,13 +79,13 @@ public class ConversionSVC implements IrisService {
         destPools.mkdirs();
         findAllNBT(in, (folder, file) -> {
             total.getAndIncrement();
-            if(roots.addIfMissing(folder)) {
+            if (roots.addIfMissing(folder)) {
                 String b = in.toURI().relativize(folder.toURI()).getPath();
-                if(b.startsWith("/")) {
+                if (b.startsWith("/")) {
                     b = b.substring(1);
                 }
 
-                if(b.endsWith("/")) {
+                if (b.endsWith("/")) {
                     b = b.substring(0, b.length() - 1);
                 }
 
@@ -100,11 +95,11 @@ public class ConversionSVC implements IrisService {
         findAllNBT(in, (folder, file) -> {
             at.getAndIncrement();
             String b = in.toURI().relativize(folder.toURI()).getPath();
-            if(b.startsWith("/")) {
+            if (b.startsWith("/")) {
                 b = b.substring(1);
             }
 
-            if(b.endsWith("/")) {
+            if (b.endsWith("/")) {
                 b = b.substring(0, b.length() - 1);
             }
             IrisJigsawPool jpool = pools.get(b);
@@ -117,7 +112,7 @@ public class ConversionSVC implements IrisService {
                 NamedTag tag = NBTUtil.read(file);
                 CompoundTag compound = (CompoundTag) tag.getTag();
 
-                if(compound.containsKey("blocks") && compound.containsKey("palette") && compound.containsKey("size")) {
+                if (compound.containsKey("blocks") && compound.containsKey("palette") && compound.containsKey("size")) {
                     String id = in.toURI().relativize(folder.toURI()).getPath() + file.getName().split("\\Q.\\E")[0];
                     @SuppressWarnings("unchecked") ListTag<IntTag> size = (ListTag<IntTag>) compound.getListTag("size");
                     int w = size.get(0).asInt();
@@ -125,14 +120,14 @@ public class ConversionSVC implements IrisService {
                     int d = size.get(2).asInt();
                     KList<BlockData> palette = new KList<>();
                     @SuppressWarnings("unchecked") ListTag<CompoundTag> paletteList = (ListTag<CompoundTag>) compound.getListTag("palette");
-                    for(int i = 0; i < paletteList.size(); i++) {
+                    for (int i = 0; i < paletteList.size(); i++) {
                         CompoundTag cp = paletteList.get(i);
                         palette.add(NBTWorld.getBlockData(cp));
                     }
                     IrisJigsawPiece piece = new IrisJigsawPiece();
                     IrisObject object = new IrisObject(w, h, d);
                     @SuppressWarnings("unchecked") ListTag<CompoundTag> blockList = (ListTag<CompoundTag>) compound.getListTag("blocks");
-                    for(int i = 0; i < blockList.size(); i++) {
+                    for (int i = 0; i < blockList.size(); i++) {
                         CompoundTag cp = blockList.get(i);
                         @SuppressWarnings("unchecked") ListTag<IntTag> pos = (ListTag<IntTag>) cp.getListTag("pos");
                         int x = pos.get(0).asInt();
@@ -140,7 +135,7 @@ public class ConversionSVC implements IrisService {
                         int z = pos.get(2).asInt();
                         BlockData bd = palette.get(cp.getInt("state")).clone();
 
-                        if(bd.getMaterial().equals(Material.JIGSAW) && cp.containsKey("nbt")) {
+                        if (bd.getMaterial().equals(Material.JIGSAW) && cp.containsKey("nbt")) {
                             piece.setObject(in.toURI().relativize(folder.toURI()).getPath() + file.getName().split("\\Q.\\E")[0]);
                             IrisPosition spos = new IrisPosition(object.getSigned(x, y, z));
                             CompoundTag nbt = cp.getCompoundTag("nbt");
@@ -162,14 +157,14 @@ public class ConversionSVC implements IrisService {
                             connector.getPools().add(poolId);
                             connector.setDirection(IrisDirection.getDirection(((Jigsaw) jd).getOrientation()));
 
-                            if(target.equals("minecraft:building_entrance")) {
+                            if (target.equals("minecraft:building_entrance")) {
                                 connector.setInnerConnector(true);
                             }
 
                             piece.getConnectors().add(connector);
                         }
 
-                        if(!bd.getMaterial().equals(Material.STRUCTURE_VOID) && !bd.getMaterial().equals(Material.AIR)) {
+                        if (!bd.getMaterial().equals(Material.STRUCTURE_VOID) && !bd.getMaterial().equals(Material.AIR)) {
                             object.setUnsigned(x, y, z, bd);
                         }
                     }
@@ -179,16 +174,16 @@ public class ConversionSVC implements IrisService {
                     IO.writeAll(new File(destPieces, file.getName().split("\\Q.\\E")[0] + ".json"), new JSONObject(new Gson().toJson(piece)).toString(4));
                     Iris.info("[Jigsaw]: (" + Form.pc((double) at.get() / (double) total.get(), 0) + ") Exported Piece: " + id);
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 e.printStackTrace();
                 Iris.reportError(e);
             }
         });
 
-        for(String i : pools.k()) {
+        for (String i : pools.k()) {
             try {
                 IO.writeAll(new File(destPools, i + ".json"), new JSONObject(new Gson().toJson(pools.get(i))).toString(4));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 e.printStackTrace();
                 Iris.reportError(e);
             }
@@ -198,19 +193,19 @@ public class ConversionSVC implements IrisService {
     }
 
     public void findAllNBT(File path, Consumer2<File, File> inFile) {
-        if(path == null) {
+        if (path == null) {
             return;
         }
 
-        if(path.isFile() && path.getName().endsWith(".nbt")) {
+        if (path.isFile() && path.getName().endsWith(".nbt")) {
             inFile.accept(path.getParentFile(), path);
             return;
         }
 
-        for(File i : path.listFiles()) {
-            if(i.isDirectory()) {
+        for (File i : path.listFiles()) {
+            if (i.isDirectory()) {
                 findAllNBT(i, inFile);
-            } else if(i.isFile() && i.getName().endsWith(".nbt")) {
+            } else if (i.isFile() && i.getName().endsWith(".nbt")) {
                 inFile.accept(path, i);
             }
         }
@@ -220,9 +215,9 @@ public class ConversionSVC implements IrisService {
         int m = 0;
         Iris.instance.getDataFolder("convert");
 
-        for(File i : folder.listFiles()) {
-            for(Converter j : converters) {
-                if(i.getName().endsWith("." + j.getInExtension())) {
+        for (File i : folder.listFiles()) {
+            for (Converter j : converters) {
+                if (i.getName().endsWith("." + j.getInExtension())) {
                     File out = new File(folder, i.getName().replaceAll("\\Q." + j.getInExtension() + "\\E", "." + j.getOutExtension()));
                     m++;
                     j.convert(i, out);
@@ -230,10 +225,10 @@ public class ConversionSVC implements IrisService {
                 }
             }
 
-            if(i.isDirectory() && i.getName().equals("structures")) {
+            if (i.isDirectory() && i.getName().equals("structures")) {
                 File f = new File(folder, "jigsaw");
 
-                if(!f.exists()) {
+                if (!f.exists()) {
                     s.sendMessage("Converting NBT Structures into Iris Jigsaw Structures...");
                     f.mkdirs();
                     J.a(() -> convertStructures(i, f, s));

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

@@ -33,6 +33,7 @@ import org.bukkit.event.world.WorldUnloadEvent;
 
 public class EditSVC implements IrisService {
     private KMap<World, BlockEditor> editors;
+    public static boolean deletingWorld = false;
 
     @Override
     public void onEnable() {
@@ -71,27 +72,28 @@ public class EditSVC implements IrisService {
 
     @EventHandler
     public void on(WorldUnloadEvent e) {
-        if(editors.containsKey(e.getWorld())) {
+        if (editors.containsKey(e.getWorld()) && !deletingWorld) {
             editors.remove(e.getWorld()).close();
         }
     }
 
+
     public void update() {
-        for(World i : editors.k()) {
-            if(M.ms() - editors.get(i).last() > 1000) {
+        for (World i : editors.k()) {
+            if (M.ms() - editors.get(i).last() > 1000) {
                 editors.remove(i).close();
             }
         }
     }
 
     public void flushNow() {
-        for(World i : editors.k()) {
+        for (World i : editors.k()) {
             editors.remove(i).close();
         }
     }
 
     public BlockEditor open(World world) {
-        if(editors.containsKey(world)) {
+        if (editors.containsKey(world)) {
             return editors.get(world);
         }
 

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

@@ -0,0 +1,187 @@
+/*
+ * 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.service;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.*;
+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;
+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;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.server.PluginEnableEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Data
+public class ExternalDataSVC implements IrisService {
+
+    private KList<ExternalDataProvider> providers = new KList<>(), activeProviders = new KList<>();
+
+    @Override
+    public void onEnable() {
+        Iris.info("Loading ExternalDataProvider...");
+        Bukkit.getPluginManager().registerEvents(this, Iris.instance);
+
+        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) {
+            Iris.info("ItemAdder found, loading ItemAdderDataProvider...");
+        }
+        providers.add(new ExecutableItemsDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("ExecutableItems") != null) {
+            Iris.info("ExecutableItems found, loading ExecutableItemsDataProvider...");
+        }
+        providers.add(new HMCLeavesDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("HMCLeaves") != null) {
+            Iris.info("BlockAdder found, loading HMCLeavesDataProvider...");
+        }
+        providers.add(new MMOItemsDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("MMOItems") != null) {
+            Iris.info("MMOItems found, loading MMOItemsDataProvider...");
+        }
+        providers.add(new EcoItemsDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("EcoItems") != null) {
+            Iris.info("EcoItems found, loading EcoItemsDataProvider...");
+        }
+
+        for (ExternalDataProvider p : providers) {
+            if (p.isReady()) {
+                activeProviders.add(p);
+                p.init();
+                Iris.info("Enabled ExternalDataProvider for %s.", p.getPluginId());
+            }
+        }
+    }
+
+    @Override
+    public void onDisable() {
+    }
+
+    @EventHandler
+    public void onPluginEnable(PluginEnableEvent e) {
+        if (activeProviders.stream().noneMatch(p -> p.getPlugin().equals(e.getPlugin()))) {
+            providers.stream().filter(p -> p.isReady() && p.getPlugin().equals(e.getPlugin())).findFirst().ifPresent(edp -> {
+                activeProviders.add(edp);
+                edp.init();
+                Iris.info("Enabled ExternalDataProvider for %s.", edp.getPluginId());
+            });
+        }
+    }
+
+    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();
+
+        Optional<ExternalDataProvider> provider = activeProviders.stream().filter(p -> p.isValidProvider(mod, false)).findFirst();
+        if (provider.isEmpty())
+            return Optional.empty();
+        try {
+            return Optional.of(provider.get().getBlockData(mod, pair.getB()));
+        } catch (MissingResourceException e) {
+            Iris.error(e.getMessage() + " - [" + e.getClassName() + ":" + e.getKey() + "]");
+            return Optional.empty();
+        }
+    }
+
+    public Optional<ItemStack> getItemStack(Identifier key, KMap<String, Object> customNbt) {
+        Optional<ExternalDataProvider> provider = activeProviders.stream().filter(p -> p.isValidProvider(key, true)).findFirst();
+        if (provider.isEmpty()) {
+            Iris.warn("No matching Provider found for modded material \"%s\"!", key);
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(provider.get().getItemStack(key, customNbt));
+        } catch (MissingResourceException e) {
+            Iris.error(e.getMessage() + " - [" + e.getClassName() + ":" + e.getKey() + "]");
+            return Optional.empty();
+        }
+    }
+
+    public void processUpdate(Engine engine, Block block, Identifier blockId) {
+        Optional<ExternalDataProvider> provider = activeProviders.stream().filter(p -> p.isValidProvider(blockId, false)).findFirst();
+        if (provider.isEmpty()) {
+            Iris.warn("No matching Provider found for modded material \"%s\"!", blockId);
+            return;
+        }
+        provider.get().processUpdate(engine, block, blockId);
+    }
+
+    public Identifier[] getAllBlockIdentifiers() {
+        KList<Identifier> names = new KList<>();
+        activeProviders.forEach(p -> names.add(p.getBlockTypes()));
+        return names.toArray(new Identifier[0]);
+    }
+
+    public Identifier[] getAllItemIdentifiers() {
+        KList<Identifier> names = new KList<>();
+        activeProviders.forEach(p -> names.add(p.getItemTypes()));
+        return names.toArray(new Identifier[0]);
+    }
+
+    public static Pair<Identifier, KMap<String, String>> parseState(Identifier key) {
+        if (!key.key().contains("[") || !key.key().contains("]")) {
+            return new Pair<>(key, new KMap<>());
+        }
+        String state = key.key().split("\\Q[\\E")[1].split("\\Q]\\E")[0];
+        KMap<String, String> stateMap = new KMap<>();
+        if (!state.isEmpty()) {
+            Arrays.stream(state.split(",")).forEach(s -> stateMap.put(s.split("=")[0], s.split("=")[1]));
+        }
+        return new Pair<>(new Identifier(key.namespace(), key.key().split("\\Q[\\E")[0]), stateMap);
+    }
+
+    public static Identifier buildState(Identifier key, KMap<String, String> state) {
+        if (state.isEmpty()) {
+            return key;
+        }
+        String path = state.entrySet()
+                .stream()
+                .map(e -> e.getKey() + "=" + e.getValue())
+                .collect(Collectors.joining(",", key.key() + "[", "]"));
+        return new Identifier(key.namespace(), path);
+    }
+}