ffs

Development

.classpath

@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-			<attribute name="test" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>

.gitignore

@@ -1,3 +1,12 @@
-/target/
 
-lib/
+build/
+
+.gradle/
+
+.idea/
+
+.DS_Store
+
+collection/
+
+src/main/java/com/volmit/iris/util/uniques/

.project

@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>Iris</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.m2e.core.maven2Builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-	</natures>
-</projectDescription>

.settings/org.eclipse.core.resources.prefs

@@ -1,4 +0,0 @@
-eclipse.preferences.version=1
-encoding//src/main/java=UTF-8
-encoding//src/main/resources=UTF-8
-encoding/<project>=UTF-8

.settings/org.eclipse.jdt.core.prefs

@@ -1,8 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
-org.eclipse.jdt.core.compiler.compliance=1.8
-org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
-org.eclipse.jdt.core.compiler.release=disabled
-org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.m2e.core.prefs

@@ -1,4 +0,0 @@
-activeProfiles=
-eclipse.preferences.version=1
-resolveWorkspaceProjects=true
-version=1

README.md

@@ -1,2 +1,83 @@
-# Iris
-World Generator
+# IrisBukkit
+
+The master branch is for the latest version of minecraft.
+
+# [Support](https://discord.gg/3xxPTpT) **|** [Documentation](https://docs.volmit.com/iris/) **
+|** [Git](https://github.com/IrisDimensions)
+
+# Building
+
+Building IrisBukkit is fairly simple, though you will need to setup a few things if your system has never been used for
+java
+development.
+
+Consider supporting our development by buying IrisBukkit on spigot! We work hard to make IrisBukkit the best it can be
+for everyone.
+
+### Command Line Builds
+
+1. Install [Java JDK 17](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html)
+2. Set the JDK installation path to `JAVA_HOME` as an environment variable.
+    * Windows
+        1. Start > Type `env` and press Enter
+        2. Advanced > Environment Variables
+        3. Under System Variables, click `New...`
+        4. Variable Name: `JAVA_HOME`
+        5. Variable Value: `C:\Program Files\Java\jdk-17.0.1` (verify this exists after installing java don't just copy
+           the example text)
+    * MacOS
+        1. Run `/usr/libexec/java_home -V` and look for Java 17
+        2. Run `sudo nano ~/.zshenv`
+        3. Add `export JAVA_HOME=$(/usr/libexec/java_home)` as a new line
+        4. Use `CTRL + X`, then Press `Y`, Then `ENTER`
+        5. Quit & Reopen Terminal and verify with `echo $JAVA_HOME`. It should print a directory
+3. If this is your first time building IrisBukkit for MC 1.18+ run `gradlew setup` inside the root IrisBukkit 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 IrisBukkit jar will be placed in `IrisBukkit/build/IrisBukkit-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 IrisBukkit into your plugins folder
+  if you
+  prefer.
+* Resync the project & run your newly created task (under the development folder in gradle tasks!)
+
+# IrisBukkit Toolbelt
+
+Everyone needs a tool-belt.
+
+```java
+package com.volmit.iris.core.tools;
+
+// Get IrisDataManager from a world
+IrisToolbelt.access(anyWorld).getCompound().getData();
+
+// Get Default Engine from world
+IrisToolbelt.access(anyWorld).getCompound().getDefaultEngine();
+
+// Get the engine at the given height
+IrisToolbelt.access(anyWorld).getCompound().getEngineForHeight(68);
+
+// IS THIS THING ON?
+boolean yes=IrisToolbelt.isIrisWorld(world);
+
+// GTFO for worlds (moves players to any other world, just not this one)
+IrisToolbelt.evacuate(world);
+
+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)
+    .radius(4)  // Radius in REGIONS. Rad of 4 means a 9x9 Region map.
+    .build())
+  .create();
+```

build.gradle

@@ -0,0 +1,41 @@
+plugins {
+    id 'java'
+    id "io.freefair.lombok" version "6.3.0"
+}
+
+group 'com.volmit.iris'
+version '1.0-SNAPSHOT'
+
+jar {
+    manifest {
+        attributes('Contains-Sources': 'java,class')
+    }
+}
+
+allprojects {
+    apply plugin: 'java'
+
+    repositories {
+        maven { url "https://arcanearts.jfrog.io/artifactory/archives" }
+        mavenCentral()
+    }
+
+    dependencies {
+        compileOnly 'org.projectlombok:lombok:1.18.24'
+        annotationProcessor 'org.projectlombok:lombok:1.18.24'
+        annotationProcessor 'systems.manifold:manifold-ext:2022.1.19'
+        implementation 'art.arcane:Source:22.9.3'
+        implementation 'art.arcane:Cram:22.9.3'
+        implementation 'art.arcane:Amulet:22.9.5'
+        implementation 'com.google.code.gson:gson:2.9.0'
+        implementation 'com.github.ben-manes.caffeine:caffeine:3.1.1'
+        testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
+        testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
+        testAnnotationProcessor 'systems.manifold:manifold-ext:2022.1.19'
+    }
+}
+
+dependencies {
+
+}
+

bukkit/build.gradle

@@ -0,0 +1,290 @@
+plugins {
+    id 'java'
+    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"
+}
+
+group rootProject.group
+version rootProject.version
+
+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.platform.bukkit.IrisBukkit'
+
+// 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()
+        )
+    }
+}
+
+/**
+ * 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 'art.arcane', 'com.volmit.iris.util.arcane'
+    relocate 'manifold', 'com.volmit.iris.util.manifold'
+    relocate 'art.arcane.source', 'com.volmit.iris.util.source'
+    relocate 'ChumBukkit.extensions', 'com.volmit.iris.util.extensions'
+    relocate 'IrisBukkit.extensions', 'com.volmit.iris.util.extensions'
+    relocate 'Fukkit.extensions', 'com.volmit.iris.util.extensions'
+    relocate 'Amulet.extensions', 'com.volmit.iris.util.extensions'
+    relocate 'Iris.extensions', 'com.volmit.iris.util.extensions'
+    dependencies {
+        include(dependency('art.arcane:'))
+        include(dependency('systems.manifold:'))
+        include(dependency("com.dfsek:Paralithic:"))
+        include(dependency(":engine"))
+    }
+}
+
+/**
+ * Faster dependency caches
+ */
+configurations.all {
+    resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
+    resolutionStrategy.cacheDynamicVersionsFor 60, 'minutes'
+}
+
+configurations {
+    testImplementation.extendsFrom annotationProcessor
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+repositories {
+    maven { url "https://arcanearts.jfrog.io/artifactory/archives" }
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'org.spigotmc:spigot-api:1.19-R0.1-SNAPSHOT'
+    implementation 'art.arcane:Fukkit:22.9.2'
+    implementation project(":engine")
+}
+
+if (JavaVersion.current() != JavaVersion.VERSION_1_8 &&
+        sourceSets.main.allJava.files.any { it.name == "module-info.java" }) {
+    tasks.withType(JavaCompile) {
+        options.compilerArgs += ['-Xplugin:Manifold', '--module-path', it.classpath.asPath]
+    }
+} else {
+    tasks.withType(JavaCompile) {
+        options.compilerArgs += ['-Xplugin:Manifold']
+    }
+}
+
+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);
+}
+
+
+System.out.println(buildDir);
+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/bukkit-" + version + "-all.jar");
+def ssiJar = new File(buildDir, "specialsource/bukkit-" + 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")
+        }
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkit.java

@@ -0,0 +1,217 @@
+package com.volmit.iris.platform.bukkit;
+
+import art.arcane.amulet.io.IO;
+import art.arcane.amulet.logging.LogListener;
+import com.volmit.iris.engine.EngineConfiguration;
+import com.volmit.iris.platform.IrisPlatform;
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.platform.PlatformWorld;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitBiome;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitBlock;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitKey;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitWorld;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Warning;
+import org.bukkit.World;
+import org.bukkit.WorldCreator;
+import org.bukkit.block.Biome;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.UUID;
+import java.util.stream.Stream;
+
+public class IrisBukkit extends JavaPlugin implements IrisPlatform, LogListener {
+    private static final String TAG = ChatColor.DARK_GRAY + "[" + ChatColor.GREEN + "Iris" + ChatColor.DARK_GREEN + "/";
+    private static final String TAG_STRIPPED = ChatColor.stripColor(TAG);
+    private static IrisBukkit instance;
+    private ConsoleCommandSender consoleSender;
+
+    public void onEnable() {
+        instance = this;
+        consoleSender = Bukkit.getConsoleSender();
+        LogListener.listener.set(this);
+
+        getServer().getScheduler().scheduleSyncDelayedTask(this, () -> {
+            World world = Bukkit.createWorld(new WorldCreator("iristests/" + UUID.randomUUID()).generator(new IrisBukkitChunkGenerator(this, EngineConfiguration.builder()
+                .timings(true).mutable(true)
+                .build())));
+            for(Player i : Bukkit.getOnlinePlayers())
+            {
+                i.teleport(world.getSpawnLocation());
+            }
+        }, 10);
+    }
+
+    public void onDisable() {
+        World w = null;
+        for(World i : Bukkit.getWorlds()) {
+            if(!i.getName().startsWith("iristest")) {
+                w = i;
+                break;
+            }
+        }
+
+        for(World i : Bukkit.getWorlds()) {
+            if(i.getName().startsWith("iristest"))
+            {
+                for(Player j : i.getPlayers())
+                {
+                    j.teleport(w.getSpawnLocation());
+                }
+
+                if(i.getGenerator() instanceof Closeable c)
+                {
+                    try {
+                        c.close();
+                    } catch(IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+                BukkitWorld.of(i).unloadChunks(false, true);
+                File folder = i.getWorldFolder();
+                Bukkit.unloadWorld(i, false);
+                IO.delete(folder);
+            }
+        }
+    }
+
+    public static IrisBukkit getInstance() {
+        return instance;
+    }
+
+    private void messageConsole(String color, String key, Object o) {
+        try {
+            consoleSender.sendMessage(TAG + key + ChatColor.DARK_GRAY + "]: " + color + o.toString());
+        }
+
+        catch(Throwable e) {
+            System.out.println(TAG_STRIPPED + key + "]: " + o.toString());
+        }
+    }
+
+    @Override
+    public void logError(String k, Object o) {
+        messageConsole(ChatColor.RED.toString(), k, o);
+    }
+
+    @Override
+    public void logInfo(String k, Object o) {
+        messageConsole(ChatColor.WHITE.toString(), k, o);
+    }
+
+    @Override
+    public void logWarning(String k, Object o) {
+        messageConsole(ChatColor.YELLOW.toString(), k, o);
+    }
+
+    @Override
+    public void logDebug(String k, Object o) {
+        messageConsole(ChatColor.GRAY.toString(), k, o);
+    }
+
+    @Override
+    public String getPlatformName() {
+        return "Bukkit";
+    }
+
+    @Override
+    public Stream<PlatformBlock> getBlocks() {
+        //This is because it's a method extension
+        //noinspection Convert2MethodRef
+        return Arrays.stream(Material.values())
+            .filter(i -> !i.isLegacy())
+            .filter(Material::isBlock)
+            .map(Material::createBlockData).map(i -> BukkitBlock.of(i));
+    }
+
+    @Override
+    public Stream<PlatformBiome> getBiomes() {
+        //This is because it's a method extension
+        //noinspection Convert2MethodRef
+        return Arrays.stream(Biome.values()).parallel().filter((i) -> i != Biome.CUSTOM).map(i -> BukkitBiome.of(i));
+    }
+
+    @Override
+    public boolean isWorldLoaded(String name) {
+        return Bukkit.getWorlds().keepWhere(i -> i.getName().equals(name)).isNotEmpty();
+    }
+
+    @Override
+    public PlatformWorld getWorld(String name) {
+        World w = Bukkit.getWorld(name);
+
+        if(w == null)
+        {
+            return null;
+        }
+
+        return BukkitWorld.of(w);
+    }
+
+    @Override
+    public PlatformBlock parseBlock(String raw) {
+        return BukkitBlock.of(Bukkit.createBlockData(raw));
+    }
+
+    @Override
+    public PlatformNamespaceKey key(String namespace, String key) {
+        return BukkitKey.of(namespace, key);
+    }
+
+    @Override
+    public File getStudioFolder(String dimension) {
+        File f = new File(getDataFolder(), "packs/" + dimension);
+        f.mkdirs();
+        return f;
+    }
+
+    @Override
+    public File getStudioFolder() {
+        File f = new File(getDataFolder(), "packs/");
+        f.mkdirs();
+        return f;
+    }
+
+    @Override
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        return new IrisBukkitChunkGenerator(this, EngineConfiguration.builder()
+            .threads(4)
+            .mutable(true)
+            .timings(true)
+            .build());
+    }
+
+    @Override
+    public void i(String s, Object o) {
+        logInfo(s, o);
+    }
+
+    @Override
+    public void f(String s, Object o) {
+        logError(s, o);
+    }
+
+    @Override
+    public void w(String s, Object o) {
+        logWarning(s, o);
+    }
+
+    @Override
+    public void d(String s, Object o) {
+        logDebug(s, o);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkitChunkGenerator.java

@@ -0,0 +1,147 @@
+package com.volmit.iris.platform.bukkit;
+
+import art.arcane.chrono.Average;
+import art.arcane.chrono.PrecisionStopwatch;
+import art.arcane.spatial.hunk.Hunk;
+import com.volmit.iris.engine.EngineConfiguration;
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.FeatureSizedTarget;
+import com.volmit.iris.engine.feature.FeatureTarget;
+import com.volmit.iris.engine.pipeline.PipedHunkStack;
+import com.volmit.iris.platform.IrisPlatform;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.bukkit.util.StaticBiomeProvider;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitWorld;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BiomeProvider;
+import org.bukkit.generator.ChunkGenerator;
+import com.volmit.iris.platform.bukkit.util.ChunkDataHunkView;
+import org.bukkit.generator.WorldInfo;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class IrisBukkitChunkGenerator extends ChunkGenerator implements Closeable {
+    private final IrisPlatform platform;
+    private final EngineConfiguration configuration;
+    private final AtomicReference<Engine> engine;
+    private final ReentrantLock engineLock;
+    private final AtomicInteger perSecond;
+    private final PrecisionStopwatch p = PrecisionStopwatch.start();
+    private final Average a = new Average(128);
+    private final StaticBiomeProvider staticBiomeProvider;
+
+    public IrisBukkitChunkGenerator(IrisPlatform platform, EngineConfiguration configuration) {
+        this.perSecond = new AtomicInteger(0);
+        this.platform = platform;
+        this.configuration = configuration;
+        this.staticBiomeProvider = new StaticBiomeProvider(Biome.PLAINS);
+        this.engine = new AtomicReference<>();
+        this.engineLock = new ReentrantLock();
+    }
+
+    @Override
+    public ChunkData generateChunkData(World world, Random random, int x, int z, BiomeGrid biome) {
+        PrecisionStopwatch pp = PrecisionStopwatch.start();
+        initEngine(world);
+        ChunkData data = Bukkit.createChunkData(world);
+        Hunk<PlatformBlock> chunk = new ChunkDataHunkView(data);
+        FeatureSizedTarget targetSize = FeatureSizedTarget.builder()
+            .width(chunk.getWidth())
+            .height(chunk.getHeight())
+            .depth(chunk.getDepth())
+            .offsetX(x << 4)
+            .offsetZ(z << 4)
+            .offsetY(0)
+            .build();
+        FeatureTarget<PlatformBlock> blockTarget = new FeatureTarget<>(chunk, targetSize);
+        PipedHunkStack stack = new PipedHunkStack();
+        stack.register(PlatformBlock.class, blockTarget);
+        engine.get().getPlumbing().generate(engine.get(), targetSize, stack);
+        perSecond.incrementAndGet();
+        a.put(pp.getMilliseconds());
+
+        if(p.getMilliseconds() > 1000)
+        {
+            p.reset();
+            p.begin();
+            System.out.println("PERSECOND: " + perSecond.getAndSet(0) + " AMS: " + ((int)Math.round(a.getAverage())) + "ms");
+        }
+
+        return data;
+    }
+
+    private void initEngine(World world) {
+        if(engine.get() == null)
+        {
+            engineLock.lock();
+
+            if(engine.get() == null)
+            {
+                try {
+                    engine.set(new Engine(platform, BukkitWorld.of(world), configuration));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+
+            engineLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean canSpawn(World world, int x, int z) {
+        return false;
+    }
+
+    @Override
+    public BiomeProvider getDefaultBiomeProvider(WorldInfo worldInfo) {
+        return staticBiomeProvider;
+    }
+
+    @Override
+    public void close() throws IOException {
+        engine.get().close();
+    }
+
+    @Override
+    public boolean shouldGenerateNoise() {
+        return super.shouldGenerateNoise();
+    }
+
+    @Override
+    public boolean shouldGenerateSurface() {
+        return super.shouldGenerateSurface();
+    }
+
+    @Override
+    public boolean shouldGenerateBedrock() {
+        return super.shouldGenerateBedrock();
+    }
+
+    @Override
+    public boolean shouldGenerateCaves() {
+        return super.shouldGenerateCaves();
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations() {
+        return super.shouldGenerateDecorations();
+    }
+
+    @Override
+    public boolean shouldGenerateMobs() {
+        return super.shouldGenerateMobs();
+    }
+
+    @Override
+    public boolean shouldGenerateStructures() {
+        return super.shouldGenerateStructures();
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/ChunkDataHunkView.java

@@ -0,0 +1,53 @@
+package com.volmit.iris.platform.bukkit.util;
+
+import art.arcane.spatial.hunk.Hunk;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitBlock;
+import org.bukkit.generator.ChunkGenerator;
+
+@SuppressWarnings("ClassCanBeRecord")
+public class ChunkDataHunkView implements Hunk<PlatformBlock> {
+    private final ChunkGenerator.ChunkData chunk;
+
+    public ChunkDataHunkView(ChunkGenerator.ChunkData chunk) {
+        this.chunk = chunk;
+    }
+
+    @Override
+    public int getWidth() {
+        return 16;
+    }
+
+    @Override
+    public int getDepth() {
+        return 16;
+    }
+
+    @Override
+    public int getHeight() {
+        return chunk.getMaxHeight() - chunk.getMinHeight();
+    }
+
+    @Override
+    public synchronized void set(int x1, int y1, int z1, int x2, int y2, int z2, PlatformBlock t) {
+        if(t == null) {
+            return;
+        }
+
+        chunk.setRegion(x1, y1 + chunk.getMinHeight(), z1, x2, y2 + chunk.getMinHeight(), z2, ((BukkitBlock)t).getDelegate());
+    }
+
+    @Override
+    public synchronized void setRaw(int x, int y, int z, PlatformBlock t) {
+        if(t == null) {
+            return;
+        }
+
+        chunk.setBlock(x, y + chunk.getMinHeight(), z, ((BukkitBlock)t).getDelegate());
+    }
+
+    @Override
+    public PlatformBlock getRaw(int x, int y, int z) {
+        return BukkitBlock.of(chunk.getBlockData(x, y + chunk.getMinHeight(), z));
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/StaticBiomeProvider.java

@@ -0,0 +1,27 @@
+package com.volmit.iris.platform.bukkit.util;
+
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BiomeProvider;
+import org.bukkit.generator.WorldInfo;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class StaticBiomeProvider extends BiomeProvider {
+    private static final List<Biome> ALL_BIOMES = Arrays.stream(Biome.values()).without((i) -> i.equals(Biome.CUSTOM)).toList().unmodifiable();
+    private final Biome defaultBiome;
+
+    public StaticBiomeProvider(Biome defaultBiome) {
+        this.defaultBiome = defaultBiome;
+    }
+
+    @Override
+    public Biome getBiome(WorldInfo worldInfo, int x, int y, int z) {
+        return defaultBiome;
+    }
+
+    @Override
+    public List<Biome> getBiomes(WorldInfo worldInfo) {
+        return ALL_BIOMES;
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitBiome.java

@@ -0,0 +1,24 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.Data;
+import org.bukkit.block.Biome;
+
+@Data
+public class BukkitBiome implements PlatformBiome {
+    private final Biome delegate;
+
+    private BukkitBiome(Biome delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public PlatformNamespaceKey getKey() {
+        return BukkitKey.of(delegate.getKey());
+    }
+
+    public static BukkitBiome of(Biome biome) {
+        return new BukkitBiome(biome);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitBlock.java

@@ -0,0 +1,71 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.platform.block.PlatformBlock;
+import lombok.Data;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.block.data.BlockData;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+@Data
+public class BukkitBlock implements PlatformBlock {
+    private final BlockData delegate;
+    private final Map<String, String> properties;
+
+    private BukkitBlock(BlockData delegate, Map<String, String> properties) {
+        this.delegate = delegate;
+        this.properties = properties;
+    }
+
+    private BukkitBlock(BlockData delegate) {
+        this.delegate = delegate;
+        String s = delegate.getAsString(true);
+
+        if(s.contains("[")) {
+            Map<String, String> properties = new HashMap<>();
+            String[] props = new String[] {s.split("\\Q[\\E")[1].split("\\Q]\\E")[0]};
+            String[] p;
+            if(props[0].contains(",")) {
+                for(String i : props[0].split("\\Q,\\E")) {
+                    p = i.split("\\Q=\\E");
+                    properties.put(p[0], p[1]);
+                }
+            } else {
+                p = props[0].split("\\Q=\\E");
+                properties.put(p[0], p[1]);
+            }
+
+            this.properties = Collections.unmodifiableMap(properties);
+        } else {
+            this.properties = Map.of();
+        }
+    }
+
+    @Override
+    public Map<String, String> getProperties() {
+        return null;
+    }
+
+    @Override
+    public PlatformNamespaceKey getKey() {
+        return BukkitKey.of(delegate.getMaterial().getKey());
+    }
+
+    public static BukkitBlock of(BlockData blockData) {
+        return new BukkitBlock(blockData);
+    }
+
+    public static BukkitBlock of(Material material) {
+        return of(material.createBlockData());
+    }
+
+    public static BukkitBlock of(String raw) {
+        return of(Bukkit.createBlockData(raw));
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitChunk.java

@@ -0,0 +1,35 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.PlatformChunk;
+import org.bukkit.Chunk;
+
+public class BukkitChunk implements PlatformChunk {
+    private final Chunk delegate;
+
+    private BukkitChunk(Chunk delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public int getX() {
+        return delegate.getX();
+    }
+
+    @Override
+    public int getZ() {
+        return delegate.getZ();
+    }
+
+    @Override
+    public void unload(boolean save, boolean force) {
+        if(force) {
+            delegate.getPluginChunkTickets().forEach(delegate::removePluginChunkTicket);
+        }
+
+        delegate.unload(save);
+    }
+
+    public static BukkitChunk of(Chunk chunk) {
+        return new BukkitChunk(chunk);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitKey.java

@@ -0,0 +1,45 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.Data;
+import org.bukkit.NamespacedKey;
+
+@Data
+public class BukkitKey implements PlatformNamespaceKey {
+    private final NamespacedKey delegate;
+
+    private BukkitKey(NamespacedKey delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public String getNamespace() {
+        return delegate.getNamespace();
+    }
+
+    @Override
+    public String getKey() {
+        return delegate.getKey();
+    }
+
+    public String toString() {
+        return delegate.toString();
+    }
+
+    public static BukkitKey of(String nsk) {
+        if(nsk.contains(":")) {
+            String[] f = nsk.split("\\Q:\\E");
+            return of(f[0], f[1]);
+        }
+
+        return of("minecraft", nsk);
+    }
+
+    public static BukkitKey of(String namespace, String key) {
+        return of(new NamespacedKey(namespace, key));
+    }
+
+    public static BukkitKey of(NamespacedKey key) {
+        return new BukkitKey(key);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitPlayer.java

@@ -0,0 +1,60 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import art.arcane.amulet.geometry.Vec;
+import com.volmit.iris.platform.PlatformPlayer;
+import com.volmit.iris.platform.PlatformWorld;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+
+public class BukkitPlayer implements PlatformPlayer {
+    private final Player delegate;
+
+    private BukkitPlayer(Player delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public UUID getUUID() {
+        return delegate.getUniqueId();
+    }
+
+    @Override
+    public String getName() {
+        return delegate.getName();
+    }
+
+    @Override
+    public Vec getLocation() {
+        return delegate.getLocation().vec();
+    }
+
+    @Override
+    public PlatformWorld getWorld() {
+        return BukkitWorld.of(delegate.getWorld());
+    }
+
+    @Override
+    public boolean canUseIris() {
+        return delegate.isOp();
+    }
+
+    @Override
+    public void sendMessage(String message) {
+        delegate.sendMessage(message);
+    }
+
+    @Override
+    public void sendActionBar(String message) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void sendTitleMessage(String title, String subtitle, int in, int stay, int out) {
+        throw new UnsupportedOperationException();
+    }
+
+    public static BukkitPlayer of(Player player) {
+        return new BukkitPlayer(player);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitWorld.java

@@ -0,0 +1,91 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformChunk;
+import com.volmit.iris.platform.PlatformPlayer;
+import com.volmit.iris.platform.PlatformWorld;
+import com.volmit.iris.util.WorldHeight;
+import lombok.Data;
+import org.bukkit.World;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+@Data
+public class BukkitWorld implements PlatformWorld {
+    private final World delegate;
+    private final WorldHeight worldHeight;
+
+    private BukkitWorld(World delegate) {
+        this.delegate = delegate;
+        this.worldHeight = new WorldHeight(delegate.getMinHeight(), delegate.getMaxHeight());
+    }
+
+    @Override
+    public WorldHeight getHeight() {
+        return worldHeight;
+    }
+
+    @Override
+    public String getName() {
+        return delegate.getName();
+    }
+
+    @Override
+    public File getFolder() {
+        return delegate.getWorldFolder();
+    }
+
+    @Override
+    public Iterable<PlatformPlayer> getPlayers() {
+        //noinspection Convert2MethodRef
+        return delegate.getPlayers().stream().map(i -> BukkitPlayer.of(i)).collect(Collectors.toList());
+    }
+
+    @Override
+    public Iterable<PlatformChunk> getLoadedChunks() {
+        //noinspection Convert2MethodRef
+        return Arrays.stream(delegate.getLoadedChunks()).map(i -> BukkitChunk.of(i)).collect(Collectors.toList());
+    }
+
+    @Override
+    public PlatformChunk getOrLoadChunk(int x, int z) {
+        return BukkitChunk.of(delegate.getChunkAt(x, z));
+    }
+
+    @Override
+    public PlatformBlock getBlock(int x, int y, int z) {
+        return BukkitBlock.of(delegate.getBlockAt(x, y, z).getBlockData());
+    }
+
+    @Override
+    public PlatformBiome getBiome(int x, int y, int z) {
+        return BukkitBiome.of(delegate.getBiome(x, y, z));
+    }
+
+    @Override
+    public long getSeed() {
+        return delegate.getSeed();
+    }
+
+    @Override
+    public boolean isChunkLoaded(int x, int z) {
+        return delegate.isChunkLoaded(x, z);
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, PlatformBlock block) {
+        delegate.setBlockData(x, y, z, ((BukkitBlock) block).getDelegate());
+    }
+
+    @Override
+    public void setBiome(int x, int y, int z, PlatformBiome biome) {
+        delegate.setBiome(x, y, z, ((BukkitBiome) biome).getDelegate());
+    }
+
+    public static BukkitWorld of(World world) {
+        return new BukkitWorld(world);
+    }
+}

bukkit/src/main/resources/plugin.yml

@@ -0,0 +1,8 @@
+name: Iris
+main: com.volmit.iris.platform.bukkit.IrisBukkit
+version: 1.0.0
+api-version: 1.19
+libraries:
+- org.apache-extras.beanshell:bsh:2.0b6
+- com.google.code.gson:gson:2.8.9
+- com.github.ben-manes.caffeine:caffeine:3.1.1

dependency-reduced-pom.xml

@@ -1,116 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>bytecode.ninja</groupId>
-  <artifactId>Iris</artifactId>
-  <name>Iris</name>
-  <version>1.0</version>
-  <build>
-    <resources>
-      <resource>
-        <filtering>true</filtering>
-        <directory>src/main/resources</directory>
-        <includes>
-          <include>**/*.xml</include>
-          <include>**/*.yml</include>
-          <include>**/*.txt</include>
-          <include>**/*.properties</include>
-          <include>**/*.html</include>
-        </includes>
-      </resource>
-    </resources>
-    <plugins>
-      <plugin>
-        <artifactId>maven-shade-plugin</artifactId>
-        <version>3.1.0</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-            <configuration>
-              <minimizeJar>true</minimizeJar>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>exec-maven-plugin</artifactId>
-        <version>1.2</version>
-        <executions>
-          <execution>
-            <id>runbatchfile</id>
-            <phase>package</phase>
-            <goals>
-              <goal>exec</goal>
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <skip>${skip.copy}</skip>
-          <executable>${project.basedir}/scripts/copy.bat</executable>
-          <arguments>
-            <argument>${project.basedir}\target\${project.name}-${project.version}.jar</argument>
-            <argument>${development.location}</argument>
-          </arguments>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-  <repositories>
-    <repository>
-      <id>pub</id>
-      <url>http://nexus.mpm.care/content/repositories/pub</url>
-    </repository>
-    <repository>
-      <id>spigot-repo</id>
-      <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
-    </repository>
-    <repository>
-      <id>volmit</id>
-      <url>http://nexus.volmit.com/content/repositories/volmit</url>
-    </repository>
-  </repositories>
-  <dependencies>
-    <dependency>
-      <groupId>org.spigotmc</groupId>
-      <artifactId>spigot-api</artifactId>
-      <version>1.14.4-R0.1-SNAPSHOT</version>
-      <scope>provided</scope>
-      <exclusions>
-        <exclusion>
-          <artifactId>commons-lang</artifactId>
-          <groupId>commons-lang</groupId>
-        </exclusion>
-        <exclusion>
-          <artifactId>guava</artifactId>
-          <groupId>com.google.guava</groupId>
-        </exclusion>
-        <exclusion>
-          <artifactId>bungeecord-chat</artifactId>
-          <groupId>net.md-5</groupId>
-        </exclusion>
-        <exclusion>
-          <artifactId>snakeyaml</artifactId>
-          <groupId>org.yaml</groupId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    <dependency>
-      <groupId>cb</groupId>
-      <artifactId>craftbukkit-1.14.4</artifactId>
-      <version>1</version>
-      <scope>system</scope>
-      <systemPath>${project.basedir}/lib/craftbukkit-1.14.4.jar</systemPath>
-    </dependency>
-  </dependencies>
-  <properties>
-    <development.location>${user.home}\Documents\development\server\plugins\${project.name}.jar</development.location>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven.compiler.source>1.8</maven.compiler.source>
-    <maven.compiler.target>1.8</maven.compiler.target>
-  </properties>
-</project>
-

engine/build.gradle

@@ -0,0 +1,34 @@
+plugins {
+    id 'java'
+    id "io.freefair.lombok" version "6.3.0"
+}
+
+group rootProject.group
+version rootProject.version
+
+jar {
+    manifest {
+        attributes('Contains-Sources': 'java,class')
+    }
+}
+
+configurations {
+    testImplementation.extendsFrom annotationProcessor
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+if (JavaVersion.current() != JavaVersion.VERSION_1_8 &&
+        sourceSets.main.allJava.files.any { it.name == "module-info.java" }) {
+    tasks.withType(JavaCompile) {
+        options.compilerArgs += ['-Xplugin:Manifold', '--module-path', it.classpath.asPath]
+    }
+} else {
+    tasks.withType(JavaCompile) {
+        options.compilerArgs += ['-Xplugin:Manifold']
+    }
+}

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

@@ -0,0 +1,91 @@
+package com.volmit.iris.engine;
+
+import com.volmit.iris.engine.feature.features.FeatureError;
+import com.volmit.iris.engine.feature.features.FeatureTerrain;
+import com.volmit.iris.engine.pipeline.EnginePipeline;
+import com.volmit.iris.engine.pipeline.EnginePlumbing;
+import com.volmit.iris.engine.pipeline.PipelinePhase;
+import com.volmit.iris.engine.pipeline.PipelineTask;
+import com.volmit.iris.platform.IrisPlatform;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.platform.PlatformRegistry;
+import com.volmit.iris.platform.PlatformWorld;
+import lombok.Data;
+import manifold.util.concurrent.ConcurrentWeakHashMap;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.lang.ref.WeakReference;
+import java.util.Map;
+import java.util.Optional;
+
+@Data
+public class Engine implements Closeable {
+    private static final Map<Thread, WeakReference<Engine>> engineContext = new ConcurrentWeakHashMap<>();
+    private final IrisPlatform platform;
+    private final EngineRegistry registry;
+    private final EngineConfiguration configuration;
+    private final PlatformWorld world;
+    private final EngineBlockCache blockCache;
+    private final EngineExecutor executor;
+    private final EnginePlumbing plumbing;
+    private final EngineSeedManager seedManager;
+    private final EngineData data;
+
+    public Engine(IrisPlatform platform, PlatformWorld world, EngineConfiguration configuration) throws IOException {
+        this.configuration = configuration.validate();
+        this.platform = platform;
+        this.world = world;
+        i("Initializing Iris Engine for " + platform.getPlatformName() + " in " + world.getName()
+            + " with " + configuration.getThreads() + " priority " + configuration.getThreadPriority()
+            + " threads in " + (configuration.isMutable() ? "edit mode" : "production mode"));
+        this.blockCache = new EngineBlockCache(this);
+        this.registry = EngineRegistry.builder()
+                .blockRegistry(new PlatformRegistry<>("Block", platform.getBlocks()))
+                .biomeRegistry(new PlatformRegistry<>("Biome", platform.getBiomes()))
+                .build();
+        this.data = new EngineData(this).loadData(
+            getConfiguration().isMutable()
+                ? getPlatform().getStudioFolder()
+                : getWorld().getIrisDataFolder(), getConfiguration().getDimension());
+        this.seedManager = getSeedManager();
+        this.executor = new EngineExecutor(this);
+        this.plumbing = EnginePlumbing.builder().engine(this)
+            .errorPipeline(EnginePipeline.builder()
+                .phase(PipelinePhase.builder()
+                    .task(new PipelineTask<>(new FeatureError(this), PlatformBlock.class))
+                    .build())
+                .build())
+            .pipeline(EnginePipeline.builder()
+                .phase(PipelinePhase.builder()
+                    .task(new PipelineTask<>(new FeatureTerrain(this), PlatformBlock.class))
+                    .build())
+                .build())
+            .build();
+    }
+
+    public PlatformBlock block(String block) {
+        return blockCache.get(block);
+    }
+
+    public PlatformNamespaceKey key(String nsk) {
+        return getPlatform().key(nsk);
+    }
+
+    public static Optional<Engine> context() {
+        WeakReference<Engine> reference = engineContext.get(Thread.currentThread());
+
+        if(reference != null)
+        {
+            return Optional.ofNullable(reference.get());
+        }
+
+        return Optional.empty();
+    }
+
+    @Override
+    public void close() throws IOException {
+        getExecutor().close();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/EngineBlockCache.java

@@ -0,0 +1,23 @@
+package com.volmit.iris.engine;
+
+import com.volmit.iris.platform.block.PlatformBlock;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class EngineBlockCache
+{
+    private final Engine engine;
+    private final Map<String, PlatformBlock> cache;
+
+    public EngineBlockCache(Engine engine)
+    {
+        this.engine = engine;
+        this.cache = new ConcurrentHashMap<>();
+    }
+
+    public PlatformBlock get(String t)
+    {
+        return cache.computeIfAbsent(t, (key) -> engine.getPlatform().parseBlock(key));
+    }
+}

engine/src/main/java/com/volmit/iris/engine/EngineConfiguration.java

@@ -0,0 +1,61 @@
+package com.volmit.iris.engine;
+
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.platform.PlatformWorld;
+import com.volmit.iris.util.NSK;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+@Builder
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class EngineConfiguration {
+    @Builder.Default
+    private int chunkSize = 16;
+
+    @Builder.Default
+    private boolean mutable = false;
+
+    @Builder.Default
+    private boolean timings = false;
+
+    @Builder.Default
+    private int threads = Runtime.getRuntime().availableProcessors();
+
+    @Builder.Default
+    private int threadPriority = 3;
+
+    @Builder.Default
+    private PlatformNamespaceKey dimension = new NSK("overworld", "main");
+
+    public EngineConfiguration validate() throws IOException {
+        validateChunkSize();
+        return this;
+    }
+
+    private void validateChunkSize() throws IOException {
+        if(Arrays.binarySearch(allowedChunkSizes, chunkSize) < 0) {
+            throw new IOException("Invalid Chunk Size: " + chunkSize + " Allowed Chunk Sizes are: " + Arrays.toString(allowedChunkSizes));
+        }
+    }
+
+    private static final int[] allowedChunkSizes;
+
+    static {
+        allowedChunkSizes = new int[16];
+
+        for(int i = 0; i < allowedChunkSizes.length; i++) {
+            allowedChunkSizes[i] = (int) Math.pow(2, i+1);
+        }
+
+        Arrays.sort(allowedChunkSizes); // for binary sorting
+    }
+}

engine/src/main/java/com/volmit/iris/engine/EngineData.java

@@ -0,0 +1,276 @@
+package com.volmit.iris.engine;
+
+import art.arcane.amulet.concurrent.J;
+import art.arcane.amulet.io.IO;
+import art.arcane.amulet.io.JarLoader;
+import art.arcane.cram.PakFile;
+import art.arcane.cram.PakKey;
+import art.arcane.cram.PakResource;
+import com.google.gson.*;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.volmit.iris.engine.dimension.IrisDimension;
+import com.volmit.iris.engine.dimension.IrisGenerator;
+import com.volmit.iris.engine.dimension.IrisRange;
+import com.volmit.iris.engine.resolver.*;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.util.NSK;
+import lombok.Data;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.*;
+
+@Data
+public class EngineData implements TypeAdapterFactory {
+    private final Engine engine;
+    private final Gson gson;
+    private List<Resolvable> resolvableTypes;
+    private final Map<Class<?>, Resolver<?>> resolvers;
+
+    public EngineData(Engine engine) throws IOException {
+        this.engine = engine;
+        this.resolvers = new HashMap<>();
+        this.resolvableTypes =  J.attempt(() -> new JarLoader(getClass()).all().parallel()
+            .filter(Objects::nonNull)
+            .filter(i -> !i.isInterface() && !i.isEnum())
+            .filter(i -> i.isAssignableFrom(Resolvable.class) || Resolvable.class.isAssignableFrom(i))
+            .filter(i -> !i.equals(EngineResolvable.class))
+            .map(i -> J.attempt(() -> (Resolvable) i.getDeclaredConstructor().newInstance(), null)).toList(), List.of());
+        GsonBuilder gsonBuilder = new GsonBuilder().registerTypeAdapterFactory(this);
+        resolvableTypes.forEach(i -> i.apply(gsonBuilder));
+        this.gson = gsonBuilder.setPrettyPrinting().create();
+        i("Registered " + resolvableTypes.size() + " Mutators with " + resolvableTypes.stream().filter(i -> i instanceof TypeAdapterFactory).count() + " Type Adapter Factories");
+    }
+
+    public void generateSchemas(File folder) throws IOException {
+        folder.mkdirs();
+
+        for(Resolvable i : resolvableTypes) {
+            IO.writeAll(new File(folder, i.entity().getId() + ".json"), i.generateSchema(this).toString());
+        }
+    }
+
+    public <T extends Resolvable> T resolve(Class<T> clazz, PlatformNamespaceKey key)
+    {
+        Resolver<?> r = resolvers.get(clazz);
+
+        if(r == null) {
+            return null;
+        }
+
+        return (T) r.resolve(key);
+    }
+
+    public void registerResolver(Class<?> type, Resolver<?> resolver, String namespace)
+    {
+        if(resolvers.containsKey(type)) {
+            Resolver r = resolvers.get(type);
+            resolvers.put(type, r.and(namespace, r));
+        }
+
+        else {
+            resolvers.put(type, resolver);
+        }
+    }
+
+    public EngineData loadData(File folder, PlatformNamespaceKey dimension) throws IOException {
+        i("Loading Data in " + folder.getPath());
+        for(File i : folder.listFiles()) {
+            if(i.isDirectory() && i.getName().equals(dimension.getNamespace())) {
+                loadDataNamespaced(i, i.getName());
+
+                if(getEngine().getConfiguration().isMutable()) {
+                    generateSchemas(new File(i, ".iris/schema"));
+                    i("Generated " + new File(i, ".iris/schema").listFiles().length + " Schemas");
+                    generateCodeWorkspace(new File(i, dimension.getNamespace() + ".code-workspace"));
+                    i("Generated Code Workspace");
+                }
+            }
+
+            else if(i.getName().equals(dimension.getNamespace() + ".dat")) {
+                loadPakFile(folder, i.getName().split("\\Q.\\E")[0]);
+            }
+        }
+
+        IrisDimension dim = resolve(IrisDimension.class, dimension);
+
+        if(dim == null) {
+            f("Failed to load dimension " + dimension);
+        }
+
+        return this;
+    }
+
+    private void generateCodeWorkspace(File file) throws IOException {
+        file.getParentFile().mkdirs();
+        JsonObject ws = new JsonObject();
+        JsonArray folders = new JsonArray();
+        JsonObject folder = new JsonObject();
+        folder.add("path", new JsonPrimitive("."));
+        folders.add(folder);
+        ws.add("folders", folders);
+        JsonObject settings = new JsonObject();
+        settings.add("workbench.colorTheme", new JsonPrimitive("Monokai"));
+        settings.add("workbench.preferredDarkColorTheme", new JsonPrimitive("Solarized Dark"));
+        settings.add("workbench.tips.enabled", new JsonPrimitive(false));
+        settings.add("workbench.tree.indent", new JsonPrimitive(24));
+        settings.add("files.autoSave", new JsonPrimitive("onFocusChange"));
+        JsonObject jc = new JsonObject();
+        jc.add("editor.autoIndent", new JsonPrimitive("brackets"));
+        jc.add("editor.acceptSuggestionOnEnter", new JsonPrimitive("smart"));
+        jc.add("editor.cursorSmoothCaretAnimation", new JsonPrimitive(true));
+        jc.add("editor.dragAndDrop", new JsonPrimitive(false));
+        jc.add("files.trimTrailingWhitespace", new JsonPrimitive(true));
+        jc.add("diffEditor.ignoreTrimWhitespace", new JsonPrimitive(true));
+        jc.add("files.trimFinalNewlines", new JsonPrimitive(true));
+        jc.add("editor.suggest.showKeywords", new JsonPrimitive(false));
+        jc.add("editor.suggest.showSnippets", new JsonPrimitive(false));
+        jc.add("editor.suggest.showWords", new JsonPrimitive(false));
+        JsonObject st = new JsonObject();
+        st.add("strings", new JsonPrimitive(true));
+        jc.add("editor.quickSuggestions", st);
+        jc.add("editor.suggest.insertMode", new JsonPrimitive("replace"));
+        settings.add("[json]", jc);
+        settings.add("json.maxItemsComputed", new JsonPrimitive(30000));
+        JsonArray schemas = new JsonArray();
+
+        for(Resolvable i : resolvableTypes) {
+            String id = i.entity().getId();
+            JsonObject o = new JsonObject();
+            JsonArray fileMatch = new JsonArray();
+            fileMatch.add("/" + id + "/*.json");
+            o.add("fileMatch", fileMatch);
+            o.add("url", new JsonPrimitive(".iris/schema/" + id + ".json"));
+            schemas.add(o);
+        }
+
+        settings.add("json.schemas", schemas);
+        ws.add("settings", settings);
+        IO.writeAll(file, ws.toString());
+    }
+
+    public void loadDataNamespaced(File folder, String namespace) throws IOException {
+        i("Loading Namespace " + namespace + " in " + folder.getPath());
+        for(Resolvable i : resolvableTypes)
+        {
+            new File(folder, i.entity().getId()).mkdirs();
+            IO.writeAll(new File(new File(folder, i.entity().getId()), "example.json"), gson.toJson(i));
+        }
+
+        for(File i : folder.listFiles())
+        {
+            if(i.isDirectory()) {
+                loadDataFolder(i, namespace);
+            }
+        }
+    }
+
+    public void loadDataFolder(File folder, String namespace) {
+        for(Resolvable i : resolvableTypes)
+        {
+            if(!folder.getName().equals(i.entity().getId())) {
+                continue;
+            }
+
+            registerResolver(i.getClass(), Resolver.hotDirectoryJson(namespace, i.getClass(), folder, gson), namespace);
+        }
+    }
+
+    public void loadPakFile(File folder, String name) throws IOException {
+        PakFile pakFile = new PakFile(folder, name);
+        Map<PakKey, PakResource> resources = pakFile.getAllResources();
+
+        for(Resolvable i : resolvableTypes)
+        {
+            Class<? extends Resolvable> resolvableClass = i.getClass();
+            CompositeResolver<?> composite = Resolver.frozen(resources, (p) -> p.getClass().equals(resolvableClass));
+
+            for(String j : composite.getResolvers().keySet())
+            {
+                Resolver<? extends Resolvable> resolver = composite.getResolvers().get(i);
+                this.registerResolver(i.getClass(), resolver, j);
+            }
+        }
+    }
+
+    public void printResolvers() {
+        resolvers.forEach((k, i) -> i.print(k.simpleName(), this));
+    }
+
+    private <T> void writeSafeJson(TypeAdapter<T> delegate, JsonWriter out, T value) {
+        try {
+            delegate.write(out, value);
+        } catch (IOException e) {
+            try {
+                delegate.write(out, null);
+            } catch(IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+    }
+
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+        final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
+
+        for(Resolvable i : resolvableTypes) {
+            if(type.getRawType().equals(i.getClass())) {
+                return new TypeAdapter<>() {
+                    public void write(JsonWriter out, T value) {writeSafeJson(delegate, out, value);}
+
+                    @SuppressWarnings("unchecked")
+                    public T read(JsonReader in) throws IOException {
+                        JsonToken token = in.peek();
+
+                        if(token == JsonToken.STRING) {
+                            Resolver<?> resolver = getResolvers().get(i.getClass());
+                            String key = in.nextString();
+
+                            if(resolver == null) {
+                                w("Unable to find a resolver for " + i.getClass() + " received " + key);
+                                return null;
+                            }
+
+                            T t = (T) resolver.resolve(new NSK(key));
+
+                            if(t == null) {
+                                w("Unable to resolve " + i.getClass() + " " + key);
+                            }
+
+                            return t;
+                        }
+
+                        return delegate.read(in);
+                    }
+                };
+            }
+        }
+
+        return null;
+    }
+
+    public Resolvable getInstance(Class<?> type) {
+        for(Resolvable i : resolvableTypes) {
+            if(i.getClass().equals(type)) {
+                return i;
+            }
+        }
+
+        return null;
+    }
+
+    public List<PlatformNamespaceKey> getAllKeys(Class<?> type) {
+        List<PlatformNamespaceKey> keys = new ArrayList<>();
+        Resolver<?> resolver = resolvers.get(type);
+
+        if(resolver != null) {
+            resolver.addAllKeys(keys);
+        }
+
+        return keys;
+    }
+}

engine/src/main/java/com/volmit/iris/engine/EngineExecutor.java

@@ -0,0 +1,51 @@
+package com.volmit.iris.engine;
+
+import art.arcane.amulet.concurrent.J;
+import lombok.Data;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.ForkJoinWorkerThread;
+
+@Data
+public class EngineExecutor implements ForkJoinPool.ForkJoinWorkerThreadFactory, Thread.UncaughtExceptionHandler, Closeable {
+    private final Engine engine;
+    private final ForkJoinPool forks;
+
+    public EngineExecutor(Engine engine)
+    {
+        this.engine = engine;
+        forks = new ForkJoinPool(engine.getConfiguration().getThreads(), this, this, true);
+        i("Started Pool with " + engine.getConfiguration().getThreads() + " priority " + engine.getConfiguration().getThreadPriority() + " threads.");
+    }
+
+    @Override
+    public void uncaughtException(Thread t, Throwable e) {
+        e.printStackTrace();
+    }
+
+    @Override
+    public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
+        final ForkJoinWorkerThread worker = ForkJoinPool.defaultForkJoinWorkerThreadFactory.newThread(pool);
+        worker.setName("Iris " + engine.getWorld().getName() + " Executor " + worker.getPoolIndex());
+        return worker;
+    }
+
+    @Override
+    public void close() throws IOException {
+        i("Shutting down generator pool");
+        forks.shutdownNow().forEach((i) -> {
+            try
+            {
+                i.run();
+            }
+
+            catch(Throwable e)
+            {
+                e.printStackTrace();
+            }
+        });
+        i("Generator pool shutdown");
+    }
+}

engine/src/main/java/com/volmit/iris/engine/EngineRegistry.java

@@ -0,0 +1,14 @@
+package com.volmit.iris.engine;
+
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformRegistry;
+import lombok.Builder;
+import lombok.Data;
+
+@Builder
+@Data
+public class EngineRegistry {
+    private final PlatformRegistry<PlatformBlock> blockRegistry;
+    private final PlatformRegistry<PlatformBiome> biomeRegistry;
+}

engine/src/main/java/com/volmit/iris/engine/EngineSeedManager.java

@@ -0,0 +1,16 @@
+package com.volmit.iris.engine;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+public class EngineSeedManager {
+    private final Engine engine;
+    private final long worldSeed;
+
+    public EngineSeedManager(Engine engine)
+    {
+        this.engine = engine;
+        this.worldSeed = engine.getWorld().getSeed();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisAuthor.java

@@ -0,0 +1,25 @@
+package com.volmit.iris.engine.dimension;
+
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.util.Map;
+
+@Data
+@NoArgsConstructor
+@Builder
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "author")
+public class IrisAuthor extends EngineResolvable
+{
+    private String name;
+    private Map<String, String> social;
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisBiome.java

@@ -0,0 +1,33 @@
+package com.volmit.iris.engine.dimension;
+
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import com.volmit.iris.platform.PlatformBiome;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "biome")
+public class IrisBiome extends EngineResolvable {
+    private String name;
+
+    @Builder.Default
+    private IrisSurface surface = new IrisSurface();
+
+    @Builder.Default
+    private IrisRange height = IrisRange.flat(1);
+
+    public PlatformBiome toPlatformBiome()
+    {
+        return null;
+    }
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisChance.java

@@ -0,0 +1,74 @@
+package com.volmit.iris.engine.dimension;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.io.IOException;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "chance", jsonTypes = {JsonToken.STRING, JsonToken.BEGIN_OBJECT})
+public class IrisChance extends EngineResolvable implements TypeAdapterFactory {
+    @Builder.Default
+    @TokenConstructor(JsonToken.NUMBER)
+    private double threshold = 0.5;
+
+    @TokenConstructor(JsonToken.STRING)
+    @Builder.Default
+    private IrisGenerator generator = IrisGenerator.WHITE;
+
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+        final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
+
+        if(!type.getRawType().equals(getClass())) {
+            return null;
+        }
+
+        return new TypeAdapter<>() {
+            public void write(JsonWriter out, T value) {writeSafeJson(delegate, out, value);}
+
+            @SuppressWarnings("unchecked")
+            public T read(JsonReader in) throws IOException {
+                JsonToken token = in.peek();
+
+                if(token == JsonToken.STRING) {
+                    return (T) IrisChance.half(gson.fromJson(in.nextString(), IrisGenerator.class));
+                }
+
+                return delegate.read(in);
+            }
+        };
+    }
+
+    public static IrisChance half(IrisGenerator generator) {
+        return IrisChance.builder()
+            .threshold(0.5)
+            .generator(generator)
+            .build();
+    }
+
+    public static IrisChance white(double chance) {
+        return IrisChance.builder()
+            .threshold(chance)
+            .generator(IrisGenerator.WHITE)
+            .build();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisDecorator.java

@@ -0,0 +1,25 @@
+package com.volmit.iris.engine.dimension;
+
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "decorator")
+public class IrisDecorator extends EngineResolvable {
+    @Builder.Default
+    private IrisPalette palette = IrisPalette.flat("minecraft:grass");
+
+    @Builder.Default
+    private IrisChance chance = IrisChance.white(0.25);
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisDimension.java

@@ -0,0 +1,30 @@
+package com.volmit.iris.engine.dimension;
+
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.Singular;
+import lombok.experimental.Accessors;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@Builder
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "dimension")
+public class IrisDimension  extends EngineResolvable {
+    @Builder.Default
+    private IrisDimensionMeta meta = new IrisDimensionMeta();
+
+    @Singular
+    @Type(IrisBiome.class)
+    private List<IrisBiome> biomes = new ArrayList<>();
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisDimensionMeta.java

@@ -0,0 +1,31 @@
+package com.volmit.iris.engine.dimension;
+
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.Singular;
+import lombok.experimental.Accessors;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@Builder
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "dimension-meta")
+public class IrisDimensionMeta  extends EngineResolvable
+{
+    private String name;
+    private String description;
+    private String version;
+    @Singular
+    @Resolvable.Type(IrisAuthor.class)
+    private List<IrisAuthor> authors = new ArrayList<>();
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisGenerator.java

@@ -0,0 +1,76 @@
+package com.volmit.iris.engine.dimension;
+
+import art.arcane.source.NoisePlane;
+import art.arcane.source.script.NoisePlaneConstructor;
+import art.arcane.source.util.NoisePreset;
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import javax.script.ScriptException;
+import java.io.IOException;
+
+@Data
+@NoArgsConstructor
+@Builder
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "generator", jsonTypes = {JsonToken.STRING, JsonToken.BEGIN_OBJECT})
+public class IrisGenerator  extends EngineResolvable implements TypeAdapterFactory {
+    public static final IrisGenerator NATURAL = IrisGenerator.builder().java("art.arcane.source.api.util.NoisePreset.NATURAL.create(seed)").build();
+    public static final IrisGenerator WHITE = IrisGenerator.builder().java("Noise.white(seed)").build();
+    public static final IrisGenerator FLAT = IrisGenerator.builder().java("Noise.flat(seed)").build();
+
+    @Builder.Default
+    private String java = "art.arcane.source.api.util.NoisePreset.NATURAL.create(seed)";
+
+    @Builder.Default
+    private IrisSeed seed = new IrisSeed();
+
+    public NoisePlane getNoisePlane(long seed)
+    {
+        try {
+            return NoisePlaneConstructor.execute(seed, java);
+        } catch(ScriptException e) {
+            e.printStackTrace();
+            return NoisePreset.NATURAL.create(seed);
+        }
+    }
+
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+        final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
+
+        if(!type.getRawType().equals(getClass())) {
+            return null;
+        }
+
+        return new TypeAdapter<>() {
+            public void write(JsonWriter out, T value) {writeSafeJson(delegate, out, value);}
+
+            @SuppressWarnings("unchecked")
+            public T read(JsonReader in) throws IOException {
+                JsonToken token = in.peek();
+
+                if(token == JsonToken.STRING) {
+                    return (T) IrisGenerator.builder().java(in.nextString()).build();
+                }
+
+                return delegate.read(in);
+            }
+        };
+    }
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisPalette.java

@@ -0,0 +1,74 @@
+package com.volmit.iris.engine.dimension;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import com.volmit.iris.platform.block.PlatformBlock;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.Singular;
+import lombok.experimental.Accessors;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "palette", jsonTypes = {JsonToken.STRING, JsonToken.BEGIN_OBJECT})
+public class IrisPalette extends EngineResolvable implements TypeAdapterFactory {
+    @Singular
+    @PlatformType(PlatformBlock.class)
+    @Type(String.class)
+    @TokenConstructor(JsonToken.STRING)
+    private List<String> blocks = new ArrayList<>();
+
+    @Builder.Default
+    private IrisGenerator generator = IrisGenerator.WHITE;
+
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+        final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
+
+        if(!type.getRawType().equals(getClass())) {
+            return null;
+        }
+
+        return new TypeAdapter<>() {
+            public void write(JsonWriter out, T value) {
+                writeSafeJson(delegate, out, value);
+            }
+
+            @SuppressWarnings("unchecked")
+            public T read(JsonReader in) throws IOException {
+                JsonToken token = in.peek();
+
+                if(token == JsonToken.STRING) {
+                    return (T) IrisPalette.flat(in.nextString());
+                }
+
+                return delegate.read(in);
+            }
+        };
+    }
+
+    public static IrisPalette flat(String block){
+        return IrisPalette.builder()
+            .block(block)
+            .generator(IrisGenerator.FLAT)
+            .build();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisRange.java

@@ -0,0 +1,71 @@
+package com.volmit.iris.engine.dimension;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.io.IOException;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "range", jsonTypes = {JsonToken.NUMBER, JsonToken.BEGIN_OBJECT})
+public class IrisRange extends EngineResolvable implements TypeAdapterFactory {
+    @Builder.Default
+    @TokenConstructor(JsonToken.NUMBER)
+    private double max = 1;
+
+    @Builder.Default
+    private double min = 1;
+
+    @Builder.Default
+    private IrisGenerator generator = IrisGenerator.NATURAL;
+
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+        final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
+
+        if(!type.getRawType().equals(getClass())) {
+            return null;
+        }
+
+        return new TypeAdapter<>() {
+            public void write(JsonWriter out, T value) {writeSafeJson(delegate, out, value);}
+
+            @SuppressWarnings("unchecked")
+            public T read(JsonReader in) throws IOException {
+                JsonToken token = in.peek();
+
+                if(token == JsonToken.NUMBER) {
+                    double d = in.nextDouble();
+                    return (T) IrisRange.builder().min(d).max(d).generator(IrisGenerator.FLAT).build();
+                }
+
+                return delegate.read(in);
+            }
+        };
+    }
+
+    public static IrisRange flat(double v) {
+        return IrisRange.builder()
+            .max(v)
+            .min(v)
+            .generator(IrisGenerator.FLAT)
+            .build();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisSeed.java

@@ -0,0 +1,87 @@
+package com.volmit.iris.engine.dimension;
+
+import com.google.gson.Gson;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.io.IOException;
+
+@Data
+@NoArgsConstructor
+@Builder
+@AllArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "seed", jsonTypes = {JsonToken.NUMBER, JsonToken.STRING, JsonToken.BEGIN_OBJECT})
+public class IrisSeed extends EngineResolvable implements TypeAdapterFactory {
+    @Builder.Default
+    private IrisSeedSetMode mode = IrisSeedSetMode.LOCAL_OFFSET;
+
+    @Builder.Default
+    @TokenConstructor(JsonToken.NUMBER)
+    private long offset = 0;
+
+    @TokenConstructor(JsonToken.STRING)
+    private String hashOffset;
+
+    public long getOffset() {
+        if(hashOffset != null && hashOffset.isNotEmpty()) {
+            return hashOffset.hashCode() + offset;
+        }
+
+        return offset;
+    }
+
+    public double getSeed(Engine engine, long localSeed) {
+        return switch(mode)
+            {
+                case WORLD -> engine.getSeedManager().getWorldSeed();
+                case LOCAL -> localSeed;
+                case LOCAL_OFFSET -> localSeed + getOffset();
+                case RAW -> getOffset();
+                case WORLD_OFFSET -> engine.getSeedManager().getWorldSeed() + getOffset();
+                case RANDOM -> (Math.random() * Long.MAX_VALUE) + (Math.random() * Long.MAX_VALUE);
+            };
+    }
+
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+        final TypeAdapter<T> delegate = gson.getDelegateAdapter(this, type);
+
+        if(!type.getRawType().equals(getClass())) {
+            return null;
+        }
+
+        return new TypeAdapter<>() {
+            public void write(JsonWriter out, T value) {writeSafeJson(delegate, out, value);}
+
+            @SuppressWarnings("unchecked")
+            public T read(JsonReader in) throws IOException {
+                JsonToken token = in.peek();
+
+                if(token == JsonToken.STRING) {
+                    return (T) IrisSeed.builder().hashOffset(in.nextString()).build();
+                }
+
+                if(token == JsonToken.NUMBER) {
+                    return (T) IrisSeed.builder().offset(Double.doubleToLongBits(in.nextDouble())).build();
+                }
+
+                return delegate.read(in);
+            }
+        };
+    }
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisSeedSetMode.java

@@ -0,0 +1,11 @@
+package com.volmit.iris.engine.dimension;
+
+public enum IrisSeedSetMode
+{
+    WORLD,
+    RAW,
+    WORLD_OFFSET,
+    LOCAL,
+    LOCAL_OFFSET,
+    RANDOM
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisSurface.java

@@ -0,0 +1,31 @@
+package com.volmit.iris.engine.dimension;
+
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.Singular;
+import lombok.experimental.Accessors;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "surface")
+public class IrisSurface extends EngineResolvable {
+    @Singular
+    @Type(IrisSurfaceLayer.class)
+    private List<IrisSurfaceLayer> layers = new ArrayList<>();
+
+    @Singular
+    @Type(IrisDecorator.class)
+    private List<IrisDecorator> decorators = new ArrayList<>();
+}

engine/src/main/java/com/volmit/iris/engine/dimension/IrisSurfaceLayer.java

@@ -0,0 +1,25 @@
+package com.volmit.iris.engine.dimension;
+
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.engine.resolver.Resolvable;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+@Builder
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@EqualsAndHashCode(callSuper=false)
+@Accessors(fluent = true, chain = true)
+@Resolvable.Entity(id = "surface-layer")
+public class IrisSurfaceLayer extends EngineResolvable {
+   @Builder.Default
+   private IrisPalette palette = IrisPalette.flat("minecraft:stone");
+
+   @Builder.Default
+   private IrisRange thickness = IrisRange.flat(1);
+}

engine/src/main/java/com/volmit/iris/engine/feature/Feature.java

@@ -0,0 +1,35 @@
+package com.volmit.iris.engine.feature;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.platform.PlatformNamespaced;
+import lombok.Data;
+
+@Data
+public abstract class Feature<T extends PlatformNamespaced, S extends FeatureState> {
+    private final String name;
+    private final Engine engine;
+    private boolean optimize;
+    private boolean heightAgnostic;
+
+    public Feature(String name, Engine engine)
+    {
+        this.engine = engine;
+        this.name = name;
+        this.optimize = true;
+        this.heightAgnostic = true;
+    }
+
+    public FeatureTask<T, S> task(FeatureSizedTarget target, FeatureTarget<T> origin, FeatureStorage storage, int verticalExecutionSize, int horizontalExecutionSize, FeatureTaskTiming timings)
+    {
+        return new FeatureTask<>(engine, this, storage, target, origin, verticalExecutionSize, horizontalExecutionSize, heightAgnostic, timings);
+    }
+
+    public FeatureTask<T, S> task(FeatureSizedTarget target, FeatureTarget<T> origin, FeatureStorage storage, int horizontalExecutionSize, FeatureTaskTiming timings)
+    {
+        return new FeatureTask<>(engine, this, storage, target, origin, Integer.MAX_VALUE, horizontalExecutionSize, heightAgnostic, timings);
+    }
+
+    public abstract S prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage);
+
+    public abstract void generate(Engine engine, S state, FeatureTarget<T> target, FeatureStorage storage);
+}

engine/src/main/java/com/volmit/iris/engine/feature/FeatureSizedTarget.java

@@ -0,0 +1,159 @@
+package com.volmit.iris.engine.feature;
+
+import art.arcane.amulet.range.IntegerRange;
+import art.arcane.spatial.hunk.storage.ArrayHunk;
+import art.arcane.spatial.hunk.view.HunkView;
+import art.arcane.spatial.util.Consume;
+import com.volmit.iris.platform.PlatformNamespaced;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+@Data
+public class FeatureSizedTarget {
+    @Builder.Default
+    private final int width = 16;
+    @Builder.Default
+    private final int height = 0;
+    @Builder.Default
+    private final int depth = 16;
+    @Builder.Default
+    private final int offsetX = 0;
+    @Builder.Default
+    private final int offsetY = 0;
+    @Builder.Default
+    private final int offsetZ = 0;
+
+    public <T extends PlatformNamespaced> FeatureTarget<T> hunked()
+    {
+        return new FeatureTarget<>(new ArrayHunk<>(width, height, depth), this);
+    }
+
+    public <T extends PlatformNamespaced> FeatureTarget<T> hunked(FeatureTarget<T> origin)
+    {
+        return new FeatureTarget<>(new HunkView<>(origin.getHunk(), width, height, depth, offsetX - origin.getOffsetX(), offsetY - origin.getOffsetY(), offsetZ - origin.getOffsetZ()), this);
+    }
+
+    Stream<FeatureSizedTarget> splitX() {
+        if(width <= 1) {
+            return Stream.of(this);
+        }
+        int wo2 = width/2;
+        return Stream.of(FeatureSizedTarget.builder()
+                .width(wo2).height(height).depth(depth)
+                .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ).build(),
+            FeatureSizedTarget.builder()
+                .width(width - wo2).height(height).depth(depth)
+                .offsetX(offsetX + wo2).offsetY(offsetY).offsetZ(offsetZ).build());
+    }
+
+    Stream<FeatureSizedTarget> splitY() {
+        if(height <= 1) {
+            return Stream.of(this);
+        }
+
+        int ho2 = height / 2;
+        return Stream.of(FeatureSizedTarget.builder()
+                .width(width).height(ho2).depth(depth)
+                .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ).build(),
+            FeatureSizedTarget.builder()
+                .width(width).height(height - ho2).depth(depth)
+                .offsetX(offsetX).offsetY(offsetY + ho2).offsetZ(offsetZ).build());
+    }
+
+    Stream<FeatureSizedTarget> splitZ() {
+        if(depth <= 1) {
+            return Stream.of(this);
+        }
+
+        int do2 = depth / 2;
+        return Stream.of(FeatureSizedTarget.builder()
+                .width(width).height(height).depth(do2)
+                .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ).build(),
+            FeatureSizedTarget.builder()
+                .width(width).height(height).depth(depth - do2)
+                .offsetX(offsetX).offsetY(offsetY).offsetZ(offsetZ + do2).build());
+    }
+
+    public int getAbsoluteMaxX()
+    {
+        return getOffsetX() + getWidth() - 1;
+    }
+
+    public int getAbsoluteMaxY()
+    {
+        return getOffsetY() + getHeight() - 1;
+    }
+
+    public int getAbsoluteMaxZ()
+    {
+        return getOffsetZ() + getDepth() - 1;
+    }
+
+    public IntegerRange yCap(int max) {
+        return new IntegerRange(y().getLeftEndpoint(), Math.min(y().getRightEndpoint(), max));
+    }
+
+    public void forYCap(Consume.One<Integer> consumer, int max) {
+        for(int y : yCap(max)) {
+            consumer.accept(y);
+        }
+    }
+
+    public void forXZ(Consume.Two<Integer, Integer> consumer) {
+        for(int x : x()) {
+            for(int z : z()) {
+                consumer.accept(x, z);
+            }
+        }
+    }
+
+    public IntegerRange x()
+    {
+        return new IntegerRange(getOffsetX(), getAbsoluteMaxX());
+    }
+
+    public IntegerRange y()
+    {
+        return new IntegerRange(getOffsetY(), getAbsoluteMaxY());
+    }
+
+    public IntegerRange z()
+    {
+        return new IntegerRange(getOffsetZ(), getAbsoluteMaxZ());
+    }
+
+    public IntegerRange localX()
+    {
+        return new IntegerRange(0, getWidth() - 1);
+    }
+
+    public IntegerRange localY()
+    {
+        return new IntegerRange(0, getHeight() - 1);
+    }
+
+    public IntegerRange localZ()
+    {
+        return new IntegerRange(0, getDepth() - 1);
+    }
+
+    public static FeatureSizedTarget mergedSize(Stream<FeatureSizedTarget> targets, boolean x, boolean y, boolean z) {
+        List<FeatureSizedTarget> t = targets.toList();
+        return FeatureSizedTarget.builder()
+            .width(x ? t.stream().mapToInt(FeatureSizedTarget::getWidth).sum() : t[0].getWidth())
+            .height(y ? t.stream().mapToInt(FeatureSizedTarget::getHeight).sum() : t[0].getHeight())
+            .depth(z ? t.stream().mapToInt(FeatureSizedTarget::getDepth).sum() : t[0].getDepth())
+            .offsetX(x ? t.stream().mapToInt(FeatureSizedTarget::getOffsetX).min().orElse(0) : t[0].getOffsetX())
+            .offsetY(y ? t.stream().mapToInt(FeatureSizedTarget::getOffsetY).min().orElse(0) : t[0].getOffsetY())
+            .offsetZ(z ? t.stream().mapToInt(FeatureSizedTarget::getOffsetZ).min().orElse(0) : t[0].getOffsetZ())
+            .build();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/feature/FeatureState.java

@@ -0,0 +1,5 @@
+package com.volmit.iris.engine.feature;
+
+public interface FeatureState {
+
+}

engine/src/main/java/com/volmit/iris/engine/feature/FeatureStorage.java

@@ -0,0 +1,22 @@
+package com.volmit.iris.engine.feature;
+
+import com.volmit.iris.engine.dimension.IrisBiome;
+import com.volmit.iris.util.NoiseCache;
+import com.volmit.iris.util.ShortNoiseCache;
+import lombok.Data;
+
+@Data
+public class FeatureStorage {
+    private ShortNoiseCache height;
+    private NoiseCache<IrisBiome> biome;
+    private final int w;
+    private final int h;
+
+    public FeatureStorage(int w, int h)
+    {
+        this.w = w;
+        this.h = h;
+        this.height = new ShortNoiseCache(w, h);
+        this.biome = new NoiseCache<>(w, h);
+    }
+}

engine/src/main/java/com/volmit/iris/engine/feature/FeatureTarget.java

@@ -0,0 +1,38 @@
+package com.volmit.iris.engine.feature;
+
+import art.arcane.spatial.hunk.Hunk;
+import art.arcane.spatial.hunk.view.HunkView;
+import com.volmit.iris.platform.PlatformNamespaced;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class FeatureTarget<T extends PlatformNamespaced> extends FeatureSizedTarget {
+    private final Hunk<T> hunk;
+
+    public FeatureTarget(Hunk<T> hunk, int offsetX, int offsetY, int offsetZ)
+    {
+        super(hunk.getWidth(), hunk.getHeight(), hunk.getDepth(), offsetX, offsetY, offsetZ);
+        this.hunk = hunk;
+    }
+
+    public FeatureTarget(Hunk<T> hunk, FeatureSizedTarget target)
+    {
+        this(hunk, target.getOffsetX(), target.getOffsetY(), target.getOffsetZ());
+    }
+
+    public static <V extends PlatformNamespaced> FeatureTarget<V> mergedTarget(Stream<FeatureTarget<V>> targets, FeatureTarget<V> origin, boolean x, boolean y, boolean z)
+    {
+        List<FeatureTarget<V>> t = targets.toList();
+        FeatureSizedTarget mergedSize = FeatureSizedTarget.mergedSize(t.stream().map(i -> i), x, y, z);
+        Hunk<V> hunk = new HunkView<>(origin.getHunk(), mergedSize.getWidth(), mergedSize.getHeight(), mergedSize.getDepth(),
+            mergedSize.getOffsetX() - origin.getOffsetX(),
+            mergedSize.getOffsetY() - origin.getOffsetY(),
+            mergedSize.getOffsetZ() - origin.getOffsetZ());
+        return new FeatureTarget<>(hunk, mergedSize);
+    }
+}

engine/src/main/java/com/volmit/iris/engine/feature/FeatureTask.java

@@ -0,0 +1,78 @@
+package com.volmit.iris.engine.feature;
+
+import art.arcane.chrono.PrecisionStopwatch;
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.platform.PlatformNamespaced;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.RecursiveTask;
+
+/**
+ * Continuously splits up a hunk of work in all 3 dimensions until the job size is within the
+ * specified limits. This allows a single hunk to be split until the ideal amount of tasks can run in parallel.
+ * @param <T> The namespaced object type
+ * @param <S> The feature state type
+ */
+@Builder
+@AllArgsConstructor
+public class FeatureTask<T extends PlatformNamespaced, S extends FeatureState> extends RecursiveTask<FeatureTarget<T>> implements Callable<FeatureTarget<T>> {
+    private final Engine engine;
+    private final Feature<T, S> feature;
+    private final FeatureStorage storage;
+    private final FeatureSizedTarget size;
+    private final FeatureTarget<T> origin;
+    private final int verticalPrepareSize;
+    private final int horizontalPrepareSize;
+    private final boolean heightAgnostic;
+    private final FeatureTaskTiming timings;
+
+    @Override
+    protected FeatureTarget<T> compute() {
+        FeatureTarget<T> result;
+        PrecisionStopwatch p = null;
+
+        if(timings != null) {
+            p = PrecisionStopwatch.start();
+        }
+
+        if(!heightAgnostic && size.getHeight() > verticalPrepareSize * 2) {
+            result = FeatureTarget.mergedTarget(size.splitY()
+                .map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<FeatureTarget<T>>) with(i)))
+                .map(ForkJoinTask::join), origin, false, true, false);
+        }
+
+        else if(size.getWidth() > horizontalPrepareSize * 2) {
+            result = FeatureTarget.mergedTarget(size.splitX().map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<FeatureTarget<T>>) with(i)))
+                .map(ForkJoinTask::join), origin, true, false, false);
+        }
+
+        else if(size.getDepth() > horizontalPrepareSize * 2) {
+            result = FeatureTarget.mergedTarget(size.splitZ().map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<FeatureTarget<T>>) with(i)))
+                .map(ForkJoinTask::join), origin, false, false, true);
+        }
+
+        else {
+            IrisPreparedFeature<T, S> preparedFeature = new IrisPreparedFeature<>(engine, feature, size, feature.prepare(engine, size, storage));
+            result = preparedFeature.generate(origin, storage);
+        }
+
+        if(timings != null) {
+            timings.onCompleted(p.getMilliseconds());
+        }
+
+        return result;
+    }
+
+    private FeatureTask<T, S> with(FeatureSizedTarget size)
+    {
+        return new FeatureTask<>(engine, feature, storage, size, origin, verticalPrepareSize, horizontalPrepareSize, heightAgnostic, null);
+    }
+
+    @Override
+    public FeatureTarget<T> call() throws Exception {
+        return compute();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/feature/FeatureTaskTiming.java

@@ -0,0 +1,6 @@
+package com.volmit.iris.engine.feature;
+
+@FunctionalInterface
+public interface FeatureTaskTiming {
+    void onCompleted(double ms);
+}

engine/src/main/java/com/volmit/iris/engine/feature/IrisPreparedFeature.java

@@ -0,0 +1,21 @@
+package com.volmit.iris.engine.feature;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.platform.PlatformNamespaced;
+import lombok.Builder;
+import lombok.Data;
+
+@Builder
+@Data
+public class IrisPreparedFeature<T extends PlatformNamespaced, S extends FeatureState> {
+    private final Engine engine;
+    private final Feature<T, S> feature;
+    private final FeatureSizedTarget size;
+    private final S state;
+
+    public FeatureTarget<T> generate(FeatureTarget<T> origin, FeatureStorage storage) {
+        FeatureTarget<T> target = size.hunked(origin);
+        feature.generate(engine, state, target, storage);
+        return target;
+    }
+}

engine/src/main/java/com/volmit/iris/engine/feature/SyntheticFeature.java

@@ -0,0 +1,12 @@
+package com.volmit.iris.engine.feature;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.FeatureStorage;
+import com.volmit.iris.engine.feature.FeatureTarget;
+import com.volmit.iris.engine.feature.features.FeatureTerrain;
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.platform.PlatformNamespaced;
+
+public interface SyntheticFeature<T extends PlatformNamespaced, V extends EngineResolvable, S extends FeatureState> {
+    void generate(Engine engine, V component, FeatureTarget<T> target, S state);
+}

engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureError.java

@@ -0,0 +1,38 @@
+package com.volmit.iris.engine.feature.features;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.Feature;
+import com.volmit.iris.engine.feature.FeatureSizedTarget;
+import com.volmit.iris.engine.feature.FeatureState;
+import com.volmit.iris.engine.feature.FeatureStorage;
+import com.volmit.iris.engine.feature.FeatureTarget;
+import com.volmit.iris.platform.block.PlatformBlock;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+public class FeatureError extends Feature<PlatformBlock, FeatureError.State> {
+    private static final State DEFAULT_STATE = new State();
+    private final PlatformBlock ERROR_BLOCK;
+
+    public FeatureError(Engine engine) {
+        super("error", engine);
+        setOptimize(false);
+        ERROR_BLOCK = engine.block("red_sandstone");
+    }
+
+    @Override
+    public State prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage) {
+        return DEFAULT_STATE;
+    }
+
+    @Override
+    public void generate(Engine engine, State state, FeatureTarget<PlatformBlock> target, FeatureStorage storage) {
+        target.forXZ((x, z) -> target.forYCap((y -> target.getHunk().set(x, y, z, ERROR_BLOCK)), 1));
+    }
+
+    @Data
+    @AllArgsConstructor
+    public static class State implements FeatureState {
+
+    }
+}

engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureOriginBiome.java

@@ -0,0 +1,44 @@
+package com.volmit.iris.engine.feature.features;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.dimension.IrisBiome;
+import com.volmit.iris.engine.feature.*;
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.util.NoiseCache;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+public class FeatureOriginBiome extends Feature<PlatformBiome, FeatureOriginBiome.State> {
+    public FeatureOriginBiome(Engine engine) {
+        super("biome-origin", engine);
+    }
+
+    @Override
+    public State prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage) {
+        final NoiseCache<IrisBiome> noise = storage.getBiome();
+
+        for(int x : target.x()) {
+            for(int z : target.z()) {
+                noise.set(x & storage.getW() - 1, z & storage.getH() - 1, null);
+            }
+        }
+
+        return new State(noise);
+    }
+
+    @Override
+    public void generate(Engine engine, State state, FeatureTarget<PlatformBiome> target, FeatureStorage storage) {
+        for(int x : target.x()) {
+            for(int z : target.z()) {
+                IrisBiome b = state.getBiomes().get(x, z);
+                target.getHunk().set(x, 0, z, b.toPlatformBiome());
+            }
+        }
+    }
+
+    @Data
+    @AllArgsConstructor
+    public static class State implements FeatureState {
+        private final NoiseCache<IrisBiome> biomes;
+    }
+}

engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureTerrain.java

@@ -0,0 +1,73 @@
+package com.volmit.iris.engine.feature.features;
+
+import art.arcane.source.NoisePlane;
+import art.arcane.source.interpolator.CubicInterpolator;
+import art.arcane.source.interpolator.Interpolator;
+import art.arcane.source.interpolator.LinearInterpolator;
+import art.arcane.source.interpolator.StarcastInterpolator;
+import art.arcane.source.noise.provider.MirroredCacheProvider;
+import art.arcane.source.util.NoisePreset;
+import art.arcane.spatial.hunk.Hunk;
+import art.arcane.spatial.hunk.storage.ArrayHunk;
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.*;
+import com.volmit.iris.platform.block.PlatformBlock;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+public class FeatureTerrain extends Feature<PlatformBlock, FeatureTerrain.State> {
+    private final PlatformBlock stone;
+    private final NoisePlane generator;
+    private final NoisePlane generator2;
+
+    public FeatureTerrain(Engine engine) {
+        super("terrain", engine);
+        setOptimize(true);
+        stone = engine.block("stone");
+        this.generator = NoisePreset.NATURAL.create(1234);
+        this.generator2 = NoisePreset.NATURAL.create(6664).fit(0, 1).scale(0.1);
+    }
+
+    @Override
+    public State prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage) {
+        Hunk<Double> snc = new ArrayHunk<>(target.getWidth(), target.getHeight(), target.getDepth());
+        short n;
+        int fdx,fdz;
+        for(int x : target.x()) {
+            fdx = Math.floorMod(x, target.getWidth());
+            for(int z : target.z()) {
+                fdz = Math.floorMod(z, target.getDepth());
+                n = (short) generator.noise(x, z);
+                for(int y = 0; y < n; y++) {
+                    if(generator2.noise(x,y,z) > 0.5) {
+                        snc.set(fdx, y, fdz, 1D);
+                    }
+                }
+            }
+        }
+
+        return new State(snc);
+    }
+
+    @Override
+    public void generate(Engine engine, State state, FeatureTarget<PlatformBlock> target, FeatureStorage storage) {
+        int y;
+        for(int x : target.localX()) {
+            for(int z : target.localZ()) {
+                for(int i = 0; i < target.getHeight(); i++) {
+                    Double v = state.getNoise().get(x, i, z);
+                    v = v == null ? 0f : v;
+                    if(v >= 0.5) {
+                        target.getHunk().set(x,i, z, stone);
+                    }
+                }
+            }
+        }
+    }
+
+    @Data
+    @AllArgsConstructor
+    public static class State implements FeatureState {
+        private final Hunk<Double> noise;
+    }
+}

engine/src/main/java/com/volmit/iris/engine/feature/features/synthetic/SyntheticBiomeTerrain.java

@@ -0,0 +1,17 @@
+package com.volmit.iris.engine.feature.features.synthetic;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.dimension.IrisBiome;
+import com.volmit.iris.engine.feature.FeatureStorage;
+import com.volmit.iris.engine.feature.FeatureTarget;
+import com.volmit.iris.engine.feature.SyntheticFeature;
+import com.volmit.iris.engine.feature.features.FeatureTerrain;
+import com.volmit.iris.platform.block.PlatformBlock;
+
+public class SyntheticBiomeTerrain implements SyntheticFeature<PlatformBlock, IrisBiome, FeatureTerrain.State>
+{
+    @Override
+    public void generate(Engine engine, IrisBiome component, FeatureTarget<PlatformBlock> target, FeatureTerrain.State state) {
+
+    }
+}

engine/src/main/java/com/volmit/iris/engine/network/Network.java

@@ -0,0 +1,4 @@
+package com.volmit.iris.engine.network;
+
+public class Network {
+}

engine/src/main/java/com/volmit/iris/engine/network/server/EngineServer.java

@@ -0,0 +1,45 @@
+package com.volmit.iris.engine.network.server;
+
+import com.volmit.iris.engine.Engine;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketTimeoutException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class EngineServer extends Thread {
+    private final Engine engine;
+    private final ServerSocket server;
+    private final Map<UUID, EngineServerConnection> connections;
+
+    public EngineServer(Engine engine, int bindPort) throws IOException {
+        this.engine = engine;
+        this.connections = new HashMap<>();
+        this.server = new ServerSocket(bindPort);
+        this.server.setPerformancePreferences(0, 0, 1);
+        this.server.setSoTimeout(5000);
+    }
+
+    public void run() {
+        while(!interrupted()) {
+            try {
+                Socket socket = server.accept();
+                EngineServerConnection connection = new EngineServerConnection(this, socket);
+                connections.put(connection.getConnectionId(), connection);
+            }
+            catch(SocketTimeoutException e) {
+                continue;
+            } catch (Throwable e) {
+                throw new RuntimeException(e);
+            }
+        }
+    }
+
+    public void close() throws IOException {
+        this.interrupt();
+        server.close();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/network/server/EngineServerConnection.java

@@ -0,0 +1,19 @@
+package com.volmit.iris.engine.network.server;
+
+import lombok.Getter;
+
+import java.net.Socket;
+import java.util.UUID;
+
+@Getter
+public class EngineServerConnection extends Thread {
+    private final EngineServer server;
+    private final Socket socket;
+    private final UUID connectionId;
+
+    public EngineServerConnection(EngineServer server, Socket socket) {
+        this.server = server;
+        this.socket = socket;
+        this.connectionId = UUID.randomUUID();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/optimizer/HunkSlizeConfiguration.java

@@ -0,0 +1,63 @@
+package com.volmit.iris.engine.optimizer;
+
+import art.arcane.amulet.range.IntegerRange;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+public class HunkSlizeConfiguration {
+    private final int verticalSlice;
+    private final int horizontalSlize;
+
+    public String toString()
+    {
+        return "H" + horizontalSlize + "" + ((verticalSlice < 8192) ? ("V" + verticalSlice) : "");
+    }
+
+    public static List<HunkSlizeConfiguration> generateConfigurations(IntegerRange vertical, IntegerRange horizontal)
+    {
+        List<HunkSlizeConfiguration> configurations = new ArrayList<>();
+
+        for(int i : slice(vertical))
+        {
+            for(int j : slice(horizontal))
+            {
+                configurations.add(new HunkSlizeConfiguration(i, j));
+            }
+        }
+
+        return configurations;
+    }
+
+    public static List<HunkSlizeConfiguration> generateConfigurations(int vertical, IntegerRange horizontal)
+    {
+        List<HunkSlizeConfiguration> configurations = new ArrayList<>();
+
+        for(int j : slice(horizontal))
+        {
+            configurations.add(new HunkSlizeConfiguration(vertical, j));
+        }
+
+        return configurations;
+    }
+
+    private static List<Integer> slice(IntegerRange range)
+    {
+        List<Integer> v = new ArrayList<>();
+        v.add(range.getRightEndpoint());
+        v.add(range.getLeftEndpoint());
+        int i = (int) (range.getRightEndpoint() / 1.25);
+
+        while(i > range.getLeftEndpoint() && i >= 1)
+        {
+            v.add(i);
+            i /= 1.25;
+        }
+
+        return v.withoutDuplicates();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizationAttempt.java

@@ -0,0 +1,38 @@
+package com.volmit.iris.engine.optimizer;
+
+import art.arcane.chrono.Average;
+import art.arcane.spatial.hunk.storage.AtomicDoubleHunk;
+import lombok.Data;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Data
+public class IrisOptimizationAttempt<T> {
+    private double value;
+    private final AtomicInteger runs;
+    private final int testRuns;
+    private final T parameters;
+
+    public IrisOptimizationAttempt(T parameters, int testRuns)
+    {
+        this.parameters = parameters;
+        this.testRuns = testRuns;
+        this.value = 0;
+        this.runs = new AtomicInteger(0);
+    }
+
+    public double getAverageTime()
+    {
+        return value;
+    }
+
+    public boolean isComplete()
+    {
+        return runs.get() >= testRuns;
+    }
+
+    public void report(double ms) {
+        value += ms;
+        runs.incrementAndGet();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizer.java

@@ -0,0 +1,88 @@
+package com.volmit.iris.engine.optimizer;
+
+import art.arcane.amulet.format.Form;
+import art.arcane.chrono.Average;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Singular;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Data
+public class IrisOptimizer<T> {
+    private final String optimizedFeatureName;
+    private final int testRuns;
+    private int dummyRuns;
+    private final List<T> options;
+    private final Map<T, Double> results;
+    private final Map<T, IrisOptimizationAttempt<T>> attempts = new ConcurrentHashMap<>();
+    private T defaultOption;
+    private final double chanceToTest;
+    private double bestTime;
+
+    public IrisOptimizer(int testRuns, List<T> options, T defaultOption, double chanceToTest, String optimizedFeatureName) {
+        this.bestTime = Double.MAX_VALUE;
+        this.dummyRuns = 1024;
+        this.testRuns = testRuns;
+        this.results = new HashMap<>();
+        this.options = options;
+        this.optimizedFeatureName = optimizedFeatureName;
+        this.defaultOption = defaultOption;
+        this.chanceToTest = chanceToTest;
+
+        for(T i : options) {
+            attempts.put(i, new IrisOptimizationAttempt<>(i, testRuns));
+        }
+    }
+
+    public String toString() {
+        return "optimizer";
+    }
+
+    public synchronized void report(T parameters, double ms)
+    {
+        if(dummyRuns-- > 0)
+        {
+            return;
+        }
+
+        IrisOptimizationAttempt<T> attempt = attempts.get(parameters);
+
+        if(attempt != null) {
+            attempt.report(ms);
+
+            if(attempt.isComplete()) {
+                results.put(parameters, attempt.getAverageTime());
+                attempts.remove(parameters);
+                double result = attempt.getAverageTime();
+
+                if(result < bestTime) {
+                    bestTime = result;
+                    defaultOption = attempt.getParameters();
+                }
+
+                d("Attempted " + optimizedFeatureName + " with " + defaultOption.toString() + " " + Form.duration(attempt.getAverageTime(), 2));
+
+                if(attempts.isEmpty()) {
+                    d("Fully Optimized " + optimizedFeatureName + " with " + defaultOption.toString());
+
+                    for(T i : results.keySet()) {
+                        d(i.toString() + ": " + Form.duration(results.get(i), 2));
+                    }
+                }
+            }
+        }
+    }
+
+    public T nextParameters() {
+        if(!attempts.isEmpty() && Math.r(chanceToTest)) {
+            return attempts.k().popRandom();
+        }
+
+        return defaultOption;
+    }
+}

engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePipeline.java

@@ -0,0 +1,28 @@
+package com.volmit.iris.engine.pipeline;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.FeatureSizedTarget;
+import com.volmit.iris.engine.feature.FeatureStorage;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Singular;
+
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+@Builder
+public class EnginePipeline
+{
+    @Singular
+    private final List<PipelinePhase> phases;
+
+    public void generate(Engine engine, FeatureSizedTarget target, PipedHunkStack stack) {
+        FeatureStorage storage = new FeatureStorage(engine.getConfiguration().getChunkSize(), engine.getConfiguration().getChunkSize());
+
+        for(PipelinePhase i : phases) {
+            i.generate(engine, target, stack, storage);
+        }
+    }
+}

engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePlumbing.java

@@ -0,0 +1,33 @@
+package com.volmit.iris.engine.pipeline;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.FeatureSizedTarget;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Singular;
+
+import java.util.List;
+
+@Data
+@Builder
+@AllArgsConstructor
+public class EnginePlumbing {
+    private final Engine engine;
+    @Singular
+    private final List<EnginePipeline> pipelines;
+    private final EnginePipeline errorPipeline;
+
+    public void generate(Engine engine, FeatureSizedTarget target, PipedHunkStack stack) {
+        for(EnginePipeline i : pipelines) {
+            i.generate(engine, target, stack);
+        }
+        try {
+        }
+
+        catch(Throwable e) {
+            e.printStackTrace();
+            getErrorPipeline().generate(engine, target, stack);
+        }
+    }
+}

engine/src/main/java/com/volmit/iris/engine/pipeline/PipedHunkStack.java

@@ -0,0 +1,27 @@
+package com.volmit.iris.engine.pipeline;
+
+import com.volmit.iris.engine.feature.FeatureTarget;
+import com.volmit.iris.platform.PlatformNamespaced;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class PipedHunkStack {
+    private final Map<Class<? extends PlatformNamespaced>, FeatureTarget<? extends PlatformNamespaced>> hunks;
+
+    public PipedHunkStack()
+    {
+        this.hunks = new HashMap<>();
+    }
+
+    public void register(Class<? extends PlatformNamespaced> clazz, FeatureTarget<? extends PlatformNamespaced> hunk)
+    {
+        hunks.put(clazz, hunk);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends PlatformNamespaced> FeatureTarget<T> hunk(Class<?> hunk)
+    {
+        return (FeatureTarget<T>) hunks.get(hunk);
+    }
+}

engine/src/main/java/com/volmit/iris/engine/pipeline/PipelinePhase.java

@@ -0,0 +1,34 @@
+package com.volmit.iris.engine.pipeline;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.FeatureSizedTarget;
+import com.volmit.iris.engine.feature.FeatureStorage;
+import com.volmit.iris.engine.feature.FeatureTarget;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Singular;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
+
+@Data
+@Builder
+@AllArgsConstructor
+public class PipelinePhase
+{
+    @Singular
+    private final List<PipelineTask<?>> tasks;
+
+    public List<FeatureTarget<?>> generate(Engine engine, FeatureSizedTarget target, PipedHunkStack stack, FeatureStorage storage) {
+        return engine.getExecutor().getForks().invokeAll(tasks.stream().map(i -> i.task(target, stack.hunk(i.getTarget()), storage))
+            .collect(Collectors.toList())).stream().map(i -> {
+            try {
+                return i.get();
+            } catch(Throwable e) {
+                throw new RuntimeException(e);
+            }
+        }).collect(Collectors.toList());
+    }
+}

engine/src/main/java/com/volmit/iris/engine/pipeline/PipelineTask.java

@@ -0,0 +1,44 @@
+package com.volmit.iris.engine.pipeline;
+
+import art.arcane.amulet.range.IntegerRange;
+import com.volmit.iris.engine.feature.*;
+import com.volmit.iris.engine.optimizer.HunkSlizeConfiguration;
+import com.volmit.iris.engine.optimizer.IrisOptimizer;
+import com.volmit.iris.platform.PlatformNamespaced;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.List;
+
+import static art.arcane.amulet.MagicalSugar.*;
+
+@AllArgsConstructor
+@Data
+public class PipelineTask<T extends PlatformNamespaced>
+{
+    private final Feature<T, ?> feature;
+    private final Class<T> target;
+    private final IntegerRange verticalEnvelope;
+    private final IntegerRange horizontalEnvelope;
+    private final IrisOptimizer<HunkSlizeConfiguration> optimizer;
+
+    public PipelineTask(Feature<T, ?> feature, Class<T> target, IntegerRange verticalEnvelope, IntegerRange horizontalEnvelope)
+    {
+        this.feature = feature;
+        this.target = target;
+        this.verticalEnvelope = verticalEnvelope;
+        this.horizontalEnvelope = horizontalEnvelope;
+        List<HunkSlizeConfiguration> configurations = feature.isHeightAgnostic() ? HunkSlizeConfiguration.generateConfigurations(Integer.MAX_VALUE, horizontalEnvelope)
+            : HunkSlizeConfiguration.generateConfigurations(verticalEnvelope, horizontalEnvelope);
+        this.optimizer = new IrisOptimizer<>(128, configurations, configurations[0], 1, feature.getName());
+    }
+
+    public PipelineTask(Feature<T, ?> feature, Class<T> target) {
+        this(feature, target, 1 to 16, 1 to 16);
+    }
+
+    public FeatureTask<T, ?> task(FeatureSizedTarget target, FeatureTarget<T> origin, FeatureStorage storage){
+        HunkSlizeConfiguration configuration = getFeature().isOptimize() ? optimizer.nextParameters() : optimizer.getDefaultOption();
+        return feature.task(target, origin, storage, configuration.getVerticalSlice(), configuration.getHorizontalSlize(), (ms) -> optimizer.report(configuration, ms));
+    }
+}

engine/src/main/java/com/volmit/iris/engine/resolver/CompositeResolver.java

@@ -0,0 +1,71 @@
+package com.volmit.iris.engine.resolver;
+
+import art.arcane.amulet.format.Form;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.Data;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class CompositeResolver<T extends Resolvable> implements Resolver<T> {
+    private final Map<String, Resolver<T>> resolvers;
+    private final String[] namespaces;
+
+    public CompositeResolver(Map<String, Resolver<T>> resolvers)
+    {
+        this.resolvers = resolvers;
+        this.namespaces = resolvers.keySet().toArray(new String[0]);
+    }
+
+    @Override
+    public boolean hasNamespace(String namespace) {
+        return resolvers.containsKey(namespace);
+    }
+
+    @Override
+    public T resolve(PlatformNamespaceKey key) {
+        return resolvers.get(key.getNamespace()).resolve(key);
+    }
+
+    @Override
+    public T resolve(String key) {
+        for(String i : getNamespaces()) {
+            if(resolvers.get(i).contains(i, key)) {
+                return resolvers.get(i).resolve(key);
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public Resolver<T> and(String namespace, Resolver<T> resolver) {
+        Map<String, Resolver<T>> resolvers = this.resolvers.copy();
+
+        if(hasNamespace(namespace)) {
+            resolvers.put(namespace, resolvers.get(namespace).and(namespace, resolver));
+        }
+
+        else {
+            resolvers.put(namespace, resolver);
+        }
+
+        return new CompositeResolver<>(resolvers);
+    }
+
+    @Override
+    public void print(String type, Object printer, int indent) {
+        printer.i(Form.repeat(" ", indent) + "Composite[" + Arrays.toString(getNamespaces()) + "] " + type);
+
+        for(Resolver<T> i : getResolvers().values()) {
+            i.print(type, printer, indent + 2);
+        }
+    }
+
+    @Override
+    public void addAllKeys(List<PlatformNamespaceKey> keys) {
+        resolvers.forEach((k, v) -> v.addAllKeys(keys));
+    }
+}

engine/src/main/java/com/volmit/iris/engine/resolver/EngineResolvable.java

@@ -0,0 +1,9 @@
+package com.volmit.iris.engine.resolver;
+
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.Data;
+
+@Data
+public class EngineResolvable implements Resolvable {
+    private PlatformNamespaceKey key;
+}

engine/src/main/java/com/volmit/iris/engine/resolver/FrozenResolver.java

@@ -0,0 +1,55 @@
+package com.volmit.iris.engine.resolver;
+
+import art.arcane.amulet.format.Form;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.util.NSK;
+import lombok.Data;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class FrozenResolver<T extends Resolvable> implements Resolver<T> {
+    private final Map<String, T> registry;
+    private final String namespace;
+
+    public FrozenResolver(String namespace, Map<String, T> registry)
+    {
+        this.registry = Collections.unmodifiableMap(registry);
+        this.namespace = namespace;
+    }
+
+    @Override
+    public boolean hasNamespace(String namespace) {
+        return this.namespace.equals(namespace);
+    }
+
+    public T resolve(PlatformNamespaceKey key) {
+        return registry.get(key.getKey());
+    }
+
+    @Override
+    public T resolve(String key) {
+        return registry.get(key);
+    }
+
+    @Override
+    public void print(String type, Object printer, int indent) {
+        printer.i(Form.repeat(" ", indent) + "Frozen[" + namespace + "] " + type);
+    }
+
+    @Override
+    public void addAllKeys(List<PlatformNamespaceKey> keys) {
+        registry.keySet().forEach((k) -> keys.add(new NSK(getNamespace(), k)));
+    }
+
+    @Override
+    public Resolver<T> and(String namespace, Resolver<T> resolver) {
+        if(!namespace.equals(getNamespace())) {
+            return new CompositeResolver<>(Map.of(namespace, resolver, getNamespace(), this));
+        }
+
+        return new MergedNamespaceResolver<>(namespace, this, resolver);
+    }
+}

engine/src/main/java/com/volmit/iris/engine/resolver/HotResolver.java

@@ -0,0 +1,84 @@
+package com.volmit.iris.engine.resolver;
+
+import art.arcane.amulet.format.Form;
+import com.github.benmanes.caffeine.cache.CacheLoader;
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.util.NSK;
+import lombok.Data;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+@Data
+public class HotResolver<T extends Resolvable> implements Resolver<T>, CacheLoader<String, T> {
+    private final LoadingCache<String, T> cache;
+    private final String namespace;
+    private final Function<String, T> loader;
+    private final Supplier<List<String>> keyGetter;
+
+    public HotResolver(String namespace, Function<String, T> loader, Supplier<List<String>> keyGetter)
+    {
+        this.namespace = namespace;
+        this.keyGetter = keyGetter;
+        this.loader = loader;
+        cache = Caffeine.newBuilder().build(this);
+    }
+
+    public T resolve(PlatformNamespaceKey key) {
+        return cache.get(key.getKey());
+    }
+
+    @Override
+    public T resolve(String key) {
+        return cache.get(key);
+    }
+
+    public boolean hasNamespace(String namespace) {
+        return this.namespace.equals(namespace);
+    }
+
+    public FrozenResolver<T> freeze()
+    {
+        cache.cleanUp();
+        Map<String, T> map = new HashMap<>((int) cache.estimatedSize());
+        Map<String, T> view = cache.asMap();
+
+        for(String i : view.keySet()) {
+            map.put(i, view.get(i));
+        }
+
+        return new FrozenResolver<>(getNamespace(), Collections.unmodifiableMap(map));
+    }
+
+    @Override
+    public @Nullable T load(String key) {
+        return loader.apply(key);
+    }
+
+    @Override
+    public Resolver<T> and(String namespace, Resolver<T> resolver) {
+        if(!namespace.equals(getNamespace())) {
+            return new CompositeResolver<>(Map.of(namespace, resolver, getNamespace(), this));
+        }
+
+        return new MergedNamespaceResolver<>(namespace, this, resolver);
+    }
+
+    @Override
+    public void print(String type, Object printer, int indent) {
+        printer.i(Form.repeat(" ", indent) + "Hot[" + namespace + "] " + type);
+    }
+
+    @Override
+    public void addAllKeys(List<PlatformNamespaceKey> keys) {
+        keys.addAll(keyGetter.get().stream().map(i -> new NSK(getNamespace(), i)).toList());
+    }
+}

engine/src/main/java/com/volmit/iris/engine/resolver/MergedNamespaceResolver.java

@@ -0,0 +1,85 @@
+package com.volmit.iris.engine.resolver;
+
+import art.arcane.amulet.format.Form;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.Data;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class MergedNamespaceResolver<T extends Resolvable> implements Resolver<T> {
+    private final String namespace;
+    private final List<Resolver<T>> resolvers;
+
+    public MergedNamespaceResolver(String namespace, Resolver<T>... resolvers)
+    {
+        this(namespace, Arrays.stream(resolvers).toList());
+    }
+
+    public MergedNamespaceResolver(String namespace, List<Resolver<T>> resolvers)
+    {
+        this.namespace = namespace;
+        this.resolvers = resolvers;
+    }
+
+    @Override
+    public boolean hasNamespace(String namespace) {
+        return this.namespace.equals(namespace);
+    }
+
+    @Override
+    public T resolve(PlatformNamespaceKey key) {
+        for(Resolver<T> i : resolvers) {
+            T t = i.resolve(key);
+
+            if(t != null)
+            {
+                return t;
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public T resolve(String key) {
+        for(Resolver<T> i : resolvers) {
+            T t = i.resolve(key);
+
+            if(t != null)
+            {
+                return t;
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public void print(String type, Object printer, int indent) {
+        printer.i(Form.repeat(" ", indent) + "Merged[" + namespace + "] " + type);
+
+        for(Resolver<T> i : getResolvers()) {
+            i.print(type, printer, indent + 2);
+        }
+    }
+
+    @Override
+    public void addAllKeys(List<PlatformNamespaceKey> keys) {
+        resolvers.forEach(i -> i.addAllKeys(keys));
+    }
+
+    @Override
+    public Resolver<T> and(String namespace, Resolver<T> resolver) {
+        if(namespace.equals(getNamespace()))
+        {
+            List<Resolver<T>> r = resolvers.copy();
+            r.add(resolver);
+            return new MergedNamespaceResolver<>(namespace, r);
+        }
+
+        return new CompositeResolver<>(Map.of(getNamespace(), this, namespace, resolver));
+    }
+}

engine/src/main/java/com/volmit/iris/engine/resolver/Resolvable.java

@@ -0,0 +1,257 @@
+package com.volmit.iris.engine.resolver;
+
+import art.arcane.amulet.format.Form;
+import art.arcane.cram.PakResource;
+import com.google.gson.*;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import com.volmit.iris.engine.EngineData;
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformNamespaced;
+import com.volmit.iris.platform.PlatformNamespacedMutable;
+import lombok.AllArgsConstructor;
+
+import java.io.IOException;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.List;
+
+public interface Resolvable extends PlatformNamespaced, PlatformNamespacedMutable, PakResource {
+    String SCHEMA = "http://json-schema.org/draft-07/schema#";
+
+    default String getSchemaId() {
+        return "https://art.arcane/iris/schemas/"+entity().getId()+".json";
+    }
+
+    default String getSchemaRefId() {
+        return entity().getId()+".json";
+    }
+
+    default JsonObject generateSchema(EngineData data) {
+        JsonObject object = new JsonObject();
+        Entity.ResolverEntityData entity = entity();
+        object.add("$schema", new JsonPrimitive(SCHEMA));
+        object.add("$id", new JsonPrimitive(getSchemaId()));
+        object.add("type", new JsonPrimitive("object"));
+        object.add("description", new JsonPrimitive("No Description for " + entity.getName()));
+
+        JsonObject properties = new JsonObject();
+        JsonObject definitions = new JsonObject();
+
+        for(Field i : getClass().getDeclaredFields()) {
+            i.access();
+
+            if (Modifier.isStatic(i.getModifiers()) || Modifier.isTransient(i.getModifiers())) {
+                continue;
+            }
+
+            properties.add(i.getName(), generateSchemaProperty(data, i.getName(), i.getType(), i.getDeclaredAnnotation(Type.class), i.getDeclaredAnnotation(PlatformType.class), definitions));
+        }
+
+        object.add("properties", properties);
+        object.add("definitions", definitions);
+        return object;
+    }
+
+    default String getSchemaDefinition(String name) {
+        return "D" + name.hashCode();
+    }
+
+    default JsonObject generateSchemaProperty(EngineData data, String name, Class<?> type, Type listType, PlatformType platformType, JsonObject definitions) {
+        JsonObject main = new JsonObject();
+        JsonArray anyOf = new JsonArray();
+        JsonObject object = new JsonObject();
+        anyOf.add(object);
+        object.add("description", new JsonPrimitive("No Description for field " + name));
+
+        if(type.isAssignableFrom(Resolvable.class) || Resolvable.class.isAssignableFrom(type)) {
+            Resolvable r = data.getInstance(type);
+
+            if(r != null) {
+                String def = getSchemaDefinition(r.getClass().simpleName());
+                object.add("$ref", new JsonPrimitive(r.getSchemaRefId()));
+                JsonObject registry = new JsonObject();
+                registry.add("description", new JsonPrimitive("No Description for field " + name));
+                String defName = getSchemaDefinition("resolve" + type.getCanonicalName());
+                registry.add("type", new JsonPrimitive("string"));
+                registry.add("$ref", new JsonPrimitive("#/definitions/" + defName));
+
+                if(!definitions.has(defName)) {
+                    JsonObject enumDef = new JsonObject();
+                    JsonArray enums = new JsonArray();
+                    data.getAllKeys(type).forEach(i -> enums.add(i.toString()));
+                    enumDef.add("enum", enums);
+                    definitions.add(defName, enumDef);
+                }
+
+                anyOf.add(registry);
+            }
+        }
+
+        else if(type.isAssignableFrom(List.class) || List.class.isAssignableFrom(type)) {
+            if(listType != null) {
+                JsonObject internal = generateSchemaProperty(data, "list", listType.value(), null, platformType, definitions);
+                object.add("items", internal);
+            }
+        }
+
+        else if(type.isEnum()) {
+            String defName = getSchemaDefinition(type.getCanonicalName());
+            object.add("type", new JsonPrimitive("string"));
+            object.add("$ref", new JsonPrimitive("#/definitions/" + defName));
+
+            if(!definitions.has(defName)) {
+                try {
+                    JsonObject enumDef = new JsonObject();
+                    JsonArray enums = new JsonArray();
+                    Arrays.stream((Enum<?>[])type.getDeclaredMethod("values").invoke(null)).forEach(i -> enums.add(i.name()));
+                    enumDef.add("enum", enums);
+                    definitions.add(defName, enumDef);
+                } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+
+        else if(type.equals(String.class)) {
+            object.add("type", new JsonPrimitive("string"));
+
+            if(platformType != null) {
+                String defName = getSchemaDefinition(platformType.value().getCanonicalName());
+                object.add("$ref", new JsonPrimitive("#/definitions/" + defName));
+
+                if(!definitions.has(defName)) {
+                    JsonObject enumDef = new JsonObject();
+                    JsonArray enums = buildSchemaPlatformEnum(data, platformType.value());
+                    enumDef.add("enum", enums);
+                    definitions.add(defName, enumDef);
+                }
+            }
+        }
+
+        else if(type.equals(int.class) || type.equals(Integer.class)
+                || type.equals(long.class) || type.equals(Long.class)
+                || type.equals(byte.class) || type.equals(Byte.class)
+                || type.equals(short.class) || type.equals(Short.class))
+        {
+            object.add("type", new JsonPrimitive("integer"));
+
+            if(type.equals(int.class) || type.equals(Integer.class)) {
+                object.add("minimum", new JsonPrimitive(Integer.MIN_VALUE));
+                object.add("maximum", new JsonPrimitive(Integer.MAX_VALUE));
+            }
+
+            else if(type.equals(long.class) || type.equals(Long.class)) {
+                object.add("minimum", new JsonPrimitive(Long.MIN_VALUE));
+                object.add("maximum", new JsonPrimitive(Long.MAX_VALUE));
+            }
+
+            else if(type.equals(short.class) || type.equals(Short.class)) {
+                object.add("minimum", new JsonPrimitive(Short.MIN_VALUE));
+                object.add("maximum", new JsonPrimitive(Short.MAX_VALUE));
+            }
+
+            else {
+                object.add("minimum", new JsonPrimitive(Byte.MIN_VALUE));
+                object.add("maximum", new JsonPrimitive(Byte.MAX_VALUE));
+            }
+        }
+
+        if(anyOf.size() == 1)
+        {
+            return object;
+        }
+
+        main.add("anyOf", anyOf);
+        return main;
+    }
+
+    default JsonArray buildSchemaPlatformEnum(EngineData data, Class<? extends PlatformNamespaced> value) {
+        JsonArray a = new JsonArray();
+
+        if(value.equals(PlatformBlock.class)) {
+            data.getEngine().getPlatform().getBlocks().map(i -> i.getKey().toString()).forEach(a::add);
+        }
+
+        else if(value.equals(PlatformBiome.class)) {
+            data.getEngine().getPlatform().getBiomes().map(i -> i.getKey().toString()).forEach(a::add);
+        }
+
+        return a;
+    }
+
+    default void apply(GsonBuilder builder) {
+        if(this instanceof TypeAdapterFactory f) {
+            builder.registerTypeAdapterFactory(f);
+        }
+    }
+
+    default Entity.ResolverEntityData entity() {
+        return new Entity.ResolverEntityData(getClass().getDeclaredAnnotation(Resolvable.Entity.class));
+    }
+
+    default <T> void writeSafeJson(TypeAdapter<T> delegate, JsonWriter out, T value) {
+        try {
+            delegate.write(out, value);
+        } catch (IOException e) {
+            try {
+                delegate.write(out, null);
+            } catch(IOException ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+    }
+
+    @Target({ElementType.FIELD, ElementType.TYPE})
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface Entity {
+        String id();
+        String name() default "";
+        String namePlural() default "";
+        JsonToken[] jsonTypes() default JsonToken.BEGIN_OBJECT;
+
+        @AllArgsConstructor
+        @lombok.Data
+        class ResolverEntityData
+        {
+            private final Entity annotation;
+
+            public String getId() {
+                return annotation.id();
+            }
+
+            public String getName() {
+                return annotation.name().isEmpty() ? Form.capitalizeWords(getId().replaceAll("\\Q-\\E", " ")) : annotation.name();
+            }
+
+            public String getNamePlural() {
+                return annotation.namePlural().isEmpty() ? getName() + "s" : annotation.namePlural();
+            }
+        }
+    }
+
+    @Target({ElementType.FIELD, ElementType.TYPE})
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface TokenConstructor {
+        JsonToken[] value();
+    }
+
+    @Target({ElementType.FIELD, ElementType.TYPE})
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface Type {
+        Class<?> value();
+    }
+
+    @Target({ElementType.FIELD, ElementType.TYPE})
+    @Retention(RetentionPolicy.RUNTIME)
+    @interface PlatformType {
+        Class<? extends PlatformNamespaced> value();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/resolver/Resolver.java

@@ -0,0 +1,120 @@
+package com.volmit.iris.engine.resolver;
+
+import art.arcane.cram.PakKey;
+import art.arcane.cram.PakResource;
+import com.google.gson.Gson;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+public interface Resolver<T extends Resolvable> {
+    @SuppressWarnings("unchecked")
+    static <F extends Resolvable> CompositeResolver<F> frozen(Map<PakKey, PakResource> resources, Predicate<PakResource> isTypePredicate) {
+        Map<String, Map<String, F>> resolvables = new HashMap<>();
+        Map<String, Resolver<F>> resolvers = new HashMap<>();
+
+        for(PakKey i : resources.keySet()) {
+            PakResource r = resources.get(i);
+
+            if(isTypePredicate.test(r)) {
+                Map<String, F> rs = resolvables.computeIfAbsent(i.getNamespace(), (k) -> new HashMap<>());
+                rs.put(i.getKey(), (F) i);
+            }
+        }
+
+        for(String i : resolvables.keySet()) {
+            resolvers.put(i, frozen(i, resolvables.get(i)));
+        }
+
+        return new CompositeResolver<>(resolvers);
+    }
+
+    static <F extends Resolvable> Resolver<F> frozen(String namespace, Map<String, F> map) {
+        return new FrozenResolver<>(namespace, map);
+    }
+
+    static <F extends Resolvable> Resolver<F> hot(String namespace, Function<String, F> loader, Supplier<List<String>> keyGetter) {
+        return new HotResolver<>(namespace, loader, keyGetter);
+    }
+
+    static <F extends Resolvable> Resolver<F> hotDirectoryJson(String namespace, Class<?> resolvableClass, File folder, Gson gson) {
+        return hotDirectory(namespace, (in) -> (F) gson.fromJson(new InputStreamReader(in), resolvableClass), folder, "json");
+    }
+
+    static <F extends Resolvable> Resolver<F> hotDirectory(String namespace, Function<InputStream, F> loader, File folder, String... extensions) {
+        return new HotResolver<>(namespace, (key) -> {
+            for(String i : extensions)
+            {
+                File f = new File(folder, key + "." + i);
+                if(f.exists())
+                {
+                    try {
+                        FileInputStream in = new FileInputStream(f);
+                        F ff = loader.apply(in);
+                        in.close();
+                        return ff;
+                    } catch(IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            }
+
+            return null;
+        }, () -> {
+            List<String> s = new ArrayList<>();
+
+            for(File i : folder.listFiles())
+            {
+                if(i.isFile()) {
+                    for(String j : extensions)
+                    {
+                        if(i.getName().endsWith(j))
+                        {
+                            s.add(i.getName().split("\\Q.\\E")[0]);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return s;
+        });
+    }
+
+    boolean hasNamespace(String namespace);
+
+    T resolve(PlatformNamespaceKey key);
+
+    T resolve(String key);
+
+    default boolean contains(String namespace, String key) {
+        return hasNamespace(namespace) && resolve(key) != null;
+    }
+
+    default boolean contains(PlatformNamespaceKey key){
+        return hasNamespace(key.getNamespace()) && resolve(key) != null;
+    }
+
+    Resolver<T> and(String namespace, Resolver<T> resolver);
+
+    default void print(String type, Object printer)
+    {
+        print(type, printer, 0);
+    }
+
+    void print(String type, Object printer, int index);
+
+    void addAllKeys(List<PlatformNamespaceKey> keys);
+}

engine/src/main/java/com/volmit/iris/platform/IrisPlatform.java

@@ -0,0 +1,39 @@
+package com.volmit.iris.platform;
+
+import com.volmit.iris.platform.block.PlatformBlock;
+
+import java.io.File;
+import java.util.stream.Stream;
+
+public interface IrisPlatform {
+    void logError(String k, Object o);
+
+    void logInfo(String k, Object o);
+
+    void logWarning(String k, Object o);
+
+    void logDebug(String k, Object o);
+
+    String getPlatformName();
+
+    Stream<PlatformBlock> getBlocks();
+
+    Stream<PlatformBiome> getBiomes();
+
+    boolean isWorldLoaded(String name);
+
+    PlatformWorld getWorld(String name);
+
+    PlatformBlock parseBlock(String raw);
+
+    PlatformNamespaceKey key(String namespace, String key);
+
+    default PlatformNamespaceKey key(String nsk)
+    {
+        return key("minecraft", nsk);
+    }
+
+    File getStudioFolder();
+
+    File getStudioFolder(String dimension);
+}

engine/src/main/java/com/volmit/iris/platform/PlatformBiome.java

@@ -0,0 +1,5 @@
+package com.volmit.iris.platform;
+
+public interface PlatformBiome extends PlatformNamespaced {
+
+}

engine/src/main/java/com/volmit/iris/platform/PlatformChunk.java

@@ -0,0 +1,9 @@
+package com.volmit.iris.platform;
+
+public interface PlatformChunk {
+    int getX();
+
+    int getZ();
+
+    void unload(boolean save, boolean force);
+}

engine/src/main/java/com/volmit/iris/platform/PlatformNamespaceKey.java

@@ -0,0 +1,16 @@
+package com.volmit.iris.platform;
+
+import art.arcane.cram.PakKey;
+import com.volmit.iris.util.NSK;
+
+public interface PlatformNamespaceKey {
+    String getNamespace();
+
+    String getKey();
+
+    String toString();
+
+    static PlatformNamespaceKey of(PakKey key) {
+        return new NSK(key.getNamespace(), key.getKey());
+    }
+}

engine/src/main/java/com/volmit/iris/platform/PlatformNamespaced.java

@@ -0,0 +1,5 @@
+package com.volmit.iris.platform;
+
+public interface PlatformNamespaced {
+    PlatformNamespaceKey getKey();
+}

engine/src/main/java/com/volmit/iris/platform/PlatformNamespacedMutable.java

@@ -0,0 +1,5 @@
+package com.volmit.iris.platform;
+
+public interface PlatformNamespacedMutable {
+    void setKey(PlatformNamespaceKey key);
+}

engine/src/main/java/com/volmit/iris/platform/PlatformPlayer.java

@@ -0,0 +1,23 @@
+package com.volmit.iris.platform;
+
+import art.arcane.amulet.geometry.Vec;
+
+import java.util.UUID;
+
+public interface PlatformPlayer {
+    UUID getUUID();
+
+    String getName();
+
+    Vec getLocation();
+
+    PlatformWorld getWorld();
+
+    boolean canUseIris();
+
+    void sendMessage(String message);
+
+    void sendActionBar(String message);
+
+    void sendTitleMessage(String title, String subtitle, int in, int stay, int out);
+}

engine/src/main/java/com/volmit/iris/platform/PlatformRegistry.java

@@ -0,0 +1,37 @@
+package com.volmit.iris.platform;
+
+import art.arcane.amulet.format.Form;
+import lombok.Data;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Data
+public class PlatformRegistry<T extends PlatformNamespaced> {
+    private final Map<PlatformNamespaceKey, T> registry;
+    private final String name;
+    private final String namePlural;
+
+    public PlatformRegistry(String name, String namePlural, Stream<T> stream) {
+        this.name = name;
+        this.namePlural = namePlural;
+        registry = Collections.unmodifiableMap(stream.collect(Collectors.toMap(PlatformNamespaced::getKey, (t) -> t)));
+        i("Registered " + Form.f(registry.size()) + " " + namePlural);
+    }
+
+    public PlatformRegistry(String name, Stream<T> stream) {
+        this(name, name + "s", stream);
+    }
+
+
+    public T get(PlatformNamespaceKey key) {
+        return registry.get(key);
+    }
+
+    public Set<PlatformNamespaceKey> getKeys() {
+        return Collections.unmodifiableSet(registry.keySet());
+    }
+}

engine/src/main/java/com/volmit/iris/platform/PlatformWorld.java

@@ -0,0 +1,66 @@
+package com.volmit.iris.platform;
+
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.util.WorldHeight;
+
+import java.io.File;
+
+public interface PlatformWorld {
+    WorldHeight getHeight();
+
+    String getName();
+
+    File getFolder();
+
+    Iterable<PlatformPlayer> getPlayers();
+
+    Iterable<PlatformChunk> getLoadedChunks();
+
+    PlatformChunk getOrLoadChunk(int x, int z);
+
+    PlatformBlock getBlock(int x, int y, int z);
+
+    PlatformBiome getBiome(int x, int y, int z);
+
+    long getSeed();
+
+    boolean isChunkLoaded(int x, int z);
+
+    void setBlock(int x, int y, int z, PlatformBlock block);
+
+    void setBiome(int x, int y, int z, PlatformBiome biome);
+
+    default File getWorldFolder(String subfolder) {
+        return new File(getFolder(), subfolder);
+    }
+
+    default File getRegionFolder() {
+        return getWorldFolder("region");
+    }
+
+    default File getIrisFolder() {
+        return getWorldFolder("iris");
+    }
+
+    default File getIrisDataFolder() {
+        File f = new File(getWorldFolder("iris"), "data");
+        f.mkdirs();
+        return f;
+    }
+
+    default boolean isRegionLoaded(int x, int z) {
+        for(PlatformChunk i : getLoadedChunks()) {
+            if(i.getX() >> 5 == x && i.getZ() >> 5 == z) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    default void unloadChunks(boolean save, boolean force) {
+        for(PlatformChunk i : getLoadedChunks()) {
+            i.unload(save, force);
+        }
+    }
+}

engine/src/main/java/com/volmit/iris/platform/block/PlatformBlock.java

@@ -0,0 +1,9 @@
+package com.volmit.iris.platform.block;
+
+import com.volmit.iris.platform.PlatformNamespaced;
+
+import java.util.Map;
+
+public interface PlatformBlock extends PlatformNamespaced {
+    Map<String, String> getProperties();
+}

engine/src/main/java/com/volmit/iris/util/FloatNoiseCache.java

@@ -0,0 +1,22 @@
+package com.volmit.iris.util;
+
+public class FloatNoiseCache {
+    private final int width;
+    private final int height;
+    private final float[] cache;
+
+    public FloatNoiseCache(int width, int height)
+    {
+        this.width = width;
+        this.height = height;
+        cache = new float[width * height];
+    }
+
+    public void set(int x, int y, float v) {
+        this.cache[y % this.height * this.width + x % this.width] = v;
+    }
+
+    public float get(int x, int y) {
+        return this.cache[y % this.height * this.width + x % this.width];
+    }
+}

engine/src/main/java/com/volmit/iris/util/HunkedNoisePlane.java

@@ -0,0 +1,17 @@
+package com.volmit.iris.util;
+
+import art.arcane.source.NoisePlane;
+import art.arcane.spatial.hunk.Hunk;
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor
+public class HunkedNoisePlane implements NoisePlane {
+    private final Hunk<Double> noise;
+
+    @Override
+    public double noise(double x, double y, double z) {
+        Double d = noise.get(Math.floorMod((int)x, noise.getWidth()), Math.floorMod((int)y, noise.getHeight()), Math.floorMod((int)z, noise.getDepth()));
+
+        return d != null ? d : 0;
+    }
+}

engine/src/main/java/com/volmit/iris/util/NSK.java

@@ -0,0 +1,32 @@
+package com.volmit.iris.util;
+
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class NSK implements PlatformNamespaceKey {
+    private final String namespace;
+    private final String key;
+
+    public NSK(String namespacedkey)
+    {
+        this(namespacedkey.contains(":") ? namespacedkey.split("\\Q:\\E")[0] : "minecraft",
+            namespacedkey.contains(":") ? namespacedkey.split("\\Q:\\E")[1] : namespacedkey);
+    }
+
+    @Override
+    public String getNamespace() {
+        return namespace;
+    }
+
+    @Override
+    public String getKey() {
+        return key;
+    }
+
+    public String toString() {
+        return namespace + ":" + key;
+    }
+}

engine/src/main/java/com/volmit/iris/util/NoiseCache.java

@@ -0,0 +1,23 @@
+package com.volmit.iris.util;
+
+public class NoiseCache<T> {
+    private final int width;
+    private final int height;
+    private final Object[] cache;
+
+    public NoiseCache(int width, int height)
+    {
+        this.width = width;
+        this.height = height;
+        cache = new Object[width * height];
+    }
+
+    public void set(int x, int y, T v) {
+        this.cache[y % this.height * this.width + x % this.width] = v;
+    }
+
+    @SuppressWarnings("unchecked")
+    public T get(int x, int y) {
+        return (T) this.cache[y % this.height * this.width + x % this.width];
+    }
+}

engine/src/main/java/com/volmit/iris/util/ShortNoiseCache.java

@@ -0,0 +1,22 @@
+package com.volmit.iris.util;
+
+public class ShortNoiseCache {
+    private final int width;
+    private final int height;
+    private final short[] cache;
+
+    public ShortNoiseCache(int width, int height)
+    {
+        this.width = width;
+        this.height = height;
+        cache = new short[width * height];
+    }
+
+    public void set(int x, int y, short v) {
+        this.cache[(Math.floorMod(y,this.height) * this.width) + Math.floorMod(x, this.width)] = v;
+    }
+
+    public short get(int x, int y) {
+        return this.cache[(Math.floorMod(y,this.height) * this.width) + Math.floorMod(x,this.width)];
+    }
+}

engine/src/main/java/com/volmit/iris/util/WorldHeight.java

@@ -0,0 +1,19 @@
+package com.volmit.iris.util;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+public class WorldHeight {
+    private final int minHeight;
+    private final int maxHeight;
+
+    public WorldHeight(int maxHeight) {
+        this(0, maxHeight);
+    }
+
+    public int getTotalHeight() {
+        return maxHeight - minHeight;
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

pom.xml

@@ -1,104 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<groupId>bytecode.ninja</groupId>
-	<artifactId>Iris</artifactId>
-	<version>1.0</version>
-	<name>Iris</name>
-	<properties>
-		<maven.compiler.source>1.8</maven.compiler.source>
-		<maven.compiler.target>1.8</maven.compiler.target>
-		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<development.location>${user.home}\Documents\development\server\plugins\${project.name}.jar</development.location>
-	</properties>
-	<build>
-		<resources>
-			<resource>
-				<directory>src/main/resources</directory>
-				<filtering>true</filtering>
-				<includes>
-					<include>**/*.xml</include>
-					<include>**/*.yml</include>
-					<include>**/*.txt</include>
-					<include>**/*.properties</include>
-					<include>**/*.html</include>
-				</includes>
-			</resource>
-		</resources>
-		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-shade-plugin</artifactId>
-				<version>3.1.0</version>
-				<executions>
-					<execution>
-						<phase>package</phase>
-						<goals>
-							<goal>shade</goal>
-						</goals>
-						<configuration>
-							<minimizeJar>true</minimizeJar>
-						</configuration>
-					</execution>
-				</executions>
-			</plugin>
-			<plugin>
-				<groupId>org.codehaus.mojo</groupId>
-				<artifactId>exec-maven-plugin</artifactId>
-				<version>1.2</version>
-				<executions>
-					<execution>
-						<id>runbatchfile</id>
-						<phase>package</phase>
-						<goals>
-							<goal>exec</goal>
-						</goals>
-					</execution>
-				</executions>
-				<configuration>
-					<skip>${skip.copy}</skip>
-					<executable>${project.basedir}/scripts/copy.bat</executable>
-					<arguments>
-						<argument>${project.basedir}\target\${project.name}-${project.version}.jar</argument>
-						<argument>${development.location}</argument>
-					</arguments>
-				</configuration>
-			</plugin>
-		</plugins>
-	</build>
-	<repositories>
-		<repository>
-			<id>pub</id>
-			<url>http://nexus.mpm.care/content/repositories/pub</url>
-		</repository>
-		<repository>
-			<id>spigot-repo</id>
-			<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
-		</repository>
-		<repository>
-			<id>volmit</id>
-			<url>http://nexus.volmit.com/content/repositories/volmit</url>
-		</repository>
-	</repositories>
-	<dependencies>
-		<dependency>
-			<groupId>ninja.bytecode</groupId>
-			<artifactId>Shuriken</artifactId>
-			<version>1.0</version>
-		</dependency>
-		<dependency>
-			<groupId>org.spigotmc</groupId>
-			<artifactId>spigot-api</artifactId>
-			<version>1.14.4-R0.1-SNAPSHOT</version>
-			<scope>provided</scope>
-		</dependency>
-		<dependency>
-			<artifactId>craftbukkit-1.14.4</artifactId>
-			<groupId>cb</groupId>
-			<version>1</version>
-			<scope>system</scope>
-			<systemPath>${project.basedir}/lib/craftbukkit-1.14.4.jar</systemPath>
-		</dependency>
-	</dependencies>
-</project>

scripts/copy.bat

@@ -1,3 +0,0 @@
-@Echo off
-echo Apply Script: COPY
-echo F|xcopy /y /s /f /q "%1" "%2"

settings.gradle

@@ -0,0 +1,14 @@
+pluginManagement {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        gradlePluginPortal()
+        maven { url "https://dl.cloudsmith.io/public/arcane/archive/maven/" }
+    }
+}
+
+rootProject.name = 'Iris'
+include 'bukkit'
+include 'engine'
+include 'engine'
+

src/main/java/ninja/bytecode/iris/Iris.java

@@ -1,91 +0,0 @@
-package ninja.bytecode.iris;
-
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.WorldCreator;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import ninja.bytecode.shuriken.collections.GSet;
-import ninja.bytecode.shuriken.execution.TaskExecutor;
-
-public class Iris extends JavaPlugin implements Listener
-{
-	public static TaskExecutor noisePool;
-	public static TaskExecutor blockPool;
-	public static IrisGenerator gen;
-	public static Settings settings;
-	public static Iris instance;
-
-	public void onEnable()
-	{
-		instance = this;
-		settings = new Settings();
-		gen = new IrisGenerator();
-		noisePool = new TaskExecutor(settings.performance.threadCount, settings.performance.threadPriority, "Iris Noise Generator");
-		blockPool = new TaskExecutor(1, Thread.MAX_PRIORITY, "Iris Decorator");
-		getServer().getPluginManager().registerEvents((Listener) this, this);
-
-		// Debug world regens
-		GSet<String> ws = new GSet<>();
-		World w = createIrisWorld();
-		for(Player i : Bukkit.getOnlinePlayers())
-		{
-			ws.add(i.getWorld().getName());
-			i.teleport(new Location(w, 0, 256, 0));
-			i.setFlying(true);
-			i.setGameMode(GameMode.CREATIVE);
-		}
-
-		for(String i : ws)
-		{
-			Bukkit.unloadWorld(i, false);
-		}
-	}
-
-	public void onDisable()
-	{
-		noisePool.close();
-		blockPool.close();
-	}
-
-	@Override
-	public ChunkGenerator getDefaultWorldGenerator(String worldName, String id)
-	{
-		return new IrisGenerator();
-	}
-
-	@EventHandler
-	public void on(PlayerCommandPreprocessEvent e)
-	{
-		if(e.getMessage().toLowerCase().equals("/iris"))
-		{
-			World wold = e.getPlayer().getWorld();
-			World w = createIrisWorld();
-			e.getPlayer().teleport(new Location(w, 0, 256, 0));
-			e.getPlayer().setFlying(true);
-			e.getPlayer().setGameMode(GameMode.CREATIVE);
-			e.setCancelled(true);
-			wold.setAutoSave(false);
-			Bukkit.unloadWorld(wold, false);
-		}
-	}
-
-	private World createIrisWorld()
-	{
-		World ww = Bukkit.createWorld(new WorldCreator("iris-worlds/" + UUID.randomUUID().toString()).generator(new IrisGenerator()).seed(0));
-		ww.setSpawnFlags(false, false);
-		ww.setAutoSave(false);
-		ww.setKeepSpawnInMemory(false);
-		ww.setSpawnLocation(0, 256, 0);
-		return ww;
-	}
-}

src/main/java/ninja/bytecode/iris/IrisGenerator.java

@@ -1,235 +0,0 @@
-package ninja.bytecode.iris;
-
-import java.util.Random;
-
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.Bisected;
-import org.bukkit.block.data.Bisected.Half;
-import org.bukkit.block.data.BlockData;
-
-import ninja.bytecode.iris.gen.GenLayerBase;
-import ninja.bytecode.iris.gen.GenLayerBiome;
-import ninja.bytecode.iris.gen.GenLayerDeepOcean;
-import ninja.bytecode.iris.gen.IGenLayer;
-import ninja.bytecode.iris.util.RealBiome;
-import ninja.bytecode.shuriken.collections.GList;
-import ninja.bytecode.shuriken.math.M;
-import ninja.bytecode.shuriken.math.RNG;
-
-public class IrisGenerator extends ParallelChunkGenerator
-{
-	private BlockData AIR = Material.AIR.createBlockData();
-	private BlockData WATER = Material.WATER.createBlockData();
-	private BlockData SAND = Material.SAND.createBlockData();
-	private BlockData BEDROCK = Material.BEDROCK.createBlockData();
-	private GList<IGenLayer> genLayers;
-	private GenLayerBiome glBiome;
-	private GenLayerBase glBase;
-	private int waterLevel = 127;
-
-	@Override
-	public void onInit(World world, Random random)
-	{
-		genLayers = new GList<>();
-		RNG rng = new RNG(world.getSeed());
-		genLayers.add(glBiome = new GenLayerBiome(world, random, rng.nextRNG()));
-		genLayers.add(glBase = new GenLayerBase(world, random, rng.nextRNG()));
-		genLayers.add(new GenLayerDeepOcean(world, random, rng.nextRNG()));
-	}
-
-	public int getHeight(double dx, double dz)
-	{
-		double noise = 0.5;
-
-		for(IGenLayer i : genLayers)
-		{
-			noise = i.generateLayer(noise, dx, dz);
-		}
-
-		double n = noise * 250;
-		n = n > 254 ? 254 : n;
-		n = n < 0 ? 0 : n;
-
-		return (int) n;
-	}
-
-	@Override
-	public Biome genColumn(int wx, int wz, int x, int z)
-	{
-		int height = getHeight(wx, wz);
-		double temp = glBiome.getTemperature(wx, wz);
-		double humidity = glBiome.getHumidity(wx, wz);
-		RealBiome b = glBiome.getBiome(wx, wz);
-		boolean underwater = height < waterLevel;
-
-		// Change biome to ocean / deep ocean if underwater height
-		if(underwater)
-		{
-			if(waterLevel - height > 20)
-			{
-				if(temp <= 0.05)
-				{
-					b = RealBiome.of(Biome.DEEP_FROZEN_OCEAN);
-				}
-
-				else if(temp <= 0.35)
-				{
-					b = RealBiome.of(Biome.DEEP_COLD_OCEAN);
-				}
-
-				else if(temp <= 0.55)
-				{
-					b = RealBiome.of(Biome.DEEP_OCEAN);
-				}
-
-				else if(temp <= 0.65)
-				{
-					b = RealBiome.of(Biome.DEEP_LUKEWARM_OCEAN);
-				}
-
-				else
-				{
-					b = RealBiome.of(Biome.DEEP_WARM_OCEAN);
-				}
-			}
-
-			else
-			{
-				if(temp <= 0.05)
-				{
-					b = RealBiome.of(Biome.FROZEN_OCEAN);
-				}
-
-				else if(temp <= 0.35)
-				{
-					b = RealBiome.of(Biome.COLD_OCEAN);
-				}
-
-				else if(temp <= 0.55)
-				{
-					b = RealBiome.of(Biome.OCEAN);
-				}
-
-				else if(temp <= 0.65)
-				{
-					b = RealBiome.of(Biome.LUKEWARM_OCEAN);
-				}
-
-				else
-				{
-					b = RealBiome.of(Biome.WARM_OCEAN);
-				}
-			}
-		}
-
-		if(height > 122 && height < 128 + (temp * 1.5) + (glBase.scatter(wx, wx * wz, wz) * 3.35))
-		{
-			b = RealBiome.of(Biome.BEACH);
-		}
-
-		for(int i = 0; i < Math.max(height, waterLevel); i++)
-		{
-			BlockData mb = AIR;
-
-			// Bedrockify
-			if(i == 0 || (!Iris.settings.gen.flatBedrock && ((i == 1 && glBase.scatterChance(wx, i, wz, 0.45)))))
-			{
-				mb = BEDROCK;
-			}
-
-			// Surface blocks
-			else if(i == height - 1)
-			{
-				if(temp > 0.6 && b.getBiome().equals(Biome.BEACH))
-				{
-					if(humidity > 0.6)
-					{
-						mb = Material.YELLOW_CONCRETE_POWDER.createBlockData();
-					}
-					
-					else
-					{
-						mb = Material.BLACK_CONCRETE_POWDER.createBlockData();
-					}
-				}
-				
-				else if(temp < 0.4 && b.getBiome().equals(Biome.BEACH))
-				{
-					if(humidity > 0.6)
-					{
-						mb = Material.WHITE_CONCRETE_POWDER.createBlockData();
-					}
-					
-					else
-					{
-						mb = Material.LIGHT_GRAY_CONCRETE_POWDER.createBlockData();
-					}
-				}
-				
-				else
-				{
-					mb = b.surface(wx, i, wz, glBase);
-				}
-			}
-
-			// Dirt Blocks
-			else if(!underwater && i > height - glBase.scatterInt(wx, i, wz, 12))
-			{
-				mb = b.dirt(wx, i, wz, glBase);
-			}
-
-			// Create Water blocks
-			else if(i >= height && underwater)
-			{
-				mb = WATER;
-			}
-
-			// Below Dirt
-			else
-			{
-				mb = b.rock(wx, i, wz, glBase);
-			}
-
-			if(mb.getMaterial().equals(Material.AIR))
-			{
-				continue;
-			}
-
-			setBlock(x, i, z, mb);
-		}
-
-		BlockData v = b.getSurfaceDecoration();
-
-		if(v != null && underwater == b.isWater() && (underwater ? height < 125 : true))
-		{
-			if(v instanceof Bisected)
-			{
-				Bisected bs = (Bisected) v;
-				bs.setHalf(Half.BOTTOM);
-				setBlock(x, height, z, bs);
-				Bisected bst = (Bisected) bs.clone();
-				bst.setHalf(Half.TOP);
-				setBlock(x, height + 1, z, bst);
-			}
-
-			else
-			{
-				setBlock(x, height, z, v);
-			}
-		}
-
-		return b.getBiome();
-	}
-
-	public int pick(int max, double noise)
-	{
-		return (int) (noise * max);
-	}
-
-	public BlockData pick(BlockData[] array, double noise)
-	{
-		return array[pick(array.length, noise)];
-	}
-}

src/main/java/ninja/bytecode/iris/ParallelChunkGenerator.java

@@ -1,116 +0,0 @@
-package ninja.bytecode.iris;
-
-import java.util.Random;
-
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.generator.ChunkGenerator;
-
-import ninja.bytecode.iris.atomics.AtomicChunkData;
-import ninja.bytecode.shuriken.Shuriken;
-import ninja.bytecode.shuriken.execution.ChronoLatch;
-import ninja.bytecode.shuriken.execution.NastyRunnable;
-import ninja.bytecode.shuriken.execution.TaskExecutor.TaskGroup;
-import ninja.bytecode.shuriken.execution.TaskExecutor.TaskResult;
-import ninja.bytecode.shuriken.format.F;
-import ninja.bytecode.shuriken.math.RollingSequence;
-
-public abstract class ParallelChunkGenerator extends ChunkGenerator
-{
-	private int i;
-	private int j;
-	private int wx;
-	private int wz;
-	private AtomicChunkData data;
-	private TaskGroup tg;
-	private TaskGroup tb;
-	private boolean ready = false;
-	private ChronoLatch cl = new ChronoLatch(1000);
-	private RollingSequence rs = new RollingSequence(512);
-
-	public ChunkData generateChunkData(World world, Random random, int x, int z, BiomeGrid biome)
-	{
-		Shuriken.profiler.start("chunkgen-" + world.getName());
-		data = new AtomicChunkData(world);
-
-		try
-		{
-			if(!ready)
-			{
-				onInit(world, random);
-				ready = true;
-			}
-
-			tg = Iris.noisePool.startWork();
-			tb = Iris.blockPool.startWork();
-
-			for(i = 0; i < 16; i++)
-			{
-				wx = (x * 16) + i;
-
-				for(j = 0; j < 16; j++)
-				{
-					wz = (z * 16) + j;
-					int a = wx;
-					int b = wz;
-					int c = i;
-					int d = j;
-					tg.queue(() ->
-					{
-						biome.setBiome(c, d, genColumn(a, b, c, d));
-					});
-				}
-			}
-
-			TaskResult r = tg.execute();
-			
-			rs.put(r.timeElapsed + tb.execute().timeElapsed);
-			Shuriken.profiler.stop("chunkgen-" + world.getName());
-
-			if(cl.flip())
-			{
-				System.out.print("Avg: " + F.duration(rs.getAverage(), 2) + " " + F.duration(rs.getMax(), 2) + " / " + F.duration(rs.getMedian(), 2) + " / " + F.duration(rs.getMin(), 2));
-			}
-		}
-
-		catch(Throwable e)
-		{
-			e.printStackTrace();
-			for(int i = 0; i < 16; i++)
-			{
-				for(int j = 0; j < 16; j++)
-				{
-					data.setBlock(i, 0, j, Material.RED_GLAZED_TERRACOTTA);
-				}
-			}
-		}
-
-		return data.toChunkData();
-	}
-
-	public boolean isParallelCapable()
-	{
-		return true;
-	}
-
-	public abstract void onInit(World world, Random random);
-
-	public abstract Biome genColumn(int wx, int wz, int x, int z);
-
-	protected void queueSets(NastyRunnable r)
-	{
-		tb.queue(r);
-	}
-
-	protected void setBlock(int x, int y, int z, BlockData b)
-	{
-		if(b.getMaterial().equals(Material.AIR))
-		{
-			return;
-		}
-
-		tb.queue(() -> data.setBlock(x, y, z, b));
-	}
-}

src/main/java/ninja/bytecode/iris/PerformanceMode.java

@@ -1,9 +0,0 @@
-package ninja.bytecode.iris;
-
-public enum PerformanceMode
-{
-	SINGLE_THREADED,
-	UNLIMITED,
-	MATCH_CPU,
-	HALF_CPU,
-}